From 939764c9e890b44d981e662bad5b94144ced811e Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 13:34:00 +0000
Subject: [PATCH 001/188] UdpServer: docs

---
 libraries/UdpServer/UdpServer.h | 54 +++++++++++++++++++++------------
 1 file changed, 34 insertions(+), 20 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.h b/libraries/UdpServer/UdpServer.h
index a51b5bd57..bc49bbe1c 100644
--- a/libraries/UdpServer/UdpServer.h
+++ b/libraries/UdpServer/UdpServer.h
@@ -4,9 +4,7 @@
  *  Created on: 19 May 2015
  *      Author: giulio moro
  */
-
-#ifndef UDPSERVER_H_
-#define UDPSERVER_H_
+#pragma once
 
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -40,34 +38,50 @@ class UdpServer{
 		~UdpServer();
 		bool setup(int aPort);
 		void cleanup();
-		bool bindToPort(int aPort);
+		/**
+		 * Get the port that the server is currently listening on
+		 */
 		int getBoundPort() const;
-		/*
+		bool bindToPort(int aPort);
+		/**
 		 * Reads bytes from the socket.
 		 *
-		 * Drop-in replacement for JUCE DatagramSocket::read()
-		 *
-			If blockUntilSpecifiedAmountHasArrived is true, the method will block until maxBytesToRead
-			bytes have been read, (or until an error occurs). If this flag is false, the method will
-			return as much data as is currently available without blocking.
+		 * @param destBuffer the destination buffer
+		 * @param maxBytesToRead the maximum number of bytes to read
+		 * @param blockUntilSpecifiedAmountHasArrived If `true`, the method
+		 * will block until @p maxBytesToRead bytes have been read, (or
+		 * until an error occurs). If it is false, the method
+		 * will return as much data as is currently available without
+		 * blocking.
 		 */
 		int read(void* destBuffer, int maxBytesToRead, bool blockUntilSpecifiedAmountHasArrived);
 		void close();
+		/**
+		 * Drain the input buffer
+		 */
 		int empty();
 		int empty(int maxCount);
-		/*
-		 * Waits until the socket is ready for reading or writing.
+		/**
+		 * Waits until the socket is ready for reading.
+		 *
+		 * @param timeoutMsecs If it is < 0, it will wait forever,
+		 * or else will give up after the specified time in milliseconds.
 		 *
-			Drop-in replacement for JUCE DatagramSocket::waitUntilReady.
-			If readyForReading is true, it will wait until the socket is ready for reading; if false, it will wait until it's ready for writing.
-			If the timeout is < 0, it will wait forever, or else will give up after the specified time.
-			If the socket is ready on return, this returns 1. If it times-out before the socket becomes ready, it returns 0. If an error occurs, it returns -1.
+		 * @return If the socket is ready on return, this returns 1.
+		 * If it times-out before the socket becomes ready, it
+		 * returns 0. If an error occurs, it returns -1.
+		 */
+		int waitUntilReady(int timeoutMsecs);
+		/**
+		 * Deprecated. Should be called with `readyForReading=true`
 		 */
 		int waitUntilReady(bool readyForReading, int timeoutMsecs);
+		/**
+		 * Get the source port for the last received message
+		 */
 		int getLastRecvPort();
+		/**
+		 * Get the source address for the last received message
+		 */
 		const char* getLastRecvAddr();
 };
-
-
-
-#endif /* UDPSERVER_H_ */

From 8a416100e08f7fc1a03b493386ab09838cbd8378 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 13:40:00 +0000
Subject: [PATCH 002/188] UdpServer: better cleanup, provided implementation
 for new version of waitUntilReady()

---
 libraries/OscReceiver/OscReceiver.cpp |  2 +-
 libraries/UdpServer/UdpServer.cpp     | 19 +++++++++++++++----
 libraries/UdpServer/UdpServer.h       |  2 +-
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/libraries/OscReceiver/OscReceiver.cpp b/libraries/OscReceiver/OscReceiver.cpp
index 15e6c4b67..6611f24a5 100644
--- a/libraries/OscReceiver/OscReceiver.cpp
+++ b/libraries/OscReceiver/OscReceiver.cpp
@@ -51,7 +51,7 @@ void OscReceiver::setup(int port, std::function<void(oscpkt::Message* msg, const
 }
 
 int OscReceiver::waitForMessage(int timeout){
-	int ret = socket->waitUntilReady(true, timeout);
+	int ret = socket->waitUntilReady(timeout);
 	if (ret == -1){
 		fprintf(stderr, "OscReceiver: Error polling UDP socket: %d %s\n", errno, strerror(errno));
 		return -1;
diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index 8c0f003af..a03e4eaef 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -50,14 +50,25 @@ bool UdpServer::bindToPort(int aPort){
 	return true;
 }
 
+int UdpServer::getBoundPort() const {
+	return enabled ? server.sin_port : -1;
+}
+
 void UdpServer::close(){
-	int ret=::close(inSocket);
-	if(ret != 0)
-		printf("Error while closing socket, errno: %d\n", errno);//Stop receiving data for this socket. If further data arrives, reject it.
-	inSocket=0;
+	if(inSocket >= 0)
+	{
+		int ret =::close(inSocket);
+		if(ret != 0)
+			fprintf(stderr, "Error while closing socket, errno: %d\n", errno);
+	}
+	inSocket = -1;
+	enabled = false;
 }
 
 int UdpServer::waitUntilReady(bool readyForReading, int timeoutMsecs){
+	return waitUntilReady(timeoutMsecs);
+}
+int UdpServer::waitUntilReady(int timeoutMsecs){
 //	If the socket is ready on return, this returns 1. If it times-out before the socket becomes ready, it returns 0. If an error occurs, it returns -1.
 	if(enabled==false)
 		return -1;
diff --git a/libraries/UdpServer/UdpServer.h b/libraries/UdpServer/UdpServer.h
index bc49bbe1c..9843b0a6d 100644
--- a/libraries/UdpServer/UdpServer.h
+++ b/libraries/UdpServer/UdpServer.h
@@ -21,7 +21,7 @@ class UdpServer{
 	private:
 		int port;
 		int enabled;
-		int inSocket;
+		int inSocket = -1;
 		struct sockaddr_in server;
 		struct timeval stTimeOut;
 		struct timeval stZeroTimeOut;

From da4a4df857f183c03eb0d0fb6a226f4cb379d67b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 13:49:54 +0000
Subject: [PATCH 003/188] NIT: UdpServer: fixed (most?) whitespaces

---
 libraries/UdpServer/UdpServer.cpp | 78 +++++++++++++++----------------
 1 file changed, 39 insertions(+), 39 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index a03e4eaef..637157bf8 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -17,36 +17,36 @@ UdpServer::~UdpServer(){
 	cleanup();
 };
 bool UdpServer::setup(int aPort){
-	enabled=true;
+	enabled = true;
 	stZeroTimeOut.tv_sec = 0; //set timeout to 0
 	stZeroTimeOut.tv_usec = 0;
-	inSocket=socket(AF_INET, SOCK_DGRAM, 0);
-	if (inSocket < 0){
-		enabled=false;
+	inSocket = socket(AF_INET, SOCK_DGRAM, 0);
+	if(inSocket < 0) {
+		enabled = false;
 		return false; 
 	}
 	length = sizeof(server);
-	server.sin_family=AF_INET;
-	server.sin_addr.s_addr=INADDR_ANY;
-	enabled=bindToPort(aPort);
-	wasteBufferSize=2048;
-	wasteBuffer=malloc(wasteBufferSize);
-	memset(&stTimeOut,0,sizeof(struct timeval));
+	server.sin_family = AF_INET;
+	server.sin_addr.s_addr = INADDR_ANY;
+	enabled = bindToPort(aPort);
+	wasteBufferSize = 2048;
+	wasteBuffer = malloc(wasteBufferSize);
+	memset(&stTimeOut, 0, sizeof(struct timeval));
 	return enabled;
 }
 
 bool UdpServer::bindToPort(int aPort){
-	port=aPort;
-	if(port<1){
-		enabled=false;
+	port = aPort;
+	if(port < 1){
+		enabled = false;
 		return false;
 	}
-	server.sin_port=htons(port);
-	if (bind(inSocket,(struct sockaddr *)&server,length)<0){
-		enabled=false;
+	server.sin_port = htons(port);
+	if (bind(inSocket, (struct sockaddr *)&server, length) < 0){
+		enabled = false;
 		return false;
 	}
-	enabled=true;
+	enabled = true;
 	return true;
 }
 
@@ -70,21 +70,21 @@ int UdpServer::waitUntilReady(bool readyForReading, int timeoutMsecs){
 }
 int UdpServer::waitUntilReady(int timeoutMsecs){
 //	If the socket is ready on return, this returns 1. If it times-out before the socket becomes ready, it returns 0. If an error occurs, it returns -1.
-	if(enabled==false)
+	if(enabled == false)
 		return -1;
-	if(timeoutMsecs<0)
-		return select(inSocket+1, &stReadFDS, NULL, NULL, NULL); //calling this with a NULL timeout will block indefinitely
+	if(timeoutMsecs < 0)
+		return select(inSocket + 1, &stReadFDS, NULL, NULL, NULL); //calling this with a NULL timeout will block indefinitely
 	FD_ZERO(&stReadFDS);
 	FD_SET(inSocket, &stReadFDS);
-	float timeOutSecs=timeoutMsecs*0.001;
-	stTimeOut.tv_sec=(long int)timeOutSecs;
-	timeOutSecs-=(int)timeOutSecs;
-	long int timeOutUsecs=timeOutSecs*1000000;
-	stTimeOut.tv_usec=timeOutUsecs;
-	int descriptorReady= select(inSocket+1, &stReadFDS, NULL, NULL, &stTimeOut);
-//	printf("stTimeOut.tv_sec=%ld, stTimeOut.tv_usec=%ld, descriptorReady: \n",stTimeOut.tv_sec,stTimeOut.tv_usec, descriptorReady);
-//	return descriptorReady>0 ? (timeOutUsecs-stTimeOut.tv_usec) : descriptorReady;
-	return descriptorReady>0 ? 1 : descriptorReady;
+	float timeOutSecs = timeoutMsecs * 0.001;
+	stTimeOut.tv_sec = (long int)timeOutSecs;
+	timeOutSecs -= (int)timeOutSecs;
+	long int timeOutUsecs = timeOutSecs * 1000000;
+	stTimeOut.tv_usec = timeOutUsecs;
+	int descriptorReady = select(inSocket + 1, &stReadFDS, NULL, NULL, &stTimeOut);
+//	printf("stTimeOut.tv_sec = %ld, stTimeOut.tv_usec = %ld, descriptorReady: \n", stTimeOut.tv_sec, stTimeOut.tv_usec, descriptorReady);
+//	return descriptorReady > 0 ? (timeOutUsecs-stTimeOut.tv_usec) : descriptorReady;
+	return descriptorReady > 0 ? 1 : descriptorReady;
 }
 
 int UdpServer::read(//Returns the number of bytes read, or -1 if there was an error.
@@ -92,26 +92,26 @@ int UdpServer::read(//Returns the number of bytes read, or -1 if there was an er
 					int maxBytesToRead,
 					bool blockUntilSpecifiedAmountHasArrived)
 {
-	if(enabled==false)
+	if(enabled == false)
 		return -1;
 	FD_ZERO(&stReadFDS);
 	FD_SET(inSocket, &stReadFDS);
-	int descriptorReady= select(inSocket+1, &stReadFDS, NULL, NULL, &stZeroTimeOut); //TODO: this is not JUCE-compliant
-	if(descriptorReady<0){ //an error occurred
+	int descriptorReady = select(inSocket + 1, &stReadFDS, NULL, NULL, &stZeroTimeOut); //TODO: this is not JUCE-compliant
+	if(descriptorReady < 0){ //an error occurred
 		return -1;
 	}
-	int numberOfBytes=0;
+	int numberOfBytes = 0;
 //	do
 	{
 		if (FD_ISSET(inSocket, &stReadFDS))
 		{
 			fromLength = sizeof(from);
 			numberOfBytes += recvfrom(inSocket, destBuffer, maxBytesToRead - numberOfBytes, 0, (struct sockaddr*)&from, &fromLength);
-			if(numberOfBytes<0)
+			if(numberOfBytes < 0)
 				return -1;
 		}
 	}
-//	while (blockUntilSpecifiedAmountHasArrived && numberOfBytes==maxBytesToRead);
+//	while (blockUntilSpecifiedAmountHasArrived && numberOfBytes == maxBytesToRead);
 	return numberOfBytes;
 }
 int UdpServer::getLastRecvPort()
@@ -128,15 +128,15 @@ int UdpServer::empty(){
 	return empty(0);
 }
 int UdpServer::empty(int maxCount){
-	int count=0;
+	int count = 0;
 	int n;
 	do {
-		if(waitUntilReady(true, 0)==0)
+		if(waitUntilReady(true, 0) == 0)
 			return 0;
 		float waste;
-		n=read(&waste, sizeof(float), false);
+		n = read(&waste, sizeof(float), false);
 		count++;
-	} while (n>0 && (maxCount<=0 || maxCount<count));
+	} while (n > 0 && (maxCount <= 0 || maxCount < count));
 	printf("socket emptied with %d reads\n", count);
 	return count;
 }

From a5bde776d4f9b2533016d0b3b486c0874c6d14cb Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 13:53:33 +0000
Subject: [PATCH 004/188] UdpServer: removed unnecessary variables and memory
 leak

---
 libraries/UdpServer/UdpServer.cpp | 5 +----
 libraries/UdpServer/UdpServer.h   | 3 ---
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index 637157bf8..1a22ed03e 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -25,12 +25,9 @@ bool UdpServer::setup(int aPort){
 		enabled = false;
 		return false; 
 	}
-	length = sizeof(server);
 	server.sin_family = AF_INET;
 	server.sin_addr.s_addr = INADDR_ANY;
 	enabled = bindToPort(aPort);
-	wasteBufferSize = 2048;
-	wasteBuffer = malloc(wasteBufferSize);
 	memset(&stTimeOut, 0, sizeof(struct timeval));
 	return enabled;
 }
@@ -42,7 +39,7 @@ bool UdpServer::bindToPort(int aPort){
 		return false;
 	}
 	server.sin_port = htons(port);
-	if (bind(inSocket, (struct sockaddr *)&server, length) < 0){
+	if (bind(inSocket, (struct sockaddr *)&server, sizeof(server)) < 0){
 		enabled = false;
 		return false;
 	}
diff --git a/libraries/UdpServer/UdpServer.h b/libraries/UdpServer/UdpServer.h
index 9843b0a6d..a64b8b92e 100644
--- a/libraries/UdpServer/UdpServer.h
+++ b/libraries/UdpServer/UdpServer.h
@@ -27,9 +27,6 @@ class UdpServer{
 		struct timeval stZeroTimeOut;
 		fd_set stReadFDS;
 		int size;
-		void *wasteBuffer;
-		int wasteBufferSize;
-		int length;
 		socklen_t fromLength;
 		struct sockaddr_in from;
 	public:

From fd35d48b9864799bb5579dfc7fd76e1b5936ecfb Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 14:12:51 +0000
Subject: [PATCH 005/188] UdpServer: removed more unnecessary instance
 variables, factored out initialisation of fd_set

---
 libraries/UdpServer/UdpServer.cpp | 23 ++++++++++++++---------
 libraries/UdpServer/UdpServer.h   |  5 +----
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index 1a22ed03e..ad81b48aa 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -18,8 +18,6 @@ UdpServer::~UdpServer(){
 };
 bool UdpServer::setup(int aPort){
 	enabled = true;
-	stZeroTimeOut.tv_sec = 0; //set timeout to 0
-	stZeroTimeOut.tv_usec = 0;
 	inSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if(inSocket < 0) {
 		enabled = false;
@@ -28,7 +26,6 @@ bool UdpServer::setup(int aPort){
 	server.sin_family = AF_INET;
 	server.sin_addr.s_addr = INADDR_ANY;
 	enabled = bindToPort(aPort);
-	memset(&stTimeOut, 0, sizeof(struct timeval));
 	return enabled;
 }
 
@@ -65,15 +62,19 @@ void UdpServer::close(){
 int UdpServer::waitUntilReady(bool readyForReading, int timeoutMsecs){
 	return waitUntilReady(timeoutMsecs);
 }
+#define FD_INIT(fd, fds) \
+	FD_ZERO(&fds); \
+	FD_SET(fd, &fds);
+
 int UdpServer::waitUntilReady(int timeoutMsecs){
-//	If the socket is ready on return, this returns 1. If it times-out before the socket becomes ready, it returns 0. If an error occurs, it returns -1.
 	if(enabled == false)
 		return -1;
+	fd_set stReadFDS;
+	FD_INIT(inSocket, stReadFDS);
 	if(timeoutMsecs < 0)
 		return select(inSocket + 1, &stReadFDS, NULL, NULL, NULL); //calling this with a NULL timeout will block indefinitely
-	FD_ZERO(&stReadFDS);
-	FD_SET(inSocket, &stReadFDS);
 	float timeOutSecs = timeoutMsecs * 0.001;
+	struct timeval stTimeOut;
 	stTimeOut.tv_sec = (long int)timeOutSecs;
 	timeOutSecs -= (int)timeOutSecs;
 	long int timeOutUsecs = timeOutSecs * 1000000;
@@ -91,9 +92,13 @@ int UdpServer::read(//Returns the number of bytes read, or -1 if there was an er
 {
 	if(enabled == false)
 		return -1;
-	FD_ZERO(&stReadFDS);
-	FD_SET(inSocket, &stReadFDS);
-	int descriptorReady = select(inSocket + 1, &stReadFDS, NULL, NULL, &stZeroTimeOut); //TODO: this is not JUCE-compliant
+	fd_set stReadFDS;
+	FD_INIT(inSocket, stReadFDS);
+	struct timeval stZeroTimeOut = {
+		.tv_sec = 0,
+		.tv_usec = 0,
+	};
+	int descriptorReady = select(inSocket + 1, &stReadFDS, NULL, NULL, &stZeroTimeOut);
 	if(descriptorReady < 0){ //an error occurred
 		return -1;
 	}
diff --git a/libraries/UdpServer/UdpServer.h b/libraries/UdpServer/UdpServer.h
index a64b8b92e..c83f1e315 100644
--- a/libraries/UdpServer/UdpServer.h
+++ b/libraries/UdpServer/UdpServer.h
@@ -20,12 +20,9 @@
 class UdpServer{
 	private:
 		int port;
-		int enabled;
+		int enabled = false;
 		int inSocket = -1;
 		struct sockaddr_in server;
-		struct timeval stTimeOut;
-		struct timeval stZeroTimeOut;
-		fd_set stReadFDS;
 		int size;
 		socklen_t fromLength;
 		struct sockaddr_in from;

From 98c4d6935acda3bd544fb0933fa98d291512b722 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 14:17:29 +0000
Subject: [PATCH 006/188] UdpServer: re-enabled (and fixed)
 blockUntilSpecifiedAmountHasArrived

---
 libraries/UdpServer/UdpServer.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index ad81b48aa..bfd24d92b 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -103,17 +103,17 @@ int UdpServer::read(//Returns the number of bytes read, or -1 if there was an er
 		return -1;
 	}
 	int numberOfBytes = 0;
-//	do
+	do
 	{
 		if (FD_ISSET(inSocket, &stReadFDS))
 		{
 			fromLength = sizeof(from);
-			numberOfBytes += recvfrom(inSocket, destBuffer, maxBytesToRead - numberOfBytes, 0, (struct sockaddr*)&from, &fromLength);
+			numberOfBytes += recvfrom(inSocket, ((char*)destBuffer) + numberOfBytes, maxBytesToRead - numberOfBytes, 0, (struct sockaddr*)&from, &fromLength);
 			if(numberOfBytes < 0)
 				return -1;
 		}
 	}
-//	while (blockUntilSpecifiedAmountHasArrived && numberOfBytes == maxBytesToRead);
+	while (blockUntilSpecifiedAmountHasArrived && numberOfBytes < maxBytesToRead);
 	return numberOfBytes;
 }
 int UdpServer::getLastRecvPort()

From 521a0ac3c666571874c002b57dfe4b947946ce1d Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 14:31:58 +0000
Subject: [PATCH 007/188] NIT: UdpServer: check for !enabled instead

---
 libraries/UdpServer/UdpServer.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index bfd24d92b..306b29c1e 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -67,7 +67,7 @@ int UdpServer::waitUntilReady(bool readyForReading, int timeoutMsecs){
 	FD_SET(fd, &fds);
 
 int UdpServer::waitUntilReady(int timeoutMsecs){
-	if(enabled == false)
+	if(!enabled)
 		return -1;
 	fd_set stReadFDS;
 	FD_INIT(inSocket, stReadFDS);
@@ -90,7 +90,7 @@ int UdpServer::read(//Returns the number of bytes read, or -1 if there was an er
 					int maxBytesToRead,
 					bool blockUntilSpecifiedAmountHasArrived)
 {
-	if(enabled == false)
+	if(!enabled)
 		return -1;
 	fd_set stReadFDS;
 	FD_INIT(inSocket, stReadFDS);

From 7ea1a428b924bc8538ef52acf2c3c5268916f5b5 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 14:33:38 +0000
Subject: [PATCH 008/188] UdpServer: removed bindToPort() which was anyhow not
 working. Also throwing if the constructor fails.

---
 libraries/UdpServer/UdpServer.cpp | 37 +++++++++++--------------------
 libraries/UdpServer/UdpServer.h   |  5 ++---
 2 files changed, 15 insertions(+), 27 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index 306b29c1e..92fde90a9 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -5,43 +5,32 @@
  *      Author: giulio moro
  */
 #include "UdpServer.h"
+#include <stdexcept>
 
 void UdpServer::cleanup(){
 	close();
 }
-UdpServer::UdpServer(int aPort){
-	setup(aPort);
+UdpServer::UdpServer(unsigned int port){
+	if(!setup(port))
+		throw std::runtime_error("UdpServer: could not bind to port " + std::to_string(port));
 };
 UdpServer::UdpServer(){}
 UdpServer::~UdpServer(){
 	cleanup();
 };
-bool UdpServer::setup(int aPort){
-	enabled = true;
+bool UdpServer::setup(unsigned int port){
+	close();
 	inSocket = socket(AF_INET, SOCK_DGRAM, 0);
-	if(inSocket < 0) {
-		enabled = false;
-		return false; 
-	}
+	if(inSocket < 0)
+		return enabled = false;
 	server.sin_family = AF_INET;
 	server.sin_addr.s_addr = INADDR_ANY;
-	enabled = bindToPort(aPort);
-	return enabled;
-}
-
-bool UdpServer::bindToPort(int aPort){
-	port = aPort;
-	if(port < 1){
-		enabled = false;
-		return false;
-	}
+	if(port < 1 || port >= 65536)
+		return enabled = false;
 	server.sin_port = htons(port);
-	if (bind(inSocket, (struct sockaddr *)&server, sizeof(server)) < 0){
-		enabled = false;
-		return false;
-	}
-	enabled = true;
-	return true;
+	if(bind(inSocket, (struct sockaddr *)&server, sizeof(server)) < 0)
+		return enabled = false;
+	return enabled = true;
 }
 
 int UdpServer::getBoundPort() const {
diff --git a/libraries/UdpServer/UdpServer.h b/libraries/UdpServer/UdpServer.h
index c83f1e315..08f67d257 100644
--- a/libraries/UdpServer/UdpServer.h
+++ b/libraries/UdpServer/UdpServer.h
@@ -28,15 +28,14 @@ class UdpServer{
 		struct sockaddr_in from;
 	public:
 		UdpServer();
-		UdpServer(int aPort);
+		UdpServer(unsigned int port);
 		~UdpServer();
-		bool setup(int aPort);
+		bool setup(unsigned int aPort);
 		void cleanup();
 		/**
 		 * Get the port that the server is currently listening on
 		 */
 		int getBoundPort() const;
-		bool bindToPort(int aPort);
 		/**
 		 * Reads bytes from the socket.
 		 *

From 0bd6d7a6466d665865b5498242a3e258ac8bae9c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Apr 2023 14:47:33 +0000
Subject: [PATCH 009/188] UdpServer: further removing unused instance
 variables, simplified includes

---
 libraries/UdpServer/UdpServer.cpp | 12 +++++-------
 libraries/UdpServer/UdpServer.h   | 18 ------------------
 2 files changed, 5 insertions(+), 25 deletions(-)

diff --git a/libraries/UdpServer/UdpServer.cpp b/libraries/UdpServer/UdpServer.cpp
index 92fde90a9..d2ca4d025 100644
--- a/libraries/UdpServer/UdpServer.cpp
+++ b/libraries/UdpServer/UdpServer.cpp
@@ -1,11 +1,9 @@
-/*
- * udpServer.cpp
- *
- *  Created on: 19 May 2015
- *      Author: giulio moro
- */
 #include "UdpServer.h"
 #include <stdexcept>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
 
 void UdpServer::cleanup(){
 	close();
@@ -96,7 +94,7 @@ int UdpServer::read(//Returns the number of bytes read, or -1 if there was an er
 	{
 		if (FD_ISSET(inSocket, &stReadFDS))
 		{
-			fromLength = sizeof(from);
+			socklen_t fromLength = sizeof(from);
 			numberOfBytes += recvfrom(inSocket, ((char*)destBuffer) + numberOfBytes, maxBytesToRead - numberOfBytes, 0, (struct sockaddr*)&from, &fromLength);
 			if(numberOfBytes < 0)
 				return -1;
diff --git a/libraries/UdpServer/UdpServer.h b/libraries/UdpServer/UdpServer.h
index 08f67d257..ed8022852 100644
--- a/libraries/UdpServer/UdpServer.h
+++ b/libraries/UdpServer/UdpServer.h
@@ -1,21 +1,5 @@
-/*
- * udpServer.h
- *
- *  Created on: 19 May 2015
- *      Author: giulio moro
- */
 #pragma once
-
-#include <sys/types.h>
-#include <sys/socket.h>
 #include <netinet/in.h>
-#include <arpa/inet.h>
-#include <errno.h>
-#include <netdb.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
 
 class UdpServer{
 	private:
@@ -23,8 +7,6 @@ class UdpServer{
 		int enabled = false;
 		int inSocket = -1;
 		struct sockaddr_in server;
-		int size;
-		socklen_t fromLength;
 		struct sockaddr_in from;
 	public:
 		UdpServer();

From 4f1bd6d5cea6756bdb704435d4ef1f037be561e6 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 12 May 2023 10:41:19 -0500
Subject: [PATCH 010/188] Bela.h: added support for printf-style compiler
 warnings

---
 include/Bela.h | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/include/Bela.h b/include/Bela.h
index ef00a56c4..4bbb0f2cd 100644
--- a/include/Bela.h
+++ b/include/Bela.h
@@ -96,10 +96,17 @@ extern "C"
 // these functions are currently provided by xenomai.
 // We put these declarations here so we do not have to include
 // Xenomai specific files
-int rt_printf(const char *format, ...);
-int rt_fprintf(FILE *stream, const char *format, ...);
-int rt_vprintf(const char *format, va_list ap);
-int rt_vfprintf(FILE *stream, const char *format, va_list ap);
+// use attributes to provide printf-style compiler warnings
+#ifdef __GNUC__
+#define _ATTRIBUTE(attrs) __attribute__ (attrs)
+#else
+#define _ATTRIBUTE(attrs)
+#endif
+
+int rt_printf(const char *format, ...) _ATTRIBUTE ((__format__ (__printf__, 1, 2)));
+int rt_fprintf(FILE *stream, const char *format, ...) _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
+int rt_vprintf(const char *format, va_list ap)  _ATTRIBUTE ((__format__ (__printf__, 1, 0)));
+int rt_vfprintf(FILE *stream, const char *format, va_list ap)  _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
 
 /**
  * A type of Bela hardware.

From ea7a398ba01c4067feed001530a684bcca300dd1 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 May 2023 14:07:38 +0000
Subject: [PATCH 011/188] Spi_Codec: enable reset pin of ADS816x.

---
 core/Spi_Codec.cpp | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/core/Spi_Codec.cpp b/core/Spi_Codec.cpp
index 61fd8510e..35e461881 100644
--- a/core/Spi_Codec.cpp
+++ b/core/Spi_Codec.cpp
@@ -194,8 +194,20 @@ int Spi_Codec::initCodec(){
 
 int Spi_Codec::startAudio(int shouldBeReady){
 	// Enable PLL
-	return writeRegister(REG_PLL_CLK_CONTROL_0, 0x9C);
-	// TODO: wait till we are ready
+	if(writeRegister(REG_PLL_CLK_CONTROL_0, 0x9C))
+		return 1;
+	// when combined with Bela cape rev C, we need to enable the
+	// ADC by toggling its reset pin. As this pin (P8.32) is already reserved
+	// by us as part of the SPI GPIO device, we can set it here regardless
+	// of the actual board we are running on.
+	const size_t kAds816xReset = 11;
+	if(gpio_export(kAds816xReset))
+		return 1;
+	if(gpio_set_dir(kAds816xReset, OUTPUT_PIN))
+		return 1;
+	if(gpio_set_value(kAds816xReset, HIGH))
+		return 1;
+	return 0;
 }
 
 int Spi_Codec::stopAudio(){

From 21eaac1b40e4474e1b47637ef64b52a243ec25f0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 31 May 2023 14:42:18 +0000
Subject: [PATCH 012/188] When ADS816x, ensure you sleep  or otherwise wait
 enough between reset the ADS816x and starting the PRU

---
 core/Es9080_Codec.cpp | 7 +++++++
 core/PRU.cpp          | 4 ++++
 core/Spi_Codec.cpp    | 6 ++++++
 3 files changed, 17 insertions(+)

diff --git a/core/Es9080_Codec.cpp b/core/Es9080_Codec.cpp
index b53b64af1..53eb14234 100644
--- a/core/Es9080_Codec.cpp
+++ b/core/Es9080_Codec.cpp
@@ -42,10 +42,17 @@ Es9080_Codec::Es9080_Codec(int i2cBus, int i2cAddress, AudioCodecParams::ClockSo
 	// polarity also changes below
 	params.bitDelay = (kClockSourceMcasp == params.wclk) ? 1 : 0;
 	initI2C_RW(i2cBus, i2cAddress, -1);
+
+	// toggle reset pin
 	gpio.open(resetPin, Gpio::OUTPUT);
 	gpio.clear();
 	usleep(1000);
 	gpio.set();
+	// The ADS816x is also wired on this reset pin, so we wait:
+	// ADS8166 datasheet 6.7 Switching characteristics
+	// Delay time: RST rising to READY rising is 4ms MAX
+	// However, there is typically enough time between here and the moment
+	// the PRU start, so we don't have to explicitly wait here
 }
 
 Es9080_Codec::~Es9080_Codec()
diff --git a/core/PRU.cpp b/core/PRU.cpp
index d028e7aae..25ab71673 100644
--- a/core/PRU.cpp
+++ b/core/PRU.cpp
@@ -442,6 +442,10 @@ int PRU::initialise(BelaHw newBelaHw, int pru_num, bool uniformSampleRate, int m
 			adcNrstPin.clear();
 			usleep(1000);
 			adcNrstPin.set();
+			// ADS8166 datasheet 6.7 Switching characteristics
+			// Delay time: RST rising to READY rising is 4ms MAX
+			// However, there is typically enough time between here and the moment
+			// the PRU start, so we don't have to explicitly wait here
 		}
 	}
 
diff --git a/core/Spi_Codec.cpp b/core/Spi_Codec.cpp
index 35e461881..f6b00f808 100644
--- a/core/Spi_Codec.cpp
+++ b/core/Spi_Codec.cpp
@@ -205,8 +205,14 @@ int Spi_Codec::startAudio(int shouldBeReady){
 		return 1;
 	if(gpio_set_dir(kAds816xReset, OUTPUT_PIN))
 		return 1;
+	if(gpio_set_value(kAds816xReset, LOW))
+		return 1;
+	usleep(1000);
 	if(gpio_set_value(kAds816xReset, HIGH))
 		return 1;
+	// ADS8166 datasheet 6.7 Switching characteristics
+	// Delay time: RST rising to READY rising is 4ms MAX
+	usleep(4000);
 	return 0;
 }
 

From 255962397c5244c1ed2ee2e6a3207a26106f3f5a Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 2 Jun 2023 00:13:48 +0000
Subject: [PATCH 013/188] default_libpd_render: BELA_LIBBPD_SERIAL: added
 support for raw bytes

---
 core/default_libpd_render.cpp | 50 ++++++++++++++++++++++++++---------
 1 file changed, 38 insertions(+), 12 deletions(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index 1c06d9953..43b30a67f 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -168,6 +168,7 @@ std::string gSerialId;
 int gSerialEom;
 enum SerialType {
 	kSerialFloats,
+	kSerialBytes,
 	kSerialSymbol,
 	kSerialSymbols,
 } gSerialType = kSerialFloats;
@@ -593,27 +594,36 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 		{
 			if(
 				argc < 5
-				|| !libpd_is_symbol(argv + 0)
-				|| !libpd_is_symbol(argv + 1)
-				|| !libpd_is_float(argv + 2)
-				|| !libpd_is_symbol(argv + 3)
-				|| !libpd_is_symbol(argv + 4)
+				|| !libpd_is_symbol(argv + 0) // serial_id
+				|| !libpd_is_symbol(argv + 1) // device
+				|| !libpd_is_float(argv + 2) // baudrate
+				|| !(libpd_is_symbol(argv + 3) || libpd_is_float(argv + 3)) // EOM
+				|| !libpd_is_symbol(argv + 4) // tyoe
 			)
 			{
-				fprintf(stderr, "Invalid bela_setSerial arguments. Should be: `new serial_id device baudrate EOM type`, where `EOM` is one of `newline` or `none` and `type` is one of `floats`, `symbol`, `symbols`\n");
+				fprintf(stderr, "Invalid bela_setSerial arguments. Should be:\n"
+				"`new serial_id device baudrate EOM type`,\n"
+				"where `EOM` is one of `newline` or `none` or a character (expressed as an integer"
+				"       between 0 and 255)\n"
+				"and `type` is one of `bytes`, `floats`, `symbol`, `symbols`\n");
 				return;
 			}
 			gSerialId = libpd_get_symbol(argv + 0);
 			const char* device = libpd_get_symbol(argv + 1);
 			unsigned int baudrate = libpd_get_float(argv + 2);
-			const char* eom = libpd_get_symbol(argv + 3);
-			if(0 == strcmp(eom, "newline"))
-				gSerialEom = '\n';
-			else
-				gSerialEom = -1;
+			gSerialEom = -1;
+			if(libpd_is_symbol(argv + 3)) {
+				const char* eom = libpd_get_symbol(argv + 3);
+				if(0 == strcmp(eom, "newline"))
+					gSerialEom = '\n';
+			} else if(libpd_is_float(argv + 3)) {
+				gSerialEom = libpd_get_float(argv + 3);
+			}
 			const char* type = libpd_get_symbol(argv + 4);
 			if(0 == strcmp("floats", type))
 				gSerialType = kSerialFloats;
+			else if(0 == strcmp("bytes", type))
+				gSerialType = kSerialBytes;
 			else if(0 == strcmp("symbol", type))
 				gSerialType = kSerialSymbol;
 			else if(0 == strcmp("symbols", type))
@@ -1135,6 +1145,22 @@ void render(BelaContext *context, void *userData)
 				if(kSerialSymbol == gSerialType)
 				{
 					libpd_symbol(rec, data);
+				} else if(kSerialBytes == gSerialType) {
+					if(gSerialEom >= 0) {
+						// messages are separated: send as a list
+						libpd_start_message(h.dataSize);
+						for(size_t n = 0; n < h.dataSize; ++n)
+							libpd_add_float(data[n]);
+						libpd_finish_message(rec, id);
+					} else {
+						// messages are not separated: send one byte at a time
+						for(size_t n = 0; n < h.dataSize; ++n)
+						{
+							libpd_start_message(h.dataSize);
+							libpd_add_float(data[n]);
+							libpd_finish_message(rec, id);
+						}
+					}
 				} else {
 					unsigned int nTokens = 1;
 					const uint8_t separators[] = { ' ', '\0'};
@@ -1177,7 +1203,7 @@ void render(BelaContext *context, void *userData)
 							start = n + 1;
 						}
 					}
-					libpd_finish_message("bela_serial", id);
+					libpd_finish_message(rec, id);
 				}
 			}
 			waitingFor = kHeader;

From 1e116c15d3747b54737ce68446e5928da3338b3e Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 2 Jun 2023 00:14:34 +0000
Subject: [PATCH 014/188] default_libpd_render: fixed argument to rt_printf

---
 core/default_libpd_render.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index 43b30a67f..a935538d1 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -742,7 +742,7 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 						value = 0;
 					if(Trill::prescalerMax < value)
 						value = Trill::prescalerMax;
-					rt_printf("bela_setTrill prescaler value out of range, clipping to %u\n", value);
+					rt_printf("bela_setTrill prescaler value out of range, clipping to %.0f\n", value);
 				}
 				gTouchSensors[idx].second->setPrescaler(value);
 			}

From f6f258787301283b713a24a0710757ba34812f8c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 18 Jul 2023 13:44:59 +0000
Subject: [PATCH 015/188] WSServer: pass address and identifier to each
 callback. Amended Gui and Scope accordingly

---
 libraries/Gui/Gui.cpp           | 30 +++++++++++++++---------------
 libraries/Gui/Gui.h             | 13 +++++++------
 libraries/Scope/Scope.cpp       |  6 +++---
 libraries/WSServer/WSServer.cpp | 24 +++++++++++++++---------
 libraries/WSServer/WSServer.h   |  7 ++++++-
 5 files changed, 46 insertions(+), 34 deletions(-)

diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index c52285f1f..a567a276c 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -20,27 +20,27 @@ int Gui::setup(unsigned int port, std::string address)
 	ws_server = std::unique_ptr<WSServer>(new WSServer());
 	ws_server->setup(port);
 	ws_server->addAddress(_addressData,
-		[this](std::string address, void* buf, int size)
+		[this](const std::string& address, const WSServerDetails* id, const unsigned char* buf, size_t size)
 		{
-			ws_onData((const char*) buf, size);
+			ws_onData(address, id, buf, size);
 		},
 	 nullptr, nullptr, true);
 
 	ws_server->addAddress(_addressControl,
 		// onData()
-		[this](std::string address, void* buf, int size)
+		[this](const std::string& address, const WSServerDetails* id,  const unsigned char* buf, size_t size)
 		{
-			ws_onControlData((const char*) buf, size);
+			ws_onControlData(address, id, buf, size);
 		},
 		// onConnect()
-		[this](std::string address)
+		[this](const std::string& address, const WSServerDetails* id)
 		{
-			ws_connect();
+			ws_connect(address, id);
 		},
 		// onDisconnect()
-		[this](std::string address)
+		[this](const std::string& address, const WSServerDetails* id)
 		{
-			ws_disconnect();
+			ws_disconnect(address, id);
 		}
 	);
 	return 0;
@@ -58,7 +58,7 @@ int Gui::setup(std::string projectName, unsigned int port, std::string address)
  * with initial settings.
  * The client replies with 'connection-ack', which should be parsed accordingly.
  */
-void Gui::ws_connect()
+void Gui::ws_connect(const std::string& address, const WSServerDetails* id)
 {
 	// send connection JSON
 	JSONObject root;
@@ -77,19 +77,19 @@ void Gui::ws_connect()
  * Called when websocket is disconnected.
  *
  */
-void Gui::ws_disconnect()
+void Gui::ws_disconnect(const std::string& address, const WSServerDetails* id)
 {
 	wsIsConnected = false;
 }
 
 /*
- *  on_data callback for scope_control websocket
+ *  on_data callback for gui_control websocket
  *  runs on the (linux priority) seasocks thread
  */
-void Gui::ws_onControlData(const char* data, unsigned int size)
+void Gui::ws_onControlData(const std::string& address, const WSServerDetails* id, const unsigned char* data, unsigned int size)
 {
 	// parse the data into a JSONValue
-	JSONValue *value = JSON::Parse(data);
+	JSONValue *value = JSON::Parse((const char*)data);
 	if (value == NULL || !value->IsObject()){
 		fprintf(stderr, "Could not parse JSON:\n%s\n", data);
 		return;
@@ -111,9 +111,9 @@ void Gui::ws_onControlData(const char* data, unsigned int size)
 	return;
 }
 
-void Gui::ws_onData(const char* data, unsigned int size)
+void Gui::ws_onData(const std::string& address, const WSServerDetails* id, const unsigned char* data, size_t size)
 {
-	if(customOnData && !customOnData(data, size, binaryCallbackArg))
+	if(customOnData && !customOnData(address, id, data, size, binaryCallbackArg))
 	{
 		return;
 	}
diff --git a/libraries/Gui/Gui.h b/libraries/Gui/Gui.h
index 4bb93055a..a83bd4b61 100644
--- a/libraries/Gui/Gui.h
+++ b/libraries/Gui/Gui.h
@@ -10,6 +10,7 @@
 
 // forward declarations
 class WSServer;
+class WSServerDetails;
 
 class Gui
 {
@@ -20,10 +21,10 @@ class Gui
 
 		bool wsIsConnected = false;
 
-		void ws_connect();
-		void ws_disconnect();
-		void ws_onControlData(const char* data, unsigned int size);
-		void ws_onData(const char* data, unsigned int size);
+		void ws_connect(const std::string& address, const WSServerDetails* id);
+		void ws_disconnect(const std::string& address, const WSServerDetails* id);
+		void ws_onControlData(const std::string& address, const WSServerDetails* id, const unsigned char* data, size_t size);
+		void ws_onData(const std::string& address, const WSServerDetails* id, const unsigned char* data, size_t size);
 		int doSendBuffer(const char* type, unsigned int bufferId, const void* data, size_t size);
 
 		unsigned int _port;
@@ -33,7 +34,7 @@ class Gui
 
 		// User defined functions
 		std::function<bool(JSONObject&, void*)> customOnControlData;
-		std::function<bool(const char*, unsigned int, void*)> customOnData;
+		std::function<bool(const std::string&, const WSServerDetails*, const unsigned char*, size_t, void*)> customOnData;
 
 		void* controlCallbackArg = nullptr;
 		void* binaryCallbackArg = nullptr;
@@ -107,7 +108,7 @@ class Gui
 		 * @param callbackArg: Pointer to be passed to the
 		 * callback.
 		 **/
-		void setBinaryDataCallback(std::function<bool(const char*, unsigned int, void*)> callback, void* callbackArg=nullptr){
+		void setBinaryDataCallback(std::function<bool(const std::string&, const WSServerDetails* id, const unsigned char*, size_t, void*)> callback, void* callbackArg=nullptr){
 			customOnData = callback;
 			binaryCallbackArg = callbackArg;
 		};
diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index 98dbe7ec4..28829b099 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -57,13 +57,13 @@ void Scope::setup(unsigned int _numChannels, float _sampleRate){
 	ws_server->setup(5432);
 	ws_server->addAddress("scope_data", nullptr, nullptr, nullptr, true);
 	ws_server->addAddress("scope_control", 
-		[this](std::string address, void* buf, int size){
+		[this](const std::string& address, const WSServerDetails* id, const unsigned char* buf, size_t size){
 			scope_control_data((const char*) buf);
 		},
-		[this](std::string address){
+		[this](const std::string& address, const WSServerDetails* id){
 			scope_control_connected();
 		},
-		[this](std::string address){
+		[this](const std::string& address, const WSServerDetails* id){
 			stop();
 		});
 
diff --git a/libraries/WSServer/WSServer.cpp b/libraries/WSServer/WSServer.cpp
index 47f271973..c8bf39497 100644
--- a/libraries/WSServer/WSServer.cpp
+++ b/libraries/WSServer/WSServer.cpp
@@ -18,25 +18,26 @@ struct WSServerDataHandler : seasocks::WebSocket::Handler {
 	std::shared_ptr<seasocks::Server> server;
 	std::set<seasocks::WebSocket*> connections;
 	std::string address;
-	std::function<void(std::string, void*, int)> on_receive;
-	std::function<void(std::string)> on_connect;
-	std::function<void(std::string)> on_disconnect;
+	std::function<void(const std::string&, const WSServerDetails*, const unsigned char*, size_t)> on_receive;
+	std::function<void(const std::string&, const WSServerDetails*)> on_connect;
+	std::function<void(const std::string&, const WSServerDetails*)> on_disconnect;
 	bool binary;
 	void onConnect(seasocks::WebSocket *socket) override {
 		connections.insert(socket);
-		if(on_connect)
-			on_connect(address);
+		if(on_connect) {
+			on_connect(address, (WSServerDetails*)socket);
+		}
 	}
 	void onData(seasocks::WebSocket *socket, const char *data) override {
-		on_receive(address, (void*)data, std::strlen(data));
+		on_receive(address, (WSServerDetails*)socket, (const unsigned char*)data, std::strlen(data));
 	}
 	void onData(seasocks::WebSocket *socket, const uint8_t* data, size_t size) override {
-		on_receive(address, (void*)data, size);
+		on_receive(address, (WSServerDetails*)socket, data, size);
 	}
 	void onDisconnect(seasocks::WebSocket *socket) override {
 		connections.erase(socket);
 		if (on_disconnect)
-			on_disconnect(address);
+			on_disconnect(address, (WSServerDetails*)socket);
 	}
 };
 
@@ -72,7 +73,12 @@ void WSServer::setup(int _port) {
 	server_task->schedule();
 }
 
-void WSServer::addAddress(std::string _address, std::function<void(std::string, void*, int)> on_receive, std::function<void(std::string)> on_connect, std::function<void(std::string)> on_disconnect, bool binary){
+void WSServer::addAddress(const std::string& _address,
+				std::function<void(const std::string&, const WSServerDetails*, const unsigned char*, size_t)> on_receive,
+				std::function<void(const std::string&, const WSServerDetails*)> on_connect,
+				std::function<void(const std::string&, const WSServerDetails*)> on_disconnect,
+				bool binary)
+{
 	auto handler = std::make_shared<WSServerDataHandler>();
 	handler->server = server;
 	handler->address = _address;
diff --git a/libraries/WSServer/WSServer.h b/libraries/WSServer/WSServer.h
index 5c6da38cf..38fb785d0 100644
--- a/libraries/WSServer/WSServer.h
+++ b/libraries/WSServer/WSServer.h
@@ -13,6 +13,7 @@ namespace seasocks{
 }
 class AuxTaskNonRT;
 struct WSServerDataHandler;
+class WSServerDetails;
 
 class WSServer{
 	friend struct WSServerDataHandler;
@@ -23,7 +24,11 @@ class WSServer{
 		
 		void setup(int port);
 
-		void addAddress(std::string address, std::function<void(std::string, void*, int)> on_receive = nullptr, std::function<void(std::string)> on_connect = nullptr, std::function<void(std::string)> on_disconnect = nullptr, bool binary = false);
+		void addAddress(const std::string& address,
+				std::function<void(const std::string&, const WSServerDetails*, const unsigned char*, size_t)> on_receive = nullptr,
+				std::function<void(const std::string&, const WSServerDetails*)> on_connect = nullptr,
+				std::function<void(const std::string&, const WSServerDetails*)> on_disconnect = nullptr,
+				bool binary = false);
 		
 		int sendNonRt(const char* address, const char* str);
 		int sendNonRt(const char* address, const void* buf, unsigned int size);

From 53313d414c76b638d393fe65066d2bdfb0617ddc Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 18 Jul 2023 01:06:16 +0000
Subject: [PATCH 016/188] Gui: better handle num of connections by keeping
 track of individual connection IDs

---
 examples/Gui/graph/render.cpp |  2 +-
 libraries/Gui/Gui.cpp         | 12 ++++++------
 libraries/Gui/Gui.h           |  6 +++---
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/examples/Gui/graph/render.cpp b/examples/Gui/graph/render.cpp
index a04b968dc..70bb9935d 100755
--- a/examples/Gui/graph/render.cpp
+++ b/examples/Gui/graph/render.cpp
@@ -94,7 +94,7 @@ void render(BelaContext *context, void *userData)
 		// Send data to GUI for visualisation once enough frames have elapsed
 		if(sendFramesElapsed > gSendPeriod * context->analogSampleRate) {
 			// If GUI is connected
-			if(gui.isConnected()) {
+			if(gui.numConnections()) {
 				// send buffers
 				gui.sendBuffer(0, gTimestamps);
 				gui.sendBuffer(1, gVoltage);
diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index a567a276c..092bed621 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -56,18 +56,16 @@ int Gui::setup(std::string projectName, unsigned int port, std::string address)
  * Called when websocket is connected.
  * Communication is started here with the server sending a 'connection' JSON object
  * with initial settings.
- * The client replies with 'connection-ack', which should be parsed accordingly.
+ * The client replies with 'connection-reply', which should be parsed accordingly.
  */
 void Gui::ws_connect(const std::string& address, const WSServerDetails* id)
 {
+	// TODO: this is currently sent to all clients, but it should only be sent to the new one
 	// send connection JSON
 	JSONObject root;
 	root[L"event"] = new JSONValue(L"connection");
 	if(!_projectName.empty())
 		root[L"projectName"] = new JSONValue(_projectName);
-
-	// Parse whatever needs to be parsed on connection
-
 	JSONValue *value = new JSONValue(root);
 	sendControl(value);
 	delete value;
@@ -79,7 +77,8 @@ void Gui::ws_connect(const std::string& address, const WSServerDetails* id)
  */
 void Gui::ws_disconnect(const std::string& address, const WSServerDetails* id)
 {
-	wsIsConnected = false;
+	if(wsConnections.count(id))
+		wsConnections.erase(id);
 }
 
 /*
@@ -104,7 +103,8 @@ void Gui::ws_onControlData(const std::string& address, const WSServerDetails* id
 	if (root.find(L"event") != root.end() && root[L"event"]->IsString()){
 		std::wstring event = root[L"event"]->AsString();
 		if (event.compare(L"connection-reply") == 0){
-			wsIsConnected = true;
+			if(!wsConnections.count(id))
+				wsConnections.insert(id);
 		}
 	}
 	delete value;
diff --git a/libraries/Gui/Gui.h b/libraries/Gui/Gui.h
index a83bd4b61..400984b2f 100644
--- a/libraries/Gui/Gui.h
+++ b/libraries/Gui/Gui.h
@@ -7,6 +7,7 @@
 #include <typeinfo> // for types in templates
 #include <memory>
 #include <DataBuffer.h>
+#include <set>
 
 // forward declarations
 class WSServer;
@@ -18,8 +19,7 @@ class Gui
 
 		std::vector<DataBuffer> _buffers;
 		std::unique_ptr<WSServer> ws_server;
-
-		bool wsIsConnected = false;
+		std::set<const WSServerDetails*> wsConnections;
 
 		void ws_connect(const std::string& address, const WSServerDetails* id);
 		void ws_disconnect(const std::string& address, const WSServerDetails* id);
@@ -56,7 +56,7 @@ class Gui
 		int setup(std::string projectName, unsigned int port = 5555, std::string address = "gui");
 		void cleanup();
 
-		bool isConnected(){ return wsIsConnected; };
+		size_t numConnections(){ return wsConnections.size(); };
 
 		// BUFFERS
 		/**

From 32f34fd1e8e751e234749c06f047a7bccfbbafd8 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 19 Jul 2023 19:19:04 +0000
Subject: [PATCH 017/188] WriteFile: overhaul, removed C-style string
 manipulation, any reliance on Bela or Xenomai (well ... except for
 rt_fprintf()...), using std::thread and a std::mutex to manipulate the static
 constructor and properties. It could still use use some clarity around thread
 starting/stopping

---
 libraries/WriteFile/WriteFile.cpp | 215 +++++++++++++++---------------
 libraries/WriteFile/WriteFile.h   |  44 +++---
 2 files changed, 125 insertions(+), 134 deletions(-)

diff --git a/libraries/WriteFile/WriteFile.cpp b/libraries/WriteFile/WriteFile.cpp
index 576c2b454..335f99c7b 100644
--- a/libraries/WriteFile/WriteFile.cpp
+++ b/libraries/WriteFile/WriteFile.cpp
@@ -8,34 +8,69 @@
 #include "WriteFile.h"
 #include <glob.h>		// alternative to dirent.h to handle files in dirs
 #include <stdlib.h>
+#include <thread>
+#include <pthread.h>
+#include <functional>
+#include <mutex>
+#include <algorithm>
+
 //setupialise static members
 bool WriteFile::staticConstructed=false;
-AuxiliaryTask WriteFile::writeAllFilesTask=NULL;
-std::vector<WriteFile *> WriteFile::objAddrs(0);
+std::vector<WriteFile*> WriteFile::objAddrs;
 bool WriteFile::threadRunning;
 bool WriteFile::threadScheduled;
 bool WriteFile::threadIsExiting;
-int WriteFile::sleepTimeMs;
+
+class autojointhread {
+public:
+	void setup(std::function<void(void)> fun) {
+		thread = std::thread(fun);
+	}
+	~autojointhread() {
+		if(thread.joinable())
+		{
+			thread.join();
+		}
+	}
+	pthread_t native_handle() {
+		return thread.native_handle();
+	}
+	bool joinable() {
+		return thread.joinable();
+	}
+	void join() {
+		return thread.join();
+	}
+private:
+	std::thread thread;
+};
+static autojointhread writeAllFilesThread;
+static std::mutex mutex;
 
 void WriteFile::staticConstructor(){
-	if(staticConstructed==true)
+	std::unique_lock<std::mutex> lock(mutex);
+	if(staticConstructed)
 		return;
+	// if previously running thread is exiting, wait for it
+	while(writeAllFilesThread.joinable()) {
+		lock.unlock();
+		usleep(100000);
+		lock.lock();
+	}
 	staticConstructed=true;
 	threadIsExiting=false;
 	threadRunning=false;
 	threadScheduled = false;
-	writeAllFilesTask = Bela_createAuxiliaryTask(WriteFile::run, 60, "writeAllFilesTask", NULL);
+	writeAllFilesThread.setup(&WriteFile::run);
+	sched_param sch = {};
+	sch.sched_priority = 60;
+	pthread_setschedparam(writeAllFilesThread.native_handle(), SCHED_FIFO, &sch);
 }
 
 WriteFile::WriteFile(){
-	format = NULL;
-	header = NULL;
-	footer = NULL;
-	stringBuffer = NULL;
-	_filename = NULL;
 };
 
-WriteFile::WriteFile(const char* filename, bool overwrite, bool append){
+WriteFile::WriteFile(const std::string& filename, bool overwrite, bool append){
 	setup(filename, overwrite, append);
 }
 
@@ -44,39 +79,45 @@ WriteFile::~WriteFile(){
 }
 
 void WriteFile::cleanup(){
-	// this will disable all instances when
-	// you destroy the first one, but at least it's safe
+	std::unique_lock<std::mutex> lock(mutex);
+	//write all that's left
+	writeOutput(true);
+	writeFooter();
+	fflush(file);
+	fclose(file);
+	// remove from objAddrs list
+	auto it = std::find(objAddrs.begin(), objAddrs.end(), this);
+	if(it != objAddrs.end())
+		objAddrs.erase(it);
+	if(objAddrs.size())
+		return;
+	// if there are no instances left, stop the thread
 	stopThread();
-	while(threadRunning)
-		usleep(100000);
-	free(format);
-	free(header);
-	free(footer);
-	free(stringBuffer);
-	free(_filename);
+	staticConstructed = false;
+	lock.unlock();
+	// let the thread run to completion
+	if(writeAllFilesThread.joinable())
+		writeAllFilesThread.join();
 }
 
-char* WriteFile::generateUniqueFilename(const char* original)
+std::string WriteFile::generateUniqueFilename(const std::string& original)
 {
-	int originalLen = strlen(original);
+	int originalLen = original.size();
 
-	// search for a dot in the file (from the end)
+	// search for a dot in the file name (from the end)
 	int dot = originalLen;
 	for(int n = dot; n >= 0; --n)
 	{
 		if(original[n] == '.')
 			dot = n;
 	}
-	char temp[originalLen + 2];
 	int count = dot;
-	snprintf(temp, count + 1, "%s", original);
 	// add a * before the dot
-	count += sprintf(temp + count, "*") - 1;
-	count += sprintf(temp + count + 1, "%s", original + dot);
+	std::string temp = std::string({original.begin(), original.begin() + dot}) + "*" + std::string({original.begin() + dot, original.end()});
 
 	// check how many log files are already there, and choose name according to this
 	glob_t globbuf;
-	glob(temp, 0, NULL, &globbuf);
+	glob(temp.c_str(), 0, NULL, &globbuf);
 
 	int logNum;
 	int logMax = -1;
@@ -91,51 +132,44 @@ char* WriteFile::generateUniqueFilename(const char* original)
 	if(logMax == -1)
 	{
 		// use the same filename
-		char* out = (char*)malloc(sizeof(char) * (originalLen +1));
-		strcpy(out, original);
-		return out;
+		return original;
 	} else {
 		// generate a new filename
 		logNum = logMax + 1;	// new index
-		count = snprintf(NULL, 0, "%d", logNum);
-		char* out = (char*)malloc(sizeof(char) * (count + originalLen + 1));
-		count = dot;
-		snprintf(out, count + 1, "%s", original);
-		count += sprintf(out + count, "%d", logNum) - 1;
-		count += sprintf(out + count + 1, "%s", original + dot);
-		printf("File %s exists, writing to %s instead\n", original, out);
+		std::string out = std::string({original.begin(), original.begin() + dot}) + std::to_string(logNum) + std::string({original.begin() + dot, original.end()});
+		printf("File %s exists, writing to %s instead\n", original.c_str(), out.c_str());
 		return out;
 	}
 }
 
-void WriteFile::setup(const char* filename, bool overwrite, bool append){
+void WriteFile::setup(const std::string& newFilename, bool overwrite, bool append){
+	filename = newFilename;
 	if(!overwrite)
 	{
-		_filename = generateUniqueFilename(filename);
-		file = fopen(_filename, "w");
+		filename = generateUniqueFilename(filename);
+		file = fopen(filename.c_str(), "w");
 	} else {
-		printf("Overwrite %s\n", filename);
-		_filename = (char*)malloc(sizeof(char) * (strlen(filename) + 1));
+		printf("Overwrite %s\n", filename.c_str());
 		if(!append)
 		{
-			file = fopen(filename, "w");
+			file = fopen(filename.c_str(), "w");
 		} else {
-			file = fopen(filename, "a");
+			file = fopen(filename.c_str(), "a");
 		}
 	}
-	variableOpen = false;
+	fileType = kBinary;
 	lineLength = 0;
 	setEcho(false);
 	textReadPointer = 0;
 	binaryReadPointer = 0;
 	writePointer = 0;
-	sleepTimeMs = 1;
-	stringBufferLength = 1000;
-	stringBuffer = (char*)malloc(sizeof(char) * (stringBufferLength));
+	stringBuffer.resize(1000);
 	setHeader("variable=[\n");
 	setFooter("];\n");
-	staticConstructor(); //TODO: this line should be in the constructor, but cannot be because of a bug in Bela
+	staticConstructor();
+	mutex.lock();
 	objAddrs.push_back(this);
+	mutex.unlock();
 	echoedLines = 0;
 	echoPeriod = 1;
 }
@@ -161,16 +195,17 @@ void WriteFile::setBufferSize(unsigned int newSize)
 	buffer.resize(newSize);
 }
 
-void WriteFile::print(const char* string){
+void WriteFile::print(const std::string& string){
+	return;
 	if(echo == true){
 		echoedLines++;
 		if (echoedLines >= echoPeriod){
 			echoedLines = 0;
-			printf("%s", string);
+			printf("%s", string.c_str());
 		}
 	}
 	if(file != NULL && fileType != kBinary){
-		fprintf(file, "%s", string);
+		fprintf(file, "%s", string.c_str());
 	}
 }
 
@@ -178,15 +213,15 @@ void WriteFile::writeLine(){
 	if(echo == true || fileType != kBinary){
 		int stringBufferPointer = 0;
 		for(unsigned int n = 0; n < formatTokens.size(); n++){
-			int numOfCharsWritten = snprintf( &stringBuffer[stringBufferPointer], stringBufferLength - stringBufferPointer,
-								formatTokens[n], buffer[textReadPointer]);
+			int numOfCharsWritten = snprintf( &stringBuffer[stringBufferPointer], stringBuffer.size() - stringBufferPointer,
+								formatTokens[n].c_str(), buffer[textReadPointer]);
 			stringBufferPointer += numOfCharsWritten;
 			textReadPointer++;
 			if(textReadPointer >= buffer.size()){
 				textReadPointer -= buffer.size();
 			}
 		}
-		print(stringBuffer);
+		print({stringBuffer.begin(), stringBuffer.begin() + strlen(stringBuffer.data())});
 	}
 }
 
@@ -197,7 +232,7 @@ void WriteFile::setLineLength(int newLineLength){
 }
 
 void WriteFile::log(float value){
-	if(fileType != kBinary && (format == NULL || buffer.size() == 0))
+	if(fileType != kBinary && (!format.size() || !buffer.size()))
 		return;
 	buffer[writePointer] = value;
 	writePointer++;
@@ -206,7 +241,7 @@ void WriteFile::log(float value){
 	}
 	if((fileType == kText && writePointer == textReadPointer - 1) ||
 			(fileType == kBinary && writePointer == binaryReadPointer - 1)){
-		rt_fprintf(stderr, "WriteFile: %s pointers crossed, you should probably slow down your writing to disk\n", _filename);
+		rt_fprintf(stderr, "WriteFile: %s pointers crossed, you should probably slow down your writing to disk\n", filename.c_str());
 	}
 	if(threadScheduled == false){
 		startThread();
@@ -219,15 +254,11 @@ void WriteFile::log(const float* array, int length){
 	}
 }
 
-void WriteFile::setFormat(const char* newFormat){
-	allocateAndCopyString(newFormat, &format);
-	for(unsigned int n = 0; n < formatTokens.size(); n++){
-		free(formatTokens[n]);
-	}
+void WriteFile::setFormat(const std::string& format){
 	formatTokens.clear();
 	int tokenStart = 0;
 	bool firstToken = true;
-	for(unsigned int n = 0; n < strlen(format)+1; n++){
+	for(unsigned int n = 0; n < format.size() + 1; n++){
 		if(format[n] == '%' && format[n + 1] == '%'){
 			n++;
 		} else if (format[n] == '%' || format[n] == 0){
@@ -235,15 +266,10 @@ void WriteFile::setFormat(const char* newFormat){
 				firstToken = false;
 				continue;
 			}
-			char* string;
 			unsigned int tokenLength = n - tokenStart;
 			if(tokenLength == 0)
 				continue;
-			string = (char*)malloc((1+tokenLength)*sizeof(char));
-			for(unsigned int i = 0; i < tokenLength; i++){
-				string[i] = format[tokenStart + i];
-			}
-			string[tokenLength] = 0;
+			std::string string = {format.begin() + tokenStart, format.begin() + tokenStart + tokenLength};
 			formatTokens.push_back(string);
 			tokenStart = n;
 		}
@@ -257,7 +283,6 @@ int WriteFile::getNumInstances(){
 
 void WriteFile::startThread(){
 	threadScheduled = true;
-	Bela_scheduleAuxiliaryTask(writeAllFilesTask);
 }
 
 void WriteFile::stopThread(){
@@ -265,7 +290,7 @@ void WriteFile::stopThread(){
 }
 
 bool WriteFile::threadShouldExit(){
-	return(Bela_stopRequested() || threadIsExiting);
+	return threadIsExiting;
 }
 
 bool WriteFile::isThreadRunning(){
@@ -327,65 +352,39 @@ void WriteFile::writeOutput(bool flush){
 }
 
 void WriteFile::writeAllOutputs(bool flush){
+	std::lock_guard<std::mutex> lock(mutex);
 	for(unsigned int n = 0; n < objAddrs.size(); n++){
 		objAddrs[n] -> writeOutput(flush);
 	}
 }
 
-void WriteFile::writeAllHeaders(){
-	for(unsigned int n = 0; n < objAddrs.size(); n++){
-		objAddrs[n] -> writeHeader();
-	}
-}
-
-void WriteFile::writeAllFooters(){
-	for(unsigned int n = 0; n < objAddrs.size(); n++){
-		objAddrs[n] -> writeFooter();
-	}
-}
-
 void WriteFile::writeHeader(){
 	print(header);
 }
 
 void WriteFile::writeFooter(){
 	print(footer);
-	fflush(file);
-	fclose(file);
 }
 
-void WriteFile::setHeader(const char* newHeader){
-	allocateAndCopyString(newHeader, &header);
-	sanitizeString(header);
+void WriteFile::setHeader(const std::string& newHeader){
+	header = sanitizeString(newHeader);
 }
 
-void WriteFile::setFooter(const char* newFooter){
-	allocateAndCopyString(newFooter, &footer);
+void WriteFile::setFooter(const std::string& newFooter){
+	footer = sanitizeString(newFooter);
 }
 
-void WriteFile::sanitizeString(char* string){
-	for(int unsigned n = 0; n < strlen(string); n++){ //purge %'s from the string
-		if(string[n] == '%'){
-			string[n] = ' ';
-		}
-	}
+std::string WriteFile::sanitizeString(const std::string& string){
+	std::string ret = string;
+	std::replace(ret.begin(), ret.end(), '%', ' ');
+	return ret;
 }
 
-void WriteFile::run(void* arg){
+void WriteFile::run(){
 	threadRunning = true;
-	printf("Running\n");
-	writeAllHeaders();
 	while(threadShouldExit()==false){
 		writeAllOutputs(false);
 		usleep(sleepTimeMs*1000);
 	}
-	writeAllOutputs(true);
-	writeAllFooters(); // when ctrl-c is pressed, the last line is closed and the file is closed
 	threadRunning = false;
 }
-
-void WriteFile::allocateAndCopyString(const char* source, char** destination){
-	free(*destination);
-	*destination = (char*)malloc(sizeof(char) * (strlen(source) + 1));
-	strcpy(*destination, source);
-}
diff --git a/libraries/WriteFile/WriteFile.h b/libraries/WriteFile/WriteFile.h
index 86dcbe690..2a67fe81f 100644
--- a/libraries/WriteFile/WriteFile.h
+++ b/libraries/WriteFile/WriteFile.h
@@ -13,6 +13,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <string>
 
 typedef enum {
 	kBinary,
@@ -21,38 +22,31 @@ typedef enum {
 
 class WriteFile {
 private:
-	static AuxiliaryTask writeAllFilesTask;
-	bool echo;
 	int echoedLines;
 	int echoPeriod;
-	char *header;
-	char *footer;
-	char *stringBuffer;
-	int stringBufferLength;
+	std::string header;
+	std::string footer;
+	std::vector<char> stringBuffer;
 	std::vector<float> buffer;
 	int textReadPointer;
 	int binaryReadPointer;
 	int writePointer;
-	bool variableOpen;
-	char* format;
+	std::string format;
 	int lineLength;
 	WriteFileType fileType;
-	static int sleepTimeMs;
 	FILE *file;
-	char* _filename;
+	std::string filename;
+	std::vector<std::string> formatTokens;
+	bool echo;
+	static constexpr size_t sleepTimeMs = 5;
 	void writeLine();
 	void writeHeader();
 	void writeFooter();
-	void allocateAndCopyString(const char* source, char** destination);
-	void print(const char* string);
-	void printBinary(const char* string);
+	void print(const std::string& string);
 	void setLineLength(int newLineLength);
 	int getOffsetFromPointer(int aPointer);
-	std::vector<char *> formatTokens;
-	static void sanitizeString(char* string);
-	static void sanitizeString(char* string, int numberOfArguments);
+	static std::string sanitizeString(const std::string& string);
 	static bool isThreadRunning();
-	static bool auxiliaryTaskRunning;
 	static bool threadShouldExit();
 	static bool threadIsExiting;
 	static bool threadRunning;
@@ -63,7 +57,7 @@ class WriteFile {
 	void writeOutput(bool flush);
 public:
 	WriteFile();
-	WriteFile(const char* filename, bool overwrite, bool append);
+	WriteFile(const std::string& filename, bool overwrite, bool append);
 
 	/**
 	 * Set the type of file to write, can be either kText or kBinary.
@@ -100,19 +94,19 @@ class WriteFile {
 	 * Only %f is allowed (with modifiers). When in binary mode,
 	 * the specified format is used only for echoing to console.
 	 */
-	void setFormat(const char* newFormat);
+	void setFormat(const std::string& newFormat);
 	/**
 	 * Set one or more lines to be printed at the beginning of the file.
 	 *
 	 * This is ignored in binary mode.
 	 */
-	void setHeader(const char* newHeader);
+	void setHeader(const std::string& newHeader);
 	/**
 	 * Set one or more lines to be printed at the end of the file.
 	 *
 	 * This is ignored in binary mode.
 	 */
-	void setFooter(const char* newFooter);
+	void setFooter(const std::string& newFooter);
 
 	/**
 	 * Log one value to the file.
@@ -129,7 +123,7 @@ class WriteFile {
 	 * If `overwrite` is false, existing files will not be overwritten
 	 * and the filename will be automatically incremented.
 	 */
-	void setup(const char* filename, bool overwrite = false, bool append = false);
+	void setup(const std::string& filename, bool overwrite = false, bool append = false);
 
 	/**
 	 * Gets the distance between the write and read pointers of
@@ -147,12 +141,10 @@ class WriteFile {
 	void cleanup();
 	~WriteFile();
 	static int getNumInstances();
-	static void writeAllHeaders();
-	static void writeAllFooters();
 	static void writeAllOutputs(bool flush);
 	static void startThread();
 	static void stopThread();
-	static void run(void*);
+	static void run();
 	/**
 	 * Returns a unique filename by appending a number at the end of the original
 	 * filename.
@@ -160,7 +152,7 @@ class WriteFile {
 	 * @return a pointer to the unique filename. This MUST be freed by the
 	 * invoking function.
 	 */
-	static char* generateUniqueFilename(const char* original);
+	static std::string generateUniqueFilename(const std::string& original);
 };
 
 #endif /* WRITEFILE_H_ */

From 378a88a7c3d58db7e8b9378a931bd4fde4bcecc7 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 19 Jul 2023 19:51:51 +0000
Subject: [PATCH 018/188] PRU: cleared up cleanup, factored out to its own
 method, also assume it is idempotent. Fixed a couple uninitialised values.
 Thanks valgrind

---
 core/PRU.cpp     | 57 ++++++++++++++++++++----------------------------
 core/RTAudio.cpp |  1 -
 include/PRU.h    |  1 +
 3 files changed, 25 insertions(+), 34 deletions(-)

diff --git a/core/PRU.cpp b/core/PRU.cpp
index 25ab71673..8aa5ac196 100644
--- a/core/PRU.cpp
+++ b/core/PRU.cpp
@@ -218,6 +218,7 @@ PRU::PRU(InternalBelaContext *input_context)
   digital_enabled(false), gpio_enabled(false), led_enabled(false),
   analog_out_is_audio(false), pru_audio_out_channels(0),
   pru_buffer_comm(0),
+  last_analog_out_frame(0), last_digital_buffer(0),
   audio_expander_input_history(0), audio_expander_output_history(0),
   audio_expander_filter_coeff(0), pruUsesMcaspIrq(false), belaHw(BelaHw_NoHw)
 {
@@ -230,12 +231,7 @@ PRU::~PRU()
 		disable();
 	exitPRUSS();
 	delete pruMemory;
-	if(gpio_enabled)
-		cleanupGPIO();
-	if(audio_expander_input_history != 0)
-		free(audio_expander_input_history);
-	if(audio_expander_output_history != 0)
-		free(audio_expander_output_history);
+	cleanup();
 }
 
 // Prepare the GPIO pins needed for the PRU
@@ -343,12 +339,12 @@ void PRU::cleanupGPIO()
 	if(digital_enabled){
 		for(unsigned int i = 0; i < context->digitalChannels; i++){
 			if(belaHw == BelaHw_Salt) {
-				if(gDigitalPins[i] == saltSwitch1Gpio)
+				if(gDigitalPins && gDigitalPins[i] == saltSwitch1Gpio)
 					continue; // leave alone this pin as it is used by bela_button.service
 			}
 			if(disabledDigitalChannels & (1 << i))
 				continue; // leave alone this pin because the user asked for it
-			if(gpio_unexport(gDigitalPins[i]))
+			if(gDigitalPins && gpio_unexport(gDigitalPins[i]))
 			{
 				// if unexport fails, we at least turn off the outputs
 				gpio_set_dir(gDigitalPins[i], OUTPUT_PIN);
@@ -377,6 +373,7 @@ void PRU::cleanupGPIO()
 // Initialise and open the PRU
 int PRU::initialise(BelaHw newBelaHw, int pru_num, bool uniformSampleRate, int mux_channels, int stopButtonPin, bool enableLed, uint32_t disabledDigitalChannels)
 {
+	cleanup();
 	this->disabledDigitalChannels = disabledDigitalChannels;
 	belaHw = newBelaHw;
 	if(BelaHw_BelaRevC == belaHw)
@@ -1602,35 +1599,29 @@ void PRU::loop(void *userData, void(*render)(BelaContext*, void*), bool highPerf
 
 	// Wait for the PRU to finish
 	task_sleep_ns(100000000);
+}
 
-	// Clean up after ourselves
+void PRU::cleanup()
+{
+	cleanupGPIO();
 	free(context->audioIn);
+	context->audioIn = 0;
 	free(context->audioOut);
-
-	if(analog_enabled) {
-		free(context->analogIn);
-		free(context->analogOut);
-		free(last_analog_out_frame);
-		if(context->multiplexerAnalogIn != 0)
-			free(context->multiplexerAnalogIn);
-		if(audio_expander_input_history != 0) {
-			free(audio_expander_input_history);
-			audio_expander_input_history = 0;
-		}
-		if(audio_expander_output_history != 0) {
-			free(audio_expander_output_history);
-			audio_expander_output_history = 0;
-		}
-	}
-
-	if(digital_enabled) {
-		free(last_digital_buffer);
-	}
-
-	context->audioIn = context->audioOut = 0;
-	context->analogIn = context->analogOut = 0;
-	context->digital = 0;
+	context->audioOut = 0;
+	free(context->analogIn);
+	context->analogIn = 0;
+	free(context->analogOut);
+	context->analogOut = 0;
+	free(last_analog_out_frame);
+	last_analog_out_frame = 0;
+	free(context->multiplexerAnalogIn);
 	context->multiplexerAnalogIn = 0;
+	free(audio_expander_input_history);
+	audio_expander_input_history = 0;
+	free(audio_expander_output_history);
+	audio_expander_output_history = 0;
+	free(last_digital_buffer);
+	last_digital_buffer = 0;
 }
 
 // Wait for an interrupt from the PRU indicate it is finished
diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 0def82ad6..147adc266 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -822,7 +822,6 @@ void audioLoop(void *)
 	// gPRU->waitForFinish();
 	gPRU->disable();
 	gAudioCodec->stopAudio();
-	gPRU->cleanupGPIO();
 
 	if(gBelaAudioThreadDone)
 		gBelaAudioThreadDone(gUserContext, gUserData);
diff --git a/include/PRU.h b/include/PRU.h
index 1dfc0a2ec..cb7d27e59 100644
--- a/include/PRU.h
+++ b/include/PRU.h
@@ -171,6 +171,7 @@ class PRU
 	// Loop: read and write data from the PRU and call the user-defined audio callback
 	void loop(void *userData, void(*render)(BelaContext*, void*), bool highPerformanceMode, BelaCpuData* cpuData);
 
+	void cleanup();
 	// Wait for an interrupt from the PRU indicate it is finished
 	void waitForFinish();
 

From 2cd6c718c284c0c2388e3e9b8e30d451a38fb112 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 19 Jul 2023 19:52:27 +0000
Subject: [PATCH 019/188] RTAudio: if exiting early because of error in
 setup(), ensure we clean up after ourselves

---
 core/RTAudio.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 147adc266..b14bb8aab 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -794,6 +794,10 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 	if(settings->setup && !(*settings->setup)(gUserContext, userData)) {
 		if(gRTAudioVerbose)
 			fprintf(stderr, "Couldn't initialise audio rendering: setup() returned false\n");
+		delete gPRU;
+		delete gAudioCodec;
+		delete gDisabledCodec;
+		delete gBcf;
 		return 1;
 	}
 

From fbdff0ca08e1ebf6399f23c52590b2d909014dc0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 19 Jul 2023 20:12:41 +0000
Subject: [PATCH 020/188] GPIOcontrol: gpio_export(): close fd only if it's
 valid, not the other way around

---
 core/GPIOcontrol.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/GPIOcontrol.cpp b/core/GPIOcontrol.cpp
index 5c2dc7089..bfe0e4e55 100644
--- a/core/GPIOcontrol.cpp
+++ b/core/GPIOcontrol.cpp
@@ -73,9 +73,9 @@ int gpio_export(unsigned int gpio)
 	len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d", gpio);
 	fd = open(buf, O_RDONLY);
 	if(fd > 0) {
+		close(fd);
 		return 0;
 	}
-	close(fd);
 	fd = open(SYSFS_GPIO_DIR "/export", O_WRONLY);
 	if (fd < 0) {
 		perror("gpio/export");

From 6ccb4ad35388ea36084cf6b906f877a16b69c37e Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 20 Jul 2023 20:28:42 +0000
Subject: [PATCH 021/188] WSServer: do _not_ store a shared_ptr to the server
 on the handler, or the ref count of neither will ever reach zero and
 destructors won't be called

---
 libraries/WSServer/WSServer.cpp | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/libraries/WSServer/WSServer.cpp b/libraries/WSServer/WSServer.cpp
index c8bf39497..9d3470dde 100644
--- a/libraries/WSServer/WSServer.cpp
+++ b/libraries/WSServer/WSServer.cpp
@@ -15,7 +15,6 @@ WSServer::~WSServer(){
 }
 
 struct WSServerDataHandler : seasocks::WebSocket::Handler {
-	std::shared_ptr<seasocks::Server> server;
 	std::set<seasocks::WebSocket*> connections;
 	std::string address;
 	std::function<void(const std::string&, const WSServerDetails*, const unsigned char*, size_t)> on_receive;
@@ -46,19 +45,19 @@ void WSServer::client_task_func(std::shared_ptr<WSServerDataHandler> handler, co
 		// make a copy of the data before we send it out
 		auto data = std::make_shared<std::vector<void*> >(size);
 		memcpy(data->data(), buf, size);
-		handler->server->execute([handler, data, size]{
-			for (auto c : handler->connections){
+		for (auto c : handler->connections){
+			c->server().execute([data, size, c]{
 				c->send((uint8_t*) data->data(), size);
-			}
-		});
+			});
+		}
 	} else {
 		// make a copy of the data before we send it out
 		std::string str = (const char*)buf;
-		handler->server->execute([handler, str]{
-			for (auto c : handler->connections){
+		for (auto c : handler->connections){
+			c->server().execute([str, c]{
 				c->send(str.c_str());
-			}
-		});
+			});
+		}
 	}
 }
 
@@ -80,7 +79,6 @@ void WSServer::addAddress(const std::string& _address,
 				bool binary)
 {
 	auto handler = std::make_shared<WSServerDataHandler>();
-	handler->server = server;
 	handler->address = _address;
 	handler->on_receive = on_receive;
 	handler->on_connect = on_connect;

From 80862edab87ee20076021c781a043ae5e4107243 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 20 Jul 2023 20:32:24 +0000
Subject: [PATCH 022/188] WSServer: avoid possible future pitfalls by capturing
 weak_ptr instead of shared_ptr. See
 https://floating.io/2017/07/lambda-shared_ptr-memory-leak/ for reasoning.
 This was not an immediate issue, but worth avoiding future issues and it
 makes more sense to have the shared_ptr for _managing_ objects and the
 weak_ptr for _using_ them

---
 libraries/WSServer/WSServer.cpp | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/libraries/WSServer/WSServer.cpp b/libraries/WSServer/WSServer.cpp
index 9d3470dde..5d365de73 100644
--- a/libraries/WSServer/WSServer.cpp
+++ b/libraries/WSServer/WSServer.cpp
@@ -40,7 +40,10 @@ struct WSServerDataHandler : seasocks::WebSocket::Handler {
 	}
 };
 
+// this is either called directly from sendNonRt(), or via callback when scheduled from sendRt()
 void WSServer::client_task_func(std::shared_ptr<WSServerDataHandler> handler, const void* buf, unsigned int size){
+	if(!handler)
+		return;
 	if (handler->binary){
 		// make a copy of the data before we send it out
 		auto data = std::make_shared<std::vector<void*> >(size);
@@ -90,7 +93,16 @@ void WSServer::addAddress(const std::string& _address,
 		.thread = std::unique_ptr<AuxTaskNonRT>(new AuxTaskNonRT()),
 		.handler = handler,
 	};
-	address_book[_address].thread->create(std::string("WSClient_")+_address, [this, handler](void* buf, int size){ client_task_func(handler, buf, size); });
+	// do _not_ capture a shared_ptr in a lambda.
+	// See possible pitfalls here
+	// https://floating.io/2017/07/lambda-shared_ptr-memory-leak/
+	std::weak_ptr<WSServerDataHandler> wkHdl(handler);
+	address_book[_address].thread->create(std::string("WSClient_")+_address,
+		[this,wkHdl](void* buf, int size){
+			auto handler = wkHdl.lock();
+			if(handler)
+				client_task_func(handler, buf, size);
+		});
 }
 
 int WSServer::sendNonRt(const char* _address, const char* str) {

From b096836613498d5ae09f92ca990ab6b015ea099f Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 20 Jul 2023 21:00:48 +0000
Subject: [PATCH 023/188] Gui: ensure the last ws_disconnect is called while
 the object (and its members) are still valid

---
 libraries/Gui/Gui.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index 092bed621..2181fb3a0 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -170,6 +170,9 @@ DataBuffer& Gui::getDataBuffer( unsigned int bufferId )
 Gui::~Gui()
 {
 	cleanup();
+	// trigger the destruction of the server so that ws_disconnect is called
+	// while the object is still valid
+	ws_server.reset();
 }
 void Gui::cleanup()
 {

From 753df1fec4299575dc82b05ac9e93f732db68c8e Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Jul 2023 20:09:06 +0000
Subject: [PATCH 024/188] AuxTask{Non,}RT: hardened by removing mallocs

---
 core/AuxTaskNonRT.cpp | 18 ++++++++----------
 core/AuxTaskRT.cpp    | 13 +++++++------
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index 83420750a..837573c75 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -5,6 +5,7 @@
 #include <fcntl.h>
 #include <stdlib.h>
 #include <errno.h>
+#include <vector>
 
 extern int volatile gRTAudioVerbose;
 
@@ -144,30 +145,28 @@ int AuxTaskNonRT::openPipe(){
 }
 
 void AuxTaskNonRT::empty_loop(){
-	void* buf = malloc(1);
+	char c;
 	while(!shouldStop()){
-		read(pipe_fd, buf, 1);
+		read(pipe_fd, &c, sizeof(c));
 		if (shouldStop())
 			break;
 		empty_callback();
 	}
-	free(buf);
 }
 void AuxTaskNonRT::str_loop(){
-	void* buf = malloc(AUX_MAX_BUFFER_SIZE);
-	memset(buf, 0, AUX_MAX_BUFFER_SIZE);
+	std::vector<char> buffer(AUX_MAX_BUFFER_SIZE);
+	char* buf = buffer.data();
 	while(!shouldStop()){
 		ssize_t size = read(pipe_fd, buf, AUX_MAX_BUFFER_SIZE);
 		if (shouldStop())
 			break;
-		str_callback(std::string((const char*)buf));
+		str_callback(std::string(buf));
 		memset(buf, 0, size);
 	}
-	free(buf);
 }
 void AuxTaskNonRT::buf_loop(){
-	void* buf = malloc(AUX_MAX_BUFFER_SIZE);
-	memset(buf, 0, AUX_MAX_BUFFER_SIZE);
+	std::vector<char> buffer(AUX_MAX_BUFFER_SIZE);
+	char* buf = buffer.data();
 	while(!shouldStop()){
 		ssize_t size = read(pipe_fd, buf, AUX_MAX_BUFFER_SIZE);
 		if (shouldStop())
@@ -175,7 +174,6 @@ void AuxTaskNonRT::buf_loop(){
 		buf_callback(buf, size);
 		memset(buf, 0, size);
 	}
-	free(buf);
 }
 
 void AuxTaskNonRT::thread_func(void* ptr){
diff --git a/core/AuxTaskRT.cpp b/core/AuxTaskRT.cpp
index 62c21b5d7..326352397 100644
--- a/core/AuxTaskRT.cpp
+++ b/core/AuxTaskRT.cpp
@@ -3,6 +3,7 @@
 #include "../include/xenomai_wraps.h"
 #include <Bela.h>
 #include <stdlib.h>
+#include <vector>
 
 extern int volatile gRTAudioVerbose;
 
@@ -138,7 +139,8 @@ void AuxTaskRT::empty_loop(){
 	}
 #endif
 #ifdef XENOMAI_SKIN_posix
-	char* buffer = (char*)malloc(AUX_RT_POOL_SIZE);
+	std::vector<char> buf(AUX_RT_POOL_SIZE);
+	char* buffer = buf.data();
 	while(!shouldStop())
 	{
 		unsigned int prio;
@@ -152,7 +154,6 @@ void AuxTaskRT::empty_loop(){
 			empty_callback();
 		}
 	}
-	free(buffer);
 #endif
 }
 void AuxTaskRT::str_loop(){
@@ -166,7 +167,8 @@ void AuxTaskRT::str_loop(){
 	}
 #endif
 #ifdef XENOMAI_SKIN_posix
-	char* buffer = (char*)malloc(AUX_RT_POOL_SIZE);
+	std::vector<char> buf(AUX_RT_POOL_SIZE);
+	char* buffer = buf.data();
 	while(!shouldStop())
 	{
 		unsigned int prio;
@@ -179,7 +181,6 @@ void AuxTaskRT::str_loop(){
 		if(!shouldStop())
 			str_callback((std::string)buffer);
 	}
-	free(buffer);
 #endif
 }
 void AuxTaskRT::buf_loop(){
@@ -193,7 +194,8 @@ void AuxTaskRT::buf_loop(){
 	}
 #endif
 #ifdef XENOMAI_SKIN_posix
-	char* buffer = (char*)malloc(AUX_RT_POOL_SIZE);
+	std::vector<char> buf(AUX_RT_POOL_SIZE);
+	char* buffer = buf.data();
 	while(!shouldStop())
 	{
 		unsigned int prio;
@@ -206,7 +208,6 @@ void AuxTaskRT::buf_loop(){
 		if(!shouldStop())
 			buf_callback((void*)buffer, ret);
 	}
-	free(buffer);
 #endif
 }
 

From c5eed1d3b405f7a130323eed4277b733196a5c26 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Jul 2023 20:11:07 +0000
Subject: [PATCH 025/188] Scope: removed some memory leaks

---
 libraries/Scope/Scope.cpp | 10 +++++-----
 libraries/Scope/Scope.h   |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index 28829b099..bef67c26a 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -550,8 +550,8 @@ void Scope::scope_control_connected(){
 	for (auto setting : settings){
 		root[setting.first] = new JSONValue(setting.second);
 	}
-	JSONValue *value = new JSONValue(root);
-	std::wstring wide = value->Stringify().c_str();
+	JSONValue value(root);
+	std::wstring wide = value.Stringify().c_str();
 	std::string str( wide.begin(), wide.end() );
 	// printf("sending JSON: \n%s\n", str.c_str());
 	ws_server->sendNonRt("scope_control", str.c_str());
@@ -564,8 +564,8 @@ void Scope::scope_control_data(const char* data){
 	// printf("recieved: %s\n", data);
 	
 	// parse the data into a JSONValue
-	JSONValue *value = JSON::Parse(data);
-	if (value == NULL || !value->IsObject()){
+	std::shared_ptr<JSONValue> value = std::shared_ptr<JSONValue>(JSON::Parse(data));
+	if (!value || !value->IsObject()){
 		printf("could not parse JSON:\n%s\n", data);
 		return;
 	}
@@ -585,7 +585,7 @@ void Scope::scope_control_data(const char* data){
 	parse_settings(value);
 }
 
-void Scope::parse_settings(JSONValue* value){
+void Scope::parse_settings(std::shared_ptr<JSONValue> value){
 	// printf("parsing settings\n");
 	std::vector<std::wstring> keys = value->ObjectKeys();
 	for (auto& key : keys){
diff --git a/libraries/Scope/Scope.h b/libraries/Scope/Scope.h
index 5e7268073..8e46fd89d 100644
--- a/libraries/Scope/Scope.h
+++ b/libraries/Scope/Scope.h
@@ -101,7 +101,7 @@ class Scope{
         void setXParams();
         void scope_control_connected();
         void scope_control_data(const char* data);
-        void parse_settings(JSONValue* value);
+        void parse_settings(std::shared_ptr<JSONValue> value);
         
 	bool volatile isUsingOutBuffer;
 	bool volatile isUsingBuffer;

From 8a195b3117a4e8f13997da2f6ac9adaa5d764425 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Jul 2023 21:39:57 +0000
Subject: [PATCH 026/188] Scope: do not call disconnect callback on a destroyed
 object

---
 libraries/Scope/Scope.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index bef67c26a..b8d7421e0 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -25,6 +25,10 @@ Scope::Scope(unsigned int numChannels, float sampleRate){
 
 void Scope::cleanup(){
 	dealloc();
+	// ensure that all connections are closed before
+	// destroying the object, so we avoid calling the disconnect callback
+	// after the Scope object has been destroyed
+	ws_server.reset();
 }
 Scope::~Scope(){
 	cleanup();

From 14e7e940ed38fca40837e668f448f93d506ce5b4 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Jul 2023 21:54:21 +0000
Subject: [PATCH 027/188] WSServer: do not capture connection in the lambda for
 execution on the server thread as it may become stale by the time the
 callback is executed. Instead, use the same weak_ptr approach used elsewhere.
 Also, use the same procedure where possible for sending binary or string.

---
 libraries/WSServer/WSServer.cpp | 36 ++++++++++++++++++---------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/libraries/WSServer/WSServer.cpp b/libraries/WSServer/WSServer.cpp
index 5d365de73..24949680b 100644
--- a/libraries/WSServer/WSServer.cpp
+++ b/libraries/WSServer/WSServer.cpp
@@ -44,21 +44,25 @@ struct WSServerDataHandler : seasocks::WebSocket::Handler {
 void WSServer::client_task_func(std::shared_ptr<WSServerDataHandler> handler, const void* buf, unsigned int size){
 	if(!handler)
 		return;
-	if (handler->binary){
-		// make a copy of the data before we send it out
-		auto data = std::make_shared<std::vector<void*> >(size);
-		memcpy(data->data(), buf, size);
-		for (auto c : handler->connections){
-			c->server().execute([data, size, c]{
-				c->send((uint8_t*) data->data(), size);
-			});
-		}
-	} else {
-		// make a copy of the data before we send it out
-		std::string str = (const char*)buf;
-		for (auto c : handler->connections){
-			c->server().execute([str, c]{
-				c->send(str.c_str());
+	// make a copy of the data before we send it out
+	if(handler->connections.size())
+	{
+			// make a copy of input data
+			auto data = std::make_shared<std::vector<void*> >(size);
+			memcpy(data->data(), buf, size);
+			std::weak_ptr<WSServerDataHandler> wkHdl(handler);
+			// schedule execution on the seasocks thread
+			// passing in a weak_ptr
+			(*handler->connections.begin())->server().execute([data, size, wkHdl]{
+				auto handler = wkHdl.lock();
+				if(!handler)
+					return;
+				for (auto c : handler->connections){
+					if(handler->binary)
+						c->send((uint8_t*) data->data(), size);
+					else
+						c->send((const char*)data->data());
+				}
 			});
 		}
 	}
@@ -106,7 +110,7 @@ void WSServer::addAddress(const std::string& _address,
 }
 
 int WSServer::sendNonRt(const char* _address, const char* str) {
-	return sendNonRt(_address, (const void*)str, strlen(str));
+	return sendNonRt(_address, (const void*)str, strlen(str) + 1);
 }
 
 int WSServer::sendNonRt(const char* _address, const void* buf, unsigned int size) {

From a154fb8fef52358c2f74df50ff09ff91163c8213 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Jul 2023 22:50:18 +0000
Subject: [PATCH 028/188] WSServer: when calling sendNonRt(), allow to specify
 if calling directly from the same thread as the callback. This allows to
 avoid allocation and copy as the send can be executed immediately instead of
 postponed in a lambda.

---
 libraries/Gui/Gui.cpp           |  6 +++---
 libraries/Gui/Gui.h             |  5 ++---
 libraries/Scope/Scope.cpp       |  2 +-
 libraries/WSServer/WSServer.cpp | 21 +++++++++++++++------
 libraries/WSServer/WSServer.h   | 12 ++++++++----
 5 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index 2181fb3a0..d0f6f3689 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -67,7 +67,7 @@ void Gui::ws_connect(const std::string& address, const WSServerDetails* id)
 	if(!_projectName.empty())
 		root[L"projectName"] = new JSONValue(_projectName);
 	JSONValue *value = new JSONValue(root);
-	sendControl(value);
+	sendControl(value, WSServer::kThreadCallback);
 	delete value;
 }
 
@@ -178,10 +178,10 @@ void Gui::cleanup()
 {
 }
 
-int Gui::sendControl(JSONValue* root) {
+int Gui::sendControl(JSONValue* root, WSServer::CallingThread callingThread) {
     std::wstring wide = JSON::Stringify(root);
     std::string str(wide.begin(), wide.end());
-    return ws_server->sendNonRt(_addressControl.c_str(), str.c_str());
+    return ws_server->sendNonRt(_addressControl.c_str(), str.c_str(), callingThread);
 }
 
 int Gui::doSendBuffer(const char* type, unsigned int bufferId, const void* data, size_t size)
diff --git a/libraries/Gui/Gui.h b/libraries/Gui/Gui.h
index 400984b2f..a8286640f 100644
--- a/libraries/Gui/Gui.h
+++ b/libraries/Gui/Gui.h
@@ -8,10 +8,9 @@
 #include <memory>
 #include <DataBuffer.h>
 #include <set>
+#include "libraries/WSServer/WSServer.h"
 
 // forward declarations
-class WSServer;
-class WSServerDetails;
 
 class Gui
 {
@@ -115,7 +114,7 @@ class Gui
 		/** Sends a JSON value to the control websocket.
 		 * @returns 0 on success, or an error code otherwise.
 		 * */
-		int sendControl(JSONValue* root);
+		int sendControl(JSONValue* root, WSServer::CallingThread callingThread);
 
 		/**
 		 * Sends a buffer (a vector) through the web-socket to the client with a given ID.
diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index b8d7421e0..b5f18e13a 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -558,7 +558,7 @@ void Scope::scope_control_connected(){
 	std::wstring wide = value.Stringify().c_str();
 	std::string str( wide.begin(), wide.end() );
 	// printf("sending JSON: \n%s\n", str.c_str());
-	ws_server->sendNonRt("scope_control", str.c_str());
+	ws_server->sendNonRt("scope_control", str.c_str(), WSServer::kThreadCallback);
 }
 
 // on_data callback for scope_control websocket
diff --git a/libraries/WSServer/WSServer.cpp b/libraries/WSServer/WSServer.cpp
index 24949680b..c3e70ce7f 100644
--- a/libraries/WSServer/WSServer.cpp
+++ b/libraries/WSServer/WSServer.cpp
@@ -41,12 +41,21 @@ struct WSServerDataHandler : seasocks::WebSocket::Handler {
 };
 
 // this is either called directly from sendNonRt(), or via callback when scheduled from sendRt()
-void WSServer::client_task_func(std::shared_ptr<WSServerDataHandler> handler, const void* buf, unsigned int size){
+void WSServer::sendToAllConnections(std::shared_ptr<WSServerDataHandler> handler, const void* buf, unsigned int size, CallingThread callingThread){
 	if(!handler)
 		return;
 	// make a copy of the data before we send it out
 	if(handler->connections.size())
 	{
+		if(kThreadCallback == callingThread) {
+			// avoid memory copy and a lot of work
+			for (auto c : handler->connections){
+				if (handler->binary)
+					c->send((uint8_t*)buf, size);
+				else
+					c->send((const char*)buf);
+			}
+		} else {
 			// make a copy of input data
 			auto data = std::make_shared<std::vector<void*> >(size);
 			memcpy(data->data(), buf, size);
@@ -105,17 +114,17 @@ void WSServer::addAddress(const std::string& _address,
 		[this,wkHdl](void* buf, int size){
 			auto handler = wkHdl.lock();
 			if(handler)
-				client_task_func(handler, buf, size);
+				sendToAllConnections(handler, buf, size, kThreadOther);
 		});
 }
 
-int WSServer::sendNonRt(const char* _address, const char* str) {
-	return sendNonRt(_address, (const void*)str, strlen(str) + 1);
+int WSServer::sendNonRt(const char* _address, const char* str, CallingThread callingThread) {
+	return sendNonRt(_address, (const void*)str, strlen(str) + 1, callingThread);
 }
 
-int WSServer::sendNonRt(const char* _address, const void* buf, unsigned int size) {
+int WSServer::sendNonRt(const char* _address, const void* buf, unsigned int size, CallingThread callingThread) {
 	try {
-		client_task_func(address_book.at(_address).handler, buf, size);
+		sendToAllConnections(address_book.at(_address).handler, buf, size, callingThread);
 		return 0;
 	} catch (std::exception&) {
 		return -1;
diff --git a/libraries/WSServer/WSServer.h b/libraries/WSServer/WSServer.h
index 38fb785d0..2eda9b7d7 100644
--- a/libraries/WSServer/WSServer.h
+++ b/libraries/WSServer/WSServer.h
@@ -1,4 +1,4 @@
-/***** WSServer.h *****/
+#pragma once
 #include <string>
 #include <memory>
 #include <set>
@@ -18,6 +18,10 @@ class WSServerDetails;
 class WSServer{
 	friend struct WSServerDataHandler;
 	public:
+		enum CallingThread {
+			kThreadCallback,
+			kThreadOther,
+		};
 		WSServer();
 		WSServer(int _port);
 		~WSServer();
@@ -30,8 +34,8 @@ class WSServer{
 				std::function<void(const std::string&, const WSServerDetails*)> on_disconnect = nullptr,
 				bool binary = false);
 		
-		int sendNonRt(const char* address, const char* str);
-		int sendNonRt(const char* address, const void* buf, unsigned int size);
+		int sendNonRt(const char* address, const char* str, CallingThread callingThread = kThreadOther);
+		int sendNonRt(const char* address, const void* buf, unsigned int size, CallingThread callingThread = kThreadOther);
 		int sendRt(const char* address, const char* str);
 		int sendRt(const char* address, const void* buf, unsigned int size);
 		
@@ -49,5 +53,5 @@ class WSServer{
 		std::map<std::string, AddressBookItem> address_book;
 		std::unique_ptr<AuxTaskNonRT> server_task;
 		
-		void client_task_func(std::shared_ptr<WSServerDataHandler> handler, const void* buf, unsigned int size);
+		void sendToAllConnections(std::shared_ptr<WSServerDataHandler> handler, const void* buf, unsigned int size, CallingThread callingThread);
 };

From 4174384a5f15e8ffffa1b95e924dfd266e90daa2 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 21 Jul 2023 23:54:04 +0000
Subject: [PATCH 029/188] AuxTaskRT: timed write on exit, to avoid hanging the
 destructor if the thread has already exited.

Should close https://github.com/BelaPlatform/Bela/issues/722
---
 core/AuxTaskRT.cpp    | 5 ++++-
 libraries/Gui/Gui.cpp | 2 +-
 libraries/Gui/Gui.h   | 8 +++++++-
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/core/AuxTaskRT.cpp b/core/AuxTaskRT.cpp
index 326352397..9a21c48ab 100644
--- a/core/AuxTaskRT.cpp
+++ b/core/AuxTaskRT.cpp
@@ -109,7 +109,10 @@ void AuxTaskRT::cleanup(){
 #endif
 #ifdef XENOMAI_SKIN_posix
 	// unblock and join thread
-	schedule();
+	char c = 0;
+	struct timespec absoluteTimeout = {0, 0};
+	// non blocking write, so if the queue is full it won't fail
+	__wrap_mq_timedsend(queueDesc, &c, sizeof(c), 0, &absoluteTimeout);
 	int ret = __wrap_pthread_join(thread, NULL);
 	if (ret < 0){
 		fprintf(stderr, "AuxTaskNonRT %s: unable to join thread: (%i) %s\n", name.c_str(), ret, strerror(ret));
diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index d0f6f3689..72b3d9bd7 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -178,7 +178,7 @@ void Gui::cleanup()
 {
 }
 
-int Gui::sendControl(JSONValue* root, WSServer::CallingThread callingThread) {
+int Gui::sendControl(const JSONValue* root, WSServer::CallingThread callingThread) {
     std::wstring wide = JSON::Stringify(root);
     std::string str(wide.begin(), wide.end());
     return ws_server->sendNonRt(_addressControl.c_str(), str.c_str(), callingThread);
diff --git a/libraries/Gui/Gui.h b/libraries/Gui/Gui.h
index a8286640f..0a184a72b 100644
--- a/libraries/Gui/Gui.h
+++ b/libraries/Gui/Gui.h
@@ -112,9 +112,15 @@ class Gui
 			binaryCallbackArg = callbackArg;
 		};
 		/** Sends a JSON value to the control websocket.
+		 *
+		 * @param root the JSONValue to send
+		 * @param callingThread set this to WSServer::ThreadCallback if
+		 * you are calling this method from the same thread that called
+		 * the control or data callback in order to save a memory
+		 * allocation and copy. Otherwise, leave it at its default value.
 		 * @returns 0 on success, or an error code otherwise.
 		 * */
-		int sendControl(JSONValue* root, WSServer::CallingThread callingThread);
+		int sendControl(const JSONValue* root, WSServer::CallingThread callingThread);
 
 		/**
 		 * Sends a buffer (a vector) through the web-socket to the client with a given ID.

From 2bce2672bb8a85677b096168235be06ca6daea4b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sat, 22 Jul 2023 00:07:51 +0000
Subject: [PATCH 030/188] default_libpd_render: remove uses of malloc and new
 [] (which were leaking in case of file not found)

---
 core/default_libpd_render.cpp | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index a935538d1..93ce8e508 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -813,7 +813,7 @@ void fdLoop(void* arg){
 
 #ifdef BELA_LIBPD_SCOPE
 Scope scope;
-float* gScopeOut;
+std::vector<float> gScopeOut;
 #endif // BELA_LIBPD_SCOPE
 void* gPatch;
 bool gDigitalEnabled = 0;
@@ -857,20 +857,17 @@ bool setup(BelaContext *context, void *userData)
 #endif // BELA_LIBPD_MIDI
 #ifdef BELA_LIBPD_SCOPE
 	scope.setup(gScopeChannelsInUse, context->audioSampleRate);
-	gScopeOut = new float[gScopeChannelsInUse];
+	gScopeOut.resize(gScopeChannelsInUse);
 #endif // BELA_LIBPD_SCOPE
 
 	// Check first of all if the patch file exists. Will actually open it later.
 	char file[] = "_main.pd";
 	char folder[] = "./";
-	unsigned int strSize = strlen(file) + strlen(folder) + 1;
-	char* str = (char*)malloc(sizeof(char) * strSize);
-	snprintf(str, strSize, "%s%s", folder, file);
-	if(access(str, F_OK) == -1 ) {
-		printf("Error file %s/%s not found. The %s file should be your main patch.\n", folder, file, file);
+	std::string path = std::string(folder) + file;
+	if(access(path.c_str(), F_OK) == -1 ) {
+		printf("Error file %s not found. The %s file should be your main patch.\n", path.c_str(), file);
 		return false;
 	}
-	free(str);
 
 	// analog setup
 	gAnalogChannelsInUse = context->analogInChannels;
@@ -1462,10 +1459,10 @@ void render(BelaContext *context, void *userData)
 #ifdef BELA_LIBPD_SCOPE
 		// scope output
 		for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) {
-			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstScopeChannel; k < gScopeChannelsInUse; k++, p1 += gLibpdBlockSize) {
+			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstScopeChannel; k < gScopeOut.size(); k++, p1 += gLibpdBlockSize) {
 				gScopeOut[k] = *p1;
 			}
-			scope.log(gScopeOut[0], gScopeOut[1], gScopeOut[2], gScopeOut[3]);
+			scope.log(gScopeOut.data());
 		}
 #endif // BELA_LIBPD_SCOPE
 
@@ -1507,7 +1504,4 @@ void cleanup(BelaContext *context, void *userData)
 	}
 #endif // BELA_LIBPD_TRILL
 	libpd_closefile(gPatch);
-#ifdef BELA_LIBPD_SCOPE
-	delete [] gScopeOut;
-#endif // BELA_LIBPD_SCOPE
 }

From c86f1f7dce6881d55c33ef4d96257df596aa14fc Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sat, 22 Jul 2023 00:25:31 +0000
Subject: [PATCH 031/188] WSServer: stop the server (and its callbacks) before
 everything else

---
 libraries/WSServer/WSServer.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/libraries/WSServer/WSServer.cpp b/libraries/WSServer/WSServer.cpp
index c3e70ce7f..599e205fe 100644
--- a/libraries/WSServer/WSServer.cpp
+++ b/libraries/WSServer/WSServer.cpp
@@ -149,4 +149,7 @@ int WSServer::sendRt(const char* _address, const void* buf, unsigned int size){
 
 void WSServer::cleanup(){
 	server->terminate();
+	// wait for server to terminate and call all callbacks before
+	// destroying the objects it may depend on
+	server_task.reset();
 }

From 53a793bbc2735699afde2839208ebd427f24eeac Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sat, 22 Jul 2023 00:33:46 +0000
Subject: [PATCH 032/188] I2c: do not leak file descriptor on shutdown.

Closes https://github.com/BelaPlatform/Bela/issues/720
---
 include/I2c.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/include/I2c.h b/include/I2c.h
index 0da089cc8..cde8be272 100644
--- a/include/I2c.h
+++ b/include/I2c.h
@@ -87,4 +87,7 @@ inline ssize_t I2c::writeBytes(const void *buf, size_t count)
 	return write(i2C_file, buf, count);
 }
 
-inline I2c::~I2c(){}
+inline I2c::~I2c(){
+	if(i2C_file >= 0)
+		close(i2C_file);
+}

From ccbad7bcb1846fc69a117ddfaec8f871a627e25b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 24 Jul 2023 17:28:22 +0000
Subject: [PATCH 033/188] default_libpd_render: handle bidirectional UART data

---
 core/default_libpd_render.cpp | 312 ++++++++++++++++++++--------------
 1 file changed, 186 insertions(+), 126 deletions(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index 93ce8e508..b330091ba 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -177,20 +177,166 @@ AuxiliaryTask gSerialOutputTask;
 
 struct serialMessageHeader
 {
-	uint32_t idSize;
-	uint32_t dataSize;
+	uint32_t idSize = 0;
+	uint32_t dataSize = 0;
+};
+enum WaitingFor {
+	kHeader,
+	kId,
+	kData,
+};
+
+struct SerialPipeState {
+	struct serialMessageHeader h;
+	enum WaitingFor waitingFor = kHeader;
+	char id[100];
 };
 
-void serialOutputLoop(void* arg) {
-	// TODO: implement
+static void processSerialPipe(bool rt, SerialPipeState& s)
+{
+	// Not sure we actually need while() below. We were using it earlier
+	// when this was coded inside render() in order to be able to perform early returns
+	while(1)
+	{
+		auto& h = s.h;
+		auto& waitingFor = s.waitingFor;
+		auto& id = s.id;
+		if(kHeader == waitingFor)
+		{
+			int ret = rt ? gSerialPipe.readRt(h) : gSerialPipe.readNonRt(h);
+			if(ret <= 0)
+				break;
+			waitingFor = kId;
+		}
+		if(kId == waitingFor)
+		{
+			if(h.idSize > sizeof(id) - 1)
+				rt_fprintf(stderr, "Serial: ID too large\n");
+			else
+			{
+				int ret = rt ? gSerialPipe.readRt(id, h.idSize) : gSerialPipe.readNonRt(id, h.idSize);
+				if(ret <= 0)
+					break;
+				if(int(h.idSize) != ret)
+				{
+					rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.idSize, ret);
+					break;
+				}
+				id[ret] = '\0'; // ensure it's null-terminated
+				waitingFor = kData;
+			}
+		}
+		if(kData == waitingFor)
+		{
+			char data[h.dataSize + 1];
+			int ret = rt ? gSerialPipe.readRt(data, h.dataSize) : gSerialPipe.readNonRt(data, h.dataSize);
+			if(ret <= 0)
+				break;
+			if(int(h.dataSize) != ret)
+			{
+				rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.dataSize, ret);
+				break;
+			}
+			if(rt)
+			{
+				// rt: forward data from pipe to Pd
+				data[h.dataSize] = '\0'; // ensure it's null-terminated
+				if(h.dataSize)
+				{
+					const char* rec = "bela_serialIn";
+					if(kSerialSymbol == gSerialType)
+					{
+						libpd_symbol(rec, data);
+					} else if(kSerialBytes == gSerialType) {
+						if(gSerialEom >= 0) {
+							// messages are separated: send as a list
+							libpd_start_message(h.dataSize);
+							for(size_t n = 0; n < h.dataSize; ++n)
+								libpd_add_float(data[n]);
+							libpd_finish_message(rec, id);
+						} else {
+							// messages are not separated: send one byte at a time
+							for(size_t n = 0; n < h.dataSize; ++n)
+							{
+								libpd_start_message(h.dataSize);
+								libpd_add_float(data[n]);
+								libpd_finish_message(rec, id);
+							}
+						}
+					} else {
+						unsigned int nTokens = 1;
+						const uint8_t separators[] = { ' ', '\0'};
+						// find number of delimiters
+						size_t start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n] && n != start) // exclude empty tokens
+								{
+									start = n + 1;
+									nTokens++;
+								}
+							}
+						}
+						libpd_start_message(nTokens);
+						start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							bool end = false;
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n])
+								{
+									if(start == n)
+										start++; // remove empty tokens
+									else
+										end = true;
+									break; // no need to check for more separators
+								}
+							}
+							if(end)
+							{
+								data[n] = '\0'; // ensure the string is null-terminated so the next line works
+								if(kSerialSymbols == gSerialType)
+									libpd_add_symbol(data + start);
+								else if (kSerialFloats == gSerialType)
+									libpd_add_float(atof(data + start));
+								start = n + 1;
+							}
+						}
+						libpd_finish_message(rec, id);
+					}
+				}
+			} else {
+				// non-rt: forward data from pipe to serial
+				if(h.dataSize)
+					gSerial.write(data, h.dataSize);
+			}
+			waitingFor = kHeader;
+		}
+	}
 }
 
-void serialInputLoop(void* arg) {
+static void serialOutputLoop(void* arg) {
+	// blocking read with timeout
+	gSerialPipe.setBlockingNonRt(true);
+	gSerialPipe.setTimeoutMsNonRt(100);
+	std::vector<uint8_t> rec(1024);
+	std::vector<uint8_t> id(100);
+
+	SerialPipeState serialStateNonRt {};
+	while(!Bela_stopRequested())
+	{
+		processSerialPipe(false, serialStateNonRt);
+	}
+}
+
+static void serialInputLoop(void* arg) {
 	char serialBuffer[10000];
 	unsigned int i = 0;
-	serialMessageHeader h = {
-		.idSize = strlen(gSerialId.c_str()) + 1,
-	};
+	serialMessageHeader h;
+	h.idSize = strlen(gSerialId.c_str()) + 1;
 	while(!Bela_stopRequested())
 	{
 		// read from the serial port with a timeout of 100ms
@@ -598,7 +744,7 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 				|| !libpd_is_symbol(argv + 1) // device
 				|| !libpd_is_float(argv + 2) // baudrate
 				|| !(libpd_is_symbol(argv + 3) || libpd_is_float(argv + 3)) // EOM
-				|| !libpd_is_symbol(argv + 4) // tyoe
+				|| !libpd_is_symbol(argv + 4) // type
 			)
 			{
 				fprintf(stderr, "Invalid bela_setSerial arguments. Should be:\n"
@@ -635,6 +781,34 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 			gSerialOutputTask = Bela_runAuxiliaryTask(serialOutputLoop, 0);
 		}
 	}
+	if(0 == strcmp(source, "bela_serialOut"))
+	{
+		if(!argc) {
+			fprintf(stderr, "Invalid bela_serialOut arguments. Should be:\n"
+			"`serial_id firstByte <other bytes>`\n");
+			return;
+		}
+		const char* id = symbol;
+		// convert floats to bytes
+		char data[argc];
+		for(size_t n = 0; n < argc; ++n)
+		{
+			t_atom *a = argv + n;
+			if(libpd_is_float(a))
+			{
+				data[n] = libpd_get_float(a);
+			} else {
+				fprintf(stderr, "bela_serialOut received non-float\n");
+				return;
+			}
+		}
+		struct serialMessageHeader h;
+		h.idSize = strlen(id);
+		h.dataSize = sizeof(data);
+		gSerialPipe.writeRt(h);
+		gSerialPipe.writeRt(id, h.idSize);
+		gSerialPipe.writeRt(data, h.dataSize);
+	}
 #endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	if(0 == strcmp(source, "bela_setTrill"))
@@ -1089,123 +1263,9 @@ void render(BelaContext *context, void *userData)
 	}
 #endif // BELA_LIBPD_GUI
 #ifdef BELA_LIBPD_SERIAL
-	while(gSerialInputTask) // proxy for 'isEnabled. Using `while` so we can do early return
-	{
-		enum WaitingFor_t {
-			kHeader,
-			kId,
-			kData,
-		};
-		static struct serialMessageHeader h;
-		static enum WaitingFor_t waitingFor = kHeader;
-		static char id[100];
-		if(kHeader == waitingFor)
-		{
-			int ret = gSerialPipe.readRt(h);
-			if(ret <= 0)
-				break;
-			waitingFor = kId;
-		}
-		if(kId == waitingFor)
-		{
-			if(h.idSize > sizeof(id) - 1)
-				rt_fprintf(stderr, "Serial: ID too large\n");
-			else
-			{
-				int ret = gSerialPipe.readRt(id, h.idSize);
-				if(ret <= 0)
-					break;
-				if(int(h.idSize) != ret)
-				{
-					rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.idSize, ret);
-					break;
-				}
-				id[ret] = '\0'; // ensure it's null-terminated
-				waitingFor = kData;
-			}
-		}
-		if(kData == waitingFor)
-		{
-			char data[h.dataSize + 1];
-			int ret = gSerialPipe.readRt(data, h.dataSize);
-			if(ret <= 0)
-				break;
-			if(int(h.dataSize) != ret)
-			{
-				rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.dataSize, ret);
-				break;
-			}
-			data[h.dataSize] = '\0'; // ensure it's null-terminated
-			if(h.dataSize)
-			{
-				const char* rec = "bela_serial";
-				if(kSerialSymbol == gSerialType)
-				{
-					libpd_symbol(rec, data);
-				} else if(kSerialBytes == gSerialType) {
-					if(gSerialEom >= 0) {
-						// messages are separated: send as a list
-						libpd_start_message(h.dataSize);
-						for(size_t n = 0; n < h.dataSize; ++n)
-							libpd_add_float(data[n]);
-						libpd_finish_message(rec, id);
-					} else {
-						// messages are not separated: send one byte at a time
-						for(size_t n = 0; n < h.dataSize; ++n)
-						{
-							libpd_start_message(h.dataSize);
-							libpd_add_float(data[n]);
-							libpd_finish_message(rec, id);
-						}
-					}
-				} else {
-					unsigned int nTokens = 1;
-					const uint8_t separators[] = { ' ', '\0'};
-					// find number of delimiters
-					size_t start = 0;
-					for(size_t n = 0; n < sizeof(data); ++n)
-					{
-						for(size_t c = 0; c < sizeof(separators); ++c)
-						{
-							if(separators[c] == data[n] && n != start) // exclude empty tokens
-							{
-								start = n + 1;
-								nTokens++;
-							}
-						}
-					}
-					libpd_start_message(nTokens);
-					start = 0;
-					for(size_t n = 0; n < sizeof(data); ++n)
-					{
-						bool end = false;
-						for(size_t c = 0; c < sizeof(separators); ++c)
-						{
-							if(separators[c] == data[n])
-							{
-								if(start == n)
-									start++; // remove empty tokens
-								else
-									end = true;
-								break; // no need to check for more separators
-							}
-						}
-						if(end)
-						{
-							data[n] = '\0'; // ensure the string is null-terminated so the next line works
-							if(kSerialSymbols == gSerialType)
-								libpd_add_symbol(data + start);
-							else if (kSerialFloats == gSerialType)
-								libpd_add_float(atof(data + start));
-							start = n + 1;
-						}
-					}
-					libpd_finish_message(rec, id);
-				}
-			}
-			waitingFor = kHeader;
-		}
-	}
+	static SerialPipeState serialPipeStateRt {};
+	if(gSerialInputTask)
+		processSerialPipe(true, serialPipeStateRt);
 #endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	for(auto& name : gTrillAcks)

From f7d843be99f9bf22e1e898a9f898b24ca27181d2 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 24 Jul 2023 17:52:49 +0000
Subject: [PATCH 034/188] uart-communication example for Pd

---
 examples/PureData/uart-communication/_main.pd | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 examples/PureData/uart-communication/_main.pd

diff --git a/examples/PureData/uart-communication/_main.pd b/examples/PureData/uart-communication/_main.pd
new file mode 100644
index 000000000..cd57801df
--- /dev/null
+++ b/examples/PureData/uart-communication/_main.pd
@@ -0,0 +1,41 @@
+#N canvas 190 75 1090 589 12;
+#X obj 31 350 loadbang;
+#X obj 31 398 s bela_setSerial;
+#X obj 29 462 route myserial;
+#X msg 31 374 new myserial /dev/ttyS4 9600 none bytes;
+#X obj 355 486 s bela_serialOut;
+#X obj 355 385 metro 1000;
+#X obj 355 361 loadbang;
+#X obj 403 413 + 1;
+#X obj 355 412 f;
+#X msg 355 455 myserial \$1 2 3 4 5 6;
+#X obj 29 438 r bela_serialIn;
+#X obj 29 486 print serialIn;
+#X text 73 20 Send a `new` message to bela_setSerial to initialise UART communication. Arguments are:;
+#X text 69 50 [new <serialId> <device> <bps> <EOM> <type>;
+#X text 72 65 Where:;
+#X text 82 78 serialId: symbol to use in future communications pertaining this object;
+#X text 85 133 bps: a valid baudrate supported by the device;
+#X text 85 111 device: path to the serial device;
+#X text 85 154 EOM: End Of Message byte \, used to identify boundaries;
+#X text 102 168 in incoming messages. Possible values are:;
+#X text 101 183 `none` (no message splitting) \, `newline` \, or a float;
+#X text 103 198 representing the character code;
+#X text 82 216 type: how the data is output from bela_serialIn. Possible;
+#X text 101 231 values are:;
+#X text 99 263 symbol: convert incoming message string to a symbol;
+#X text 100 246 floats: convert incoming message string to a float;
+#X text 99 279 symbols: convert incoming data to a symbol ignoring EOM;
+#X text 98 294 bytes: convert each incoming byte to a float \, output them;
+#X text 98 307 one byte at a time if EOM is none \, or as one list per message;
+#X text 442 413 Output raw bytes (that's the only output mode supported right now);
+#X connect 0 0 3 0;
+#X connect 2 0 11 0;
+#X connect 3 0 1 0;
+#X connect 5 0 8 0;
+#X connect 6 0 5 0;
+#X connect 7 0 8 1;
+#X connect 8 0 7 0;
+#X connect 8 0 9 0;
+#X connect 9 0 4 0;
+#X connect 10 0 2 0;

From 903ba4e289964ba7bc05b150419898c0cdc21849 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 3 Aug 2023 21:25:09 +0000
Subject: [PATCH 035/188] DataBuffer: support all data types that the GUI
 already supports

---
 include/DataBuffer.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/DataBuffer.h b/include/DataBuffer.h
index 7c31b4daf..28c7cea83 100644
--- a/include/DataBuffer.h
+++ b/include/DataBuffer.h
@@ -18,7 +18,7 @@ class DataBuffer
 
 		void setType (char type)
 	       	{
-			if(type == 'c' || type == 'd' || type == 'f')
+			if(type == 'c' || type == 'j' || type == 'i' || type == 'd' || type == 'f')
 			{
 				_type = type;
 			}

From 23bf06660a740da67bb50a6d085208b598b899de Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 4 Aug 2023 17:16:42 +0000
Subject: [PATCH 036/188] Gui: backwards-compatible API

---
 libraries/Gui/Gui.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/Gui/Gui.h b/libraries/Gui/Gui.h
index 0a184a72b..31f6455e9 100644
--- a/libraries/Gui/Gui.h
+++ b/libraries/Gui/Gui.h
@@ -120,7 +120,7 @@ class Gui
 		 * allocation and copy. Otherwise, leave it at its default value.
 		 * @returns 0 on success, or an error code otherwise.
 		 * */
-		int sendControl(const JSONValue* root, WSServer::CallingThread callingThread);
+		int sendControl(const JSONValue* root, WSServer::CallingThread callingThread = WSServer::kThreadOther);
 
 		/**
 		 * Sends a buffer (a vector) through the web-socket to the client with a given ID.

From 50af3c07efc89b2cc7eb093e392d150f94994408 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 7 Aug 2023 19:13:20 +0000
Subject: [PATCH 037/188] AudioFileReader: allow to set starting frame at setup

---
 libraries/AudioFile/AudioFile.cpp | 15 +++++++++++----
 libraries/AudioFile/AudioFile.h   |  6 ++++--
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/libraries/AudioFile/AudioFile.cpp b/libraries/AudioFile/AudioFile.cpp
index 054ab28b7..6eca18acb 100644
--- a/libraries/AudioFile/AudioFile.cpp
+++ b/libraries/AudioFile/AudioFile.cpp
@@ -12,16 +12,19 @@ std::vector<float>& AudioFile::getRtBuffer()
 	return internalBuffers[idx];
 }
 
-int AudioFile::setup(const std::string& path, size_t bufferSize, Mode mode, size_t channels /* = 0 */, unsigned int sampleRate /* = 0 */)
+int AudioFile::setup(const std::string& path, size_t bufferSize, Mode mode, size_t arg0 /* = 0 */, unsigned int arg1 /* = 0 */)
 {
 	cleanup();
 	int sf_mode;
 	switch(mode){
-	case kWrite:
+	case kWrite: {
+		unsigned int channels = arg0;
+		unsigned int sampleRate = arg1;
 		sf_mode = SFM_WRITE;
 		sfinfo.samplerate = sampleRate;
 		sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;
 		sfinfo.channels = channels;
+	}
 		break;
 	case kRead:
 		sfinfo.format = 0;
@@ -50,6 +53,9 @@ int AudioFile::setup(const std::string& path, size_t bufferSize, Mode mode, size
 	ioBufferOld = ioBuffer;
 	if(kRead == mode)
 	{
+		size_t readFirstFrame = arg0;
+		if(!ramOnly)
+			sf_seek(sndfile, readFirstFrame, SEEK_SET);
 		// fill up the first buffer
 		io(internalBuffers[ioBuffer]);
 		// signal threadLoop() to start filling in the next buffer
@@ -94,10 +100,11 @@ AudioFile::~AudioFile()
 	cleanup();
 }
 
-int AudioFileReader::setup(const std::string& path, size_t bufferSize)
+int AudioFileReader::setup(const std::string& path, size_t bufferSize, size_t firstFrame)
 {
 	loop = false;
-	return AudioFile::setup(path, bufferSize, kRead);
+	idx = firstFrame;
+	return AudioFile::setup(path, bufferSize, kRead, firstFrame);
 }
 
 int AudioFileReader::setLoop(bool doLoop)
diff --git a/libraries/AudioFile/AudioFile.h b/libraries/AudioFile/AudioFile.h
index 43457ed97..dd8c41844 100644
--- a/libraries/AudioFile/AudioFile.h
+++ b/libraries/AudioFile/AudioFile.h
@@ -89,7 +89,7 @@ class AudioFile
 	} Mode;
 	enum { kNumBufs = 2};
 protected:
-	int setup(const std::string& path, size_t bufferSize, Mode mode, size_t channels = 0, unsigned int sampleRate = 0);
+	int setup(const std::string& path, size_t bufferSize, Mode mode, size_t arg0 = 0, unsigned int arg1 = 0);
 public:
 	size_t getLength() const { return sfinfo.frames; };
 	size_t getChannels() const { return sfinfo.channels; };
@@ -125,8 +125,10 @@ class AudioFileReader : public AudioFile
 	 * @param bufferSize the size of the internal buffer. If this is larger
 	 * than the file itself, the whole file will be loaded in memory, otherwise
 	 * the file will be read from disk from a separate thread.
+	 * @param firstFrame the first frame to start plaback from. When
+	 * looping, unless set differnetly with setLoop(), it will start back from 0.
 	 */
-	int setup(const std::string& path, size_t bufferSize);
+	int setup(const std::string& path, size_t bufferSize, size_t firstFrame = 0);
 	/**
 	 * Write interleaved samples from the file to the destination.
 	 *

From 71dec078c169b8e6da06a9da658eecf25b31d1f4 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 11 Aug 2023 16:40:38 +0000
Subject: [PATCH 038/188] WriteFile: using + separator between base of filename
 and counter. Also added getName()

---
 libraries/WriteFile/WriteFile.cpp | 25 ++++++++++++++++++++-----
 libraries/WriteFile/WriteFile.h   |  6 ++++++
 2 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/libraries/WriteFile/WriteFile.cpp b/libraries/WriteFile/WriteFile.cpp
index 335f99c7b..6f27833bb 100644
--- a/libraries/WriteFile/WriteFile.cpp
+++ b/libraries/WriteFile/WriteFile.cpp
@@ -112,8 +112,10 @@ std::string WriteFile::generateUniqueFilename(const std::string& original)
 			dot = n;
 	}
 	int count = dot;
+	constexpr char sep = '+';
+	constexpr size_t sepLen = 1;
 	// add a * before the dot
-	std::string temp = std::string({original.begin(), original.begin() + dot}) + "*" + std::string({original.begin() + dot, original.end()});
+	std::string temp = std::string({original.begin(), original.begin() + dot}) + '*' + std::string({original.begin() + dot, original.end()});
 
 	// check how many log files are already there, and choose name according to this
 	glob_t globbuf;
@@ -122,21 +124,34 @@ std::string WriteFile::generateUniqueFilename(const std::string& original)
 	int logNum;
 	int logMax = -1;
 	// cycle through all and find the existing one with the highest index
-	for(unsigned int i=0; i<globbuf.gl_pathc; i++)
+	bool originalFree = true;
+	for(unsigned int i = 0; i < globbuf.gl_pathc; ++i)
 	{
-		logNum = atoi(globbuf.gl_pathv[i] + dot);
+		const char* path = globbuf.gl_pathv[i];
+		size_t len = strlen(path);
+		if(len < dot + sepLen)
+			continue;
+		if(sep != path[dot]) // quick check first
+		{
+			// this is either the same as the original or an unmatching pattern
+			if(0 == strcmp(original.c_str(), path))
+				originalFree = false;
+			continue;
+		}
+		const char* start = path + dot + 1;
+		logNum = atoi(start);
 		if(logNum > logMax)
 			logMax = logNum;
 	}
 	globfree(&globbuf);
-	if(logMax == -1)
+	if(logMax == -1 && originalFree)
 	{
 		// use the same filename
 		return original;
 	} else {
 		// generate a new filename
 		logNum = logMax + 1;	// new index
-		std::string out = std::string({original.begin(), original.begin() + dot}) + std::to_string(logNum) + std::string({original.begin() + dot, original.end()});
+		std::string out = std::string({original.begin(), original.begin() + dot}) + sep + std::to_string(logNum) + std::string({original.begin() + dot, original.end()});
 		printf("File %s exists, writing to %s instead\n", original.c_str(), out.c_str());
 		return out;
 	}
diff --git a/libraries/WriteFile/WriteFile.h b/libraries/WriteFile/WriteFile.h
index 2a67fe81f..d1603748d 100644
--- a/libraries/WriteFile/WriteFile.h
+++ b/libraries/WriteFile/WriteFile.h
@@ -125,6 +125,12 @@ class WriteFile {
 	 */
 	void setup(const std::string& filename, bool overwrite = false, bool append = false);
 
+	/**
+	 * Get the name of the file being written. This may be different from
+	 * the filename passed to setup() if it was called with `overwrite =
+	 * false`.
+	 */
+	const std::string& getName() { return filename; }
 	/**
 	 * Gets the distance between the write and read pointers of
 	 * the buffer that holds data to be written to disk.

From 5f1c0bc918df45dfcb70c018a93e4692a967932c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 11 Aug 2023 16:41:10 +0000
Subject: [PATCH 039/188] WriteFile: use 1MB buffer per binary file as default
 instead of 10MB

---
 libraries/WriteFile/WriteFile.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/WriteFile/WriteFile.cpp b/libraries/WriteFile/WriteFile.cpp
index 6f27833bb..f69170890 100644
--- a/libraries/WriteFile/WriteFile.cpp
+++ b/libraries/WriteFile/WriteFile.cpp
@@ -192,7 +192,7 @@ void WriteFile::setup(const std::string& newFilename, bool overwrite, bool appen
 void WriteFile::setFileType(WriteFileType newFileType){
 	fileType = newFileType;
 	if(fileType == kBinary)
-		setBufferSize(1e7);
+		setBufferSize(1e6);
 }
 void WriteFile::setEcho(bool newEcho){
 	echo=newEcho;

From 8fdc5c80f77ee0c8a956a78b75b3d7b0b3c8fd4f Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 11 Aug 2023 19:18:21 +0000
Subject: [PATCH 040/188] WriteFile: allow to delete file upon cleanup()

---
 libraries/WriteFile/WriteFile.cpp | 12 +++++++++++-
 libraries/WriteFile/WriteFile.h   |  9 ++++++++-
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/libraries/WriteFile/WriteFile.cpp b/libraries/WriteFile/WriteFile.cpp
index f69170890..257a80871 100644
--- a/libraries/WriteFile/WriteFile.cpp
+++ b/libraries/WriteFile/WriteFile.cpp
@@ -78,13 +78,23 @@ WriteFile::~WriteFile(){
 	cleanup();	
 }
 
-void WriteFile::cleanup(){
+void WriteFile::cleanup(bool discard){
+	if(cleaned)
+		return;
+	cleaned = true;
 	std::unique_lock<std::mutex> lock(mutex);
 	//write all that's left
 	writeOutput(true);
 	writeFooter();
 	fflush(file);
 	fclose(file);
+	if(discard)
+	{
+		int ret = unlink(filename.c_str());
+		if(ret)
+			fprintf(stderr, "Error while deleting file %s: %d %s\n", filename.c_str(), errno, strerror(errno));
+	}
+
 	// remove from objAddrs list
 	auto it = std::find(objAddrs.begin(), objAddrs.end(), this);
 	if(it != objAddrs.end())
diff --git a/libraries/WriteFile/WriteFile.h b/libraries/WriteFile/WriteFile.h
index d1603748d..71a7a3557 100644
--- a/libraries/WriteFile/WriteFile.h
+++ b/libraries/WriteFile/WriteFile.h
@@ -38,6 +38,7 @@ class WriteFile {
 	std::string filename;
 	std::vector<std::string> formatTokens;
 	bool echo;
+	bool cleaned = false;
 	static constexpr size_t sleepTimeMs = 5;
 	void writeLine();
 	void writeHeader();
@@ -144,7 +145,13 @@ class WriteFile {
 	 * and 1 being buffer empty (writing to disk is fast enough).
 	 */
 	float getBufferStatus();
-	void cleanup();
+	/**
+	 * Stop the logging, flush to disk and remove the file from the writing
+	 * thread. After this, you need a new call to setup().
+	 *
+	 * @param discard Whether to delete the file after closing it.
+	 */
+	void cleanup(bool discard = false);
 	~WriteFile();
 	static int getNumInstances();
 	static void writeAllOutputs(bool flush);

From 75c274b44e9509ed986eef1ae5a54dd68e8ff51c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sat, 12 Aug 2023 00:21:55 +0000
Subject: [PATCH 041/188] Gui: (js) add .type to each buffer

---
 IDE/public/gui/js/BelaData.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/IDE/public/gui/js/BelaData.js b/IDE/public/gui/js/BelaData.js
index 41816dca0..888a80366 100644
--- a/IDE/public/gui/js/BelaData.js
+++ b/IDE/public/gui/js/BelaData.js
@@ -108,7 +108,9 @@ export default class BelaData extends BelaWebSocket {
                 }
                 if(err)
                         return;
-                this.buffers[this.newBuffer['id']] = this.newBuffer['data'];
+                let idx = this.newBuffer['id'];
+                this.buffers[idx] = this.newBuffer['data'];
+                this.buffers[idx].type = type;
                 this.bufferReady = true;
 
                 this.target.dispatchEvent( new CustomEvent('buffer-ready', { detail: this.newBuffer['id'] }) );

From ca4abd46d9191822959082dbb9dfa043230ea087 Mon Sep 17 00:00:00 2001
From: anbjoernskov <77576836+anbjoernskov@users.noreply.github.com>
Date: Fri, 11 Aug 2023 14:15:38 +0200
Subject: [PATCH 042/188] createXenomaiPipe: poolsz should be size_t

---
 include/xenomai_wraps.h | 2 +-
 libraries/Pipe/Pipe.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/xenomai_wraps.h b/include/xenomai_wraps.h
index 5fcf7ab86..a9985d87d 100644
--- a/include/xenomai_wraps.h
+++ b/include/xenomai_wraps.h
@@ -176,7 +176,7 @@ inline int create_and_start_thread(pthread_t* task, const char* taskName, int pr
 	return 0;
 }
 // from xenomai-3/demo/posix/cobalt/xddp-echo.c
-inline int createXenomaiPipe(const char* portName, int poolsz)
+inline int createXenomaiPipe(const char* portName, size_t poolsz)
 {
 	/*
 	 * Get a datagram socket to bind to the RT endpoint. Each
diff --git a/libraries/Pipe/Pipe.h b/libraries/Pipe/Pipe.h
index ae8c9f667..fe5b478fd 100644
--- a/libraries/Pipe/Pipe.h
+++ b/libraries/Pipe/Pipe.h
@@ -84,7 +84,7 @@ class Pipe
 	std::string path;
 	int pipeSocket;
 	int fd = 0;
-	int pipeSize;
+	size_t pipeSize;
 	double timeoutMsRt = 0;
 	double timeoutMsNonRt = 0;
 	bool blockingRt = false;

From fe1c43323c5b2bb602b22e95c646e6b0db8f740f Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 15 Aug 2023 16:08:41 +0000
Subject: [PATCH 043/188] OscReceiver: missing include

---
 libraries/OscReceiver/OscReceiver.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libraries/OscReceiver/OscReceiver.cpp b/libraries/OscReceiver/OscReceiver.cpp
index 6611f24a5..8a557173a 100644
--- a/libraries/OscReceiver/OscReceiver.cpp
+++ b/libraries/OscReceiver/OscReceiver.cpp
@@ -1,6 +1,7 @@
 #include "OscReceiver.h"
 #include <libraries/UdpServer/UdpServer.h>
 #include <thread>
+#include <unistd.h>
 
 constexpr unsigned int OscReceiverBlockReadUs = 50000;
 constexpr unsigned int OscReceiverSleepBetweenReadsUs = 5000;

From 512a21df888bd2368416818a2a350ea60b698aa1 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 15 Aug 2023 16:09:00 +0000
Subject: [PATCH 044/188] NIT: UdpClient: const

---
 libraries/UdpClient/UdpClient.cpp | 2 +-
 libraries/UdpClient/UdpClient.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/libraries/UdpClient/UdpClient.cpp b/libraries/UdpClient/UdpClient.cpp
index 55f456418..7e2b541c7 100644
--- a/libraries/UdpClient/UdpClient.cpp
+++ b/libraries/UdpClient/UdpClient.cpp
@@ -52,7 +52,7 @@ static void dieUninitialized(std::string str){
 		inet_pton(AF_INET,aServerName,&destinationServer.sin_addr);
 		isSetServer=true;
 	};
-	int UdpClient::send(void * message, int size){
+	int UdpClient::send(const void * message, int size){
 		if(!enabled)
 			return -1;
 		unsigned int length;
diff --git a/libraries/UdpClient/UdpClient.h b/libraries/UdpClient/UdpClient.h
index 99d2394e2..507315e54 100644
--- a/libraries/UdpClient/UdpClient.h
+++ b/libraries/UdpClient/UdpClient.h
@@ -42,7 +42,7 @@ class UdpClient{
 		 * @param size The number of bytes to be read from memory and sent to the destination.
 		 * @return the number of bytes sent or -1 if an error occurred.
 		 */
-		int send(void* message, int size);
+		int send(const void* message, int size);
 
 		int write(const char* remoteHostname, int remotePortNumber, void* sourceBuffer, int numBytesToWrite);
 		int waitUntilReady(bool readyForReading, int timeoutMsecs);

From b58758f1488df140f3f48883324236af77a47845 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 15 Aug 2023 16:22:58 +0000
Subject: [PATCH 045/188] OscSender: added sendNonRt() which bypasses the
 outgoing pipe

---
 libraries/OscSender/OscSender.cpp | 19 +++++++++++++++----
 libraries/OscSender/OscSender.h   | 11 ++++++++++-
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/libraries/OscSender/OscSender.cpp b/libraries/OscSender/OscSender.cpp
index 480054cc6..704decdd1 100644
--- a/libraries/OscSender/OscSender.cpp
+++ b/libraries/OscSender/OscSender.cpp
@@ -14,9 +14,8 @@ OscSender::OscSender(int port, std::string ip_address){
 }
 OscSender::~OscSender(){}
 
-void OscSender::send_task_func(void* buf, int size){
-	OscSender* instance = this;
-	instance->socket->send(buf, size);
+void OscSender::doSendToSocket(const void* buf, size_t size) {
+	socket->send(buf, size);
 }
 
 void OscSender::setup(int port, std::string ip_address){
@@ -29,7 +28,9 @@ void OscSender::setup(int port, std::string ip_address){
 	socket->setup(port, ip_address.c_str());
 	
 	send_task = std::unique_ptr<AuxTaskNonRT>(new AuxTaskNonRT());
-	send_task->create(std::string("OscSndrTsk_") + ip_address + std::to_string(port), [this](void* buf, int size){send_task_func(buf, size); });
+	send_task->create(std::string("OscSndrTsk_") + ip_address + std::to_string(port), [this](const void* buf, int size){
+		doSendToSocket(buf, size);
+	});
 }
 
 OscSender &OscSender::newMessage(std::string address){
@@ -63,7 +64,17 @@ void OscSender::send(){
 	send_task->schedule(pw->packetData(), pw->packetSize());
 }
 
+void OscSender::sendNonRt(){
+	pw->init().addMessage(*msg);
+	doSendToSocket(pw->packetData(), pw->packetSize());
+}
+
 void OscSender::send(const oscpkt::Message& extMsg){
 	pw->init().addMessage(extMsg);
 	send_task->schedule(pw->packetData(), pw->packetSize());
 }
+
+void OscSender::sendNonRt(const oscpkt::Message& extMsg){
+	pw->init().addMessage(extMsg);
+	doSendToSocket(pw->packetData(), pw->packetSize());
+}
diff --git a/libraries/OscSender/OscSender.h b/libraries/OscSender/OscSender.h
index 051686975..27f4323ae 100644
--- a/libraries/OscSender/OscSender.h
+++ b/libraries/OscSender/OscSender.h
@@ -102,6 +102,10 @@ class OscSender{
 		 *
 		 */
 		void send();
+		/**
+		 * \brief Sends the message from the non-realtime thread.
+		 */
+		void sendNonRt();
 		/**
 		 * \brief Sends a message
 		 *
@@ -109,6 +113,10 @@ class OscSender{
 		 * externally. It is safe to call from the audio thread.
 		 */
 		void send(const oscpkt::Message& extMsg);
+		/**
+		 * \brief Sends a message from the non-realtime thread.
+		 */
+		void sendNonRt(const oscpkt::Message& extMsg);
 
         	std::unique_ptr<UdpClient> socket;
         
@@ -116,5 +124,6 @@ class OscSender{
         	std::unique_ptr<oscpkt::PacketWriter> pw;
 
 		std::unique_ptr<AuxTaskNonRT> send_task;
-		void send_task_func(void* buf, int size);
+	private:
+		void doSendToSocket(const void* buf, size_t len);
 };

From 66b425a5a5b1da6f6c5e8cd6f4ef46ce4a3ce056 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 15 Aug 2023 16:23:48 +0000
Subject: [PATCH 046/188] Communication/OSC: fixed

---
 examples/Communication/OSC/render.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/Communication/OSC/render.cpp b/examples/Communication/OSC/render.cpp
index 094a9ee15..2b9e1ff3a 100644
--- a/examples/Communication/OSC/render.cpp
+++ b/examples/Communication/OSC/render.cpp
@@ -51,7 +51,7 @@ void on_receive(oscpkt::Message* msg, const char* addr, void* arg)
 		float floatArg;
 		msg->match("/osc-test").popInt32(intArg).popFloat(floatArg).isOkNoMoreArgs();
 		printf("received a message with int %i and float %f\n", intArg, floatArg);
-		oscSender.newMessage("/osc-acknowledge").add(intArg).add(4.2f).add(std::string("OSC message received")).send();
+		oscSender.newMessage("/osc-acknowledge").add(intArg).add(4.2f).add(std::string("OSC message received")).sendNonRt();
 	}
 }
 
@@ -62,7 +62,7 @@ bool setup(BelaContext *context, void *userData)
 
 	// the following code sends an OSC message to address /osc-setup
 	// then waits 1 second for a reply on /osc-setup-reply
-	oscSender.newMessage("/osc-setup").send();
+	oscSender.newMessage("/osc-setup").sendNonRt();
 	int count = 0;
 	int timeoutCount = 10;
 	printf("Waiting for handshake ....\n");

From 8f24bae6fc42a1582ef77d5f876365e51aa23e6d Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 15 Aug 2023 17:44:57 +0000
Subject: [PATCH 047/188] WriteFile: requestFlush()

---
 libraries/WriteFile/WriteFile.cpp | 8 ++++++++
 libraries/WriteFile/WriteFile.h   | 5 +++++
 2 files changed, 13 insertions(+)

diff --git a/libraries/WriteFile/WriteFile.cpp b/libraries/WriteFile/WriteFile.cpp
index 257a80871..9a3e96c8a 100644
--- a/libraries/WriteFile/WriteFile.cpp
+++ b/libraries/WriteFile/WriteFile.cpp
@@ -346,6 +346,10 @@ void WriteFile::writeOutput(bool flush){
 							 	 // So we make sure we only write full lines
 		writeLine();
 	}
+	if(shouldFlush) {
+		shouldFlush = false;
+		flush = true;
+	}
 	if(fileType == kBinary){
 		int numBinaryElementsToWriteAtOnce = 4096;
 		bool wasWritten = false;
@@ -413,3 +417,7 @@ void WriteFile::run(){
 	}
 	threadRunning = false;
 }
+
+void WriteFile::requestFlush() {
+	shouldFlush = true;
+}
diff --git a/libraries/WriteFile/WriteFile.h b/libraries/WriteFile/WriteFile.h
index 71a7a3557..8acc4651d 100644
--- a/libraries/WriteFile/WriteFile.h
+++ b/libraries/WriteFile/WriteFile.h
@@ -39,6 +39,7 @@ class WriteFile {
 	std::vector<std::string> formatTokens;
 	bool echo;
 	bool cleaned = false;
+	volatile bool shouldFlush = false;
 	static constexpr size_t sleepTimeMs = 5;
 	void writeLine();
 	void writeHeader();
@@ -145,6 +146,10 @@ class WriteFile {
 	 * and 1 being buffer empty (writing to disk is fast enough).
 	 */
 	float getBufferStatus();
+	/**
+	 * Request that all of the data logged so far is flushed to disk.
+	 */
+	void requestFlush();
 	/**
 	 * Stop the logging, flush to disk and remove the file from the writing
 	 * thread. After this, you need a new call to setup().

From 29d6f7eed05200877b4b49bab189e1703c24e309 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 18 Aug 2023 23:14:26 +0000
Subject: [PATCH 048/188] NIT: WriteFile: moved headers to implementation

---
 libraries/WriteFile/WriteFile.cpp | 4 ++++
 libraries/WriteFile/WriteFile.h   | 6 +-----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/libraries/WriteFile/WriteFile.cpp b/libraries/WriteFile/WriteFile.cpp
index 9a3e96c8a..d9a9772d2 100644
--- a/libraries/WriteFile/WriteFile.cpp
+++ b/libraries/WriteFile/WriteFile.cpp
@@ -13,6 +13,10 @@
 #include <functional>
 #include <mutex>
 #include <algorithm>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
 
 //setupialise static members
 bool WriteFile::staticConstructed=false;
diff --git a/libraries/WriteFile/WriteFile.h b/libraries/WriteFile/WriteFile.h
index 8acc4651d..f5bb3596d 100644
--- a/libraries/WriteFile/WriteFile.h
+++ b/libraries/WriteFile/WriteFile.h
@@ -7,13 +7,9 @@
 
 #ifndef WRITEFILE_H_
 #define WRITEFILE_H_
-#include <Bela.h>
 #include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
 #include <string>
+#include <stdint.h>
 
 typedef enum {
 	kBinary,

From 0d819eac4d455c2af33e02f3b567516b949af56c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 08:22:01 -0500
Subject: [PATCH 049/188] Scope: display ms/div or hz/div in a decent format.
 Also fixes a bug in hz/div viz and refactors

---
 IDE/frontend-dev/scope-src/ControlView.js | 51 +++++++++++++++--------
 IDE/public/scope/js/bundle.js             | 49 ++++++++++++++--------
 2 files changed, 64 insertions(+), 36 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/ControlView.js b/IDE/frontend-dev/scope-src/ControlView.js
index 3ce2f6811..6f0045904 100644
--- a/IDE/frontend-dev/scope-src/ControlView.js
+++ b/IDE/frontend-dev/scope-src/ControlView.js
@@ -84,43 +84,58 @@ class ControlView extends View{
     }
   }
 
+  msDiv() {
+    let time = (xTime * downSampling/upSampling);
+    if(time < 10)
+      time = time.toFixed(2);
+    else if (time < 100)
+      time = time.toFixed(1);
+    else
+      time = time.toFixed(0);
+    return time;
+  }
+
+  hzDiv() {
+    let hz = (sampleRate/20 * upSampling/downSampling);
+    return hz.toFixed(0);
+  }
+
+  updateUnitDisplay(data) {
+    let unitDisplay;
+    if (data.plotMode == 0){
+      unitDisplay = this.msDiv();
+    } else if (data.plotMode == 1){
+      unitDisplay = this.hzDiv();
+    }
+    $('.xUnit-display').html(unitDisplay);
+  }
+
   plotMode(val, data){
     this.emit('plotMode', val, data);
     if (val == 0){
       if ($('#control-underlay').hasClass('')) $('#control-underlay').addClass('hidden');
       if ($('#triggerControls').hasClass('hidden')) $('#triggerControls').removeClass('hidden');
       if (!$('#FFTControls').hasClass('hidden')) $('#FFTControls').addClass('hidden');
-      $('.xAxisUnits').html('<p>ms</p>');
-      $('.xUnit-display').html('<p>'+ (xTime * downSampling/upSampling).toPrecision(2) +'</p>');
-      $('#zoomUp').html('Zoom in');
-      $('#zoomDown').html('Zoom out');
+      $('.xAxisUnits').html("ms");
     } else if (val == 1){
       if ($('#control-underlay').hasClass('hidden')) $('#control-underlay').removeClass('hidden');
       if (!$('#trigger-controls').hasClass('hidden')) $('#triggerControls').addClass('hidden');
       if ($('#FFTControls').hasClass('hidden')) $('#FFTControls').removeClass('hidden');
-      $('.xAxisUnits').html('Hz');
-      $('.xUnit-display').html((sampleRate/20 * upSampling/downSampling));
-      $('#zoomUp').html('Zoom out');
-      $('#zoomDown').html('Zoom in');
+      $('.xAxisUnits').html("Hz");
     }
+    this.updateUnitDisplay(data);
+    $('#zoomUp').html('Zoom in');
+    $('#zoomDown').html('Zoom out');
   }
 
   _upSampling(value, data){
     upSampling = value;
-    if (data.plotMode == 0){
-      $('.xUnit-display').html('<p>'+ (xTime * downSampling/upSampling).toPrecision(2) +'</p>');
-    } else if (data.plotMode == 1){
-      $('.xUnit-display').html((data.sampleRate/20 * data.upSampling/data.downSampling));
-    }
+    this.updateUnitDisplay(data);
     $('.zoom-display').html((100*upSampling/downSampling).toPrecision(4)+'%');
   }
   _downSampling(value, data){
     downSampling = value;
-    if (data.plotMode == 0){
-      $('.xUnit-display').html('<p>'+ (xTime * downSampling/upSampling).toPrecision(2) +'</p>');
-    } else if (data.plotMode == 1){
-      $('.xUnit-display').html('<p>'+ (xTime * downSampling/upSampling).toPrecision(2) +'</p>');
-    }
+    this.updateUnitDisplay(data);
   }
   _xTimeBase(value, data){
     xTime = data.xTimeBase;
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index d03df67b8..6e770bf26 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -927,6 +927,30 @@ var ControlView = function (_View) {
         this.$elements.filterByData('key', key).val(data[key]);
       }
     }
+  }, {
+    key: 'msDiv',
+    value: function msDiv() {
+      var time = xTime * downSampling / upSampling;
+      if (time < 10) time = time.toFixed(2);else if (time < 100) time = time.toFixed(1);else time = time.toFixed(0);
+      return time;
+    }
+  }, {
+    key: 'hzDiv',
+    value: function hzDiv() {
+      var hz = sampleRate / 20 * upSampling / downSampling;
+      return hz.toFixed(0);
+    }
+  }, {
+    key: 'updateUnitDisplay',
+    value: function updateUnitDisplay(data) {
+      var unitDisplay = void 0;
+      if (data.plotMode == 0) {
+        unitDisplay = this.msDiv();
+      } else if (data.plotMode == 1) {
+        unitDisplay = this.hzDiv();
+      }
+      $('.xUnit-display').html(unitDisplay);
+    }
   }, {
     key: 'plotMode',
     value: function plotMode(val, data) {
@@ -935,40 +959,29 @@ var ControlView = function (_View) {
         if ($('#control-underlay').hasClass('')) $('#control-underlay').addClass('hidden');
         if ($('#triggerControls').hasClass('hidden')) $('#triggerControls').removeClass('hidden');
         if (!$('#FFTControls').hasClass('hidden')) $('#FFTControls').addClass('hidden');
-        $('.xAxisUnits').html('<p>ms</p>');
-        $('.xUnit-display').html('<p>' + (xTime * downSampling / upSampling).toPrecision(2) + '</p>');
-        $('#zoomUp').html('Zoom in');
-        $('#zoomDown').html('Zoom out');
+        $('.xAxisUnits').html("ms");
       } else if (val == 1) {
         if ($('#control-underlay').hasClass('hidden')) $('#control-underlay').removeClass('hidden');
         if (!$('#trigger-controls').hasClass('hidden')) $('#triggerControls').addClass('hidden');
         if ($('#FFTControls').hasClass('hidden')) $('#FFTControls').removeClass('hidden');
-        $('.xAxisUnits').html('Hz');
-        $('.xUnit-display').html(sampleRate / 20 * upSampling / downSampling);
-        $('#zoomUp').html('Zoom out');
-        $('#zoomDown').html('Zoom in');
+        $('.xAxisUnits').html("Hz");
       }
+      this.updateUnitDisplay(data);
+      $('#zoomUp').html('Zoom in');
+      $('#zoomDown').html('Zoom out');
     }
   }, {
     key: '_upSampling',
     value: function _upSampling(value, data) {
       upSampling = value;
-      if (data.plotMode == 0) {
-        $('.xUnit-display').html('<p>' + (xTime * downSampling / upSampling).toPrecision(2) + '</p>');
-      } else if (data.plotMode == 1) {
-        $('.xUnit-display').html(data.sampleRate / 20 * data.upSampling / data.downSampling);
-      }
+      this.updateUnitDisplay(data);
       $('.zoom-display').html((100 * upSampling / downSampling).toPrecision(4) + '%');
     }
   }, {
     key: '_downSampling',
     value: function _downSampling(value, data) {
       downSampling = value;
-      if (data.plotMode == 0) {
-        $('.xUnit-display').html('<p>' + (xTime * downSampling / upSampling).toPrecision(2) + '</p>');
-      } else if (data.plotMode == 1) {
-        $('.xUnit-display').html('<p>' + (xTime * downSampling / upSampling).toPrecision(2) + '</p>');
-      }
+      this.updateUnitDisplay(data);
     }
   }, {
     key: '_xTimeBase',

From be8ef5406daa6c7bb64ea63a1da09369ca2cb3af Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 08:33:47 -0500
Subject: [PATCH 050/188] Scope: Zoom In and Zoom Out work more naturally
 ("logarithmically") by duplicating / halving instead of adding/decreasing

---
 IDE/frontend-dev/scope-src/ControlView.js | 8 ++++----
 IDE/public/scope/js/bundle.js             | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/ControlView.js b/IDE/frontend-dev/scope-src/ControlView.js
index 6f0045904..f5a41e337 100644
--- a/IDE/frontend-dev/scope-src/ControlView.js
+++ b/IDE/frontend-dev/scope-src/ControlView.js
@@ -46,19 +46,19 @@ class ControlView extends View{
   buttonClicked($element, e){
     if ($element.data().key === 'upSampling'){
       if (downSampling > 1){
-        downSampling -= 1;
+        downSampling /= 2;
         this.emit('settings-event', 'downSampling', downSampling);
       } else {
-        upSampling += 1;
+        upSampling *= 2;
         this.emit('settings-event', 'upSampling', upSampling);
       }
       // this._upSampling();
     } else if ($element.data().key === 'downSampling'){
       if (upSampling > 1){
-        upSampling -= 1;
+        upSampling /= 2;
         this.emit('settings-event', 'upSampling', upSampling);
       } else {
-        downSampling += 1;
+        downSampling *= 2;
         this.emit('settings-event', 'downSampling', downSampling);
       }
       // this._downSampling();
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 6e770bf26..5ad3d8204 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -865,19 +865,19 @@ var ControlView = function (_View) {
     value: function buttonClicked($element, e) {
       if ($element.data().key === 'upSampling') {
         if (downSampling > 1) {
-          downSampling -= 1;
+          downSampling /= 2;
           this.emit('settings-event', 'downSampling', downSampling);
         } else {
-          upSampling += 1;
+          upSampling *= 2;
           this.emit('settings-event', 'upSampling', upSampling);
         }
         // this._upSampling();
       } else if ($element.data().key === 'downSampling') {
         if (upSampling > 1) {
-          upSampling -= 1;
+          upSampling /= 2;
           this.emit('settings-event', 'upSampling', upSampling);
         } else {
-          downSampling += 1;
+          downSampling *= 2;
           this.emit('settings-event', 'downSampling', downSampling);
         }
         // this._downSampling();

From dfd5fa77b0f7c15247283f5f22c1b5fee99a0e68 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 09:10:00 -0500
Subject: [PATCH 051/188] Scope: allow remoteHost= querystring to replace the
 default server:port (localhost:5432)

---
 IDE/frontend-dev/scope-src/scope-browser.js | 34 +++++++++++++-------
 IDE/public/scope/js/bundle.js               | 35 +++++++++++++--------
 IDE/public/scope/js/scope-worker.js         | 31 +++++++++++-------
 3 files changed, 63 insertions(+), 37 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 1d79f2a59..40782ad9b 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -1,7 +1,17 @@
 'use strict';
 
 // worker
+let remoteHost = location.hostname + ":5432";
+let qs = new URLSearchParams(location.search);
+let qsRemoteHost = qs.get("remoteHost");
+if(qsRemoteHost)
+  remoteHost = qsRemoteHost
+var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
+worker.postMessage({
+  event: 'wsConnect',
+  remote: wsRemote,
+});
 
 // models
 var Model = require('./Model');
@@ -24,20 +34,12 @@ var sliderView = new (require('./SliderView'))('sliderView', [settings]);
 // main bela socket
 var belaSocket = io('/IDE');
 
-// scope websocket
-var ws;
-
-var wsAddress = "ws://" + location.host + ":5432/scope_control"
-ws = new WebSocket(wsAddress);
 var ws_onerror = function(e){
   setTimeout(() => {
-    ws = new WebSocket(wsAddress);
-    ws.onerror = ws_onerror;
-    ws.onopen = ws_onopen;
-    ws.onmessage = ws_onmessage;
+    ws = new WebSocket(wsUrl);
+    setWsCbs(ws)
   }, 500);
 };
-ws.onerror = ws_onerror;
 
 var ws_onopen = function(){
   ws.binaryType = 'arraybuffer';
@@ -45,7 +47,6 @@ var ws_onopen = function(){
   ws.onclose = ws_onerror;
   ws.onerror = undefined;
 };
-ws.onopen = ws_onopen;
 
 var ws_onmessage = function(msg){
   // console.log('recieved scope control message:', msg.data);
@@ -85,7 +86,16 @@ var ws_onmessage = function(msg){
     }
   }
 };
-ws.onmessage = ws_onmessage;
+function setWsCbs(ws) {
+  ws.onerror = ws_onerror;
+  ws.onopen = ws_onopen;
+  ws.onmessage = ws_onmessage;
+}
+
+// scope websocket
+let wsUrl = wsRemote + "scope_control";
+var ws = new WebSocket(wsUrl);
+setWsCbs(ws);
 
 var paused = false, oneShot = false;
 
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 5ad3d8204..9687374ba 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1369,7 +1369,16 @@ var _settings$setData;
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+var remoteHost = location.hostname + ":5432";
+var qs = new URLSearchParams(location.search);
+var qsRemoteHost = qs.get("remoteHost");
+if (qsRemoteHost) remoteHost = qsRemoteHost;
+var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
+worker.postMessage({
+  event: 'wsConnect',
+  remote: wsRemote
+});
 
 // models
 var Model = require('./Model');
@@ -1392,20 +1401,12 @@ var sliderView = new (require('./SliderView'))('sliderView', [settings]);
 // main bela socket
 var belaSocket = io('/IDE');
 
-// scope websocket
-var ws;
-
-var wsAddress = "ws://" + location.host + ":5432/scope_control";
-ws = new WebSocket(wsAddress);
 var ws_onerror = function ws_onerror(e) {
   setTimeout(function () {
-    ws = new WebSocket(wsAddress);
-    ws.onerror = ws_onerror;
-    ws.onopen = ws_onopen;
-    ws.onmessage = ws_onmessage;
+    ws = new WebSocket(wsUrl);
+    setWsCbs(ws);
   }, 500);
 };
-ws.onerror = ws_onerror;
 
 var ws_onopen = function ws_onopen() {
   ws.binaryType = 'arraybuffer';
@@ -1413,7 +1414,6 @@ var ws_onopen = function ws_onopen() {
   ws.onclose = ws_onerror;
   ws.onerror = undefined;
 };
-ws.onopen = ws_onopen;
 
 var ws_onmessage = function ws_onmessage(msg) {
   // console.log('recieved scope control message:', msg.data);
@@ -1450,7 +1450,16 @@ var ws_onmessage = function ws_onmessage(msg) {
     }
   }
 };
-ws.onmessage = ws_onmessage;
+function setWsCbs(ws) {
+  ws.onerror = ws_onerror;
+  ws.onopen = ws_onopen;
+  ws.onmessage = ws_onmessage;
+}
+
+// scope websocket
+var wsUrl = wsRemote + "scope_control";
+var ws = new WebSocket(wsUrl);
+setWsCbs(ws);
 
 var paused = false,
     oneShot = false;
@@ -1848,7 +1857,7 @@ settings.setData((_settings$setData = {
   FFTXAxis: 0,
   FFTYAxis: 0,
   holdOff: 0
-}, _defineProperty(_settings$setData, 'numSliders', 0), _defineProperty(_settings$setData, 'interpolation', 0), _settings$setData));
+}, _defineProperty(_settings$setData, "numSliders", 0), _defineProperty(_settings$setData, "interpolation", 0), _settings$setData));
 
 },{"./BackgroundView":2,"./ChannelView":3,"./ControlView":4,"./Model":5,"./SliderView":6}]},{},[8])
 
diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index 4ed9fe9ca..c64fe2e7d 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -1,25 +1,31 @@
 
 var settings = {}, channelConfig = [];
 
-var wsAddress = "ws://" + location.host + ":5432/scope_data";
-var ws = new WebSocket(wsAddress);
-var ws_onerror = function(e){
+let wsUrl;
+function setWsCbs(ws) {
+	ws.onerror = ws_onerror.bind(null,ws);
+	ws.onopen = ws_onopen.bind(null, ws);
+	ws.onmessage = ws_onmessage.bind(null, ws);
+}
+var ws_onerror = function(ws, e){
 	setTimeout(() => {
-		ws = new WebSocket(wsAddress);
-		ws.onerror = ws_onerror;
-		ws.onopen = ws_onopen;
-		ws.onmessage = ws_onmessage;
+		ws = new WebSocket(wsUrl);
+		setWsCbs(ws);
 	}, 500);
 };
-ws.onerror = ws_onerror;
 
-var ws_onopen = function(){
+function wsConnect(wsRemote) {
+	wsUrl = wsRemote + "scope_data"
+	let ws = new WebSocket(wsUrl)
+	setWsCbs(ws);
+}
+
+var ws_onopen = function(ws){
 	ws.binaryType = 'arraybuffer';
 	console.log('scope data websocket open');
 	ws.onclose = ws_onerror;
 	ws.onerror = undefined;
 };
-ws.onopen = ws_onopen;
 
 var zero = 0, triggerChannel = 0, xOffset = 0, triggerLevel = 0, numChannels = 0, upSampling = 0;
 var inFrameWidth = 0, outFrameWidth = 0, inArrayWidth = 0, outArrayWidth = 0, interpolation = 0;
@@ -55,10 +61,12 @@ onmessage = function(e){
 	} else if (e.data.event === 'channelConfig'){
 		channelConfig = e.data.channelConfig;
 		//console.log(channelConfig);
+	} else if (e.data.event === 'wsConnect') {
+		wsConnect(e.data.remote);
 	}
 }
 
-var ws_onmessage = function(e){
+var ws_onmessage = function(ws, e){
 
 	var inArray = new Float32Array(e.data);
 // 	console.log("worker: recieved buffer of length "+inArray.length, inArrayWidth);
@@ -108,4 +116,3 @@ var ws_onmessage = function(e){
 	postMessage(outArray, [outArray.buffer]);
 
 };
-ws.onmessage = ws_onmessage;

From f39be917f8ceec7a309ce4a561e384e155dddcee Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 15:13:13 +0000
Subject: [PATCH 052/188] Scope: safely avoid division by zero

---
 libraries/Scope/Scope.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index b5f18e13a..ee313a5c0 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -104,6 +104,8 @@ void Scope::setPlotMode(){
     
     // setup the input buffer
     frameWidth = pixelWidth/upSampling;
+    if(0 == frameWidth)
+	    frameWidth = 1; // avoid divides by zero
 	if(TIME_DOMAIN == plotMode) {
 		channelWidth = frameWidth * FRAMES_STORED;
 	} else {

From 511bf75bc4b344f291fd449c6eccec2120a97429 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 10:15:11 -0500
Subject: [PATCH 053/188] Scope: also set a zoom in limit in the frontend

---
 IDE/frontend-dev/scope-src/ControlView.js | 7 +++++--
 IDE/public/scope/js/bundle.js             | 7 +++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/ControlView.js b/IDE/frontend-dev/scope-src/ControlView.js
index f5a41e337..a7c0abde1 100644
--- a/IDE/frontend-dev/scope-src/ControlView.js
+++ b/IDE/frontend-dev/scope-src/ControlView.js
@@ -49,8 +49,11 @@ class ControlView extends View{
         downSampling /= 2;
         this.emit('settings-event', 'downSampling', downSampling);
       } else {
-        upSampling *= 2;
-        this.emit('settings-event', 'upSampling', upSampling);
+        if(upSampling < 64) {
+          // an arbitrary limit: higher than this and pileups start happening
+          upSampling *= 2;
+          this.emit('settings-event', 'upSampling', upSampling);
+        }
       }
       // this._upSampling();
     } else if ($element.data().key === 'downSampling'){
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 9687374ba..a4be6ff0d 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -868,8 +868,11 @@ var ControlView = function (_View) {
           downSampling /= 2;
           this.emit('settings-event', 'downSampling', downSampling);
         } else {
-          upSampling *= 2;
-          this.emit('settings-event', 'upSampling', upSampling);
+          if (upSampling < 64) {
+            // an arbitrary limit: higher than this and pileups start happening
+            upSampling *= 2;
+            this.emit('settings-event', 'upSampling', upSampling);
+          }
         }
         // this._upSampling();
       } else if ($element.data().key === 'downSampling') {

From 89c4583e2d937ec882a458829df2e0ff66dd2b23 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 17:23:58 +0000
Subject: [PATCH 054/188] Scope: prepend timestamp to outgoing buffer

---
 IDE/public/scope/js/scope-worker.js |  3 +-
 libraries/Scope/Scope.cpp           | 51 +++++++++++++++++++----------
 libraries/Scope/Scope.h             |  8 ++++-
 3 files changed, 42 insertions(+), 20 deletions(-)

diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index c64fe2e7d..8bc00b8d6 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -68,7 +68,8 @@ onmessage = function(e){
 
 var ws_onmessage = function(ws, e){
 
-	var inArray = new Float32Array(e.data);
+	let timestamp = new Uint32Array(e.data.slice(0, 4))[0];
+	var inArray = new Float32Array(e.data.slice(4));
 // 	console.log("worker: recieved buffer of length "+inArray.length, inArrayWidth);
 //	console.log(settings.frameHeight, settings.numChannels, settings.frameWidth, channelConfig);
 	
diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index ee313a5c0..1c12c756e 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -114,7 +114,7 @@ void Scope::setPlotMode(){
     buffer.resize(numChannels*channelWidth);
     
     // setup the output buffer
-    outBuffer.resize(numChannels*frameWidth);
+    outBuffer.resize(numChannels * frameWidth  + kTimestampSlots);
     
     // reset the trigger
     triggerPointer = 0;
@@ -239,11 +239,37 @@ bool Scope::triggered(){
 	return false;
 }
 
+void Scope::outBufferSetTimestamp(){
+	memcpy(outBuffer.data(), &timestamp, sizeof(timestamp));
+	outBufferSize = 0;
+}
+
+void Scope::outBufferAppendData(size_t startptr, size_t endptr, size_t outChannelWidth){
+	if(endptr > startptr) {
+		for(size_t i = 0; i < numChannels; ++i){
+			std::copy(&buffer[channelWidth*i+startptr], &buffer[channelWidth*i+endptr], outBuffer.begin()+(i*outChannelWidth) + kTimestampSlots + outBufferSize);
+		}
+		outBufferSize += endptr - startptr;
+	} else {
+		for(size_t i = 0; i < numChannels; ++i){
+			std::copy(&buffer[channelWidth*i+startptr], &buffer[channelWidth*(i+1)], outBuffer.begin()+(i*outChannelWidth) + kTimestampSlots + outBufferSize);
+			std::copy(&buffer[channelWidth*i], &buffer[channelWidth*i+endptr], outBuffer.begin()+((i+1)*outChannelWidth-endptr) + kTimestampSlots + outBufferSize);
+		}
+		outBufferSize += endptr + channelWidth - startptr;
+	}
+}
+
+void Scope::outBufferSend(){
+	size_t elems = kTimestampSlots + outBufferSize * numChannels;
+	size_t bytes = sizeof(outBuffer[0]) * elems;
+	ws_server->sendRt("scope_data", outBuffer.data(), bytes);
+}
+
 void Scope::triggerTimeDomain(){
 // printf("do trigger %i, %i\n", readPointer, writePointer);
     // iterate over the samples between the read and write pointers and check for / deal with triggers
     while (readPointer != writePointer){
-        
+	timestamp++;
         // if we are currently listening for a trigger
         if (triggerPrimed){
             
@@ -292,24 +318,13 @@ void Scope::triggerTimeDomain(){
 					// copy the previous to next frameWidth/2.0f samples into the outBuffer
 					int startptr = (triggerPointer-(int)(frameWidth/2.0f) + channelWidth)%channelWidth;
 					int endptr = (startptr + frameWidth)%channelWidth;
-					
-					if (endptr > startptr){
-						for (int i=0; i<numChannels; i++){
-							std::copy(&buffer[channelWidth*i+startptr], &buffer[channelWidth*i+endptr], outBuffer.begin()+(i*frameWidth));
-						}
-					} else {
-						for (int i=0; i<numChannels; i++){
-							std::copy(&buffer[channelWidth*i+startptr], &buffer[channelWidth*(i+1)], outBuffer.begin()+(i*frameWidth));
-							std::copy(&buffer[channelWidth*i], &buffer[channelWidth*i+endptr], outBuffer.begin()+((i+1)*frameWidth-endptr));
-						}
-					}
+
+					outBufferSetTimestamp();
+					outBufferAppendData(startptr, endptr, frameWidth);
 					isUsingBuffer = false;
 					
 					// the whole frame has been saved in outBuffer, so send it
-					// sendBufferTask.schedule((void*)&outBuffer[0], outBuffer.size()*sizeof(float));
-					// rt_printf("scheduling sendBufferTask size: %i\n", outBuffer.size());
-					ws_server->sendRt("scope_data", outBuffer.data(), outBuffer.size() * sizeof(float));
-					
+					outBufferSend();
 					isUsingOutBuffer = false;
                 }
 				
@@ -532,7 +547,7 @@ void Scope::setSetting(std::wstring setting, float value){
 	} else if (setting.compare(L"FFTYAxis") == 0){
         FFTYAxis = (int)value;
 	} else if (setting.compare(L"numChannels") == 0){
-		numChannels = (int)value;
+		numChannels = value;
 	} else if (setting.compare(L"sampleRate") == 0){
 		sampleRate = value;
 	}
diff --git a/libraries/Scope/Scope.h b/libraries/Scope/Scope.h
index 8e46fd89d..b553507e2 100644
--- a/libraries/Scope/Scope.h
+++ b/libraries/Scope/Scope.h
@@ -102,13 +102,16 @@ class Scope{
         void scope_control_connected();
         void scope_control_data(const char* data);
         void parse_settings(std::shared_ptr<JSONValue> value);
+	void outBufferSetTimestamp();
+	void outBufferAppendData(size_t startptr, size_t endptr, size_t outChannelWidth);
+	void outBufferSend();
         
 	bool volatile isUsingOutBuffer;
 	bool volatile isUsingBuffer;
 	bool volatile isResizing;
 		
         // settings
-        int numChannels;
+        size_t numChannels;
         float sampleRate;
         int pixelWidth;
         int frameWidth;
@@ -132,6 +135,9 @@ class Scope{
         // buffers
         std::vector<float> buffer;
         std::vector<float> outBuffer;
+	uint32_t timestamp = 0;
+	size_t outBufferSize;
+	static constexpr size_t kTimestampSlots = sizeof(timestamp) / sizeof(outBuffer[0]);
         
         // pointers
         int writePointer;

From f76e5486599d1e739ef9630dada802d497f99fc3 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 21:21:00 +0000
Subject: [PATCH 055/188] Scope: autoRoll when downSampling is above 8

---
 IDE/public/scope/js/scope-worker.js | 30 +++++++++++++++++++++++++++--
 libraries/Scope/Scope.cpp           | 23 ++++++++++++++++++++--
 libraries/Scope/Scope.h             |  1 +
 3 files changed, 50 insertions(+), 4 deletions(-)

diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index 8bc00b8d6..fd77055a5 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -27,7 +27,7 @@ var ws_onopen = function(ws){
 	ws.onerror = undefined;
 };
 
-var zero = 0, triggerChannel = 0, xOffset = 0, triggerLevel = 0, numChannels = 0, upSampling = 0;
+var zero = 0, triggerChannel = 0, xOffset = 0, triggerLevel = 0, numChannels = 0, upSampling = 0, downSampling = 1;
 var inFrameWidth = 0, outFrameWidth = 0, inArrayWidth = 0, outArrayWidth = 0, interpolation = 0;
 
 const plotModeTimeDomain = 0;
@@ -49,6 +49,7 @@ onmessage = function(e){
 	
 		numChannels = settings.numChannels;
 		upSampling = settings.upSampling;
+		downSampling = settings.downSampling;
 	
 		inFrameWidth = Math.floor(settings.frameWidth/upSampling);
 		outFrameWidth = settings.frameWidth;
@@ -66,6 +67,14 @@ onmessage = function(e){
 	}
 }
 
+let rollPtr = 0;
+let globalArray = new Array();
+let counter = 0;
+
+function inToOut(c, val) {
+	return zero * (1 - (channelConfig[c].yOffset + val) * channelConfig[c].yAmplitude);
+}
+
 var ws_onmessage = function(ws, e){
 
 	let timestamp = new Uint32Array(e.data.slice(0, 4))[0];
@@ -73,8 +82,24 @@ var ws_onmessage = function(ws, e){
 // 	console.log("worker: recieved buffer of length "+inArray.length, inArrayWidth);
 //	console.log(settings.frameHeight, settings.numChannels, settings.frameWidth, channelConfig);
 	
+	globalArray.length = outArrayWidth;
 	var outArray = new Float32Array(outArrayWidth);
 		
+	let roll = downSampling > 8;
+	if(roll) {
+		let frames = inArray.length / numChannels;
+		for(let n = 0; n < frames; ++n) {
+			for(let c = 0; c < numChannels; ++c) {
+				let inIndex = c * frames + n;
+				outIndex = c * outFrameWidth + rollPtr;
+				globalArray[outIndex] = inToOut(c, inArray[inIndex]);
+			}
+			rollPtr++;
+			rollPtr %= outFrameWidth;
+		}
+		for(let i = 0; i < outArray.length; ++i)
+			outArray[i] = globalArray[i];
+	} else {
 	if (inArray.length !== inArrayWidth) {
 		console.log(inArray.length, inArrayWidth, inFrameWidth);
 		console.log('worker: frame dropped');
@@ -91,7 +116,7 @@ var ws_onmessage = function(ws, e){
 				var second = inArray[inIndex + 1 < endOfInArray ? inIndex + 1 : endOfInArray];
 				var diff = interpolation ? u*(second-first)/upSampling : 0;
 				outIndex = channel*outFrameWidth + frame*upSampling + u;
-				outArray[outIndex] = zero * (1 - (channelConfig[channel].yOffset + (inArray[inIndex]+diff)) * channelConfig[channel].yAmplitude);
+				outArray[outIndex] = inToOut(channel, inArray[inIndex] + diff);
 			}
 		}
 		// the above will not always get to the end of outArray, depending on the ratio between upSampling and outFrameWidth
@@ -110,6 +135,7 @@ var ws_onmessage = function(ws, e){
 			outArray[outIndex++] = fillValue;
 		}
 	}
+	}
 //  	for(var n = 0; n < upSampling; ++n){
 // 		outArray[outArray.length - 1 - n] = outArray[outArray.length - upSampling - 1];
 // 	}
diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index 1c12c756e..e2936682b 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -268,10 +268,29 @@ void Scope::outBufferSend(){
 void Scope::triggerTimeDomain(){
 // printf("do trigger %i, %i\n", readPointer, writePointer);
     // iterate over the samples between the read and write pointers and check for / deal with triggers
+	// target approx 30 Hz
+	size_t numRollSamples = sampleRate / 30 / downSampling;
+	if(!numRollSamples)
+		numRollSamples = 1;
     while (readPointer != writePointer){
 	timestamp++;
-        // if we are currently listening for a trigger
-        if (triggerPrimed){
+	bool autoRoll = true;
+	if(downSampling > 8 && autoRoll)
+	{
+		rollPtr++;
+		if(rollPtr >= numRollSamples)
+		{
+			rollPtr = 0;
+			isUsingOutBuffer = true;
+			isUsingBuffer = true;
+			outBufferSetTimestamp();
+			outBufferAppendData((readPointer - numRollSamples + channelWidth) % channelWidth , readPointer % channelWidth, numRollSamples);
+			outBufferSend();
+			isUsingBuffer = false;
+			isUsingOutBuffer = false;
+		}
+	} else if (triggerPrimed){
+            //if we are currently listening for a trigger
             
             // if we crossed the trigger threshold
             if (triggered()){
diff --git a/libraries/Scope/Scope.h b/libraries/Scope/Scope.h
index b553507e2..ad4e1b2ec 100644
--- a/libraries/Scope/Scope.h
+++ b/libraries/Scope/Scope.h
@@ -137,6 +137,7 @@ class Scope{
         std::vector<float> outBuffer;
 	uint32_t timestamp = 0;
 	size_t outBufferSize;
+	size_t rollPtr = 0;
 	static constexpr size_t kTimestampSlots = sizeof(timestamp) / sizeof(outBuffer[0]);
         
         // pointers

From bc8eb08767c07b8081952d2a3dc514ab3df3ad1b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 21:24:49 +0000
Subject: [PATCH 056/188] Scope: for high downSampling, schedule trigger task
 frequently enough

---
 libraries/Scope/Scope.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index e2936682b..fa59db15d 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -203,7 +203,7 @@ void Scope::postlog(){
 	isUsingBuffer = false;
     writePointer = (writePointer+1)%channelWidth;
 	
-    if (logCount++ > TRIGGER_LOG_COUNT){
+    if (logCount++ > TRIGGER_LOG_COUNT || downSampling > TRIGGER_LOG_COUNT){
         logCount = 0;
         scopeTriggerTask->schedule();
     }

From e44a629df72b5d0c4472434a524ab878c673cb5b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 17:46:31 -0500
Subject: [PATCH 057/188] Scope: toggle between real roll and simple
 non-triggering incremental drawing via hardcoded flag

---
 IDE/public/scope/js/scope-worker.js | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index fd77055a5..07ceed6b2 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -82,23 +82,33 @@ var ws_onmessage = function(ws, e){
 // 	console.log("worker: recieved buffer of length "+inArray.length, inArrayWidth);
 //	console.log(settings.frameHeight, settings.numChannels, settings.frameWidth, channelConfig);
 	
-	globalArray.length = outArrayWidth;
+	let roll = false;
+	let incDrawing = downSampling > 8;
+	globalArray.length = outArrayWidth * (roll ? 2 : 1);
 	var outArray = new Float32Array(outArrayWidth);
 		
-	let roll = downSampling > 8;
-	if(roll) {
+	if(incDrawing) {
+		let globalFrameWidth = outFrameWidth * (roll ? 2 : 1);
 		let frames = inArray.length / numChannels;
 		for(let n = 0; n < frames; ++n) {
 			for(let c = 0; c < numChannels; ++c) {
 				let inIndex = c * frames + n;
-				outIndex = c * outFrameWidth + rollPtr;
+				let outIndex = c * globalFrameWidth + rollPtr;
 				globalArray[outIndex] = inToOut(c, inArray[inIndex]);
 			}
 			rollPtr++;
-			rollPtr %= outFrameWidth;
+			rollPtr %= globalFrameWidth;
 		}
-		for(let i = 0; i < outArray.length; ++i)
-			outArray[i] = globalArray[i];
+		if(roll) {
+			for(let n = 0; n < outFrameWidth; ++n) {
+				for(let c = 0; c < numChannels; ++c) {
+					let offset = (globalFrameWidth + n + rollPtr - outFrameWidth) % globalFrameWidth;
+					outArray[c * outFrameWidth + n] = globalArray[(c * globalFrameWidth + offset)];
+				}
+			}
+		} else
+			for(let i = 0; i < outArray.length; ++i)
+				outArray[i] = globalArray[i];
 	} else {
 	if (inArray.length !== inArrayWidth) {
 		console.log(inArray.length, inArrayWidth, inFrameWidth);

From 8b0aea1e1a09e791fdf9e1813f3e6f3729801459 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 17:59:42 -0500
Subject: [PATCH 058/188] Scope: added control for X axis behaviour

---
 IDE/frontend-dev/scope-src/scope-browser.js |  1 +
 IDE/public/scope/index.html                 | 12 ++++++++++++
 IDE/public/scope/js/bundle.js               |  1 +
 IDE/public/scope/js/scope-worker.js         |  7 ++++---
 libraries/Scope/Scope.cpp                   |  6 ++++--
 libraries/Scope/Scope.h                     |  6 ++++++
 6 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 40782ad9b..cb7d522a2 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -478,6 +478,7 @@ settings.setData({
   triggerDir  : 0,
   triggerLevel  : 0,
   xOffset   : 0,
+  xAxisBehaviour: 0,
   upSampling  : 1,
   downSampling  : 1,
   FFTLength : 1024,
diff --git a/IDE/public/scope/index.html b/IDE/public/scope/index.html
index b1270e8f4..a081aa1a5 100644
--- a/IDE/public/scope/index.html
+++ b/IDE/public/scope/index.html
@@ -70,6 +70,18 @@ <h3>X-Axis</h3>
             <div class="slider range">
               <input  class="scope-controls scope-range-slider" data-key="holdOff" type="range" min="0" max="1000" value="0" step="1" />
             </div>
+            <div class="scope-label">
+              <p>Behaviour:</p>
+			</div>
+            <div class="scope-input">
+              <span class="mini-dropdown">
+                <select class="scope-controls" data-key="xAxisBehaviour">
+                  <option value="0" selected>Normal</option>
+                  <option value="1">Incremental</option>
+                  <option value="2">Roll</option>
+                </select>
+              </span>
+            </div>
           </div>
 
         </div> <!-- end axis section -->
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index a4be6ff0d..b88bb12c0 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1854,6 +1854,7 @@ settings.setData((_settings$setData = {
   triggerDir: 0,
   triggerLevel: 0,
   xOffset: 0,
+  xAxisBehaviour: 0,
   upSampling: 1,
   downSampling: 1,
   FFTLength: 1024,
diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index 07ceed6b2..26abcd451 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -27,7 +27,7 @@ var ws_onopen = function(ws){
 	ws.onerror = undefined;
 };
 
-var zero = 0, triggerChannel = 0, xOffset = 0, triggerLevel = 0, numChannels = 0, upSampling = 0, downSampling = 1;
+var zero = 0, triggerChannel = 0, xOffset = 0, triggerLevel = 0, numChannels = 0, upSampling = 0, downSampling = 1, xAxisBehaviour = 0;
 var inFrameWidth = 0, outFrameWidth = 0, inArrayWidth = 0, outArrayWidth = 0, interpolation = 0;
 
 const plotModeTimeDomain = 0;
@@ -50,6 +50,7 @@ onmessage = function(e){
 		numChannels = settings.numChannels;
 		upSampling = settings.upSampling;
 		downSampling = settings.downSampling;
+		xAxisBehaviour = settings.xAxisBehaviour;
 	
 		inFrameWidth = Math.floor(settings.frameWidth/upSampling);
 		outFrameWidth = settings.frameWidth;
@@ -82,8 +83,8 @@ var ws_onmessage = function(ws, e){
 // 	console.log("worker: recieved buffer of length "+inArray.length, inArrayWidth);
 //	console.log(settings.frameHeight, settings.numChannels, settings.frameWidth, channelConfig);
 	
-	let roll = false;
-	let incDrawing = downSampling > 8;
+	let roll = 2 == xAxisBehaviour;
+	let incDrawing = downSampling > 1 && 0 != xAxisBehaviour;
 	globalArray.length = outArrayWidth * (roll ? 2 : 1);
 	var outArray = new Float32Array(outArrayWidth);
 		
diff --git a/libraries/Scope/Scope.cpp b/libraries/Scope/Scope.cpp
index fa59db15d..98844b1eb 100644
--- a/libraries/Scope/Scope.cpp
+++ b/libraries/Scope/Scope.cpp
@@ -274,9 +274,9 @@ void Scope::triggerTimeDomain(){
 		numRollSamples = 1;
     while (readPointer != writePointer){
 	timestamp++;
-	bool autoRoll = true;
-	if(downSampling > 8 && autoRoll)
+	if(downSampling > 1 && X_NORMAL != xAxisBehaviour)
 	{
+		// send "rolling" blocks without waiting for a trigger
 		rollPtr++;
 		if(rollPtr >= numRollSamples)
 		{
@@ -544,6 +544,8 @@ void Scope::setSetting(std::wstring setting, float value){
 	} else if (setting.compare(L"xOffset") == 0){
         xOffset = (int)value;
         setXParams();
+	} else if (setting.compare(L"xAxisBehaviour") == 0){
+		xAxisBehaviour = (XAxisBehaviour)value;
 	} else if (setting.compare(L"upSampling") == 0){
 		stop();
         upSampling = (int)value;
diff --git a/libraries/Scope/Scope.h b/libraries/Scope/Scope.h
index ad4e1b2ec..301c39677 100644
--- a/libraries/Scope/Scope.h
+++ b/libraries/Scope/Scope.h
@@ -32,6 +32,11 @@ class Scope{
 		NEGATIVE, ///< Trigger when crossing the threshold and the signal is decreasing
 		BOTH, ///< Trigger on any crossing of the threshold.
 	} TriggerSlope;
+	typedef enum {
+		X_NORMAL, ///< X-axis normal
+		X_INCREMENTAL, ///< X-axis incremental
+		X_ROLLING, ///< X-axis rolling
+	} XAxisBehaviour;
 
         Scope();
 	Scope(unsigned int numChannels, float sampleRate);
@@ -119,6 +124,7 @@ class Scope{
         TriggerMode triggerMode;
         unsigned int triggerChannel;
         TriggerSlope triggerDir;
+	XAxisBehaviour xAxisBehaviour = X_NORMAL;
         float triggerLevel;
         int xOffset;
         int xOffsetSamples;

From abd4bcc14faae0b2a0de7ea5ab2bbd0d2d764b8a Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 18:29:03 -0500
Subject: [PATCH 059/188] Scope: for incremental drawing, fade out older values

---
 IDE/frontend-dev/scope-src/scope-browser.js | 19 +++++++++++++++++--
 IDE/public/scope/js/bundle.js               | 18 ++++++++++++++++--
 IDE/public/scope/js/scope-worker.js         |  5 ++++-
 3 files changed, 37 insertions(+), 5 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index cb7d522a2..f8b079bf0 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -332,12 +332,16 @@ function CPU(data){
   channelView.on('channelConfig', (config) => channelConfig = config );
   
   let frame, length, plot = false;
+  let oldDataSeparator = -1;
 
   worker.onmessage = function(e) {
-    frame = e.data;
+    oldDataSeparator = e.data.oldDataSeparator;
+    frame = e.data.outArray;
     length = Math.floor(frame.length/numChannels);
     // if scope is paused, don't set the plot flag
     plot = !paused;
+    if(plot)
+      requestAnimationFrame(plotLoop);
     
     // interpolate the trigger sample to get the sub-pixel x-offset
     if (settings.getKey('plotMode') == 0){
@@ -361,7 +365,6 @@ function CPU(data){
   };
   
   function plotLoop(){
-    requestAnimationFrame(plotLoop);
     if (plot){
       plot = false;
       ctx.clear();
@@ -382,8 +385,20 @@ function CPU(data){
         let curr = constrain(frame[iLength], minY, maxY);
         let next = constrain(frame[iLength + 1], minY, maxY);
         ctx.moveTo(0, curr + xOff*(next - curr));
+        let lastAlpha = 1;
         for (var j=1; (j-xOff)<length; j++){
           let curr = constrain(frame[j + iLength], minY, maxY);
+          // when drawing incrementally, alpha will be 1 when close to the most
+          // recent and then progressively fade out for older values
+          if(oldDataSeparator >= 0) {
+            let dist = (length + oldDataSeparator - j - 1) % length;
+            let alpha = dist < length / 2 ? 1 : 1 - (dist - length / 2) / (length / 2);
+            // throttle lineStyle() calls as they are CPU-heavy
+            if(Math.abs(alpha - lastAlpha) > 0.1 || (lastAlpha != 1 && alpha == 1)) {
+              lastAlpha = alpha;
+              ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, alpha);
+            }
+          }
           ctx.lineTo(j-xOff, curr);
         }
       }
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index b88bb12c0..47c296d0e 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1668,7 +1668,6 @@ function CPU(data) {
 // plotting
 {
   var plotLoop = function plotLoop() {
-    requestAnimationFrame(plotLoop);
     if (plot) {
       plot = false;
       ctx.clear();
@@ -1686,8 +1685,20 @@ function CPU(data) {
         var curr = constrain(frame[iLength], minY, maxY);
         var next = constrain(frame[iLength + 1], minY, maxY);
         ctx.moveTo(0, curr + xOff * (next - curr));
+        var lastAlpha = 1;
         for (var j = 1; j - xOff < length; j++) {
           var _curr = constrain(frame[j + iLength], minY, maxY);
+          // when drawing incrementally, alpha will be 1 when close to the most
+          // recent and then progressively fade out for older values
+          if (oldDataSeparator >= 0) {
+            var dist = (length + oldDataSeparator - j - 1) % length;
+            var alpha = dist < length / 2 ? 1 : 1 - (dist - length / 2) / (length / 2);
+            // throttle lineStyle() calls as they are CPU-heavy
+            if (Math.abs(alpha - lastAlpha) > 0.1 || lastAlpha != 1 && alpha == 1) {
+              lastAlpha = alpha;
+              ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, alpha);
+            }
+          }
           ctx.lineTo(j - xOff, _curr);
         }
       }
@@ -1762,12 +1773,15 @@ function CPU(data) {
   var frame = void 0,
       length = void 0,
       plot = false;
+  var oldDataSeparator = -1;
 
   worker.onmessage = function (e) {
-    frame = e.data;
+    oldDataSeparator = e.data.oldDataSeparator;
+    frame = e.data.outArray;
     length = Math.floor(frame.length / numChannels);
     // if scope is paused, don't set the plot flag
     plot = !paused;
+    if (plot) requestAnimationFrame(plotLoop);
 
     // interpolate the trigger sample to get the sub-pixel x-offset
     if (settings.getKey('plotMode') == 0) {
diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index 26abcd451..6d36b06c7 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -151,6 +151,9 @@ var ws_onmessage = function(ws, e){
 // 		outArray[outArray.length - 1 - n] = outArray[outArray.length - upSampling - 1];
 // 	}
 	
-	postMessage(outArray, [outArray.buffer]);
+	postMessage({
+		outArray: outArray,
+		oldDataSeparator: 1 == xAxisBehaviour ? rollPtr : -1,
+	}, [outArray.buffer]);
 
 };

From 09884050a8a8b2a6b483825bce13572866087d81 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 22 Aug 2023 23:09:54 -0500
Subject: [PATCH 060/188] Scope: if passing controlOnly=1, do not try to
 establish data websocket

---
 IDE/frontend-dev/scope-src/scope-browser.js | 11 +++++++----
 IDE/public/scope/js/bundle.js               | 11 +++++++----
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index f8b079bf0..b2fda3978 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -4,14 +4,17 @@
 let remoteHost = location.hostname + ":5432";
 let qs = new URLSearchParams(location.search);
 let qsRemoteHost = qs.get("remoteHost");
+let qsControlOnly = qs.get("controlOnly");
 if(qsRemoteHost)
   remoteHost = qsRemoteHost
 var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
-worker.postMessage({
-  event: 'wsConnect',
-  remote: wsRemote,
-});
+if(!qsControlOnly) {
+  worker.postMessage({
+    event: 'wsConnect',
+    remote: wsRemote,
+  });
+}
 
 // models
 var Model = require('./Model');
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 47c296d0e..4bd9b9f91 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1375,13 +1375,16 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 var remoteHost = location.hostname + ":5432";
 var qs = new URLSearchParams(location.search);
 var qsRemoteHost = qs.get("remoteHost");
+var qsControlOnly = qs.get("controlOnly");
 if (qsRemoteHost) remoteHost = qsRemoteHost;
 var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
-worker.postMessage({
-  event: 'wsConnect',
-  remote: wsRemote
-});
+if (!qsControlOnly) {
+  worker.postMessage({
+    event: 'wsConnect',
+    remote: wsRemote
+  });
+}
 
 // models
 var Model = require('./Model');

From 277bcaec9f9223aaab68194aad1ecebbdaa1b8f8 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 23 Aug 2023 13:46:31 -0500
Subject: [PATCH 061/188] Scope: pixi updated to v6.5.10

---
 IDE/public/scope/js/pixi.js | 77475 +++++++++++++++++-----------------
 1 file changed, 38140 insertions(+), 39335 deletions(-)

diff --git a/IDE/public/scope/js/pixi.js b/IDE/public/scope/js/pixi.js
index d7e4565b5..52fd42b73 100644
--- a/IDE/public/scope/js/pixi.js
+++ b/IDE/public/scope/js/pixi.js
@@ -1,40026 +1,38831 @@
 /*!
- * pixi.js - v4.5.4
- * Compiled Mon, 24 Jul 2017 18:13:16 UTC
+ * pixi.js - v6.5.10
+ * Compiled Thu, 06 Jul 2023 15:25:11 UTC
  *
  * pixi.js is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
  */
-(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.PIXI = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
-/**
- * Bit twiddling hacks for JavaScript.
- *
- * Author: Mikola Lysenko
- *
- * Ported from Stanford bit twiddling hack library:
- *    http://graphics.stanford.edu/~seander/bithacks.html
- */
+var PIXI = (function (exports) {
+  'use strict';
 
-"use strict"; "use restrict";
-
-//Number of bits in an integer
-var INT_BITS = 32;
-
-//Constants
-exports.INT_BITS  = INT_BITS;
-exports.INT_MAX   =  0x7fffffff;
-exports.INT_MIN   = -1<<(INT_BITS-1);
-
-//Returns -1, 0, +1 depending on sign of x
-exports.sign = function(v) {
-  return (v > 0) - (v < 0);
-}
-
-//Computes absolute value of integer
-exports.abs = function(v) {
-  var mask = v >> (INT_BITS-1);
-  return (v ^ mask) - mask;
-}
-
-//Computes minimum of integers x and y
-exports.min = function(x, y) {
-  return y ^ ((x ^ y) & -(x < y));
-}
-
-//Computes maximum of integers x and y
-exports.max = function(x, y) {
-  return x ^ ((x ^ y) & -(x < y));
-}
-
-//Checks if a number is a power of two
-exports.isPow2 = function(v) {
-  return !(v & (v-1)) && (!!v);
-}
-
-//Computes log base 2 of v
-exports.log2 = function(v) {
-  var r, shift;
-  r =     (v > 0xFFFF) << 4; v >>>= r;
-  shift = (v > 0xFF  ) << 3; v >>>= shift; r |= shift;
-  shift = (v > 0xF   ) << 2; v >>>= shift; r |= shift;
-  shift = (v > 0x3   ) << 1; v >>>= shift; r |= shift;
-  return r | (v >> 1);
-}
-
-//Computes log base 10 of v
-exports.log10 = function(v) {
-  return  (v >= 1000000000) ? 9 : (v >= 100000000) ? 8 : (v >= 10000000) ? 7 :
-          (v >= 1000000) ? 6 : (v >= 100000) ? 5 : (v >= 10000) ? 4 :
-          (v >= 1000) ? 3 : (v >= 100) ? 2 : (v >= 10) ? 1 : 0;
-}
-
-//Counts number of bits
-exports.popCount = function(v) {
-  v = v - ((v >>> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
-  return ((v + (v >>> 4) & 0xF0F0F0F) * 0x1010101) >>> 24;
-}
-
-//Counts number of trailing zeros
-function countTrailingZeros(v) {
-  var c = 32;
-  v &= -v;
-  if (v) c--;
-  if (v & 0x0000FFFF) c -= 16;
-  if (v & 0x00FF00FF) c -= 8;
-  if (v & 0x0F0F0F0F) c -= 4;
-  if (v & 0x33333333) c -= 2;
-  if (v & 0x55555555) c -= 1;
-  return c;
-}
-exports.countTrailingZeros = countTrailingZeros;
-
-//Rounds to next power of 2
-exports.nextPow2 = function(v) {
-  v += v === 0;
-  --v;
-  v |= v >>> 1;
-  v |= v >>> 2;
-  v |= v >>> 4;
-  v |= v >>> 8;
-  v |= v >>> 16;
-  return v + 1;
-}
-
-//Rounds down to previous power of 2
-exports.prevPow2 = function(v) {
-  v |= v >>> 1;
-  v |= v >>> 2;
-  v |= v >>> 4;
-  v |= v >>> 8;
-  v |= v >>> 16;
-  return v - (v>>>1);
-}
-
-//Computes parity of word
-exports.parity = function(v) {
-  v ^= v >>> 16;
-  v ^= v >>> 8;
-  v ^= v >>> 4;
-  v &= 0xf;
-  return (0x6996 >>> v) & 1;
-}
-
-var REVERSE_TABLE = new Array(256);
-
-(function(tab) {
-  for(var i=0; i<256; ++i) {
-    var v = i, r = i, s = 7;
-    for (v >>>= 1; v; v >>>= 1) {
-      r <<= 1;
-      r |= v & 1;
-      --s;
-    }
-    tab[i] = (r << s) & 0xff;
+  /**
+   * @this {Promise}
+   */
+  function finallyConstructor(callback) {
+    var constructor = this.constructor;
+    return this.then(
+      function(value) {
+        // @ts-ignore
+        return constructor.resolve(callback()).then(function() {
+          return value;
+        });
+      },
+      function(reason) {
+        // @ts-ignore
+        return constructor.resolve(callback()).then(function() {
+          // @ts-ignore
+          return constructor.reject(reason);
+        });
+      }
+    );
   }
-})(REVERSE_TABLE);
-
-//Reverse bits in a 32 bit word
-exports.reverse = function(v) {
-  return  (REVERSE_TABLE[ v         & 0xff] << 24) |
-          (REVERSE_TABLE[(v >>> 8)  & 0xff] << 16) |
-          (REVERSE_TABLE[(v >>> 16) & 0xff] << 8)  |
-           REVERSE_TABLE[(v >>> 24) & 0xff];
-}
-
-//Interleave bits of 2 coordinates with 16 bits.  Useful for fast quadtree codes
-exports.interleave2 = function(x, y) {
-  x &= 0xFFFF;
-  x = (x | (x << 8)) & 0x00FF00FF;
-  x = (x | (x << 4)) & 0x0F0F0F0F;
-  x = (x | (x << 2)) & 0x33333333;
-  x = (x | (x << 1)) & 0x55555555;
-
-  y &= 0xFFFF;
-  y = (y | (y << 8)) & 0x00FF00FF;
-  y = (y | (y << 4)) & 0x0F0F0F0F;
-  y = (y | (y << 2)) & 0x33333333;
-  y = (y | (y << 1)) & 0x55555555;
-
-  return x | (y << 1);
-}
-
-//Extracts the nth interleaved component
-exports.deinterleave2 = function(v, n) {
-  v = (v >>> n) & 0x55555555;
-  v = (v | (v >>> 1))  & 0x33333333;
-  v = (v | (v >>> 2))  & 0x0F0F0F0F;
-  v = (v | (v >>> 4))  & 0x00FF00FF;
-  v = (v | (v >>> 16)) & 0x000FFFF;
-  return (v << 16) >> 16;
-}
-
-
-//Interleave bits of 3 coordinates, each with 10 bits.  Useful for fast octree codes
-exports.interleave3 = function(x, y, z) {
-  x &= 0x3FF;
-  x  = (x | (x<<16)) & 4278190335;
-  x  = (x | (x<<8))  & 251719695;
-  x  = (x | (x<<4))  & 3272356035;
-  x  = (x | (x<<2))  & 1227133513;
-
-  y &= 0x3FF;
-  y  = (y | (y<<16)) & 4278190335;
-  y  = (y | (y<<8))  & 251719695;
-  y  = (y | (y<<4))  & 3272356035;
-  y  = (y | (y<<2))  & 1227133513;
-  x |= (y << 1);
-  
-  z &= 0x3FF;
-  z  = (z | (z<<16)) & 4278190335;
-  z  = (z | (z<<8))  & 251719695;
-  z  = (z | (z<<4))  & 3272356035;
-  z  = (z | (z<<2))  & 1227133513;
-  
-  return x | (z << 2);
-}
-
-//Extracts nth interleaved component of a 3-tuple
-exports.deinterleave3 = function(v, n) {
-  v = (v >>> n)       & 1227133513;
-  v = (v | (v>>>2))   & 3272356035;
-  v = (v | (v>>>4))   & 251719695;
-  v = (v | (v>>>8))   & 4278190335;
-  v = (v | (v>>>16))  & 0x3FF;
-  return (v<<22)>>22;
-}
-
-//Computes next combination in colexicographic order (this is mistakenly called nextPermutation on the bit twiddling hacks page)
-exports.nextCombination = function(v) {
-  var t = v | (v - 1);
-  return (t + 1) | (((~t & -~t) - 1) >>> (countTrailingZeros(v) + 1));
-}
-
-
-},{}],2:[function(require,module,exports){
-'use strict';
-
-module.exports = earcut;
-
-function earcut(data, holeIndices, dim) {
-
-    dim = dim || 2;
-
-    var hasHoles = holeIndices && holeIndices.length,
-        outerLen = hasHoles ? holeIndices[0] * dim : data.length,
-        outerNode = linkedList(data, 0, outerLen, dim, true),
-        triangles = [];
-
-    if (!outerNode) return triangles;
-
-    var minX, minY, maxX, maxY, x, y, size;
-
-    if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
-
-    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-    if (data.length > 80 * dim) {
-        minX = maxX = data[0];
-        minY = maxY = data[1];
-
-        for (var i = dim; i < outerLen; i += dim) {
-            x = data[i];
-            y = data[i + 1];
-            if (x < minX) minX = x;
-            if (y < minY) minY = y;
-            if (x > maxX) maxX = x;
-            if (y > maxY) maxY = y;
-        }
-
-        // minX, minY and size are later used to transform coords into integers for z-order calculation
-        size = Math.max(maxX - minX, maxY - minY);
-    }
-
-    earcutLinked(outerNode, triangles, dim, minX, minY, size);
-
-    return triangles;
-}
-
-// create a circular doubly linked list from polygon points in the specified winding order
-function linkedList(data, start, end, dim, clockwise) {
-    var i, last;
-
-    if (clockwise === (signedArea(data, start, end, dim) > 0)) {
-        for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
-    } else {
-        for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
-    }
-
-    if (last && equals(last, last.next)) {
-        removeNode(last);
-        last = last.next;
-    }
-
-    return last;
-}
-
-// eliminate colinear or duplicate points
-function filterPoints(start, end) {
-    if (!start) return start;
-    if (!end) end = start;
-
-    var p = start,
-        again;
-    do {
-        again = false;
-
-        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-            removeNode(p);
-            p = end = p.prev;
-            if (p === p.next) return null;
-            again = true;
 
-        } else {
-            p = p.next;
+  function allSettled(arr) {
+    var P = this;
+    return new P(function(resolve, reject) {
+      if (!(arr && typeof arr.length !== 'undefined')) {
+        return reject(
+          new TypeError(
+            typeof arr +
+              ' ' +
+              arr +
+              ' is not iterable(cannot read property Symbol(Symbol.iterator))'
+          )
+        );
+      }
+      var args = Array.prototype.slice.call(arr);
+      if (args.length === 0) { return resolve([]); }
+      var remaining = args.length;
+
+      function res(i, val) {
+        if (val && (typeof val === 'object' || typeof val === 'function')) {
+          var then = val.then;
+          if (typeof then === 'function') {
+            then.call(
+              val,
+              function(val) {
+                res(i, val);
+              },
+              function(e) {
+                args[i] = { status: 'rejected', reason: e };
+                if (--remaining === 0) {
+                  resolve(args);
+                }
+              }
+            );
+            return;
+          }
         }
-    } while (again || p !== end);
-
-    return end;
-}
-
-// main ear slicing loop which triangulates a polygon (given as a linked list)
-function earcutLinked(ear, triangles, dim, minX, minY, size, pass) {
-    if (!ear) return;
-
-    // interlink polygon nodes in z-order
-    if (!pass && size) indexCurve(ear, minX, minY, size);
-
-    var stop = ear,
-        prev, next;
-
-    // iterate through ears, slicing them one by one
-    while (ear.prev !== ear.next) {
-        prev = ear.prev;
-        next = ear.next;
-
-        if (size ? isEarHashed(ear, minX, minY, size) : isEar(ear)) {
-            // cut off the triangle
-            triangles.push(prev.i / dim);
-            triangles.push(ear.i / dim);
-            triangles.push(next.i / dim);
-
-            removeNode(ear);
-
-            // skipping the next vertice leads to less sliver triangles
-            ear = next.next;
-            stop = next.next;
-
-            continue;
+        args[i] = { status: 'fulfilled', value: val };
+        if (--remaining === 0) {
+          resolve(args);
         }
+      }
 
-        ear = next;
-
-        // if we looped through the whole remaining polygon and can't find any more ears
-        if (ear === stop) {
-            // try filtering points and slicing again
-            if (!pass) {
-                earcutLinked(filterPoints(ear), triangles, dim, minX, minY, size, 1);
-
-            // if this didn't work, try curing all small self-intersections locally
-            } else if (pass === 1) {
-                ear = cureLocalIntersections(ear, triangles, dim);
-                earcutLinked(ear, triangles, dim, minX, minY, size, 2);
+      for (var i = 0; i < args.length; i++) {
+        res(i, args[i]);
+      }
+    });
+  }
 
-            // as a last resort, try splitting the remaining polygon into two
-            } else if (pass === 2) {
-                splitEarcut(ear, triangles, dim, minX, minY, size);
-            }
+  // Store setTimeout reference so promise-polyfill will be unaffected by
+  // other code modifying setTimeout (like sinon.useFakeTimers())
+  var setTimeoutFunc = setTimeout;
 
-            break;
-        }
-    }
-}
+  function isArray(x) {
+    return Boolean(x && typeof x.length !== 'undefined');
+  }
 
-// check whether a polygon node forms a valid ear with adjacent nodes
-function isEar(ear) {
-    var a = ear.prev,
-        b = ear,
-        c = ear.next;
+  function noop() {}
 
-    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+  // Polyfill for Function.prototype.bind
+  function bind(fn, thisArg) {
+    return function() {
+      fn.apply(thisArg, arguments);
+    };
+  }
 
-    // now make sure we don't have other points inside the potential ear
-    var p = ear.next.next;
+  /**
+   * @constructor
+   * @param {Function} fn
+   */
+  function Promise$1(fn) {
+    if (!(this instanceof Promise$1))
+      { throw new TypeError('Promises must be constructed via new'); }
+    if (typeof fn !== 'function') { throw new TypeError('not a function'); }
+    /** @type {!number} */
+    this._state = 0;
+    /** @type {!boolean} */
+    this._handled = false;
+    /** @type {Promise|undefined} */
+    this._value = undefined;
+    /** @type {!Array<!Function>} */
+    this._deferreds = [];
+
+    doResolve(fn, this);
+  }
 
-    while (p !== ear.prev) {
-        if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
-            area(p.prev, p, p.next) >= 0) return false;
-        p = p.next;
+  function handle(self, deferred) {
+    while (self._state === 3) {
+      self = self._value;
     }
-
-    return true;
-}
-
-function isEarHashed(ear, minX, minY, size) {
-    var a = ear.prev,
-        b = ear,
-        c = ear.next;
-
-    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-    // triangle bbox; min & max are calculated like this for speed
-    var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : (b.x < c.x ? b.x : c.x),
-        minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : (b.y < c.y ? b.y : c.y),
-        maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : (b.x > c.x ? b.x : c.x),
-        maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : (b.y > c.y ? b.y : c.y);
-
-    // z-order range for the current triangle bbox;
-    var minZ = zOrder(minTX, minTY, minX, minY, size),
-        maxZ = zOrder(maxTX, maxTY, minX, minY, size);
-
-    // first look for points inside the triangle in increasing z-order
-    var p = ear.nextZ;
-
-    while (p && p.z <= maxZ) {
-        if (p !== ear.prev && p !== ear.next &&
-            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
-            area(p.prev, p, p.next) >= 0) return false;
-        p = p.nextZ;
+    if (self._state === 0) {
+      self._deferreds.push(deferred);
+      return;
     }
+    self._handled = true;
+    Promise$1._immediateFn(function() {
+      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+      if (cb === null) {
+        (self._state === 1 ? resolve$1 : reject)(deferred.promise, self._value);
+        return;
+      }
+      var ret;
+      try {
+        ret = cb(self._value);
+      } catch (e) {
+        reject(deferred.promise, e);
+        return;
+      }
+      resolve$1(deferred.promise, ret);
+    });
+  }
 
-    // then look for points in decreasing z-order
-    p = ear.prevZ;
-
-    while (p && p.z >= minZ) {
-        if (p !== ear.prev && p !== ear.next &&
-            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
-            area(p.prev, p, p.next) >= 0) return false;
-        p = p.prevZ;
+  function resolve$1(self, newValue) {
+    try {
+      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+      if (newValue === self)
+        { throw new TypeError('A promise cannot be resolved with itself.'); }
+      if (
+        newValue &&
+        (typeof newValue === 'object' || typeof newValue === 'function')
+      ) {
+        var then = newValue.then;
+        if (newValue instanceof Promise$1) {
+          self._state = 3;
+          self._value = newValue;
+          finale(self);
+          return;
+        } else if (typeof then === 'function') {
+          doResolve(bind(then, newValue), self);
+          return;
+        }
+      }
+      self._state = 1;
+      self._value = newValue;
+      finale(self);
+    } catch (e) {
+      reject(self, e);
     }
+  }
 
-    return true;
-}
-
-// go through all polygon nodes and cure small local self-intersections
-function cureLocalIntersections(start, triangles, dim) {
-    var p = start;
-    do {
-        var a = p.prev,
-            b = p.next.next;
-
-        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-
-            triangles.push(a.i / dim);
-            triangles.push(p.i / dim);
-            triangles.push(b.i / dim);
-
-            // remove two nodes involved
-            removeNode(p);
-            removeNode(p.next);
+  function reject(self, newValue) {
+    self._state = 2;
+    self._value = newValue;
+    finale(self);
+  }
 
-            p = start = b;
-        }
-        p = p.next;
-    } while (p !== start);
-
-    return p;
-}
-
-// try splitting polygon into two and triangulate them independently
-function splitEarcut(start, triangles, dim, minX, minY, size) {
-    // look for a valid diagonal that divides the polygon into two
-    var a = start;
-    do {
-        var b = a.next.next;
-        while (b !== a.prev) {
-            if (a.i !== b.i && isValidDiagonal(a, b)) {
-                // split the polygon in two by the diagonal
-                var c = splitPolygon(a, b);
-
-                // filter colinear points around the cuts
-                a = filterPoints(a, a.next);
-                c = filterPoints(c, c.next);
-
-                // run earcut on each half
-                earcutLinked(a, triangles, dim, minX, minY, size);
-                earcutLinked(c, triangles, dim, minX, minY, size);
-                return;
-            }
-            b = b.next;
+  function finale(self) {
+    if (self._state === 2 && self._deferreds.length === 0) {
+      Promise$1._immediateFn(function() {
+        if (!self._handled) {
+          Promise$1._unhandledRejectionFn(self._value);
         }
-        a = a.next;
-    } while (a !== start);
-}
-
-// link every hole into the outer loop, producing a single-ring polygon without holes
-function eliminateHoles(data, holeIndices, outerNode, dim) {
-    var queue = [],
-        i, len, start, end, list;
-
-    for (i = 0, len = holeIndices.length; i < len; i++) {
-        start = holeIndices[i] * dim;
-        end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-        list = linkedList(data, start, end, dim, false);
-        if (list === list.next) list.steiner = true;
-        queue.push(getLeftmost(list));
+      });
     }
 
-    queue.sort(compareX);
-
-    // process holes from left to right
-    for (i = 0; i < queue.length; i++) {
-        eliminateHole(queue[i], outerNode);
-        outerNode = filterPoints(outerNode, outerNode.next);
+    for (var i = 0, len = self._deferreds.length; i < len; i++) {
+      handle(self, self._deferreds[i]);
     }
+    self._deferreds = null;
+  }
 
-    return outerNode;
-}
-
-function compareX(a, b) {
-    return a.x - b.x;
-}
+  /**
+   * @constructor
+   */
+  function Handler(onFulfilled, onRejected, promise) {
+    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+    this.promise = promise;
+  }
 
-// find a bridge between vertices that connects hole with an outer ring and and link it
-function eliminateHole(hole, outerNode) {
-    outerNode = findHoleBridge(hole, outerNode);
-    if (outerNode) {
-        var b = splitPolygon(outerNode, hole);
-        filterPoints(b, b.next);
-    }
-}
-
-// David Eberly's algorithm for finding a bridge between hole and outer polygon
-function findHoleBridge(hole, outerNode) {
-    var p = outerNode,
-        hx = hole.x,
-        hy = hole.y,
-        qx = -Infinity,
-        m;
-
-    // find a segment intersected by a ray from the hole's leftmost point to the left;
-    // segment's endpoint with lesser x will be potential connection point
-    do {
-        if (hy <= p.y && hy >= p.next.y) {
-            var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-            if (x <= hx && x > qx) {
-                qx = x;
-                if (x === hx) {
-                    if (hy === p.y) return p;
-                    if (hy === p.next.y) return p.next;
-                }
-                m = p.x < p.next.x ? p : p.next;
-            }
+  /**
+   * Take a potentially misbehaving resolver function and make sure
+   * onFulfilled and onRejected are only called once.
+   *
+   * Makes no guarantees about asynchrony.
+   */
+  function doResolve(fn, self) {
+    var done = false;
+    try {
+      fn(
+        function(value) {
+          if (done) { return; }
+          done = true;
+          resolve$1(self, value);
+        },
+        function(reason) {
+          if (done) { return; }
+          done = true;
+          reject(self, reason);
         }
-        p = p.next;
-    } while (p !== outerNode);
-
-    if (!m) return null;
-
-    if (hx === qx) return m.prev; // hole touches outer segment; pick lower endpoint
-
-    // look for points inside the triangle of hole point, segment intersection and endpoint;
-    // if there are no points found, we have a valid connection;
-    // otherwise choose the point of the minimum angle with the ray as connection point
-
-    var stop = m,
-        mx = m.x,
-        my = m.y,
-        tanMin = Infinity,
-        tan;
-
-    p = m.next;
-
-    while (p !== stop) {
-        if (hx >= p.x && p.x >= mx &&
-                pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+      );
+    } catch (ex) {
+      if (done) { return; }
+      done = true;
+      reject(self, ex);
+    }
+  }
 
-            tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
+  Promise$1.prototype['catch'] = function(onRejected) {
+    return this.then(null, onRejected);
+  };
 
-            if ((tan < tanMin || (tan === tanMin && p.x > m.x)) && locallyInside(p, hole)) {
-                m = p;
-                tanMin = tan;
-            }
-        }
+  Promise$1.prototype.then = function(onFulfilled, onRejected) {
+    // @ts-ignore
+    var prom = new this.constructor(noop);
 
-        p = p.next;
-    }
+    handle(this, new Handler(onFulfilled, onRejected, prom));
+    return prom;
+  };
 
-    return m;
-}
-
-// interlink polygon nodes in z-order
-function indexCurve(start, minX, minY, size) {
-    var p = start;
-    do {
-        if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, size);
-        p.prevZ = p.prev;
-        p.nextZ = p.next;
-        p = p.next;
-    } while (p !== start);
-
-    p.prevZ.nextZ = null;
-    p.prevZ = null;
-
-    sortLinked(p);
-}
-
-// Simon Tatham's linked list merge sort algorithm
-// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-function sortLinked(list) {
-    var i, p, q, e, tail, numMerges, pSize, qSize,
-        inSize = 1;
-
-    do {
-        p = list;
-        list = null;
-        tail = null;
-        numMerges = 0;
-
-        while (p) {
-            numMerges++;
-            q = p;
-            pSize = 0;
-            for (i = 0; i < inSize; i++) {
-                pSize++;
-                q = q.nextZ;
-                if (!q) break;
-            }
+  Promise$1.prototype['finally'] = finallyConstructor;
 
-            qSize = inSize;
-
-            while (pSize > 0 || (qSize > 0 && q)) {
-
-                if (pSize === 0) {
-                    e = q;
-                    q = q.nextZ;
-                    qSize--;
-                } else if (qSize === 0 || !q) {
-                    e = p;
-                    p = p.nextZ;
-                    pSize--;
-                } else if (p.z <= q.z) {
-                    e = p;
-                    p = p.nextZ;
-                    pSize--;
-                } else {
-                    e = q;
-                    q = q.nextZ;
-                    qSize--;
-                }
+  Promise$1.all = function(arr) {
+    return new Promise$1(function(resolve, reject) {
+      if (!isArray(arr)) {
+        return reject(new TypeError('Promise.all accepts an array'));
+      }
 
-                if (tail) tail.nextZ = e;
-                else list = e;
+      var args = Array.prototype.slice.call(arr);
+      if (args.length === 0) { return resolve([]); }
+      var remaining = args.length;
 
-                e.prevZ = tail;
-                tail = e;
+      function res(i, val) {
+        try {
+          if (val && (typeof val === 'object' || typeof val === 'function')) {
+            var then = val.then;
+            if (typeof then === 'function') {
+              then.call(
+                val,
+                function(val) {
+                  res(i, val);
+                },
+                reject
+              );
+              return;
             }
-
-            p = q;
+          }
+          args[i] = val;
+          if (--remaining === 0) {
+            resolve(args);
+          }
+        } catch (ex) {
+          reject(ex);
         }
+      }
 
-        tail.nextZ = null;
-        inSize *= 2;
-
-    } while (numMerges > 1);
-
-    return list;
-}
-
-// z-order of a point given coords and size of the data bounding box
-function zOrder(x, y, minX, minY, size) {
-    // coords are transformed into non-negative 15-bit integer range
-    x = 32767 * (x - minX) / size;
-    y = 32767 * (y - minY) / size;
-
-    x = (x | (x << 8)) & 0x00FF00FF;
-    x = (x | (x << 4)) & 0x0F0F0F0F;
-    x = (x | (x << 2)) & 0x33333333;
-    x = (x | (x << 1)) & 0x55555555;
-
-    y = (y | (y << 8)) & 0x00FF00FF;
-    y = (y | (y << 4)) & 0x0F0F0F0F;
-    y = (y | (y << 2)) & 0x33333333;
-    y = (y | (y << 1)) & 0x55555555;
-
-    return x | (y << 1);
-}
-
-// find the leftmost node of a polygon ring
-function getLeftmost(start) {
-    var p = start,
-        leftmost = start;
-    do {
-        if (p.x < leftmost.x) leftmost = p;
-        p = p.next;
-    } while (p !== start);
-
-    return leftmost;
-}
-
-// check if a point lies within a convex triangle
-function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
-    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
-           (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
-           (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
-}
-
-// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
-function isValidDiagonal(a, b) {
-    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) &&
-           locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);
-}
-
-// signed area of a triangle
-function area(p, q, r) {
-    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-}
-
-// check if two points are equal
-function equals(p1, p2) {
-    return p1.x === p2.x && p1.y === p2.y;
-}
-
-// check if two segments intersect
-function intersects(p1, q1, p2, q2) {
-    if ((equals(p1, q1) && equals(p2, q2)) ||
-        (equals(p1, q2) && equals(p2, q1))) return true;
-    return area(p1, q1, p2) > 0 !== area(p1, q1, q2) > 0 &&
-           area(p2, q2, p1) > 0 !== area(p2, q2, q1) > 0;
-}
-
-// check if a polygon diagonal intersects any polygon segments
-function intersectsPolygon(a, b) {
-    var p = a;
-    do {
-        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
-                intersects(p, p.next, a, b)) return true;
-        p = p.next;
-    } while (p !== a);
-
-    return false;
-}
-
-// check if a polygon diagonal is locally inside the polygon
-function locallyInside(a, b) {
-    return area(a.prev, a, a.next) < 0 ?
-        area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
-        area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
-}
-
-// check if the middle point of a polygon diagonal is inside the polygon
-function middleInside(a, b) {
-    var p = a,
-        inside = false,
-        px = (a.x + b.x) / 2,
-        py = (a.y + b.y) / 2;
-    do {
-        if (((p.y > py) !== (p.next.y > py)) && (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
-            inside = !inside;
-        p = p.next;
-    } while (p !== a);
-
-    return inside;
-}
-
-// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
-// if one belongs to the outer ring and another to a hole, it merges it into a single ring
-function splitPolygon(a, b) {
-    var a2 = new Node(a.i, a.x, a.y),
-        b2 = new Node(b.i, b.x, b.y),
-        an = a.next,
-        bp = b.prev;
-
-    a.next = b;
-    b.prev = a;
-
-    a2.next = an;
-    an.prev = a2;
-
-    b2.next = a2;
-    a2.prev = b2;
-
-    bp.next = b2;
-    b2.prev = bp;
-
-    return b2;
-}
-
-// create a node and optionally link it with previous one (in a circular doubly linked list)
-function insertNode(i, x, y, last) {
-    var p = new Node(i, x, y);
-
-    if (!last) {
-        p.prev = p;
-        p.next = p;
+      for (var i = 0; i < args.length; i++) {
+        res(i, args[i]);
+      }
+    });
+  };
 
-    } else {
-        p.next = last.next;
-        p.prev = last;
-        last.next.prev = p;
-        last.next = p;
-    }
-    return p;
-}
-
-function removeNode(p) {
-    p.next.prev = p.prev;
-    p.prev.next = p.next;
-
-    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
-    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
-}
-
-function Node(i, x, y) {
-    // vertice index in coordinates array
-    this.i = i;
-
-    // vertex coordinates
-    this.x = x;
-    this.y = y;
-
-    // previous and next vertice nodes in a polygon ring
-    this.prev = null;
-    this.next = null;
-
-    // z-order curve value
-    this.z = null;
-
-    // previous and next nodes in z-order
-    this.prevZ = null;
-    this.nextZ = null;
-
-    // indicates whether this is a steiner point
-    this.steiner = false;
-}
-
-// return a percentage difference between the polygon area and its triangulation area;
-// used to verify correctness of triangulation
-earcut.deviation = function (data, holeIndices, dim, triangles) {
-    var hasHoles = holeIndices && holeIndices.length;
-    var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-
-    var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
-    if (hasHoles) {
-        for (var i = 0, len = holeIndices.length; i < len; i++) {
-            var start = holeIndices[i] * dim;
-            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-            polygonArea -= Math.abs(signedArea(data, start, end, dim));
-        }
-    }
+  Promise$1.allSettled = allSettled;
 
-    var trianglesArea = 0;
-    for (i = 0; i < triangles.length; i += 3) {
-        var a = triangles[i] * dim;
-        var b = triangles[i + 1] * dim;
-        var c = triangles[i + 2] * dim;
-        trianglesArea += Math.abs(
-            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
-            (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
+  Promise$1.resolve = function(value) {
+    if (value && typeof value === 'object' && value.constructor === Promise$1) {
+      return value;
     }
 
-    return polygonArea === 0 && trianglesArea === 0 ? 0 :
-        Math.abs((trianglesArea - polygonArea) / polygonArea);
-};
+    return new Promise$1(function(resolve) {
+      resolve(value);
+    });
+  };
 
-function signedArea(data, start, end, dim) {
-    var sum = 0;
-    for (var i = start, j = end - dim; i < end; i += dim) {
-        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
-        j = i;
-    }
-    return sum;
-}
-
-// turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
-earcut.flatten = function (data) {
-    var dim = data[0][0].length,
-        result = {vertices: [], holes: [], dimensions: dim},
-        holeIndex = 0;
-
-    for (var i = 0; i < data.length; i++) {
-        for (var j = 0; j < data[i].length; j++) {
-            for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);
-        }
-        if (i > 0) {
-            holeIndex += data[i - 1].length;
-            result.holes.push(holeIndex);
-        }
-    }
-    return result;
-};
+  Promise$1.reject = function(value) {
+    return new Promise$1(function(resolve, reject) {
+      reject(value);
+    });
+  };
 
-},{}],3:[function(require,module,exports){
-'use strict';
+  Promise$1.race = function(arr) {
+    return new Promise$1(function(resolve, reject) {
+      if (!isArray(arr)) {
+        return reject(new TypeError('Promise.race accepts an array'));
+      }
 
-var has = Object.prototype.hasOwnProperty
-  , prefix = '~';
+      for (var i = 0, len = arr.length; i < len; i++) {
+        Promise$1.resolve(arr[i]).then(resolve, reject);
+      }
+    });
+  };
 
-/**
- * Constructor to create a storage for our `EE` objects.
- * An `Events` instance is a plain object whose properties are event names.
- *
- * @constructor
- * @api private
- */
-function Events() {}
-
-//
-// We try to not inherit from `Object.prototype`. In some engines creating an
-// instance in this way is faster than calling `Object.create(null)` directly.
-// If `Object.create(null)` is not supported we prefix the event names with a
-// character to make sure that the built-in object properties are not
-// overridden or used as an attack vector.
-//
-if (Object.create) {
-  Events.prototype = Object.create(null);
+  // Use polyfill for setImmediate for performance gains
+  Promise$1._immediateFn =
+    // @ts-ignore
+    (typeof setImmediate === 'function' &&
+      function(fn) {
+        // @ts-ignore
+        setImmediate(fn);
+      }) ||
+    function(fn) {
+      setTimeoutFunc(fn, 0);
+    };
 
-  //
-  // This hack is needed because the `__proto__` property is still inherited in
-  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
-  //
-  if (!new Events().__proto__) prefix = false;
-}
+  Promise$1._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+    if (typeof console !== 'undefined' && console) {
+      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
+    }
+  };
 
-/**
- * Representation of a single event listener.
- *
- * @param {Function} fn The listener function.
- * @param {Mixed} context The context to invoke the listener with.
- * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
- * @constructor
- * @api private
- */
-function EE(fn, context, once) {
-  this.fn = fn;
-  this.context = context;
-  this.once = once || false;
-}
-
-/**
- * Minimal `EventEmitter` interface that is molded against the Node.js
- * `EventEmitter` interface.
- *
- * @constructor
- * @api public
- */
-function EventEmitter() {
-  this._events = new Events();
-  this._eventsCount = 0;
-}
-
-/**
- * Return an array listing the events for which the emitter has registered
- * listeners.
- *
- * @returns {Array}
- * @api public
- */
-EventEmitter.prototype.eventNames = function eventNames() {
-  var names = []
-    , events
-    , name;
+  /*
+  object-assign
+  (c) Sindre Sorhus
+  @license MIT
+  */
 
-  if (this._eventsCount === 0) return names;
+  'use strict';
+  /* eslint-disable no-unused-vars */
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+  var propIsEnumerable = Object.prototype.propertyIsEnumerable;
 
-  for (name in (events = this._events)) {
-    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
-  }
+  function toObject(val) {
+  	if (val === null || val === undefined) {
+  		throw new TypeError('Object.assign cannot be called with null or undefined');
+  	}
 
-  if (Object.getOwnPropertySymbols) {
-    return names.concat(Object.getOwnPropertySymbols(events));
+  	return Object(val);
   }
 
-  return names;
-};
-
-/**
- * Return the listeners registered for a given event.
- *
- * @param {String|Symbol} event The event name.
- * @param {Boolean} exists Only check if there are listeners.
- * @returns {Array|Boolean}
- * @api public
- */
-EventEmitter.prototype.listeners = function listeners(event, exists) {
-  var evt = prefix ? prefix + event : event
-    , available = this._events[evt];
-
-  if (exists) return !!available;
-  if (!available) return [];
-  if (available.fn) return [available.fn];
-
-  for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {
-    ee[i] = available[i].fn;
+  function shouldUseNative() {
+  	try {
+  		if (!Object.assign) {
+  			return false;
+  		}
+
+  		// Detect buggy property enumeration order in older V8 versions.
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+  		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+  		test1[5] = 'de';
+  		if (Object.getOwnPropertyNames(test1)[0] === '5') {
+  			return false;
+  		}
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+  		var test2 = {};
+  		for (var i = 0; i < 10; i++) {
+  			test2['_' + String.fromCharCode(i)] = i;
+  		}
+  		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+  			return test2[n];
+  		});
+  		if (order2.join('') !== '0123456789') {
+  			return false;
+  		}
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+  		var test3 = {};
+  		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+  			test3[letter] = letter;
+  		});
+  		if (Object.keys(Object.assign({}, test3)).join('') !==
+  				'abcdefghijklmnopqrst') {
+  			return false;
+  		}
+
+  		return true;
+  	} catch (err) {
+  		// We don't expect any of the above to throw, but better to be safe.
+  		return false;
+  	}
   }
 
-  return ee;
-};
-
-/**
- * Calls each of the listeners registered for a given event.
- *
- * @param {String|Symbol} event The event name.
- * @returns {Boolean} `true` if the event had listeners, else `false`.
- * @api public
- */
-EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-  var evt = prefix ? prefix + event : event;
-
-  if (!this._events[evt]) return false;
-
-  var listeners = this._events[evt]
-    , len = arguments.length
-    , args
-    , i;
-
-  if (listeners.fn) {
-    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
-
-    switch (len) {
-      case 1: return listeners.fn.call(listeners.context), true;
-      case 2: return listeners.fn.call(listeners.context, a1), true;
-      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
-      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
-      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-    }
-
-    for (i = 1, args = new Array(len -1); i < len; i++) {
-      args[i - 1] = arguments[i];
-    }
-
-    listeners.fn.apply(listeners.context, args);
-  } else {
-    var length = listeners.length
-      , j;
-
-    for (i = 0; i < length; i++) {
-      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+  var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+  	var arguments$1 = arguments;
+
+  	var from;
+  	var to = toObject(target);
+  	var symbols;
+
+  	for (var s = 1; s < arguments.length; s++) {
+  		from = Object(arguments$1[s]);
+
+  		for (var key in from) {
+  			if (hasOwnProperty$1.call(from, key)) {
+  				to[key] = from[key];
+  			}
+  		}
+
+  		if (getOwnPropertySymbols) {
+  			symbols = getOwnPropertySymbols(from);
+  			for (var i = 0; i < symbols.length; i++) {
+  				if (propIsEnumerable.call(from, symbols[i])) {
+  					to[symbols[i]] = from[symbols[i]];
+  				}
+  			}
+  		}
+  	}
+
+  	return to;
+  };
 
-      switch (len) {
-        case 1: listeners[i].fn.call(listeners[i].context); break;
-        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
-        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
-        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
-        default:
-          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
-            args[j - 1] = arguments[j];
-          }
+  /*!
+   * @pixi/polyfill - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/polyfill is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-          listeners[i].fn.apply(listeners[i].context, args);
+  if (typeof globalThis === 'undefined') {
+      if (typeof self !== 'undefined') {
+          // covers browsers
+          // @ts-expect-error not-writable ts(2540) error only on node
+          self.globalThis = self;
+      }
+      else if (typeof global !== 'undefined') {
+          // covers versions of Node < 12
+          // @ts-expect-error not-writable ts(2540) error only on node
+          global.globalThis = global;
       }
-    }
   }
 
-  return true;
-};
-
-/**
- * Add a listener for a given event.
- *
- * @param {String|Symbol} event The event name.
- * @param {Function} fn The listener function.
- * @param {Mixed} [context=this] The context to invoke the listener with.
- * @returns {EventEmitter} `this`.
- * @api public
- */
-EventEmitter.prototype.on = function on(event, fn, context) {
-  var listener = new EE(fn, context || this)
-    , evt = prefix ? prefix + event : event;
-
-  if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
-  else if (!this._events[evt].fn) this._events[evt].push(listener);
-  else this._events[evt] = [this._events[evt], listener];
-
-  return this;
-};
-
-/**
- * Add a one-time listener for a given event.
- *
- * @param {String|Symbol} event The event name.
- * @param {Function} fn The listener function.
- * @param {Mixed} [context=this] The context to invoke the listener with.
- * @returns {EventEmitter} `this`.
- * @api public
- */
-EventEmitter.prototype.once = function once(event, fn, context) {
-  var listener = new EE(fn, context || this, true)
-    , evt = prefix ? prefix + event : event;
-
-  if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
-  else if (!this._events[evt].fn) this._events[evt].push(listener);
-  else this._events[evt] = [this._events[evt], listener];
-
-  return this;
-};
-
-/**
- * Remove the listeners of a given event.
- *
- * @param {String|Symbol} event The event name.
- * @param {Function} fn Only remove the listeners that match this function.
- * @param {Mixed} context Only remove the listeners that have this context.
- * @param {Boolean} once Only remove one-time listeners.
- * @returns {EventEmitter} `this`.
- * @api public
- */
-EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-  var evt = prefix ? prefix + event : event;
-
-  if (!this._events[evt]) return this;
-  if (!fn) {
-    if (--this._eventsCount === 0) this._events = new Events();
-    else delete this._events[evt];
-    return this;
+  // Support for IE 9 - 11 which does not include Promises
+  if (!globalThis.Promise) {
+      globalThis.Promise = Promise$1;
   }
 
-  var listeners = this._events[evt];
+  // References:
+  if (!Object.assign) {
+      Object.assign = objectAssign;
+  }
 
-  if (listeners.fn) {
-    if (
-         listeners.fn === fn
-      && (!once || listeners.once)
-      && (!context || listeners.context === context)
-    ) {
-      if (--this._eventsCount === 0) this._events = new Events();
-      else delete this._events[evt];
-    }
-  } else {
-    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-      if (
-           listeners[i].fn !== fn
-        || (once && !listeners[i].once)
-        || (context && listeners[i].context !== context)
-      ) {
-        events.push(listeners[i]);
+  // References:
+  // http://paulirish.com/2011/requestanimationframe-for-smart-animating/
+  // https://gist.github.com/1579671
+  // http://updates.html5rocks.com/2012/05/requestAnimationFrame-API-now-with-sub-millisecond-precision
+  // https://gist.github.com/timhall/4078614
+  // https://github.com/Financial-Times/polyfill-service/tree/master/polyfills/requestAnimationFrame
+  // Expected to be used with Browserfiy
+  // Browserify automatically detects the use of `global` and passes the
+  // correct reference of `global`, `globalThis`, and finally `window`
+  var ONE_FRAME_TIME = 16;
+  // Date.now
+  if (!(Date.now && Date.prototype.getTime)) {
+      Date.now = function now() {
+          return new Date().getTime();
+      };
+  }
+  // performance.now
+  if (!(globalThis.performance && globalThis.performance.now)) {
+      var startTime_1 = Date.now();
+      if (!globalThis.performance) {
+          globalThis.performance = {};
       }
-    }
-
-    //
-    // Reset the array, or remove it completely if we have no more listeners.
-    //
-    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
-    else if (--this._eventsCount === 0) this._events = new Events();
-    else delete this._events[evt];
+      globalThis.performance.now = function () { return Date.now() - startTime_1; };
   }
-
-  return this;
-};
-
-/**
- * Remove all listeners, or those of the specified event.
- *
- * @param {String|Symbol} [event] The event name.
- * @returns {EventEmitter} `this`.
- * @api public
- */
-EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-  var evt;
-
-  if (event) {
-    evt = prefix ? prefix + event : event;
-    if (this._events[evt]) {
-      if (--this._eventsCount === 0) this._events = new Events();
-      else delete this._events[evt];
-    }
-  } else {
-    this._events = new Events();
-    this._eventsCount = 0;
+  // requestAnimationFrame
+  var lastTime = Date.now();
+  var vendors = ['ms', 'moz', 'webkit', 'o'];
+  for (var x = 0; x < vendors.length && !globalThis.requestAnimationFrame; ++x) {
+      var p = vendors[x];
+      globalThis.requestAnimationFrame = globalThis[p + "RequestAnimationFrame"];
+      globalThis.cancelAnimationFrame = globalThis[p + "CancelAnimationFrame"]
+          || globalThis[p + "CancelRequestAnimationFrame"];
+  }
+  if (!globalThis.requestAnimationFrame) {
+      globalThis.requestAnimationFrame = function (callback) {
+          if (typeof callback !== 'function') {
+              throw new TypeError(callback + "is not a function");
+          }
+          var currentTime = Date.now();
+          var delay = ONE_FRAME_TIME + lastTime - currentTime;
+          if (delay < 0) {
+              delay = 0;
+          }
+          lastTime = currentTime;
+          return globalThis.self.setTimeout(function () {
+              lastTime = Date.now();
+              callback(performance.now());
+          }, delay);
+      };
+  }
+  if (!globalThis.cancelAnimationFrame) {
+      globalThis.cancelAnimationFrame = function (id) { return clearTimeout(id); };
   }
 
-  return this;
-};
-
-//
-// Alias methods names because people roll like that.
-//
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-//
-// This function doesn't apply anymore.
-//
-EventEmitter.prototype.setMaxListeners = function setMaxListeners() {
-  return this;
-};
-
-//
-// Expose the prefix.
-//
-EventEmitter.prefixed = prefix;
-
-//
-// Allow `EventEmitter` to be imported as module namespace.
-//
-EventEmitter.EventEmitter = EventEmitter;
-
-//
-// Expose the module.
-//
-if ('undefined' !== typeof module) {
-  module.exports = EventEmitter;
-}
-
-},{}],4:[function(require,module,exports){
-/**
- * isMobile.js v0.4.1
- *
- * A simple library to detect Apple phones and tablets,
- * Android phones and tablets, other mobile devices (like blackberry, mini-opera and windows phone),
- * and any kind of seven inch device, via user agent sniffing.
- *
- * @author: Kai Mallea (kmallea@gmail.com)
- *
- * @license: http://creativecommons.org/publicdomain/zero/1.0/
- */
-(function (global) {
-
-    var apple_phone         = /iPhone/i,
-        apple_ipod          = /iPod/i,
-        apple_tablet        = /iPad/i,
-        android_phone       = /(?=.*\bAndroid\b)(?=.*\bMobile\b)/i, // Match 'Android' AND 'Mobile'
-        android_tablet      = /Android/i,
-        amazon_phone        = /(?=.*\bAndroid\b)(?=.*\bSD4930UR\b)/i,
-        amazon_tablet       = /(?=.*\bAndroid\b)(?=.*\b(?:KFOT|KFTT|KFJWI|KFJWA|KFSOWI|KFTHWI|KFTHWA|KFAPWI|KFAPWA|KFARWI|KFASWI|KFSAWI|KFSAWA)\b)/i,
-        windows_phone       = /Windows Phone/i,
-        windows_tablet      = /(?=.*\bWindows\b)(?=.*\bARM\b)/i, // Match 'Windows' AND 'ARM'
-        other_blackberry    = /BlackBerry/i,
-        other_blackberry_10 = /BB10/i,
-        other_opera         = /Opera Mini/i,
-        other_chrome        = /(CriOS|Chrome)(?=.*\bMobile\b)/i,
-        other_firefox       = /(?=.*\bFirefox\b)(?=.*\bMobile\b)/i, // Match 'Firefox' AND 'Mobile'
-        seven_inch = new RegExp(
-            '(?:' +         // Non-capturing group
-
-            'Nexus 7' +     // Nexus 7
-
-            '|' +           // OR
-
-            'BNTV250' +     // B&N Nook Tablet 7 inch
-
-            '|' +           // OR
-
-            'Kindle Fire' + // Kindle Fire
-
-            '|' +           // OR
-
-            'Silk' +        // Kindle Fire, Silk Accelerated
-
-            '|' +           // OR
-
-            'GT-P1000' +    // Galaxy Tab 7 inch
-
-            ')',            // End non-capturing group
-
-            'i');           // Case-insensitive matching
-
-    var match = function(regex, userAgent) {
-        return regex.test(userAgent);
-    };
-
-    var IsMobileClass = function(userAgent) {
-        var ua = userAgent || navigator.userAgent;
-
-        // Facebook mobile app's integrated browser adds a bunch of strings that
-        // match everything. Strip it out if it exists.
-        var tmp = ua.split('[FBAN');
-        if (typeof tmp[1] !== 'undefined') {
-            ua = tmp[0];
-        }
-
-        // Twitter mobile app's integrated browser on iPad adds a "Twitter for
-        // iPhone" string. Same probable happens on other tablet platforms.
-        // This will confuse detection so strip it out if it exists.
-        tmp = ua.split('Twitter');
-        if (typeof tmp[1] !== 'undefined') {
-            ua = tmp[0];
-        }
-
-        this.apple = {
-            phone:  match(apple_phone, ua),
-            ipod:   match(apple_ipod, ua),
-            tablet: !match(apple_phone, ua) && match(apple_tablet, ua),
-            device: match(apple_phone, ua) || match(apple_ipod, ua) || match(apple_tablet, ua)
-        };
-        this.amazon = {
-            phone:  match(amazon_phone, ua),
-            tablet: !match(amazon_phone, ua) && match(amazon_tablet, ua),
-            device: match(amazon_phone, ua) || match(amazon_tablet, ua)
-        };
-        this.android = {
-            phone:  match(amazon_phone, ua) || match(android_phone, ua),
-            tablet: !match(amazon_phone, ua) && !match(android_phone, ua) && (match(amazon_tablet, ua) || match(android_tablet, ua)),
-            device: match(amazon_phone, ua) || match(amazon_tablet, ua) || match(android_phone, ua) || match(android_tablet, ua)
-        };
-        this.windows = {
-            phone:  match(windows_phone, ua),
-            tablet: match(windows_tablet, ua),
-            device: match(windows_phone, ua) || match(windows_tablet, ua)
-        };
-        this.other = {
-            blackberry:   match(other_blackberry, ua),
-            blackberry10: match(other_blackberry_10, ua),
-            opera:        match(other_opera, ua),
-            firefox:      match(other_firefox, ua),
-            chrome:       match(other_chrome, ua),
-            device:       match(other_blackberry, ua) || match(other_blackberry_10, ua) || match(other_opera, ua) || match(other_firefox, ua) || match(other_chrome, ua)
-        };
-        this.seven_inch = match(seven_inch, ua);
-        this.any = this.apple.device || this.android.device || this.windows.device || this.other.device || this.seven_inch;
-
-        // excludes 'other' devices and ipods, targeting touchscreen phones
-        this.phone = this.apple.phone || this.android.phone || this.windows.phone;
-
-        // excludes 7 inch devices, classifying as phone or tablet is left to the user
-        this.tablet = this.apple.tablet || this.android.tablet || this.windows.tablet;
-
-        if (typeof window === 'undefined') {
-            return this;
-        }
-    };
-
-    var instantiate = function() {
-        var IM = new IsMobileClass();
-        IM.Class = IsMobileClass;
-        return IM;
-    };
-
-    if (typeof module !== 'undefined' && module.exports && typeof window === 'undefined') {
-        //node
-        module.exports = IsMobileClass;
-    } else if (typeof module !== 'undefined' && module.exports && typeof window !== 'undefined') {
-        //browserify
-        module.exports = instantiate();
-    } else if (typeof define === 'function' && define.amd) {
-        //AMD
-        define('isMobile', [], global.isMobile = instantiate());
-    } else {
-        global.isMobile = instantiate();
-    }
+  // References:
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
+  if (!Math.sign) {
+      Math.sign = function mathSign(x) {
+          x = Number(x);
+          if (x === 0 || isNaN(x)) {
+              return x;
+          }
+          return x > 0 ? 1 : -1;
+      };
+  }
 
-})(this);
-
-},{}],5:[function(require,module,exports){
-/*
-object-assign
-(c) Sindre Sorhus
-@license MIT
-*/
-
-'use strict';
-/* eslint-disable no-unused-vars */
-var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-
-function toObject(val) {
-	if (val === null || val === undefined) {
-		throw new TypeError('Object.assign cannot be called with null or undefined');
-	}
-
-	return Object(val);
-}
-
-function shouldUseNative() {
-	try {
-		if (!Object.assign) {
-			return false;
-		}
-
-		// Detect buggy property enumeration order in older V8 versions.
-
-		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
-		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
-		test1[5] = 'de';
-		if (Object.getOwnPropertyNames(test1)[0] === '5') {
-			return false;
-		}
-
-		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-		var test2 = {};
-		for (var i = 0; i < 10; i++) {
-			test2['_' + String.fromCharCode(i)] = i;
-		}
-		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
-			return test2[n];
-		});
-		if (order2.join('') !== '0123456789') {
-			return false;
-		}
-
-		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-		var test3 = {};
-		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
-			test3[letter] = letter;
-		});
-		if (Object.keys(Object.assign({}, test3)).join('') !==
-				'abcdefghijklmnopqrst') {
-			return false;
-		}
-
-		return true;
-	} catch (err) {
-		// We don't expect any of the above to throw, but better to be safe.
-		return false;
-	}
-}
-
-module.exports = shouldUseNative() ? Object.assign : function (target, source) {
-	var from;
-	var to = toObject(target);
-	var symbols;
-
-	for (var s = 1; s < arguments.length; s++) {
-		from = Object(arguments[s]);
-
-		for (var key in from) {
-			if (hasOwnProperty.call(from, key)) {
-				to[key] = from[key];
-			}
-		}
-
-		if (getOwnPropertySymbols) {
-			symbols = getOwnPropertySymbols(from);
-			for (var i = 0; i < symbols.length; i++) {
-				if (propIsEnumerable.call(from, symbols[i])) {
-					to[symbols[i]] = from[symbols[i]];
-				}
-			}
-		}
-	}
-
-	return to;
-};
-
-},{}],6:[function(require,module,exports){
-var EMPTY_ARRAY_BUFFER = new ArrayBuffer(0);
-
-/**
- * Helper class to create a webGL buffer
- *
- * @class
- * @memberof PIXI.glCore
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- * @param type {gl.ARRAY_BUFFER | gl.ELEMENT_ARRAY_BUFFER} @mat
- * @param data {ArrayBuffer| SharedArrayBuffer|ArrayBufferView} an array of data
- * @param drawType {gl.STATIC_DRAW|gl.DYNAMIC_DRAW|gl.STREAM_DRAW}
- */
-var Buffer = function(gl, type, data, drawType)
-{
-
-	/**
-     * The current WebGL rendering context
-     *
-     * @member {WebGLRenderingContext}
-     */
-	this.gl = gl;
-
-	/**
-     * The WebGL buffer, created upon instantiation
-     *
-     * @member {WebGLBuffer}
-     */
-	this.buffer = gl.createBuffer();
-
-	/**
-     * The type of the buffer
-     *
-     * @member {gl.ARRAY_BUFFER|gl.ELEMENT_ARRAY_BUFFER}
-     */
-	this.type = type || gl.ARRAY_BUFFER;
-
-	/**
-     * The draw type of the buffer
-     *
-     * @member {gl.STATIC_DRAW|gl.DYNAMIC_DRAW|gl.STREAM_DRAW}
-     */
-	this.drawType = drawType || gl.STATIC_DRAW;
-
-	/**
-     * The data in the buffer, as a typed array
-     *
-     * @member {ArrayBuffer| SharedArrayBuffer|ArrayBufferView}
-     */
-	this.data = EMPTY_ARRAY_BUFFER;
-
-	if(data)
-	{
-		this.upload(data);
-	}
-
-	this._updateID = 0;
-};
-
-/**
- * Uploads the buffer to the GPU
- * @param data {ArrayBuffer| SharedArrayBuffer|ArrayBufferView} an array of data to upload
- * @param offset {Number} if only a subset of the data should be uploaded, this is the amount of data to subtract
- * @param dontBind {Boolean} whether to bind the buffer before uploading it
- */
-Buffer.prototype.upload = function(data, offset, dontBind)
-{
-	// todo - needed?
-	if(!dontBind) this.bind();
-
-	var gl = this.gl;
-
-	data = data || this.data;
-	offset = offset || 0;
-
-	if(this.data.byteLength >= data.byteLength)
-	{
-		gl.bufferSubData(this.type, offset, data);
-	}
-	else
-	{
-		gl.bufferData(this.type, data, this.drawType);
-	}
-
-	this.data = data;
-};
-/**
- * Binds the buffer
- *
- */
-Buffer.prototype.bind = function()
-{
-	var gl = this.gl;
-	gl.bindBuffer(this.type, this.buffer);
-};
-
-Buffer.createVertexBuffer = function(gl, data, drawType)
-{
-	return new Buffer(gl, gl.ARRAY_BUFFER, data, drawType);
-};
-
-Buffer.createIndexBuffer = function(gl, data, drawType)
-{
-	return new Buffer(gl, gl.ELEMENT_ARRAY_BUFFER, data, drawType);
-};
-
-Buffer.create = function(gl, type, data, drawType)
-{
-	return new Buffer(gl, type, data, drawType);
-};
-
-/**
- * Destroys the buffer
- *
- */
-Buffer.prototype.destroy = function(){
-	this.gl.deleteBuffer(this.buffer);
-};
+  // References:
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
+  if (!Number.isInteger) {
+      Number.isInteger = function numberIsInteger(value) {
+          return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+      };
+  }
 
-module.exports = Buffer;
+  if (!globalThis.ArrayBuffer) {
+      globalThis.ArrayBuffer = Array;
+  }
+  if (!globalThis.Float32Array) {
+      globalThis.Float32Array = Array;
+  }
+  if (!globalThis.Uint32Array) {
+      globalThis.Uint32Array = Array;
+  }
+  if (!globalThis.Uint16Array) {
+      globalThis.Uint16Array = Array;
+  }
+  if (!globalThis.Uint8Array) {
+      globalThis.Uint8Array = Array;
+  }
+  if (!globalThis.Int32Array) {
+      globalThis.Int32Array = Array;
+  }
 
-},{}],7:[function(require,module,exports){
-
-var Texture = require('./GLTexture');
+  /*!
+   * @pixi/constants - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/constants is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
+  /**
+   * Different types of environments for WebGL.
+   * @static
+   * @memberof PIXI
+   * @name ENV
+   * @enum {number}
+   * @property {number} WEBGL_LEGACY - Used for older v1 WebGL devices. PixiJS will aim to ensure compatibility
+   *  with older / less advanced devices. If you experience unexplained flickering prefer this environment.
+   * @property {number} WEBGL - Version 1 of WebGL
+   * @property {number} WEBGL2 - Version 2 of WebGL
+   */
+  exports.ENV = void 0;
+  (function (ENV) {
+      ENV[ENV["WEBGL_LEGACY"] = 0] = "WEBGL_LEGACY";
+      ENV[ENV["WEBGL"] = 1] = "WEBGL";
+      ENV[ENV["WEBGL2"] = 2] = "WEBGL2";
+  })(exports.ENV || (exports.ENV = {}));
+  /**
+   * Constant to identify the Renderer Type.
+   * @static
+   * @memberof PIXI
+   * @name RENDERER_TYPE
+   * @enum {number}
+   * @property {number} UNKNOWN - Unknown render type.
+   * @property {number} WEBGL - WebGL render type.
+   * @property {number} CANVAS - Canvas render type.
+   */
+  exports.RENDERER_TYPE = void 0;
+  (function (RENDERER_TYPE) {
+      RENDERER_TYPE[RENDERER_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
+      RENDERER_TYPE[RENDERER_TYPE["WEBGL"] = 1] = "WEBGL";
+      RENDERER_TYPE[RENDERER_TYPE["CANVAS"] = 2] = "CANVAS";
+  })(exports.RENDERER_TYPE || (exports.RENDERER_TYPE = {}));
+  /**
+   * Bitwise OR of masks that indicate the buffers to be cleared.
+   * @static
+   * @memberof PIXI
+   * @name BUFFER_BITS
+   * @enum {number}
+   * @property {number} COLOR - Indicates the buffers currently enabled for color writing.
+   * @property {number} DEPTH - Indicates the depth buffer.
+   * @property {number} STENCIL - Indicates the stencil buffer.
+   */
+  exports.BUFFER_BITS = void 0;
+  (function (BUFFER_BITS) {
+      BUFFER_BITS[BUFFER_BITS["COLOR"] = 16384] = "COLOR";
+      BUFFER_BITS[BUFFER_BITS["DEPTH"] = 256] = "DEPTH";
+      BUFFER_BITS[BUFFER_BITS["STENCIL"] = 1024] = "STENCIL";
+  })(exports.BUFFER_BITS || (exports.BUFFER_BITS = {}));
+  /**
+   * Various blend modes supported by PIXI.
+   *
+   * IMPORTANT - The WebGL renderer only supports the NORMAL, ADD, MULTIPLY and SCREEN blend modes.
+   * Anything else will silently act like NORMAL.
+   * @memberof PIXI
+   * @name BLEND_MODES
+   * @enum {number}
+   * @property {number} NORMAL -
+   * @property {number} ADD -
+   * @property {number} MULTIPLY -
+   * @property {number} SCREEN -
+   * @property {number} OVERLAY -
+   * @property {number} DARKEN -
+   * @property {number} LIGHTEN -
+   * @property {number} COLOR_DODGE -
+   * @property {number} COLOR_BURN -
+   * @property {number} HARD_LIGHT -
+   * @property {number} SOFT_LIGHT -
+   * @property {number} DIFFERENCE -
+   * @property {number} EXCLUSION -
+   * @property {number} HUE -
+   * @property {number} SATURATION -
+   * @property {number} COLOR -
+   * @property {number} LUMINOSITY -
+   * @property {number} NORMAL_NPM -
+   * @property {number} ADD_NPM -
+   * @property {number} SCREEN_NPM -
+   * @property {number} NONE -
+   * @property {number} SRC_IN -
+   * @property {number} SRC_OUT -
+   * @property {number} SRC_ATOP -
+   * @property {number} DST_OVER -
+   * @property {number} DST_IN -
+   * @property {number} DST_OUT -
+   * @property {number} DST_ATOP -
+   * @property {number} SUBTRACT -
+   * @property {number} SRC_OVER -
+   * @property {number} ERASE -
+   * @property {number} XOR -
+   */
+  exports.BLEND_MODES = void 0;
+  (function (BLEND_MODES) {
+      BLEND_MODES[BLEND_MODES["NORMAL"] = 0] = "NORMAL";
+      BLEND_MODES[BLEND_MODES["ADD"] = 1] = "ADD";
+      BLEND_MODES[BLEND_MODES["MULTIPLY"] = 2] = "MULTIPLY";
+      BLEND_MODES[BLEND_MODES["SCREEN"] = 3] = "SCREEN";
+      BLEND_MODES[BLEND_MODES["OVERLAY"] = 4] = "OVERLAY";
+      BLEND_MODES[BLEND_MODES["DARKEN"] = 5] = "DARKEN";
+      BLEND_MODES[BLEND_MODES["LIGHTEN"] = 6] = "LIGHTEN";
+      BLEND_MODES[BLEND_MODES["COLOR_DODGE"] = 7] = "COLOR_DODGE";
+      BLEND_MODES[BLEND_MODES["COLOR_BURN"] = 8] = "COLOR_BURN";
+      BLEND_MODES[BLEND_MODES["HARD_LIGHT"] = 9] = "HARD_LIGHT";
+      BLEND_MODES[BLEND_MODES["SOFT_LIGHT"] = 10] = "SOFT_LIGHT";
+      BLEND_MODES[BLEND_MODES["DIFFERENCE"] = 11] = "DIFFERENCE";
+      BLEND_MODES[BLEND_MODES["EXCLUSION"] = 12] = "EXCLUSION";
+      BLEND_MODES[BLEND_MODES["HUE"] = 13] = "HUE";
+      BLEND_MODES[BLEND_MODES["SATURATION"] = 14] = "SATURATION";
+      BLEND_MODES[BLEND_MODES["COLOR"] = 15] = "COLOR";
+      BLEND_MODES[BLEND_MODES["LUMINOSITY"] = 16] = "LUMINOSITY";
+      BLEND_MODES[BLEND_MODES["NORMAL_NPM"] = 17] = "NORMAL_NPM";
+      BLEND_MODES[BLEND_MODES["ADD_NPM"] = 18] = "ADD_NPM";
+      BLEND_MODES[BLEND_MODES["SCREEN_NPM"] = 19] = "SCREEN_NPM";
+      BLEND_MODES[BLEND_MODES["NONE"] = 20] = "NONE";
+      BLEND_MODES[BLEND_MODES["SRC_OVER"] = 0] = "SRC_OVER";
+      BLEND_MODES[BLEND_MODES["SRC_IN"] = 21] = "SRC_IN";
+      BLEND_MODES[BLEND_MODES["SRC_OUT"] = 22] = "SRC_OUT";
+      BLEND_MODES[BLEND_MODES["SRC_ATOP"] = 23] = "SRC_ATOP";
+      BLEND_MODES[BLEND_MODES["DST_OVER"] = 24] = "DST_OVER";
+      BLEND_MODES[BLEND_MODES["DST_IN"] = 25] = "DST_IN";
+      BLEND_MODES[BLEND_MODES["DST_OUT"] = 26] = "DST_OUT";
+      BLEND_MODES[BLEND_MODES["DST_ATOP"] = 27] = "DST_ATOP";
+      BLEND_MODES[BLEND_MODES["ERASE"] = 26] = "ERASE";
+      BLEND_MODES[BLEND_MODES["SUBTRACT"] = 28] = "SUBTRACT";
+      BLEND_MODES[BLEND_MODES["XOR"] = 29] = "XOR";
+  })(exports.BLEND_MODES || (exports.BLEND_MODES = {}));
+  /**
+   * Various webgl draw modes. These can be used to specify which GL drawMode to use
+   * under certain situations and renderers.
+   * @memberof PIXI
+   * @static
+   * @name DRAW_MODES
+   * @enum {number}
+   * @property {number} POINTS -
+   * @property {number} LINES -
+   * @property {number} LINE_LOOP -
+   * @property {number} LINE_STRIP -
+   * @property {number} TRIANGLES -
+   * @property {number} TRIANGLE_STRIP -
+   * @property {number} TRIANGLE_FAN -
+   */
+  exports.DRAW_MODES = void 0;
+  (function (DRAW_MODES) {
+      DRAW_MODES[DRAW_MODES["POINTS"] = 0] = "POINTS";
+      DRAW_MODES[DRAW_MODES["LINES"] = 1] = "LINES";
+      DRAW_MODES[DRAW_MODES["LINE_LOOP"] = 2] = "LINE_LOOP";
+      DRAW_MODES[DRAW_MODES["LINE_STRIP"] = 3] = "LINE_STRIP";
+      DRAW_MODES[DRAW_MODES["TRIANGLES"] = 4] = "TRIANGLES";
+      DRAW_MODES[DRAW_MODES["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+      DRAW_MODES[DRAW_MODES["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+  })(exports.DRAW_MODES || (exports.DRAW_MODES = {}));
+  /**
+   * Various GL texture/resources formats.
+   * @memberof PIXI
+   * @static
+   * @name FORMATS
+   * @enum {number}
+   * @property {number} [RGBA=6408] -
+   * @property {number} [RGB=6407] -
+   * @property {number} [RG=33319] -
+   * @property {number} [RED=6403] -
+   * @property {number} [RGBA_INTEGER=36249] -
+   * @property {number} [RGB_INTEGER=36248] -
+   * @property {number} [RG_INTEGER=33320] -
+   * @property {number} [RED_INTEGER=36244] -
+   * @property {number} [ALPHA=6406] -
+   * @property {number} [LUMINANCE=6409] -
+   * @property {number} [LUMINANCE_ALPHA=6410] -
+   * @property {number} [DEPTH_COMPONENT=6402] -
+   * @property {number} [DEPTH_STENCIL=34041] -
+   */
+  exports.FORMATS = void 0;
+  (function (FORMATS) {
+      FORMATS[FORMATS["RGBA"] = 6408] = "RGBA";
+      FORMATS[FORMATS["RGB"] = 6407] = "RGB";
+      FORMATS[FORMATS["RG"] = 33319] = "RG";
+      FORMATS[FORMATS["RED"] = 6403] = "RED";
+      FORMATS[FORMATS["RGBA_INTEGER"] = 36249] = "RGBA_INTEGER";
+      FORMATS[FORMATS["RGB_INTEGER"] = 36248] = "RGB_INTEGER";
+      FORMATS[FORMATS["RG_INTEGER"] = 33320] = "RG_INTEGER";
+      FORMATS[FORMATS["RED_INTEGER"] = 36244] = "RED_INTEGER";
+      FORMATS[FORMATS["ALPHA"] = 6406] = "ALPHA";
+      FORMATS[FORMATS["LUMINANCE"] = 6409] = "LUMINANCE";
+      FORMATS[FORMATS["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
+      FORMATS[FORMATS["DEPTH_COMPONENT"] = 6402] = "DEPTH_COMPONENT";
+      FORMATS[FORMATS["DEPTH_STENCIL"] = 34041] = "DEPTH_STENCIL";
+  })(exports.FORMATS || (exports.FORMATS = {}));
+  /**
+   * Various GL target types.
+   * @memberof PIXI
+   * @static
+   * @name TARGETS
+   * @enum {number}
+   * @property {number} [TEXTURE_2D=3553] -
+   * @property {number} [TEXTURE_CUBE_MAP=34067] -
+   * @property {number} [TEXTURE_2D_ARRAY=35866] -
+   * @property {number} [TEXTURE_CUBE_MAP_POSITIVE_X=34069] -
+   * @property {number} [TEXTURE_CUBE_MAP_NEGATIVE_X=34070] -
+   * @property {number} [TEXTURE_CUBE_MAP_POSITIVE_Y=34071] -
+   * @property {number} [TEXTURE_CUBE_MAP_NEGATIVE_Y=34072] -
+   * @property {number} [TEXTURE_CUBE_MAP_POSITIVE_Z=34073] -
+   * @property {number} [TEXTURE_CUBE_MAP_NEGATIVE_Z=34074] -
+   */
+  exports.TARGETS = void 0;
+  (function (TARGETS) {
+      TARGETS[TARGETS["TEXTURE_2D"] = 3553] = "TEXTURE_2D";
+      TARGETS[TARGETS["TEXTURE_CUBE_MAP"] = 34067] = "TEXTURE_CUBE_MAP";
+      TARGETS[TARGETS["TEXTURE_2D_ARRAY"] = 35866] = "TEXTURE_2D_ARRAY";
+      TARGETS[TARGETS["TEXTURE_CUBE_MAP_POSITIVE_X"] = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X";
+      TARGETS[TARGETS["TEXTURE_CUBE_MAP_NEGATIVE_X"] = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X";
+      TARGETS[TARGETS["TEXTURE_CUBE_MAP_POSITIVE_Y"] = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y";
+      TARGETS[TARGETS["TEXTURE_CUBE_MAP_NEGATIVE_Y"] = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y";
+      TARGETS[TARGETS["TEXTURE_CUBE_MAP_POSITIVE_Z"] = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z";
+      TARGETS[TARGETS["TEXTURE_CUBE_MAP_NEGATIVE_Z"] = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z";
+  })(exports.TARGETS || (exports.TARGETS = {}));
+  /**
+   * Various GL data format types.
+   * @memberof PIXI
+   * @static
+   * @name TYPES
+   * @enum {number}
+   * @property {number} [UNSIGNED_BYTE=5121] -
+   * @property {number} [UNSIGNED_SHORT=5123] -
+   * @property {number} [UNSIGNED_SHORT_5_6_5=33635] -
+   * @property {number} [UNSIGNED_SHORT_4_4_4_4=32819] -
+   * @property {number} [UNSIGNED_SHORT_5_5_5_1=32820] -
+   * @property {number} [UNSIGNED_INT=5125] -
+   * @property {number} [UNSIGNED_INT_10F_11F_11F_REV=35899] -
+   * @property {number} [UNSIGNED_INT_2_10_10_10_REV=33640] -
+   * @property {number} [UNSIGNED_INT_24_8=34042] -
+   * @property {number} [UNSIGNED_INT_5_9_9_9_REV=35902] -
+   * @property {number} [BYTE=5120] -
+   * @property {number} [SHORT=5122] -
+   * @property {number} [INT=5124] -
+   * @property {number} [FLOAT=5126] -
+   * @property {number} [FLOAT_32_UNSIGNED_INT_24_8_REV=36269] -
+   * @property {number} [HALF_FLOAT=36193] -
+   */
+  exports.TYPES = void 0;
+  (function (TYPES) {
+      TYPES[TYPES["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+      TYPES[TYPES["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+      TYPES[TYPES["UNSIGNED_SHORT_5_6_5"] = 33635] = "UNSIGNED_SHORT_5_6_5";
+      TYPES[TYPES["UNSIGNED_SHORT_4_4_4_4"] = 32819] = "UNSIGNED_SHORT_4_4_4_4";
+      TYPES[TYPES["UNSIGNED_SHORT_5_5_5_1"] = 32820] = "UNSIGNED_SHORT_5_5_5_1";
+      TYPES[TYPES["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
+      TYPES[TYPES["UNSIGNED_INT_10F_11F_11F_REV"] = 35899] = "UNSIGNED_INT_10F_11F_11F_REV";
+      TYPES[TYPES["UNSIGNED_INT_2_10_10_10_REV"] = 33640] = "UNSIGNED_INT_2_10_10_10_REV";
+      TYPES[TYPES["UNSIGNED_INT_24_8"] = 34042] = "UNSIGNED_INT_24_8";
+      TYPES[TYPES["UNSIGNED_INT_5_9_9_9_REV"] = 35902] = "UNSIGNED_INT_5_9_9_9_REV";
+      TYPES[TYPES["BYTE"] = 5120] = "BYTE";
+      TYPES[TYPES["SHORT"] = 5122] = "SHORT";
+      TYPES[TYPES["INT"] = 5124] = "INT";
+      TYPES[TYPES["FLOAT"] = 5126] = "FLOAT";
+      TYPES[TYPES["FLOAT_32_UNSIGNED_INT_24_8_REV"] = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV";
+      TYPES[TYPES["HALF_FLOAT"] = 36193] = "HALF_FLOAT";
+  })(exports.TYPES || (exports.TYPES = {}));
+  /**
+   * Various sampler types. Correspond to `sampler`, `isampler`, `usampler` GLSL types respectively.
+   * WebGL1 works only with FLOAT.
+   * @memberof PIXI
+   * @static
+   * @name SAMPLER_TYPES
+   * @enum {number}
+   * @property {number} [FLOAT=0] -
+   * @property {number} [INT=1] -
+   * @property {number} [UINT=2] -
+   */
+  exports.SAMPLER_TYPES = void 0;
+  (function (SAMPLER_TYPES) {
+      SAMPLER_TYPES[SAMPLER_TYPES["FLOAT"] = 0] = "FLOAT";
+      SAMPLER_TYPES[SAMPLER_TYPES["INT"] = 1] = "INT";
+      SAMPLER_TYPES[SAMPLER_TYPES["UINT"] = 2] = "UINT";
+  })(exports.SAMPLER_TYPES || (exports.SAMPLER_TYPES = {}));
+  /**
+   * The scale modes that are supported by pixi.
+   *
+   * The {@link PIXI.settings.SCALE_MODE} scale mode affects the default scaling mode of future operations.
+   * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
+   * @memberof PIXI
+   * @static
+   * @name SCALE_MODES
+   * @enum {number}
+   * @property {number} LINEAR Smooth scaling
+   * @property {number} NEAREST Pixelating scaling
+   */
+  exports.SCALE_MODES = void 0;
+  (function (SCALE_MODES) {
+      SCALE_MODES[SCALE_MODES["NEAREST"] = 0] = "NEAREST";
+      SCALE_MODES[SCALE_MODES["LINEAR"] = 1] = "LINEAR";
+  })(exports.SCALE_MODES || (exports.SCALE_MODES = {}));
+  /**
+   * The wrap modes that are supported by pixi.
+   *
+   * The {@link PIXI.settings.WRAP_MODE} wrap mode affects the default wrapping mode of future operations.
+   * It can be re-assigned to either CLAMP or REPEAT, depending upon suitability.
+   * If the texture is non power of two then clamp will be used regardless as WebGL can
+   * only use REPEAT if the texture is po2.
+   *
+   * This property only affects WebGL.
+   * @name WRAP_MODES
+   * @memberof PIXI
+   * @static
+   * @enum {number}
+   * @property {number} CLAMP - The textures uvs are clamped
+   * @property {number} REPEAT - The texture uvs tile and repeat
+   * @property {number} MIRRORED_REPEAT - The texture uvs tile and repeat with mirroring
+   */
+  exports.WRAP_MODES = void 0;
+  (function (WRAP_MODES) {
+      WRAP_MODES[WRAP_MODES["CLAMP"] = 33071] = "CLAMP";
+      WRAP_MODES[WRAP_MODES["REPEAT"] = 10497] = "REPEAT";
+      WRAP_MODES[WRAP_MODES["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+  })(exports.WRAP_MODES || (exports.WRAP_MODES = {}));
+  /**
+   * Mipmap filtering modes that are supported by pixi.
+   *
+   * The {@link PIXI.settings.MIPMAP_TEXTURES} affects default texture filtering.
+   * Mipmaps are generated for a baseTexture if its `mipmap` field is `ON`,
+   * or its `POW2` and texture dimensions are powers of 2.
+   * Due to platform restriction, `ON` option will work like `POW2` for webgl-1.
+   *
+   * This property only affects WebGL.
+   * @name MIPMAP_MODES
+   * @memberof PIXI
+   * @static
+   * @enum {number}
+   * @property {number} OFF - No mipmaps
+   * @property {number} POW2 - Generate mipmaps if texture dimensions are pow2
+   * @property {number} ON - Always generate mipmaps
+   * @property {number} ON_MANUAL - Use mipmaps, but do not auto-generate them; this is used with a resource
+   *   that supports buffering each level-of-detail.
+   */
+  exports.MIPMAP_MODES = void 0;
+  (function (MIPMAP_MODES) {
+      MIPMAP_MODES[MIPMAP_MODES["OFF"] = 0] = "OFF";
+      MIPMAP_MODES[MIPMAP_MODES["POW2"] = 1] = "POW2";
+      MIPMAP_MODES[MIPMAP_MODES["ON"] = 2] = "ON";
+      MIPMAP_MODES[MIPMAP_MODES["ON_MANUAL"] = 3] = "ON_MANUAL";
+  })(exports.MIPMAP_MODES || (exports.MIPMAP_MODES = {}));
+  /**
+   * How to treat textures with premultiplied alpha
+   * @name ALPHA_MODES
+   * @memberof PIXI
+   * @static
+   * @enum {number}
+   * @property {number} NO_PREMULTIPLIED_ALPHA - Source is not premultiplied, leave it like that.
+   *  Option for compressed and data textures that are created from typed arrays.
+   * @property {number} PREMULTIPLY_ON_UPLOAD - Source is not premultiplied, premultiply on upload.
+   *  Default option, used for all loaded images.
+   * @property {number} PREMULTIPLIED_ALPHA - Source is already premultiplied
+   *  Example: spine atlases with `_pma` suffix.
+   * @property {number} NPM - Alias for NO_PREMULTIPLIED_ALPHA.
+   * @property {number} UNPACK - Default option, alias for PREMULTIPLY_ON_UPLOAD.
+   * @property {number} PMA - Alias for PREMULTIPLIED_ALPHA.
+   */
+  exports.ALPHA_MODES = void 0;
+  (function (ALPHA_MODES) {
+      ALPHA_MODES[ALPHA_MODES["NPM"] = 0] = "NPM";
+      ALPHA_MODES[ALPHA_MODES["UNPACK"] = 1] = "UNPACK";
+      ALPHA_MODES[ALPHA_MODES["PMA"] = 2] = "PMA";
+      ALPHA_MODES[ALPHA_MODES["NO_PREMULTIPLIED_ALPHA"] = 0] = "NO_PREMULTIPLIED_ALPHA";
+      ALPHA_MODES[ALPHA_MODES["PREMULTIPLY_ON_UPLOAD"] = 1] = "PREMULTIPLY_ON_UPLOAD";
+      ALPHA_MODES[ALPHA_MODES["PREMULTIPLY_ALPHA"] = 2] = "PREMULTIPLY_ALPHA";
+      ALPHA_MODES[ALPHA_MODES["PREMULTIPLIED_ALPHA"] = 2] = "PREMULTIPLIED_ALPHA";
+  })(exports.ALPHA_MODES || (exports.ALPHA_MODES = {}));
+  /**
+   * Configure whether filter textures are cleared after binding.
+   *
+   * Filter textures need not be cleared if the filter does not use pixel blending. {@link CLEAR_MODES.BLIT} will detect
+   * this and skip clearing as an optimization.
+   * @name CLEAR_MODES
+   * @memberof PIXI
+   * @static
+   * @enum {number}
+   * @property {number} BLEND - Do not clear the filter texture. The filter's output will blend on top of the output texture.
+   * @property {number} CLEAR - Always clear the filter texture.
+   * @property {number} BLIT - Clear only if {@link FilterSystem.forceClear} is set or if the filter uses pixel blending.
+   * @property {number} NO - Alias for BLEND, same as `false` in earlier versions
+   * @property {number} YES - Alias for CLEAR, same as `true` in earlier versions
+   * @property {number} AUTO - Alias for BLIT
+   */
+  exports.CLEAR_MODES = void 0;
+  (function (CLEAR_MODES) {
+      CLEAR_MODES[CLEAR_MODES["NO"] = 0] = "NO";
+      CLEAR_MODES[CLEAR_MODES["YES"] = 1] = "YES";
+      CLEAR_MODES[CLEAR_MODES["AUTO"] = 2] = "AUTO";
+      CLEAR_MODES[CLEAR_MODES["BLEND"] = 0] = "BLEND";
+      CLEAR_MODES[CLEAR_MODES["CLEAR"] = 1] = "CLEAR";
+      CLEAR_MODES[CLEAR_MODES["BLIT"] = 2] = "BLIT";
+  })(exports.CLEAR_MODES || (exports.CLEAR_MODES = {}));
+  /**
+   * The gc modes that are supported by pixi.
+   *
+   * The {@link PIXI.settings.GC_MODE} Garbage Collection mode for PixiJS textures is AUTO
+   * If set to GC_MODE, the renderer will occasionally check textures usage. If they are not
+   * used for a specified period of time they will be removed from the GPU. They will of course
+   * be uploaded again when they are required. This is a silent behind the scenes process that
+   * should ensure that the GPU does not  get filled up.
+   *
+   * Handy for mobile devices!
+   * This property only affects WebGL.
+   * @name GC_MODES
+   * @enum {number}
+   * @static
+   * @memberof PIXI
+   * @property {number} AUTO - Garbage collection will happen periodically automatically
+   * @property {number} MANUAL - Garbage collection will need to be called manually
+   */
+  exports.GC_MODES = void 0;
+  (function (GC_MODES) {
+      GC_MODES[GC_MODES["AUTO"] = 0] = "AUTO";
+      GC_MODES[GC_MODES["MANUAL"] = 1] = "MANUAL";
+  })(exports.GC_MODES || (exports.GC_MODES = {}));
+  /**
+   * Constants that specify float precision in shaders.
+   * @name PRECISION
+   * @memberof PIXI
+   * @constant
+   * @static
+   * @enum {string}
+   * @property {string} [LOW='lowp'] -
+   * @property {string} [MEDIUM='mediump'] -
+   * @property {string} [HIGH='highp'] -
+   */
+  exports.PRECISION = void 0;
+  (function (PRECISION) {
+      PRECISION["LOW"] = "lowp";
+      PRECISION["MEDIUM"] = "mediump";
+      PRECISION["HIGH"] = "highp";
+  })(exports.PRECISION || (exports.PRECISION = {}));
+  /**
+   * Constants for mask implementations.
+   * We use `type` suffix because it leads to very different behaviours
+   * @name MASK_TYPES
+   * @memberof PIXI
+   * @static
+   * @enum {number}
+   * @property {number} NONE - Mask is ignored
+   * @property {number} SCISSOR - Scissor mask, rectangle on screen, cheap
+   * @property {number} STENCIL - Stencil mask, 1-bit, medium, works only if renderer supports stencil
+   * @property {number} SPRITE - Mask that uses SpriteMaskFilter, uses temporary RenderTexture
+   * @property {number} COLOR - Color mask (RGBA)
+   */
+  exports.MASK_TYPES = void 0;
+  (function (MASK_TYPES) {
+      MASK_TYPES[MASK_TYPES["NONE"] = 0] = "NONE";
+      MASK_TYPES[MASK_TYPES["SCISSOR"] = 1] = "SCISSOR";
+      MASK_TYPES[MASK_TYPES["STENCIL"] = 2] = "STENCIL";
+      MASK_TYPES[MASK_TYPES["SPRITE"] = 3] = "SPRITE";
+      MASK_TYPES[MASK_TYPES["COLOR"] = 4] = "COLOR";
+  })(exports.MASK_TYPES || (exports.MASK_TYPES = {}));
+  /**
+   * Bitwise OR of masks that indicate the color channels that are rendered to.
+   * @static
+   * @memberof PIXI
+   * @name COLOR_MASK_BITS
+   * @enum {number}
+   * @property {number} RED - Red channel.
+   * @property {number} GREEN - Green channel
+   * @property {number} BLUE - Blue channel.
+   * @property {number} ALPHA - Alpha channel.
+   */
+  exports.COLOR_MASK_BITS = void 0;
+  (function (COLOR_MASK_BITS) {
+      COLOR_MASK_BITS[COLOR_MASK_BITS["RED"] = 1] = "RED";
+      COLOR_MASK_BITS[COLOR_MASK_BITS["GREEN"] = 2] = "GREEN";
+      COLOR_MASK_BITS[COLOR_MASK_BITS["BLUE"] = 4] = "BLUE";
+      COLOR_MASK_BITS[COLOR_MASK_BITS["ALPHA"] = 8] = "ALPHA";
+  })(exports.COLOR_MASK_BITS || (exports.COLOR_MASK_BITS = {}));
+  /**
+   * Constants for multi-sampling antialiasing.
+   * @see PIXI.Framebuffer#multisample
+   * @name MSAA_QUALITY
+   * @memberof PIXI
+   * @static
+   * @enum {number}
+   * @property {number} NONE - No multisampling for this renderTexture
+   * @property {number} LOW - Try 2 samples
+   * @property {number} MEDIUM - Try 4 samples
+   * @property {number} HIGH - Try 8 samples
+   */
+  exports.MSAA_QUALITY = void 0;
+  (function (MSAA_QUALITY) {
+      MSAA_QUALITY[MSAA_QUALITY["NONE"] = 0] = "NONE";
+      MSAA_QUALITY[MSAA_QUALITY["LOW"] = 2] = "LOW";
+      MSAA_QUALITY[MSAA_QUALITY["MEDIUM"] = 4] = "MEDIUM";
+      MSAA_QUALITY[MSAA_QUALITY["HIGH"] = 8] = "HIGH";
+  })(exports.MSAA_QUALITY || (exports.MSAA_QUALITY = {}));
+  /**
+   * Constants for various buffer types in Pixi
+   * @see PIXI.BUFFER_TYPE
+   * @name BUFFER_TYPE
+   * @memberof PIXI
+   * @static
+   * @enum {number}
+   * @property {number} ELEMENT_ARRAY_BUFFER - buffer type for using as an index buffer
+   * @property {number} ARRAY_BUFFER - buffer type for using attribute data
+   * @property {number} UNIFORM_BUFFER - the buffer type is for uniform buffer objects
+   */
+  exports.BUFFER_TYPE = void 0;
+  (function (BUFFER_TYPE) {
+      BUFFER_TYPE[BUFFER_TYPE["ELEMENT_ARRAY_BUFFER"] = 34963] = "ELEMENT_ARRAY_BUFFER";
+      BUFFER_TYPE[BUFFER_TYPE["ARRAY_BUFFER"] = 34962] = "ARRAY_BUFFER";
+      // NOT YET SUPPORTED
+      BUFFER_TYPE[BUFFER_TYPE["UNIFORM_BUFFER"] = 35345] = "UNIFORM_BUFFER";
+  })(exports.BUFFER_TYPE || (exports.BUFFER_TYPE = {}));
+
+  /*!
+   * @pixi/settings - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/settings is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-/**
- * Helper class to create a webGL Framebuffer
- *
- * @class
- * @memberof PIXI.glCore
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- * @param width {Number} the width of the drawing area of the frame buffer
- * @param height {Number} the height of the drawing area of the frame buffer
- */
-var Framebuffer = function(gl, width, height)
-{
-    /**
-     * The current WebGL rendering context
-     *
-     * @member {WebGLRenderingContext}
-     */
-    this.gl = gl;
-
-    /**
-     * The frame buffer
-     *
-     * @member {WebGLFramebuffer}
-     */
-    this.framebuffer = gl.createFramebuffer();
-
-    /**
-     * The stencil buffer
-     *
-     * @member {WebGLRenderbuffer}
-     */
-    this.stencil = null;
-
-    /**
-     * The stencil buffer
-     *
-     * @member {PIXI.glCore.GLTexture}
-     */
-    this.texture = null;
-
-    /**
-     * The width of the drawing area of the buffer
-     *
-     * @member {Number}
-     */
-    this.width = width || 100;
-    /**
-     * The height of the drawing area of the buffer
-     *
-     * @member {Number}
-     */
-    this.height = height || 100;
-};
-
-/**
- * Adds a texture to the frame buffer
- * @param texture {PIXI.glCore.GLTexture}
- */
-Framebuffer.prototype.enableTexture = function(texture)
-{
-    var gl = this.gl;
+  var BrowserAdapter = {
+      /**
+       * Creates a canvas element of the given size.
+       * This canvas is created using the browser's native canvas element.
+       * @param width - width of the canvas
+       * @param height - height of the canvas
+       */
+      createCanvas: function (width, height) {
+          var canvas = document.createElement('canvas');
+          canvas.width = width;
+          canvas.height = height;
+          return canvas;
+      },
+      getWebGLRenderingContext: function () { return WebGLRenderingContext; },
+      getNavigator: function () { return navigator; },
+      getBaseUrl: function () { var _a; return ((_a = document.baseURI) !== null && _a !== void 0 ? _a : window.location.href); },
+      fetch: function (url, options) { return fetch(url, options); },
+  };
 
-    this.texture = texture || new Texture(gl);
+  var appleIphone = /iPhone/i;
+  var appleIpod = /iPod/i;
+  var appleTablet = /iPad/i;
+  var appleUniversal = /\biOS-universal(?:.+)Mac\b/i;
+  var androidPhone = /\bAndroid(?:.+)Mobile\b/i;
+  var androidTablet = /Android/i;
+  var amazonPhone = /(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i;
+  var amazonTablet = /Silk/i;
+  var windowsPhone = /Windows Phone/i;
+  var windowsTablet = /\bWindows(?:.+)ARM\b/i;
+  var otherBlackBerry = /BlackBerry/i;
+  var otherBlackBerry10 = /BB10/i;
+  var otherOpera = /Opera Mini/i;
+  var otherChrome = /\b(CriOS|Chrome)(?:.+)Mobile/i;
+  var otherFirefox = /Mobile(?:.+)Firefox\b/i;
+  var isAppleTabletOnIos13 = function (navigator) {
+      return (typeof navigator !== 'undefined' &&
+          navigator.platform === 'MacIntel' &&
+          typeof navigator.maxTouchPoints === 'number' &&
+          navigator.maxTouchPoints > 1 &&
+          typeof MSStream === 'undefined');
+  };
+  function createMatch(userAgent) {
+      return function (regex) { return regex.test(userAgent); };
+  }
+  function isMobile$1(param) {
+      var nav = {
+          userAgent: '',
+          platform: '',
+          maxTouchPoints: 0
+      };
+      if (!param && typeof navigator !== 'undefined') {
+          nav = {
+              userAgent: navigator.userAgent,
+              platform: navigator.platform,
+              maxTouchPoints: navigator.maxTouchPoints || 0
+          };
+      }
+      else if (typeof param === 'string') {
+          nav.userAgent = param;
+      }
+      else if (param && param.userAgent) {
+          nav = {
+              userAgent: param.userAgent,
+              platform: param.platform,
+              maxTouchPoints: param.maxTouchPoints || 0
+          };
+      }
+      var userAgent = nav.userAgent;
+      var tmp = userAgent.split('[FBAN');
+      if (typeof tmp[1] !== 'undefined') {
+          userAgent = tmp[0];
+      }
+      tmp = userAgent.split('Twitter');
+      if (typeof tmp[1] !== 'undefined') {
+          userAgent = tmp[0];
+      }
+      var match = createMatch(userAgent);
+      var result = {
+          apple: {
+              phone: match(appleIphone) && !match(windowsPhone),
+              ipod: match(appleIpod),
+              tablet: !match(appleIphone) &&
+                  (match(appleTablet) || isAppleTabletOnIos13(nav)) &&
+                  !match(windowsPhone),
+              universal: match(appleUniversal),
+              device: (match(appleIphone) ||
+                  match(appleIpod) ||
+                  match(appleTablet) ||
+                  match(appleUniversal) ||
+                  isAppleTabletOnIos13(nav)) &&
+                  !match(windowsPhone)
+          },
+          amazon: {
+              phone: match(amazonPhone),
+              tablet: !match(amazonPhone) && match(amazonTablet),
+              device: match(amazonPhone) || match(amazonTablet)
+          },
+          android: {
+              phone: (!match(windowsPhone) && match(amazonPhone)) ||
+                  (!match(windowsPhone) && match(androidPhone)),
+              tablet: !match(windowsPhone) &&
+                  !match(amazonPhone) &&
+                  !match(androidPhone) &&
+                  (match(amazonTablet) || match(androidTablet)),
+              device: (!match(windowsPhone) &&
+                  (match(amazonPhone) ||
+                      match(amazonTablet) ||
+                      match(androidPhone) ||
+                      match(androidTablet))) ||
+                  match(/\bokhttp\b/i)
+          },
+          windows: {
+              phone: match(windowsPhone),
+              tablet: match(windowsTablet),
+              device: match(windowsPhone) || match(windowsTablet)
+          },
+          other: {
+              blackberry: match(otherBlackBerry),
+              blackberry10: match(otherBlackBerry10),
+              opera: match(otherOpera),
+              firefox: match(otherFirefox),
+              chrome: match(otherChrome),
+              device: match(otherBlackBerry) ||
+                  match(otherBlackBerry10) ||
+                  match(otherOpera) ||
+                  match(otherFirefox) ||
+                  match(otherChrome)
+          },
+          any: false,
+          phone: false,
+          tablet: false
+      };
+      result.any =
+          result.apple.device ||
+              result.android.device ||
+              result.windows.device ||
+              result.other.device;
+      result.phone =
+          result.apple.phone || result.android.phone || result.windows.phone;
+      result.tablet =
+          result.apple.tablet || result.android.tablet || result.windows.tablet;
+      return result;
+  }
 
-    this.texture.bind();
+  var isMobile = isMobile$1(globalThis.navigator);
 
-    //gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA,  this.width, this.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+  /**
+   * Uploading the same buffer multiple times in a single frame can cause performance issues.
+   * Apparent on iOS so only check for that at the moment
+   * This check may become more complex if this issue pops up elsewhere.
+   * @private
+   * @returns {boolean} `true` if the same buffer may be uploaded more than once.
+   */
+  function canUploadSameBuffer() {
+      return !isMobile.apple.device;
+  }
 
-    this.bind();
+  /**
+   * The maximum recommended texture units to use.
+   * In theory the bigger the better, and for desktop we'll use as many as we can.
+   * But some mobile devices slow down if there is to many branches in the shader.
+   * So in practice there seems to be a sweet spot size that varies depending on the device.
+   *
+   * In v4, all mobile devices were limited to 4 texture units because for this.
+   * In v5, we allow all texture units to be used on modern Apple or Android devices.
+   * @private
+   * @param {number} max
+   * @returns {number} The maximum recommended texture units to use.
+   */
+  function maxRecommendedTextures(max) {
+      var allowMax = true;
+      if (isMobile.tablet || isMobile.phone) {
+          if (isMobile.apple.device) {
+              var match = (navigator.userAgent).match(/OS (\d+)_(\d+)?/);
+              if (match) {
+                  var majorVersion = parseInt(match[1], 10);
+                  // Limit texture units on devices below iOS 11, which will be older hardware
+                  if (majorVersion < 11) {
+                      allowMax = false;
+                  }
+              }
+          }
+          if (isMobile.android.device) {
+              var match = (navigator.userAgent).match(/Android\s([0-9.]*)/);
+              if (match) {
+                  var majorVersion = parseInt(match[1], 10);
+                  // Limit texture units on devices below Android 7 (Nougat), which will be older hardware
+                  if (majorVersion < 7) {
+                      allowMax = false;
+                  }
+              }
+          }
+      }
+      return allowMax ? max : 4;
+  }
 
-    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.texture.texture, 0);
-};
+  /**
+   * User's customizable globals for overriding the default PIXI settings, such
+   * as a renderer's default resolution, framerate, float precision, etc.
+   * @example
+   * // Use the native window resolution as the default resolution
+   * // will support high-density displays when rendering
+   * PIXI.settings.RESOLUTION = window.devicePixelRatio;
+   *
+   * // Disable interpolation when scaling, will make texture be pixelated
+   * PIXI.settings.SCALE_MODE = PIXI.SCALE_MODES.NEAREST;
+   * @namespace PIXI.settings
+   */
+  var settings = {
+      /**
+       * This adapter is used to call methods that are platform dependent.
+       * For example `document.createElement` only runs on the web but fails in node environments.
+       * This allows us to support more platforms by abstracting away specific implementations per platform.
+       *
+       * By default the adapter is set to work in the browser. However you can create your own
+       * by implementing the `IAdapter` interface. See `IAdapter` for more information.
+       * @name ADAPTER
+       * @memberof PIXI.settings
+       * @type {PIXI.IAdapter}
+       * @default PIXI.BrowserAdapter
+       */
+      ADAPTER: BrowserAdapter,
+      /**
+       * If set to true WebGL will attempt make textures mimpaped by default.
+       * Mipmapping will only succeed if the base texture uploaded has power of two dimensions.
+       * @static
+       * @name MIPMAP_TEXTURES
+       * @memberof PIXI.settings
+       * @type {PIXI.MIPMAP_MODES}
+       * @default PIXI.MIPMAP_MODES.POW2
+       */
+      MIPMAP_TEXTURES: exports.MIPMAP_MODES.POW2,
+      /**
+       * Default anisotropic filtering level of textures.
+       * Usually from 0 to 16
+       * @static
+       * @name ANISOTROPIC_LEVEL
+       * @memberof PIXI.settings
+       * @type {number}
+       * @default 0
+       */
+      ANISOTROPIC_LEVEL: 0,
+      /**
+       * Default resolution / device pixel ratio of the renderer.
+       * @static
+       * @name RESOLUTION
+       * @memberof PIXI.settings
+       * @type {number}
+       * @default 1
+       */
+      RESOLUTION: 1,
+      /**
+       * Default filter resolution.
+       * @static
+       * @name FILTER_RESOLUTION
+       * @memberof PIXI.settings
+       * @type {number}
+       * @default 1
+       */
+      FILTER_RESOLUTION: 1,
+      /**
+       * Default filter samples.
+       * @static
+       * @name FILTER_MULTISAMPLE
+       * @memberof PIXI.settings
+       * @type {PIXI.MSAA_QUALITY}
+       * @default PIXI.MSAA_QUALITY.NONE
+       */
+      FILTER_MULTISAMPLE: exports.MSAA_QUALITY.NONE,
+      /**
+       * The maximum textures that this device supports.
+       * @static
+       * @name SPRITE_MAX_TEXTURES
+       * @memberof PIXI.settings
+       * @type {number}
+       * @default 32
+       */
+      SPRITE_MAX_TEXTURES: maxRecommendedTextures(32),
+      // TODO: maybe change to SPRITE.BATCH_SIZE: 2000
+      // TODO: maybe add PARTICLE.BATCH_SIZE: 15000
+      /**
+       * The default sprite batch size.
+       *
+       * The default aims to balance desktop and mobile devices.
+       * @static
+       * @name SPRITE_BATCH_SIZE
+       * @memberof PIXI.settings
+       * @type {number}
+       * @default 4096
+       */
+      SPRITE_BATCH_SIZE: 4096,
+      /**
+       * The default render options if none are supplied to {@link PIXI.Renderer}
+       * or {@link PIXI.CanvasRenderer}.
+       * @static
+       * @name RENDER_OPTIONS
+       * @memberof PIXI.settings
+       * @type {object}
+       * @property {boolean} [antialias=false] - {@link PIXI.IRendererOptions.antialias}
+       * @property {boolean} [autoDensity=false] - {@link PIXI.IRendererOptions.autoDensity}
+       * @property {number} [backgroundAlpha=1] - {@link PIXI.IRendererOptions.backgroundAlpha}
+       * @property {number} [backgroundColor=0x000000] - {@link PIXI.IRendererOptions.backgroundColor}
+       * @property {boolean} [clearBeforeRender=true] - {@link PIXI.IRendererOptions.clearBeforeRender}
+       * @property {number} [height=600] - {@link PIXI.IRendererOptions.height}
+       * @property {boolean} [preserveDrawingBuffer=false] - {@link PIXI.IRendererOptions.preserveDrawingBuffer}
+       * @property {boolean|'notMultiplied'} [useContextAlpha=true] - {@link PIXI.IRendererOptions.useContextAlpha}
+       * @property {HTMLCanvasElement} [view=null] - {@link PIXI.IRendererOptions.view}
+       * @property {number} [width=800] - {@link PIXI.IRendererOptions.width}
+       */
+      RENDER_OPTIONS: {
+          view: null,
+          width: 800,
+          height: 600,
+          autoDensity: false,
+          backgroundColor: 0x000000,
+          backgroundAlpha: 1,
+          useContextAlpha: true,
+          clearBeforeRender: true,
+          antialias: false,
+          preserveDrawingBuffer: false,
+      },
+      /**
+       * Default Garbage Collection mode.
+       * @static
+       * @name GC_MODE
+       * @memberof PIXI.settings
+       * @type {PIXI.GC_MODES}
+       * @default PIXI.GC_MODES.AUTO
+       */
+      GC_MODE: exports.GC_MODES.AUTO,
+      /**
+       * Default Garbage Collection max idle.
+       * @static
+       * @name GC_MAX_IDLE
+       * @memberof PIXI.settings
+       * @type {number}
+       * @default 3600
+       */
+      GC_MAX_IDLE: 60 * 60,
+      /**
+       * Default Garbage Collection maximum check count.
+       * @static
+       * @name GC_MAX_CHECK_COUNT
+       * @memberof PIXI.settings
+       * @type {number}
+       * @default 600
+       */
+      GC_MAX_CHECK_COUNT: 60 * 10,
+      /**
+       * Default wrap modes that are supported by pixi.
+       * @static
+       * @name WRAP_MODE
+       * @memberof PIXI.settings
+       * @type {PIXI.WRAP_MODES}
+       * @default PIXI.WRAP_MODES.CLAMP
+       */
+      WRAP_MODE: exports.WRAP_MODES.CLAMP,
+      /**
+       * Default scale mode for textures.
+       * @static
+       * @name SCALE_MODE
+       * @memberof PIXI.settings
+       * @type {PIXI.SCALE_MODES}
+       * @default PIXI.SCALE_MODES.LINEAR
+       */
+      SCALE_MODE: exports.SCALE_MODES.LINEAR,
+      /**
+       * Default specify float precision in vertex shader.
+       * @static
+       * @name PRECISION_VERTEX
+       * @memberof PIXI.settings
+       * @type {PIXI.PRECISION}
+       * @default PIXI.PRECISION.HIGH
+       */
+      PRECISION_VERTEX: exports.PRECISION.HIGH,
+      /**
+       * Default specify float precision in fragment shader.
+       * iOS is best set at highp due to https://github.com/pixijs/pixi.js/issues/3742
+       * @static
+       * @name PRECISION_FRAGMENT
+       * @memberof PIXI.settings
+       * @type {PIXI.PRECISION}
+       * @default PIXI.PRECISION.MEDIUM
+       */
+      PRECISION_FRAGMENT: isMobile.apple.device ? exports.PRECISION.HIGH : exports.PRECISION.MEDIUM,
+      /**
+       * Can we upload the same buffer in a single frame?
+       * @static
+       * @name CAN_UPLOAD_SAME_BUFFER
+       * @memberof PIXI.settings
+       * @type {boolean}
+       */
+      CAN_UPLOAD_SAME_BUFFER: canUploadSameBuffer(),
+      /**
+       * Enables bitmap creation before image load. This feature is experimental.
+       * @static
+       * @name CREATE_IMAGE_BITMAP
+       * @memberof PIXI.settings
+       * @type {boolean}
+       * @default false
+       */
+      CREATE_IMAGE_BITMAP: false,
+      /**
+       * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
+       * Advantages can include sharper image quality (like text) and faster rendering on canvas.
+       * The main disadvantage is movement of objects may appear less smooth.
+       * @static
+       * @constant
+       * @memberof PIXI.settings
+       * @type {boolean}
+       * @default false
+       */
+      ROUND_PIXELS: false,
+  };
 
-/**
- * Initialises the stencil buffer
- */
-Framebuffer.prototype.enableStencil = function()
-{
-    if(this.stencil)return;
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-    var gl = this.gl;
+  function getDefaultExportFromCjs (x) {
+  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+  }
 
-    this.stencil = gl.createRenderbuffer();
+  function createCommonjsModule(fn, basedir, module) {
+  	return module = {
+  		path: basedir,
+  		exports: {},
+  		require: function (path, base) {
+  			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+  		}
+  	}, fn(module, module.exports), module.exports;
+  }
 
-    gl.bindRenderbuffer(gl.RENDERBUFFER, this.stencil);
+  function getDefaultExportFromNamespaceIfPresent (n) {
+  	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
+  }
 
-    // TODO.. this is depth AND stencil?
-    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, this.stencil);
-    gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL,  this.width  , this.height );
+  function getDefaultExportFromNamespaceIfNotNamed (n) {
+  	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
+  }
 
+  function getAugmentedNamespace(n) {
+  	if (n.__esModule) return n;
+  	var a = Object.defineProperty({}, '__esModule', {value: true});
+  	Object.keys(n).forEach(function (k) {
+  		var d = Object.getOwnPropertyDescriptor(n, k);
+  		Object.defineProperty(a, k, d.get ? d : {
+  			enumerable: true,
+  			get: function () {
+  				return n[k];
+  			}
+  		});
+  	});
+  	return a;
+  }
 
-};
+  function commonjsRequire () {
+  	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+  }
 
-/**
- * Erases the drawing area and fills it with a colour
- * @param  r {Number} the red value of the clearing colour
- * @param  g {Number} the green value of the clearing colour
- * @param  b {Number} the blue value of the clearing colour
- * @param  a {Number} the alpha value of the clearing colour
- */
-Framebuffer.prototype.clear = function( r, g, b, a )
-{
-    this.bind();
+  var eventemitter3 = createCommonjsModule(function (module) {
+  'use strict';
 
-    var gl = this.gl;
+  var has = Object.prototype.hasOwnProperty
+    , prefix = '~';
 
-    gl.clearColor(r, g, b, a);
-    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
-};
+  /**
+   * Constructor to create a storage for our `EE` objects.
+   * An `Events` instance is a plain object whose properties are event names.
+   *
+   * @constructor
+   * @private
+   */
+  function Events() {}
 
-/**
- * Binds the frame buffer to the WebGL context
- */
-Framebuffer.prototype.bind = function()
-{
-    var gl = this.gl;
-    gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer );
-};
-
-/**
- * Unbinds the frame buffer to the WebGL context
- */
-Framebuffer.prototype.unbind = function()
-{
-    var gl = this.gl;
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null );
-};
-/**
- * Resizes the drawing area of the buffer to the given width and height
- * @param  width  {Number} the new width
- * @param  height {Number} the new height
- */
-Framebuffer.prototype.resize = function(width, height)
-{
-    var gl = this.gl;
+  //
+  // We try to not inherit from `Object.prototype`. In some engines creating an
+  // instance in this way is faster than calling `Object.create(null)` directly.
+  // If `Object.create(null)` is not supported we prefix the event names with a
+  // character to make sure that the built-in object properties are not
+  // overridden or used as an attack vector.
+  //
+  if (Object.create) {
+    Events.prototype = Object.create(null);
 
-    this.width = width;
-    this.height = height;
+    //
+    // This hack is needed because the `__proto__` property is still inherited in
+    // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+    //
+    if (!new Events().__proto__) { prefix = false; }
+  }
 
-    if ( this.texture )
-    {
-        this.texture.uploadData(null, width, height);
-    }
+  /**
+   * Representation of a single event listener.
+   *
+   * @param {Function} fn The listener function.
+   * @param {*} context The context to invoke the listener with.
+   * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+   * @constructor
+   * @private
+   */
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
 
-    if ( this.stencil )
-    {
-        // update the stencil buffer width and height
-        gl.bindRenderbuffer(gl.RENDERBUFFER, this.stencil);
-        gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, width, height);
+  /**
+   * Add a listener for a given event.
+   *
+   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} context The context to invoke the listener with.
+   * @param {Boolean} once Specify if the listener is a one-time listener.
+   * @returns {EventEmitter}
+   * @private
+   */
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== 'function') {
+      throw new TypeError('The listener must be a function');
     }
-};
 
-/**
- * Destroys this buffer
- */
-Framebuffer.prototype.destroy = function()
-{
-    var gl = this.gl;
-
-    //TODO
-    if(this.texture)
-    {
-        this.texture.destroy();
-    }
+    var listener = new EE(fn, context || emitter, once)
+      , evt = prefix ? prefix + event : event;
 
-    gl.deleteFramebuffer(this.framebuffer);
+    if (!emitter._events[evt]) { emitter._events[evt] = listener, emitter._eventsCount++; }
+    else if (!emitter._events[evt].fn) { emitter._events[evt].push(listener); }
+    else { emitter._events[evt] = [emitter._events[evt], listener]; }
 
-    this.gl = null;
+    return emitter;
+  }
 
-    this.stencil = null;
-    this.texture = null;
-};
+  /**
+   * Clear event by name.
+   *
+   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+   * @param {(String|Symbol)} evt The Event name.
+   * @private
+   */
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0) { emitter._events = new Events(); }
+    else { delete emitter._events[evt]; }
+  }
 
-/**
- * Creates a frame buffer with a texture containing the given data
- * @static
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- * @param width {Number} the width of the drawing area of the frame buffer
- * @param height {Number} the height of the drawing area of the frame buffer
- * @param data {ArrayBuffer| SharedArrayBuffer|ArrayBufferView} an array of data
- */
-Framebuffer.createRGBA = function(gl, width, height, data)
-{
-    var texture = Texture.fromData(gl, null, width, height);
-    texture.enableNearestScaling();
-    texture.enableWrapClamp();
-
-    //now create the framebuffer object and attach the texture to it.
-    var fbo = new Framebuffer(gl, width, height);
-    fbo.enableTexture(texture);
-
-    //fbo.enableStencil(); // get this back on soon!
-
-    fbo.unbind();
-
-    return fbo;
-};
-
-/**
- * Creates a frame buffer with a texture containing the given data
- * @static
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- * @param width {Number} the width of the drawing area of the frame buffer
- * @param height {Number} the height of the drawing area of the frame buffer
- * @param data {ArrayBuffer| SharedArrayBuffer|ArrayBufferView} an array of data
- */
-Framebuffer.createFloat32 = function(gl, width, height, data)
-{
-    // create a new texture..
-    var texture = new Texture.fromData(gl, data, width, height);
-    texture.enableNearestScaling();
-    texture.enableWrapClamp();
+  /**
+   * Minimal `EventEmitter` interface that is molded against the Node.js
+   * `EventEmitter` interface.
+   *
+   * @constructor
+   * @public
+   */
+  function EventEmitter() {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
 
-    //now create the framebuffer object and attach the texture to it.
-    var fbo = new Framebuffer(gl, width, height);
-    fbo.enableTexture(texture);
+  /**
+   * Return an array listing the events for which the emitter has registered
+   * listeners.
+   *
+   * @returns {Array}
+   * @public
+   */
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = []
+      , events
+      , name;
 
-    fbo.unbind();
+    if (this._eventsCount === 0) { return names; }
 
-    return fbo;
-};
+    for (name in (events = this._events)) {
+      if (has.call(events, name)) { names.push(prefix ? name.slice(1) : name); }
+    }
 
-module.exports = Framebuffer;
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
 
-},{"./GLTexture":9}],8:[function(require,module,exports){
+    return names;
+  };
 
-var compileProgram = require('./shader/compileProgram'),
-	extractAttributes = require('./shader/extractAttributes'),
-	extractUniforms = require('./shader/extractUniforms'),
-	setPrecision = require('./shader/setPrecision'),
-	generateUniformAccessObject = require('./shader/generateUniformAccessObject');
+  /**
+   * Return the listeners registered for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Array} The registered listeners.
+   * @public
+   */
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event
+      , handlers = this._events[evt];
 
-/**
- * Helper class to create a webGL Shader
- *
- * @class
- * @memberof PIXI.glCore
- * @param gl {WebGLRenderingContext}
- * @param vertexSrc {string|string[]} The vertex shader source as an array of strings.
- * @param fragmentSrc {string|string[]} The fragment shader source as an array of strings.
- * @param precision {precision]} The float precision of the shader. Options are 'lowp', 'mediump' or 'highp'.
- * @param attributeLocations {object} A key value pair showing which location eact attribute should sit eg {position:0, uvs:1}
- */
-var Shader = function(gl, vertexSrc, fragmentSrc, precision, attributeLocations)
-{
-	/**
-	 * The current WebGL rendering context
-	 *
-	 * @member {WebGLRenderingContext}
-	 */
-	this.gl = gl;
-
-	if(precision)
-	{
-		vertexSrc = setPrecision(vertexSrc, precision);
-		fragmentSrc = setPrecision(fragmentSrc, precision);
-	}
-
-	/**
-	 * The shader program
-	 *
-	 * @member {WebGLProgram}
-	 */
-	// First compile the program..
-	this.program = compileProgram(gl, vertexSrc, fragmentSrc, attributeLocations);
-
-	/**
-	 * The attributes of the shader as an object containing the following properties
-	 * {
-	 * 	type,
-	 * 	size,
-	 * 	location,
-	 * 	pointer
-	 * }
-	 * @member {Object}
-	 */
-	// next extract the attributes
-	this.attributes = extractAttributes(gl, this.program);
-
-    this.uniformData = extractUniforms(gl, this.program);
-
-	/**
-	 * The uniforms of the shader as an object containing the following properties
-	 * {
-	 * 	gl,
-	 * 	data
-	 * }
-	 * @member {Object}
-	 */
-	this.uniforms = generateUniformAccessObject( gl, this.uniformData );
-
-};
-/**
- * Uses this shader
- */
-Shader.prototype.bind = function()
-{
-	this.gl.useProgram(this.program);
-};
-
-/**
- * Destroys this shader
- * TODO
- */
-Shader.prototype.destroy = function()
-{
-	this.attributes = null;
-	this.uniformData = null;
-	this.uniforms = null;
+    if (!handlers) { return []; }
+    if (handlers.fn) { return [handlers.fn]; }
 
-	var gl = this.gl;
-	gl.deleteProgram(this.program);
-};
+    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
 
+    return ee;
+  };
 
-module.exports = Shader;
+  /**
+   * Return the number of listeners listening to a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Number} The number of listeners.
+   * @public
+   */
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event
+      , listeners = this._events[evt];
 
-},{"./shader/compileProgram":14,"./shader/extractAttributes":16,"./shader/extractUniforms":17,"./shader/generateUniformAccessObject":18,"./shader/setPrecision":22}],9:[function(require,module,exports){
+    if (!listeners) { return 0; }
+    if (listeners.fn) { return 1; }
+    return listeners.length;
+  };
 
-/**
- * Helper class to create a WebGL Texture
- *
- * @class
- * @memberof PIXI.glCore
- * @param gl {WebGLRenderingContext} The current WebGL context
- * @param width {number} the width of the texture
- * @param height {number} the height of the texture
- * @param format {number} the pixel format of the texture. defaults to gl.RGBA
- * @param type {number} the gl type of the texture. defaults to gl.UNSIGNED_BYTE
- */
-var Texture = function(gl, width, height, format, type)
-{
-	/**
-	 * The current WebGL rendering context
-	 *
-	 * @member {WebGLRenderingContext}
-	 */
-	this.gl = gl;
-
-
-	/**
-	 * The WebGL texture
-	 *
-	 * @member {WebGLTexture}
-	 */
-	this.texture = gl.createTexture();
-
-	/**
-	 * If mipmapping was used for this texture, enable and disable with enableMipmap()
-	 *
-	 * @member {Boolean}
-	 */
-	// some settings..
-	this.mipmap = false;
-
-
-	/**
-	 * Set to true to enable pre-multiplied alpha
-	 *
-	 * @member {Boolean}
-	 */
-	this.premultiplyAlpha = false;
-
-	/**
-	 * The width of texture
-	 *
-	 * @member {Number}
-	 */
-	this.width = width || -1;
-	/**
-	 * The height of texture
-	 *
-	 * @member {Number}
-	 */
-	this.height = height || -1;
-
-	/**
-	 * The pixel format of the texture. defaults to gl.RGBA
-	 *
-	 * @member {Number}
-	 */
-	this.format = format || gl.RGBA;
-
-	/**
-	 * The gl type of the texture. defaults to gl.UNSIGNED_BYTE
-	 *
-	 * @member {Number}
-	 */
-	this.type = type || gl.UNSIGNED_BYTE;
-
-
-};
-
-/**
- * Uploads this texture to the GPU
- * @param source {HTMLImageElement|ImageData|HTMLVideoElement} the source image of the texture
- */
-Texture.prototype.upload = function(source)
-{
-	this.bind();
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Boolean} `true` if the event had listeners, else `false`.
+   * @public
+   */
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var arguments$1 = arguments;
 
-	var gl = this.gl;
+    var evt = prefix ? prefix + event : event;
 
+    if (!this._events[evt]) { return false; }
 
-	gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this.premultiplyAlpha);
+    var listeners = this._events[evt]
+      , len = arguments.length
+      , args
+      , i;
 
-	var newWidth = source.videoWidth || source.width;
-	var newHeight = source.videoHeight || source.height;
+    if (listeners.fn) {
+      if (listeners.once) { this.removeListener(event, listeners.fn, undefined, true); }
 
-	if(newHeight !== this.height || newWidth !== this.width)
-	{
-		gl.texImage2D(gl.TEXTURE_2D, 0, this.format, this.format, this.type, source);
-	}
-	else
-	{
-    	gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, this.format, this.type, source);
-	}
+      switch (len) {
+        case 1: return listeners.fn.call(listeners.context), true;
+        case 2: return listeners.fn.call(listeners.context, a1), true;
+        case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
 
-	// if the source is a video, we need to use the videoWidth / videoHeight properties as width / height will be incorrect.
-	this.width = newWidth;
-	this.height = newHeight;
+      for (i = 1, args = new Array(len -1); i < len; i++) {
+        args[i - 1] = arguments$1[i];
+      }
 
-};
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length
+        , j;
 
-var FLOATING_POINT_AVAILABLE = false;
+      for (i = 0; i < length; i++) {
+        if (listeners[i].once) { this.removeListener(event, listeners[i].fn, undefined, true); }
 
-/**
- * Use a data source and uploads this texture to the GPU
- * @param data {TypedArray} the data to upload to the texture
- * @param width {number} the new width of the texture
- * @param height {number} the new height of the texture
- */
-Texture.prototype.uploadData = function(data, width, height)
-{
-	this.bind();
-
-	var gl = this.gl;
-
-
-	if(data instanceof Float32Array)
-	{
-		if(!FLOATING_POINT_AVAILABLE)
-		{
-			var ext = gl.getExtension("OES_texture_float");
-
-			if(ext)
-			{
-				FLOATING_POINT_AVAILABLE = true;
-			}
-			else
-			{
-				throw new Error('floating point textures not available');
-			}
-		}
-
-		this.type = gl.FLOAT;
-	}
-	else
-	{
-		// TODO support for other types
-		this.type = this.type || gl.UNSIGNED_BYTE;
-	}
-
-	// what type of data?
-	gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this.premultiplyAlpha);
-
-
-	if(width !== this.width || height !== this.height)
-	{
-		gl.texImage2D(gl.TEXTURE_2D, 0, this.format,  width, height, 0, this.format, this.type, data || null);
-	}
-	else
-	{
-		gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, this.format, this.type, data || null);
-	}
-
-	this.width = width;
-	this.height = height;
-
-
-//	texSubImage2D
-};
-
-/**
- * Binds the texture
- * @param  location
- */
-Texture.prototype.bind = function(location)
-{
-	var gl = this.gl;
+        switch (len) {
+          case 1: listeners[i].fn.call(listeners[i].context); break;
+          case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+          case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+          case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+          default:
+            if (!args) { for (j = 1, args = new Array(len -1); j < len; j++) {
+              args[j - 1] = arguments$1[j];
+            } }
 
-	if(location !== undefined)
-	{
-		gl.activeTexture(gl.TEXTURE0 + location);
-	}
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
 
-	gl.bindTexture(gl.TEXTURE_2D, this.texture);
-};
+    return true;
+  };
 
-/**
- * Unbinds the texture
- */
-Texture.prototype.unbind = function()
-{
-	var gl = this.gl;
-	gl.bindTexture(gl.TEXTURE_2D, null);
-};
-
-/**
- * @param linear {Boolean} if we want to use linear filtering or nearest neighbour interpolation
- */
-Texture.prototype.minFilter = function( linear )
-{
-	var gl = this.gl;
-
-	this.bind();
-
-	if(this.mipmap)
-	{
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, linear ? gl.LINEAR_MIPMAP_LINEAR : gl.NEAREST_MIPMAP_NEAREST);
-	}
-	else
-	{
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, linear ? gl.LINEAR : gl.NEAREST);
-	}
-};
-
-/**
- * @param linear {Boolean} if we want to use linear filtering or nearest neighbour interpolation
- */
-Texture.prototype.magFilter = function( linear )
-{
-	var gl = this.gl;
+  /**
+   * Add a listener for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} [context=this] The context to invoke the listener with.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
 
-	this.bind();
+  /**
+   * Add a one-time listener for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} [context=this] The context to invoke the listener with.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
 
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, linear ? gl.LINEAR : gl.NEAREST);
-};
+  /**
+   * Remove the listeners of a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn Only remove the listeners that match this function.
+   * @param {*} context Only remove the listeners that have this context.
+   * @param {Boolean} once Only remove one-time listeners.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
 
-/**
- * Enables mipmapping
- */
-Texture.prototype.enableMipmap = function()
-{
-	var gl = this.gl;
+    if (!this._events[evt]) { return this; }
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
 
-	this.bind();
+    var listeners = this._events[evt];
 
-	this.mipmap = true;
+    if (listeners.fn) {
+      if (
+        listeners.fn === fn &&
+        (!once || listeners.once) &&
+        (!context || listeners.context === context)
+      ) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+        if (
+          listeners[i].fn !== fn ||
+          (once && !listeners[i].once) ||
+          (context && listeners[i].context !== context)
+        ) {
+          events.push(listeners[i]);
+        }
+      }
 
-	gl.generateMipmap(gl.TEXTURE_2D);
-};
+      //
+      // Reset the array, or remove it completely if we have no more listeners.
+      //
+      if (events.length) { this._events[evt] = events.length === 1 ? events[0] : events; }
+      else { clearEvent(this, evt); }
+    }
 
-/**
- * Enables linear filtering
- */
-Texture.prototype.enableLinearScaling = function()
-{
-	this.minFilter(true);
-	this.magFilter(true);
-};
-
-/**
- * Enables nearest neighbour interpolation
- */
-Texture.prototype.enableNearestScaling = function()
-{
-	this.minFilter(false);
-	this.magFilter(false);
-};
-
-/**
- * Enables clamping on the texture so WebGL will not repeat it
- */
-Texture.prototype.enableWrapClamp = function()
-{
-	var gl = this.gl;
+    return this;
+  };
 
-	this.bind();
+  /**
+   * Remove all listeners, or those of the specified event.
+   *
+   * @param {(String|Symbol)} [event] The event name.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
 
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-};
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt]) { clearEvent(this, evt); }
+    } else {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
 
-/**
- * Enable tiling on the texture
- */
-Texture.prototype.enableWrapRepeat = function()
-{
-	var gl = this.gl;
+    return this;
+  };
 
-	this.bind();
+  //
+  // Alias methods names because people roll like that.
+  //
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
 
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
-};
+  //
+  // Expose the prefix.
+  //
+  EventEmitter.prefixed = prefix;
 
-Texture.prototype.enableWrapMirrorRepeat = function()
-{
-	var gl = this.gl;
+  //
+  // Allow `EventEmitter` to be imported as module namespace.
+  //
+  EventEmitter.EventEmitter = EventEmitter;
 
-	this.bind();
+  //
+  // Expose the module.
+  //
+  if ('undefined' !== 'object') {
+    module.exports = EventEmitter;
+  }
+  });
 
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.MIRRORED_REPEAT);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.MIRRORED_REPEAT);
-};
+  'use strict';
 
+  var earcut_1 = earcut;
+  var _default = earcut;
 
-/**
- * Destroys this texture
- */
-Texture.prototype.destroy = function()
-{
-	var gl = this.gl;
-	//TODO
-	gl.deleteTexture(this.texture);
-};
-
-/**
- * @static
- * @param gl {WebGLRenderingContext} The current WebGL context
- * @param source {HTMLImageElement|ImageData} the source image of the texture
- * @param premultiplyAlpha {Boolean} If we want to use pre-multiplied alpha
- */
-Texture.fromSource = function(gl, source, premultiplyAlpha)
-{
-	var texture = new Texture(gl);
-	texture.premultiplyAlpha = premultiplyAlpha || false;
-	texture.upload(source);
-
-	return texture;
-};
-
-/**
- * @static
- * @param gl {WebGLRenderingContext} The current WebGL context
- * @param data {TypedArray} the data to upload to the texture
- * @param width {number} the new width of the texture
- * @param height {number} the new height of the texture
- */
-Texture.fromData = function(gl, data, width, height)
-{
-	//console.log(data, width, height);
-	var texture = new Texture(gl);
-	texture.uploadData(data, width, height);
+  function earcut(data, holeIndices, dim) {
 
-	return texture;
-};
+      dim = dim || 2;
 
+      var hasHoles = holeIndices && holeIndices.length,
+          outerLen = hasHoles ? holeIndices[0] * dim : data.length,
+          outerNode = linkedList(data, 0, outerLen, dim, true),
+          triangles = [];
 
-module.exports = Texture;
+      if (!outerNode || outerNode.next === outerNode.prev) { return triangles; }
 
-},{}],10:[function(require,module,exports){
+      var minX, minY, maxX, maxY, x, y, invSize;
 
-// state object//
-var setVertexAttribArrays = require( './setVertexAttribArrays' );
+      if (hasHoles) { outerNode = eliminateHoles(data, holeIndices, outerNode, dim); }
 
-/**
- * Helper class to work with WebGL VertexArrayObjects (vaos)
- * Only works if WebGL extensions are enabled (they usually are)
- *
- * @class
- * @memberof PIXI.glCore
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- */
-function VertexArrayObject(gl, state)
-{
-    this.nativeVaoExtension = null;
-
-    if(!VertexArrayObject.FORCE_NATIVE)
-    {
-        this.nativeVaoExtension = gl.getExtension('OES_vertex_array_object') ||
-                                  gl.getExtension('MOZ_OES_vertex_array_object') ||
-                                  gl.getExtension('WEBKIT_OES_vertex_array_object');
-    }
+      // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+      if (data.length > 80 * dim) {
+          minX = maxX = data[0];
+          minY = maxY = data[1];
 
-    this.nativeState = state;
+          for (var i = dim; i < outerLen; i += dim) {
+              x = data[i];
+              y = data[i + 1];
+              if (x < minX) { minX = x; }
+              if (y < minY) { minY = y; }
+              if (x > maxX) { maxX = x; }
+              if (y > maxY) { maxY = y; }
+          }
 
-    if(this.nativeVaoExtension)
-    {
-        this.nativeVao = this.nativeVaoExtension.createVertexArrayOES();
+          // minX, minY and invSize are later used to transform coords into integers for z-order calculation
+          invSize = Math.max(maxX - minX, maxY - minY);
+          invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
 
-        var maxAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
 
-        // VAO - overwrite the state..
-        this.nativeState = {
-            tempAttribState: new Array(maxAttribs),
-            attribState: new Array(maxAttribs)
-        };
-    }
+      return triangles;
+  }
 
-    /**
-     * The current WebGL rendering context
-     *
-     * @member {WebGLRenderingContext}
-     */
-    this.gl = gl;
-
-    /**
-     * An array of attributes
-     *
-     * @member {Array}
-     */
-    this.attributes = [];
-
-    /**
-     * @member {PIXI.glCore.GLBuffer}
-     */
-    this.indexBuffer = null;
-
-    /**
-     * A boolean flag
-     *
-     * @member {Boolean}
-     */
-    this.dirty = false;
-}
-
-VertexArrayObject.prototype.constructor = VertexArrayObject;
-module.exports = VertexArrayObject;
-
-/**
-* Some devices behave a bit funny when using the newer extensions (im looking at you ipad 2!)
-* If you find on older devices that things have gone a bit weird then set this to true.
-*/
-/**
- * Lets the VAO know if you should use the WebGL extension or the native methods.
- * Some devices behave a bit funny when using the newer extensions (im looking at you ipad 2!)
- * If you find on older devices that things have gone a bit weird then set this to true.
- * @static
- * @property {Boolean} FORCE_NATIVE
- */
-VertexArrayObject.FORCE_NATIVE = false;
+  // create a circular doubly linked list from polygon points in the specified winding order
+  function linkedList(data, start, end, dim, clockwise) {
+      var i, last;
 
-/**
- * Binds the buffer
- */
-VertexArrayObject.prototype.bind = function()
-{
-    if(this.nativeVao)
-    {
-        this.nativeVaoExtension.bindVertexArrayOES(this.nativeVao);
-
-        if(this.dirty)
-        {
-            this.dirty = false;
-            this.activate();
-        }
-    }
-    else
-    {
+      if (clockwise === (signedArea(data, start, end, dim) > 0)) {
+          for (i = start; i < end; i += dim) { last = insertNode(i, data[i], data[i + 1], last); }
+      } else {
+          for (i = end - dim; i >= start; i -= dim) { last = insertNode(i, data[i], data[i + 1], last); }
+      }
 
-        this.activate();
-    }
+      if (last && equals(last, last.next)) {
+          removeNode(last);
+          last = last.next;
+      }
 
-    return this;
-};
+      return last;
+  }
 
-/**
- * Unbinds the buffer
- */
-VertexArrayObject.prototype.unbind = function()
-{
-    if(this.nativeVao)
-    {
-        this.nativeVaoExtension.bindVertexArrayOES(null);
-    }
+  // eliminate colinear or duplicate points
+  function filterPoints(start, end) {
+      if (!start) { return start; }
+      if (!end) { end = start; }
 
-    return this;
-};
+      var p = start,
+          again;
+      do {
+          again = false;
 
-/**
- * Uses this vao
- */
-VertexArrayObject.prototype.activate = function()
-{
+          if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+              removeNode(p);
+              p = end = p.prev;
+              if (p === p.next) { break; }
+              again = true;
 
-    var gl = this.gl;
-    var lastBuffer = null;
+          } else {
+              p = p.next;
+          }
+      } while (again || p !== end);
 
-    for (var i = 0; i < this.attributes.length; i++)
-    {
-        var attrib = this.attributes[i];
+      return end;
+  }
 
-        if(lastBuffer !== attrib.buffer)
-        {
-            attrib.buffer.bind();
-            lastBuffer = attrib.buffer;
-        }
+  // main ear slicing loop which triangulates a polygon (given as a linked list)
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+      if (!ear) { return; }
 
-        gl.vertexAttribPointer(attrib.attribute.location,
-                               attrib.attribute.size,
-                               attrib.type || gl.FLOAT,
-                               attrib.normalized || false,
-                               attrib.stride || 0,
-                               attrib.start || 0);
-    }
+      // interlink polygon nodes in z-order
+      if (!pass && invSize) { indexCurve(ear, minX, minY, invSize); }
 
-    setVertexAttribArrays(gl, this.attributes, this.nativeState);
+      var stop = ear,
+          prev, next;
 
-    if(this.indexBuffer)
-    {
-        this.indexBuffer.bind();
-    }
+      // iterate through ears, slicing them one by one
+      while (ear.prev !== ear.next) {
+          prev = ear.prev;
+          next = ear.next;
 
-    return this;
-};
+          if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+              // cut off the triangle
+              triangles.push(prev.i / dim | 0);
+              triangles.push(ear.i / dim | 0);
+              triangles.push(next.i / dim | 0);
 
-/**
- *
- * @param buffer     {PIXI.gl.GLBuffer}
- * @param attribute  {*}
- * @param type       {String}
- * @param normalized {Boolean}
- * @param stride     {Number}
- * @param start      {Number}
- */
-VertexArrayObject.prototype.addAttribute = function(buffer, attribute, type, normalized, stride, start)
-{
-    this.attributes.push({
-        buffer:     buffer,
-        attribute:  attribute,
-
-        location:   attribute.location,
-        type:       type || this.gl.FLOAT,
-        normalized: normalized || false,
-        stride:     stride || 0,
-        start:      start || 0
-    });
+              removeNode(ear);
 
-    this.dirty = true;
+              // skipping the next vertex leads to less sliver triangles
+              ear = next.next;
+              stop = next.next;
 
-    return this;
-};
+              continue;
+          }
 
-/**
- *
- * @param buffer   {PIXI.gl.GLBuffer}
- */
-VertexArrayObject.prototype.addIndex = function(buffer/*, options*/)
-{
-    this.indexBuffer = buffer;
+          ear = next;
 
-    this.dirty = true;
+          // if we looped through the whole remaining polygon and can't find any more ears
+          if (ear === stop) {
+              // try filtering points and slicing again
+              if (!pass) {
+                  earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
 
-    return this;
-};
+              // if this didn't work, try curing all small self-intersections locally
+              } else if (pass === 1) {
+                  ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+                  earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
 
-/**
- * Unbinds this vao and disables it
- */
-VertexArrayObject.prototype.clear = function()
-{
-    // var gl = this.gl;
-
-    // TODO - should this function unbind after clear?
-    // for now, no but lets see what happens in the real world!
-    if(this.nativeVao)
-    {
-        this.nativeVaoExtension.bindVertexArrayOES(this.nativeVao);
-    }
+              // as a last resort, try splitting the remaining polygon into two
+              } else if (pass === 2) {
+                  splitEarcut(ear, triangles, dim, minX, minY, invSize);
+              }
 
-    this.attributes.length = 0;
-    this.indexBuffer = null;
+              break;
+          }
+      }
+  }
 
-    return this;
-};
+  // check whether a polygon node forms a valid ear with adjacent nodes
+  function isEar(ear) {
+      var a = ear.prev,
+          b = ear,
+          c = ear.next;
+
+      if (area(a, b, c) >= 0) { return false; } // reflex, can't be an ear
+
+      // now make sure we don't have other points inside the potential ear
+      var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+
+      // triangle bbox; min & max are calculated like this for speed
+      var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
+          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
+          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
+          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
+
+      var p = c.next;
+      while (p !== a) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
+              area(p.prev, p, p.next) >= 0) { return false; }
+          p = p.next;
+      }
 
-/**
- * @param type  {Number}
- * @param size  {Number}
- * @param start {Number}
- */
-VertexArrayObject.prototype.draw = function(type, size, start)
-{
-    var gl = this.gl;
+      return true;
+  }
 
-    if(this.indexBuffer)
-    {
-        gl.drawElements(type, size || this.indexBuffer.data.length, gl.UNSIGNED_SHORT, (start || 0) * 2 );
-    }
-    else
-    {
-        // TODO need a better way to calculate size..
-        gl.drawArrays(type, start, size || this.getSize());
-    }
+  function isEarHashed(ear, minX, minY, invSize) {
+      var a = ear.prev,
+          b = ear,
+          c = ear.next;
 
-    return this;
-};
+      if (area(a, b, c) >= 0) { return false; } // reflex, can't be an ear
 
-/**
- * Destroy this vao
- */
-VertexArrayObject.prototype.destroy = function()
-{
-    // lose references
-    this.gl = null;
-    this.indexBuffer = null;
-    this.attributes = null;
-    this.nativeState = null;
-
-    if(this.nativeVao)
-    {
-        this.nativeVaoExtension.deleteVertexArrayOES(this.nativeVao);
-    }
+      var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
 
-    this.nativeVaoExtension = null;
-    this.nativeVao = null;
-};
+      // triangle bbox; min & max are calculated like this for speed
+      var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
+          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
+          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
+          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
 
-VertexArrayObject.prototype.getSize = function()
-{
-    var attrib = this.attributes[0];
-    return attrib.buffer.data.length / (( attrib.stride/4 ) || attrib.attribute.size);
-};
+      // z-order range for the current triangle bbox;
+      var minZ = zOrder(x0, y0, minX, minY, invSize),
+          maxZ = zOrder(x1, y1, minX, minY, invSize);
 
-},{"./setVertexAttribArrays":13}],11:[function(require,module,exports){
+      var p = ear.prevZ,
+          n = ear.nextZ;
 
-/**
- * Helper class to create a webGL Context
- *
- * @class
- * @memberof PIXI.glCore
- * @param canvas {HTMLCanvasElement} the canvas element that we will get the context from
- * @param options {Object} An options object that gets passed in to the canvas element containing the context attributes,
- *                         see https://developer.mozilla.org/en/docs/Web/API/HTMLCanvasElement/getContext for the options available
- * @return {WebGLRenderingContext} the WebGL context
- */
-var createContext = function(canvas, options)
-{
-    var gl = canvas.getContext('webgl', options) || 
-         canvas.getContext('experimental-webgl', options);
-
-    if (!gl)
-    {
-        // fail, not able to get a context
-        throw new Error('This browser does not support webGL. Try using the canvas renderer');
-    }
+      // look for points inside the triangle in both directions
+      while (p && p.z >= minZ && n && n.z <= maxZ) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) { return false; }
+          p = p.prevZ;
 
-    return gl;
-};
-
-module.exports = createContext;
-
-},{}],12:[function(require,module,exports){
-var gl = {
-    createContext:          require('./createContext'),
-    setVertexAttribArrays:  require('./setVertexAttribArrays'),
-    GLBuffer:               require('./GLBuffer'),
-    GLFramebuffer:          require('./GLFramebuffer'),
-    GLShader:               require('./GLShader'),
-    GLTexture:              require('./GLTexture'),
-    VertexArrayObject:      require('./VertexArrayObject'),
-    shader:                 require('./shader')
-};
-
-// Export for Node-compatible environments
-if (typeof module !== 'undefined' && module.exports)
-{
-    // Export the module
-    module.exports = gl;
-}
-
-// Add to the browser window pixi.gl
-if (typeof window !== 'undefined')
-{
-    // add the window object
-    window.PIXI = window.PIXI || {};
-    window.PIXI.glCore = gl;
-}
-
-},{"./GLBuffer":6,"./GLFramebuffer":7,"./GLShader":8,"./GLTexture":9,"./VertexArrayObject":10,"./createContext":11,"./setVertexAttribArrays":13,"./shader":19}],13:[function(require,module,exports){
-// var GL_MAP = {};
-
-/**
- * @param gl {WebGLRenderingContext} The current WebGL context
- * @param attribs {*}
- * @param state {*}
- */
-var setVertexAttribArrays = function (gl, attribs, state)
-{
-    var i;
-    if(state)
-    {
-        var tempAttribState = state.tempAttribState,
-            attribState = state.attribState;
-
-        for (i = 0; i < tempAttribState.length; i++)
-        {
-            tempAttribState[i] = false;
-        }
+          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) { return false; }
+          n = n.nextZ;
+      }
 
-        // set the new attribs
-        for (i = 0; i < attribs.length; i++)
-        {
-            tempAttribState[attribs[i].attribute.location] = true;
-        }
+      // look for remaining points in decreasing z-order
+      while (p && p.z >= minZ) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) { return false; }
+          p = p.prevZ;
+      }
+
+      // look for remaining points in increasing z-order
+      while (n && n.z <= maxZ) {
+          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) { return false; }
+          n = n.nextZ;
+      }
 
-        for (i = 0; i < attribState.length; i++)
-        {
-            if (attribState[i] !== tempAttribState[i])
-            {
-                attribState[i] = tempAttribState[i];
+      return true;
+  }
 
-                if (state.attribState[i])
-                {
-                    gl.enableVertexAttribArray(i);
-                }
-                else
-                {
-                    gl.disableVertexAttribArray(i);
-                }
-            }
-        }
+  // go through all polygon nodes and cure small local self-intersections
+  function cureLocalIntersections(start, triangles, dim) {
+      var p = start;
+      do {
+          var a = p.prev,
+              b = p.next.next;
 
-    }
-    else
-    {
-        for (i = 0; i < attribs.length; i++)
-        {
-            var attrib = attribs[i];
-            gl.enableVertexAttribArray(attrib.attribute.location);
-        }
-    }
-};
+          if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
 
-module.exports = setVertexAttribArrays;
+              triangles.push(a.i / dim | 0);
+              triangles.push(p.i / dim | 0);
+              triangles.push(b.i / dim | 0);
 
-},{}],14:[function(require,module,exports){
+              // remove two nodes involved
+              removeNode(p);
+              removeNode(p.next);
 
-/**
- * @class
- * @memberof PIXI.glCore.shader
- * @param gl {WebGLRenderingContext} The current WebGL context {WebGLProgram}
- * @param vertexSrc {string|string[]} The vertex shader source as an array of strings.
- * @param fragmentSrc {string|string[]} The fragment shader source as an array of strings.
- * @param attributeLocations {Object} An attribute location map that lets you manually set the attribute locations
- * @return {WebGLProgram} the shader program
- */
-var compileProgram = function(gl, vertexSrc, fragmentSrc, attributeLocations)
-{
-    var glVertShader = compileShader(gl, gl.VERTEX_SHADER, vertexSrc);
-    var glFragShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);
-
-    var program = gl.createProgram();
-
-    gl.attachShader(program, glVertShader);
-    gl.attachShader(program, glFragShader);
-
-    // optionally, set the attributes manually for the program rather than letting WebGL decide..
-    if(attributeLocations)
-    {
-        for(var i in attributeLocations)
-        {
-            gl.bindAttribLocation(program, attributeLocations[i], i);
-        }
-    }
+              p = start = b;
+          }
+          p = p.next;
+      } while (p !== start);
 
+      return filterPoints(p);
+  }
 
-    gl.linkProgram(program);
+  // try splitting polygon into two and triangulate them independently
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+      // look for a valid diagonal that divides the polygon into two
+      var a = start;
+      do {
+          var b = a.next.next;
+          while (b !== a.prev) {
+              if (a.i !== b.i && isValidDiagonal(a, b)) {
+                  // split the polygon in two by the diagonal
+                  var c = splitPolygon(a, b);
+
+                  // filter colinear points around the cuts
+                  a = filterPoints(a, a.next);
+                  c = filterPoints(c, c.next);
+
+                  // run earcut on each half
+                  earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+                  earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+                  return;
+              }
+              b = b.next;
+          }
+          a = a.next;
+      } while (a !== start);
+  }
 
-    // if linking fails, then log and cleanup
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS))
-    {
-        console.error('Pixi.js Error: Could not initialize shader.');
-        console.error('gl.VALIDATE_STATUS', gl.getProgramParameter(program, gl.VALIDATE_STATUS));
-        console.error('gl.getError()', gl.getError());
+  // link every hole into the outer loop, producing a single-ring polygon without holes
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+      var queue = [],
+          i, len, start, end, list;
+
+      for (i = 0, len = holeIndices.length; i < len; i++) {
+          start = holeIndices[i] * dim;
+          end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+          list = linkedList(data, start, end, dim, false);
+          if (list === list.next) { list.steiner = true; }
+          queue.push(getLeftmost(list));
+      }
 
-        // if there is a program info log, log it
-        if (gl.getProgramInfoLog(program) !== '')
-        {
-            console.warn('Pixi.js Warning: gl.getProgramInfoLog()', gl.getProgramInfoLog(program));
-        }
+      queue.sort(compareX);
 
-        gl.deleteProgram(program);
-        program = null;
-    }
+      // process holes from left to right
+      for (i = 0; i < queue.length; i++) {
+          outerNode = eliminateHole(queue[i], outerNode);
+      }
 
-    // clean up some shaders
-    gl.deleteShader(glVertShader);
-    gl.deleteShader(glFragShader);
+      return outerNode;
+  }
 
-    return program;
-};
+  function compareX(a, b) {
+      return a.x - b.x;
+  }
 
-/**
- * @private
- * @param gl {WebGLRenderingContext} The current WebGL context {WebGLProgram}
- * @param type {Number} the type, can be either VERTEX_SHADER or FRAGMENT_SHADER
- * @param vertexSrc {string|string[]} The vertex shader source as an array of strings.
- * @return {WebGLShader} the shader
- */
-var compileShader = function (gl, type, src)
-{
-    var shader = gl.createShader(type);
+  // find a bridge between vertices that connects hole with an outer ring and and link it
+  function eliminateHole(hole, outerNode) {
+      var bridge = findHoleBridge(hole, outerNode);
+      if (!bridge) {
+          return outerNode;
+      }
 
-    gl.shaderSource(shader, src);
-    gl.compileShader(shader);
+      var bridgeReverse = splitPolygon(bridge, hole);
 
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))
-    {
-        console.log(gl.getShaderInfoLog(shader));
-        return null;
-    }
+      // filter collinear points around the cuts
+      filterPoints(bridgeReverse, bridgeReverse.next);
+      return filterPoints(bridge, bridge.next);
+  }
 
-    return shader;
-};
+  // David Eberly's algorithm for finding a bridge between hole and outer polygon
+  function findHoleBridge(hole, outerNode) {
+      var p = outerNode,
+          hx = hole.x,
+          hy = hole.y,
+          qx = -Infinity,
+          m;
+
+      // find a segment intersected by a ray from the hole's leftmost point to the left;
+      // segment's endpoint with lesser x will be potential connection point
+      do {
+          if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+              var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+              if (x <= hx && x > qx) {
+                  qx = x;
+                  m = p.x < p.next.x ? p : p.next;
+                  if (x === hx) { return m; } // hole touches outer segment; pick leftmost endpoint
+              }
+          }
+          p = p.next;
+      } while (p !== outerNode);
 
-module.exports = compileProgram;
+      if (!m) { return null; }
 
-},{}],15:[function(require,module,exports){
-/**
- * @class
- * @memberof PIXI.glCore.shader
- * @param type {String} Type of value
- * @param size {Number}
- */
-var defaultValue = function(type, size) 
-{
-    switch (type)
-    {
-        case 'float':
-            return 0;
+      // look for points inside the triangle of hole point, segment intersection and endpoint;
+      // if there are no points found, we have a valid connection;
+      // otherwise choose the point of the minimum angle with the ray as connection point
 
-        case 'vec2': 
-            return new Float32Array(2 * size);
+      var stop = m,
+          mx = m.x,
+          my = m.y,
+          tanMin = Infinity,
+          tan;
 
-        case 'vec3':
-            return new Float32Array(3 * size);
+      p = m;
 
-        case 'vec4':     
-            return new Float32Array(4 * size);
-            
-        case 'int':
-        case 'sampler2D':
-            return 0;
+      do {
+          if (hx >= p.x && p.x >= mx && hx !== p.x &&
+                  pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
 
-        case 'ivec2':   
-            return new Int32Array(2 * size);
+              tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
 
-        case 'ivec3':
-            return new Int32Array(3 * size);
+              if (locallyInside(p, hole) &&
+                  (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
+                  m = p;
+                  tanMin = tan;
+              }
+          }
 
-        case 'ivec4': 
-            return new Int32Array(4 * size);
+          p = p.next;
+      } while (p !== stop);
 
-        case 'bool':     
-            return false;
+      return m;
+  }
 
-        case 'bvec2':
+  // whether sector in vertex m contains sector in vertex p in the same coordinates
+  function sectorContainsSector(m, p) {
+      return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
 
-            return booleanArray( 2 * size);
+  // interlink polygon nodes in z-order
+  function indexCurve(start, minX, minY, invSize) {
+      var p = start;
+      do {
+          if (p.z === 0) { p.z = zOrder(p.x, p.y, minX, minY, invSize); }
+          p.prevZ = p.prev;
+          p.nextZ = p.next;
+          p = p.next;
+      } while (p !== start);
 
-        case 'bvec3':
-            return booleanArray(3 * size);
+      p.prevZ.nextZ = null;
+      p.prevZ = null;
 
-        case 'bvec4':
-            return booleanArray(4 * size);
+      sortLinked(p);
+  }
 
-        case 'mat2':
-            return new Float32Array([1, 0,
-                                     0, 1]);
+  // Simon Tatham's linked list merge sort algorithm
+  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+  function sortLinked(list) {
+      var i, p, q, e, tail, numMerges, pSize, qSize,
+          inSize = 1;
+
+      do {
+          p = list;
+          list = null;
+          tail = null;
+          numMerges = 0;
+
+          while (p) {
+              numMerges++;
+              q = p;
+              pSize = 0;
+              for (i = 0; i < inSize; i++) {
+                  pSize++;
+                  q = q.nextZ;
+                  if (!q) { break; }
+              }
+              qSize = inSize;
+
+              while (pSize > 0 || (qSize > 0 && q)) {
+
+                  if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+                      e = p;
+                      p = p.nextZ;
+                      pSize--;
+                  } else {
+                      e = q;
+                      q = q.nextZ;
+                      qSize--;
+                  }
+
+                  if (tail) { tail.nextZ = e; }
+                  else { list = e; }
+
+                  e.prevZ = tail;
+                  tail = e;
+              }
+
+              p = q;
+          }
 
-        case 'mat3': 
-            return new Float32Array([1, 0, 0,
-                                     0, 1, 0,
-                                     0, 0, 1]);
+          tail.nextZ = null;
+          inSize *= 2;
 
-        case 'mat4':
-            return new Float32Array([1, 0, 0, 0,
-                                     0, 1, 0, 0,
-                                     0, 0, 1, 0,
-                                     0, 0, 0, 1]);
-    }
-};
+      } while (numMerges > 1);
 
-var booleanArray = function(size)
-{
-    var array = new Array(size);
+      return list;
+  }
 
-    for (var i = 0; i < array.length; i++) 
-    {
-        array[i] = false;
-    }
+  // z-order of a point given coords and inverse of the longer side of data bbox
+  function zOrder(x, y, minX, minY, invSize) {
+      // coords are transformed into non-negative 15-bit integer range
+      x = (x - minX) * invSize | 0;
+      y = (y - minY) * invSize | 0;
 
-    return array;
-};
+      x = (x | (x << 8)) & 0x00FF00FF;
+      x = (x | (x << 4)) & 0x0F0F0F0F;
+      x = (x | (x << 2)) & 0x33333333;
+      x = (x | (x << 1)) & 0x55555555;
 
-module.exports = defaultValue;
+      y = (y | (y << 8)) & 0x00FF00FF;
+      y = (y | (y << 4)) & 0x0F0F0F0F;
+      y = (y | (y << 2)) & 0x33333333;
+      y = (y | (y << 1)) & 0x55555555;
 
-},{}],16:[function(require,module,exports){
+      return x | (y << 1);
+  }
 
-var mapType = require('./mapType');
-var mapSize = require('./mapSize');
+  // find the leftmost node of a polygon ring
+  function getLeftmost(start) {
+      var p = start,
+          leftmost = start;
+      do {
+          if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) { leftmost = p; }
+          p = p.next;
+      } while (p !== start);
 
-/**
- * Extracts the attributes
- * @class
- * @memberof PIXI.glCore.shader
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- * @param program {WebGLProgram} The shader program to get the attributes from
- * @return attributes {Object}
- */
-var extractAttributes = function(gl, program)
-{
-    var attributes = {};
-
-    var totalAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
-
-    for (var i = 0; i < totalAttributes; i++)
-    {
-        var attribData = gl.getActiveAttrib(program, i);
-        var type = mapType(gl, attribData.type);
-
-        attributes[attribData.name] = {
-            type:type,
-            size:mapSize(type),
-            location:gl.getAttribLocation(program, attribData.name),
-            //TODO - make an attribute object
-            pointer: pointer
-        };
-    }
+      return leftmost;
+  }
 
-    return attributes;
-};
+  // check if a point lies within a convex triangle
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+      return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
+             (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
+             (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
 
-var pointer = function(type, normalized, stride, start){
-    // console.log(this.location)
-    gl.vertexAttribPointer(this.location,this.size, type || gl.FLOAT, normalized || false, stride || 0, start || 0);
-};
+  // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+  function isValidDiagonal(a, b) {
+      return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+             (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+              (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+              equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
+  }
 
-module.exports = extractAttributes;
+  // signed area of a triangle
+  function area(p, q, r) {
+      return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
 
-},{"./mapSize":20,"./mapType":21}],17:[function(require,module,exports){
-var mapType = require('./mapType');
-var defaultValue = require('./defaultValue');
+  // check if two points are equal
+  function equals(p1, p2) {
+      return p1.x === p2.x && p1.y === p2.y;
+  }
 
-/**
- * Extracts the uniforms
- * @class
- * @memberof PIXI.glCore.shader
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- * @param program {WebGLProgram} The shader program to get the uniforms from
- * @return uniforms {Object}
- */
-var extractUniforms = function(gl, program)
-{
-	var uniforms = {};
-
-    var totalUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
-
-    for (var i = 0; i < totalUniforms; i++)
-    {
-    	var uniformData = gl.getActiveUniform(program, i);
-    	var name = uniformData.name.replace(/\[.*?\]/, "");
-        var type = mapType(gl, uniformData.type );
-
-    	uniforms[name] = {
-    		type:type,
-    		size:uniformData.size,
-    		location:gl.getUniformLocation(program, name),
-    		value:defaultValue(type, uniformData.size)
-    	};
-    }
+  // check if two segments intersect
+  function intersects(p1, q1, p2, q2) {
+      var o1 = sign$1(area(p1, q1, p2));
+      var o2 = sign$1(area(p1, q1, q2));
+      var o3 = sign$1(area(p2, q2, p1));
+      var o4 = sign$1(area(p2, q2, q1));
 
-	return uniforms;
-};
+      if (o1 !== o2 && o3 !== o4) { return true; } // general case
 
-module.exports = extractUniforms;
+      if (o1 === 0 && onSegment(p1, p2, q1)) { return true; } // p1, q1 and p2 are collinear and p2 lies on p1q1
+      if (o2 === 0 && onSegment(p1, q2, q1)) { return true; } // p1, q1 and q2 are collinear and q2 lies on p1q1
+      if (o3 === 0 && onSegment(p2, p1, q2)) { return true; } // p2, q2 and p1 are collinear and p1 lies on p2q2
+      if (o4 === 0 && onSegment(p2, q1, q2)) { return true; } // p2, q2 and q1 are collinear and q1 lies on p2q2
 
-},{"./defaultValue":15,"./mapType":21}],18:[function(require,module,exports){
-/**
- * Extracts the attributes
- * @class
- * @memberof PIXI.glCore.shader
- * @param gl {WebGLRenderingContext} The current WebGL rendering context
- * @param uniforms {Array} @mat ?
- * @return attributes {Object}
- */
-var generateUniformAccessObject = function(gl, uniformData)
-{
-    // this is the object we will be sending back.
-    // an object hierachy will be created for structs
-    var uniforms = {data:{}};
+      return false;
+  }
 
-    uniforms.gl = gl;
+  // for collinear points p, q, r, check if point q lies on segment pr
+  function onSegment(p, q, r) {
+      return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
 
-    var uniformKeys= Object.keys(uniformData);
+  function sign$1(num) {
+      return num > 0 ? 1 : num < 0 ? -1 : 0;
+  }
 
-    for (var i = 0; i < uniformKeys.length; i++)
-    {
-        var fullName = uniformKeys[i];
+  // check if a polygon diagonal intersects any polygon segments
+  function intersectsPolygon(a, b) {
+      var p = a;
+      do {
+          if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
+                  intersects(p, p.next, a, b)) { return true; }
+          p = p.next;
+      } while (p !== a);
 
-        var nameTokens = fullName.split('.');
-        var name = nameTokens[nameTokens.length - 1];
+      return false;
+  }
 
+  // check if a polygon diagonal is locally inside the polygon
+  function locallyInside(a, b) {
+      return area(a.prev, a, a.next) < 0 ?
+          area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
+          area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
 
-        var uniformGroup = getUniformGroup(nameTokens, uniforms);
+  // check if the middle point of a polygon diagonal is inside the polygon
+  function middleInside(a, b) {
+      var p = a,
+          inside = false,
+          px = (a.x + b.x) / 2,
+          py = (a.y + b.y) / 2;
+      do {
+          if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
+                  (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
+              { inside = !inside; }
+          p = p.next;
+      } while (p !== a);
+
+      return inside;
+  }
 
-        var uniform =  uniformData[fullName];
-        uniformGroup.data[name] = uniform;
+  // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
+  // if one belongs to the outer ring and another to a hole, it merges it into a single ring
+  function splitPolygon(a, b) {
+      var a2 = new Node(a.i, a.x, a.y),
+          b2 = new Node(b.i, b.x, b.y),
+          an = a.next,
+          bp = b.prev;
 
-        uniformGroup.gl = gl;
+      a.next = b;
+      b.prev = a;
 
-        Object.defineProperty(uniformGroup, name, {
-            get: generateGetter(name),
-            set: generateSetter(name, uniform)
-        });
-    }
+      a2.next = an;
+      an.prev = a2;
 
-    return uniforms;
-};
+      b2.next = a2;
+      a2.prev = b2;
 
-var generateGetter = function(name)
-{
-	var template = getterTemplate.replace('%%', name);
-	return new Function(template); // jshint ignore:line
-};
+      bp.next = b2;
+      b2.prev = bp;
 
-var generateSetter = function(name, uniform)
-{
-    var template = setterTemplate.replace(/%%/g, name);
-    var setTemplate;
+      return b2;
+  }
 
-    if(uniform.size === 1)
-    {
-        setTemplate = GLSL_TO_SINGLE_SETTERS[uniform.type];
-    }
-    else
-    {
-        setTemplate = GLSL_TO_ARRAY_SETTERS[uniform.type];
-    }
+  // create a node and optionally link it with previous one (in a circular doubly linked list)
+  function insertNode(i, x, y, last) {
+      var p = new Node(i, x, y);
 
-    if(setTemplate)
-    {
-        template += "\nthis.gl." + setTemplate + ";";
-    }
+      if (!last) {
+          p.prev = p;
+          p.next = p;
 
-  	return new Function('value', template); // jshint ignore:line
-};
+      } else {
+          p.next = last.next;
+          p.prev = last;
+          last.next.prev = p;
+          last.next = p;
+      }
+      return p;
+  }
 
-var getUniformGroup = function(nameTokens, uniform)
-{
-    var cur = uniform;
+  function removeNode(p) {
+      p.next.prev = p.prev;
+      p.prev.next = p.next;
 
-    for (var i = 0; i < nameTokens.length - 1; i++)
-    {
-        var o = cur[nameTokens[i]] || {data:{}};
-        cur[nameTokens[i]] = o;
-        cur = o;
-    }
+      if (p.prevZ) { p.prevZ.nextZ = p.nextZ; }
+      if (p.nextZ) { p.nextZ.prevZ = p.prevZ; }
+  }
 
-    return cur;
-};
+  function Node(i, x, y) {
+      // vertex index in coordinates array
+      this.i = i;
 
-var getterTemplate = [
-    'return this.data.%%.value;',
-].join('\n');
+      // vertex coordinates
+      this.x = x;
+      this.y = y;
 
-var setterTemplate = [
-    'this.data.%%.value = value;',
-    'var location = this.data.%%.location;'
-].join('\n');
+      // previous and next vertex nodes in a polygon ring
+      this.prev = null;
+      this.next = null;
 
+      // z-order curve value
+      this.z = 0;
 
-var GLSL_TO_SINGLE_SETTERS = {
+      // previous and next nodes in z-order
+      this.prevZ = null;
+      this.nextZ = null;
 
-    'float':    'uniform1f(location, value)',
+      // indicates whether this is a steiner point
+      this.steiner = false;
+  }
 
-    'vec2':     'uniform2f(location, value[0], value[1])',
-    'vec3':     'uniform3f(location, value[0], value[1], value[2])',
-    'vec4':     'uniform4f(location, value[0], value[1], value[2], value[3])',
+  // return a percentage difference between the polygon area and its triangulation area;
+  // used to verify correctness of triangulation
+  earcut.deviation = function (data, holeIndices, dim, triangles) {
+      var hasHoles = holeIndices && holeIndices.length;
+      var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+
+      var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+      if (hasHoles) {
+          for (var i = 0, len = holeIndices.length; i < len; i++) {
+              var start = holeIndices[i] * dim;
+              var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+              polygonArea -= Math.abs(signedArea(data, start, end, dim));
+          }
+      }
 
-    'int':      'uniform1i(location, value)',
-    'ivec2':    'uniform2i(location, value[0], value[1])',
-    'ivec3':    'uniform3i(location, value[0], value[1], value[2])',
-    'ivec4':    'uniform4i(location, value[0], value[1], value[2], value[3])',
+      var trianglesArea = 0;
+      for (i = 0; i < triangles.length; i += 3) {
+          var a = triangles[i] * dim;
+          var b = triangles[i + 1] * dim;
+          var c = triangles[i + 2] * dim;
+          trianglesArea += Math.abs(
+              (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
+              (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
+      }
 
-    'bool':     'uniform1i(location, value)',
-    'bvec2':    'uniform2i(location, value[0], value[1])',
-    'bvec3':    'uniform3i(location, value[0], value[1], value[2])',
-    'bvec4':    'uniform4i(location, value[0], value[1], value[2], value[3])',
+      return polygonArea === 0 && trianglesArea === 0 ? 0 :
+          Math.abs((trianglesArea - polygonArea) / polygonArea);
+  };
 
-    'mat2':     'uniformMatrix2fv(location, false, value)',
-    'mat3':     'uniformMatrix3fv(location, false, value)',
-    'mat4':     'uniformMatrix4fv(location, false, value)',
+  function signedArea(data, start, end, dim) {
+      var sum = 0;
+      for (var i = start, j = end - dim; i < end; i += dim) {
+          sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+          j = i;
+      }
+      return sum;
+  }
 
-    'sampler2D':'uniform1i(location, value)'
-};
+  // turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
+  earcut.flatten = function (data) {
+      var dim = data[0][0].length,
+          result = {vertices: [], holes: [], dimensions: dim},
+          holeIndex = 0;
 
-var GLSL_TO_ARRAY_SETTERS = {
+      for (var i = 0; i < data.length; i++) {
+          for (var j = 0; j < data[i].length; j++) {
+              for (var d = 0; d < dim; d++) { result.vertices.push(data[i][j][d]); }
+          }
+          if (i > 0) {
+              holeIndex += data[i - 1].length;
+              result.holes.push(holeIndex);
+          }
+      }
+      return result;
+  };
+  earcut_1.default = _default;
+
+  var punycode = createCommonjsModule(function (module, exports) {
+  /*! https://mths.be/punycode v1.3.2 by @mathias */
+  ;(function(root) {
+
+  	/** Detect free variables */
+  	var freeExports = 'object' == 'object' && exports &&
+  		!exports.nodeType && exports;
+  	var freeModule = 'object' == 'object' && module &&
+  		!module.nodeType && module;
+  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+  	if (
+  		freeGlobal.global === freeGlobal ||
+  		freeGlobal.window === freeGlobal ||
+  		freeGlobal.self === freeGlobal
+  	) {
+  		root = freeGlobal;
+  	}
+
+  	/**
+  	 * The `punycode` object.
+  	 * @name punycode
+  	 * @type Object
+  	 */
+  	var punycode,
+
+  	/** Highest positive signed 32-bit float value */
+  	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
+
+  	/** Bootstring parameters */
+  	base = 36,
+  	tMin = 1,
+  	tMax = 26,
+  	skew = 38,
+  	damp = 700,
+  	initialBias = 72,
+  	initialN = 128, // 0x80
+  	delimiter = '-', // '\x2D'
+
+  	/** Regular expressions */
+  	regexPunycode = /^xn--/,
+  	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
+  	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
+
+  	/** Error messages */
+  	errors = {
+  		'overflow': 'Overflow: input needs wider integers to process',
+  		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+  		'invalid-input': 'Invalid input'
+  	},
+
+  	/** Convenience shortcuts */
+  	baseMinusTMin = base - tMin,
+  	floor = Math.floor,
+  	stringFromCharCode = String.fromCharCode,
+
+  	/** Temporary variable */
+  	key;
+
+  	/*--------------------------------------------------------------------------*/
+
+  	/**
+  	 * A generic error utility function.
+  	 * @private
+  	 * @param {String} type The error type.
+  	 * @returns {Error} Throws a `RangeError` with the applicable error message.
+  	 */
+  	function error(type) {
+  		throw RangeError(errors[type]);
+  	}
+
+  	/**
+  	 * A generic `Array#map` utility function.
+  	 * @private
+  	 * @param {Array} array The array to iterate over.
+  	 * @param {Function} callback The function that gets called for every array
+  	 * item.
+  	 * @returns {Array} A new array of values returned by the callback function.
+  	 */
+  	function map(array, fn) {
+  		var length = array.length;
+  		var result = [];
+  		while (length--) {
+  			result[length] = fn(array[length]);
+  		}
+  		return result;
+  	}
+
+  	/**
+  	 * A simple `Array#map`-like wrapper to work with domain name strings or email
+  	 * addresses.
+  	 * @private
+  	 * @param {String} domain The domain name or email address.
+  	 * @param {Function} callback The function that gets called for every
+  	 * character.
+  	 * @returns {Array} A new string of characters returned by the callback
+  	 * function.
+  	 */
+  	function mapDomain(string, fn) {
+  		var parts = string.split('@');
+  		var result = '';
+  		if (parts.length > 1) {
+  			// In email addresses, only the domain name should be punycoded. Leave
+  			// the local part (i.e. everything up to `@`) intact.
+  			result = parts[0] + '@';
+  			string = parts[1];
+  		}
+  		// Avoid `split(regex)` for IE8 compatibility. See #17.
+  		string = string.replace(regexSeparators, '\x2E');
+  		var labels = string.split('.');
+  		var encoded = map(labels, fn).join('.');
+  		return result + encoded;
+  	}
+
+  	/**
+  	 * Creates an array containing the numeric code points of each Unicode
+  	 * character in the string. While JavaScript uses UCS-2 internally,
+  	 * this function will convert a pair of surrogate halves (each of which
+  	 * UCS-2 exposes as separate characters) into a single code point,
+  	 * matching UTF-16.
+  	 * @see `punycode.ucs2.encode`
+  	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+  	 * @memberOf punycode.ucs2
+  	 * @name decode
+  	 * @param {String} string The Unicode input string (UCS-2).
+  	 * @returns {Array} The new array of code points.
+  	 */
+  	function ucs2decode(string) {
+  		var output = [],
+  		    counter = 0,
+  		    length = string.length,
+  		    value,
+  		    extra;
+  		while (counter < length) {
+  			value = string.charCodeAt(counter++);
+  			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+  				// high surrogate, and there is a next character
+  				extra = string.charCodeAt(counter++);
+  				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+  					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+  				} else {
+  					// unmatched surrogate; only append this code unit, in case the next
+  					// code unit is the high surrogate of a surrogate pair
+  					output.push(value);
+  					counter--;
+  				}
+  			} else {
+  				output.push(value);
+  			}
+  		}
+  		return output;
+  	}
+
+  	/**
+  	 * Creates a string based on an array of numeric code points.
+  	 * @see `punycode.ucs2.decode`
+  	 * @memberOf punycode.ucs2
+  	 * @name encode
+  	 * @param {Array} codePoints The array of numeric code points.
+  	 * @returns {String} The new Unicode string (UCS-2).
+  	 */
+  	function ucs2encode(array) {
+  		return map(array, function(value) {
+  			var output = '';
+  			if (value > 0xFFFF) {
+  				value -= 0x10000;
+  				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+  				value = 0xDC00 | value & 0x3FF;
+  			}
+  			output += stringFromCharCode(value);
+  			return output;
+  		}).join('');
+  	}
+
+  	/**
+  	 * Converts a basic code point into a digit/integer.
+  	 * @see `digitToBasic()`
+  	 * @private
+  	 * @param {Number} codePoint The basic numeric code point value.
+  	 * @returns {Number} The numeric value of a basic code point (for use in
+  	 * representing integers) in the range `0` to `base - 1`, or `base` if
+  	 * the code point does not represent a value.
+  	 */
+  	function basicToDigit(codePoint) {
+  		if (codePoint - 48 < 10) {
+  			return codePoint - 22;
+  		}
+  		if (codePoint - 65 < 26) {
+  			return codePoint - 65;
+  		}
+  		if (codePoint - 97 < 26) {
+  			return codePoint - 97;
+  		}
+  		return base;
+  	}
+
+  	/**
+  	 * Converts a digit/integer into a basic code point.
+  	 * @see `basicToDigit()`
+  	 * @private
+  	 * @param {Number} digit The numeric value of a basic code point.
+  	 * @returns {Number} The basic code point whose value (when used for
+  	 * representing integers) is `digit`, which needs to be in the range
+  	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+  	 * used; else, the lowercase form is used. The behavior is undefined
+  	 * if `flag` is non-zero and `digit` has no uppercase form.
+  	 */
+  	function digitToBasic(digit, flag) {
+  		//  0..25 map to ASCII a..z or A..Z
+  		// 26..35 map to ASCII 0..9
+  		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+  	}
+
+  	/**
+  	 * Bias adaptation function as per section 3.4 of RFC 3492.
+  	 * http://tools.ietf.org/html/rfc3492#section-3.4
+  	 * @private
+  	 */
+  	function adapt(delta, numPoints, firstTime) {
+  		var k = 0;
+  		delta = firstTime ? floor(delta / damp) : delta >> 1;
+  		delta += floor(delta / numPoints);
+  		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+  			delta = floor(delta / baseMinusTMin);
+  		}
+  		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+  	}
+
+  	/**
+  	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+  	 * symbols.
+  	 * @memberOf punycode
+  	 * @param {String} input The Punycode string of ASCII-only symbols.
+  	 * @returns {String} The resulting string of Unicode symbols.
+  	 */
+  	function decode(input) {
+  		// Don't use UCS-2
+  		var output = [],
+  		    inputLength = input.length,
+  		    out,
+  		    i = 0,
+  		    n = initialN,
+  		    bias = initialBias,
+  		    basic,
+  		    j,
+  		    index,
+  		    oldi,
+  		    w,
+  		    k,
+  		    digit,
+  		    t,
+  		    /** Cached calculation results */
+  		    baseMinusT;
+
+  		// Handle the basic code points: let `basic` be the number of input code
+  		// points before the last delimiter, or `0` if there is none, then copy
+  		// the first basic code points to the output.
+
+  		basic = input.lastIndexOf(delimiter);
+  		if (basic < 0) {
+  			basic = 0;
+  		}
+
+  		for (j = 0; j < basic; ++j) {
+  			// if it's not a basic code point
+  			if (input.charCodeAt(j) >= 0x80) {
+  				error('not-basic');
+  			}
+  			output.push(input.charCodeAt(j));
+  		}
+
+  		// Main decoding loop: start just after the last delimiter if any basic code
+  		// points were copied; start at the beginning otherwise.
+
+  		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+  			// `index` is the index of the next character to be consumed.
+  			// Decode a generalized variable-length integer into `delta`,
+  			// which gets added to `i`. The overflow checking is easier
+  			// if we increase `i` as we go, then subtract off its starting
+  			// value at the end to obtain `delta`.
+  			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
+
+  				if (index >= inputLength) {
+  					error('invalid-input');
+  				}
+
+  				digit = basicToDigit(input.charCodeAt(index++));
+
+  				if (digit >= base || digit > floor((maxInt - i) / w)) {
+  					error('overflow');
+  				}
+
+  				i += digit * w;
+  				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+  				if (digit < t) {
+  					break;
+  				}
+
+  				baseMinusT = base - t;
+  				if (w > floor(maxInt / baseMinusT)) {
+  					error('overflow');
+  				}
+
+  				w *= baseMinusT;
+
+  			}
+
+  			out = output.length + 1;
+  			bias = adapt(i - oldi, out, oldi == 0);
+
+  			// `i` was supposed to wrap around from `out` to `0`,
+  			// incrementing `n` each time, so we'll fix that now:
+  			if (floor(i / out) > maxInt - n) {
+  				error('overflow');
+  			}
+
+  			n += floor(i / out);
+  			i %= out;
+
+  			// Insert `n` at position `i` of the output
+  			output.splice(i++, 0, n);
+
+  		}
+
+  		return ucs2encode(output);
+  	}
+
+  	/**
+  	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
+  	 * Punycode string of ASCII-only symbols.
+  	 * @memberOf punycode
+  	 * @param {String} input The string of Unicode symbols.
+  	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
+  	 */
+  	function encode(input) {
+  		var n,
+  		    delta,
+  		    handledCPCount,
+  		    basicLength,
+  		    bias,
+  		    j,
+  		    m,
+  		    q,
+  		    k,
+  		    t,
+  		    currentValue,
+  		    output = [],
+  		    /** `inputLength` will hold the number of code points in `input`. */
+  		    inputLength,
+  		    /** Cached calculation results */
+  		    handledCPCountPlusOne,
+  		    baseMinusT,
+  		    qMinusT;
+
+  		// Convert the input in UCS-2 to Unicode
+  		input = ucs2decode(input);
+
+  		// Cache the length
+  		inputLength = input.length;
+
+  		// Initialize the state
+  		n = initialN;
+  		delta = 0;
+  		bias = initialBias;
+
+  		// Handle the basic code points
+  		for (j = 0; j < inputLength; ++j) {
+  			currentValue = input[j];
+  			if (currentValue < 0x80) {
+  				output.push(stringFromCharCode(currentValue));
+  			}
+  		}
+
+  		handledCPCount = basicLength = output.length;
+
+  		// `handledCPCount` is the number of code points that have been handled;
+  		// `basicLength` is the number of basic code points.
+
+  		// Finish the basic string - if it is not empty - with a delimiter
+  		if (basicLength) {
+  			output.push(delimiter);
+  		}
+
+  		// Main encoding loop:
+  		while (handledCPCount < inputLength) {
+
+  			// All non-basic code points < n have been handled already. Find the next
+  			// larger one:
+  			for (m = maxInt, j = 0; j < inputLength; ++j) {
+  				currentValue = input[j];
+  				if (currentValue >= n && currentValue < m) {
+  					m = currentValue;
+  				}
+  			}
+
+  			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+  			// but guard against overflow
+  			handledCPCountPlusOne = handledCPCount + 1;
+  			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+  				error('overflow');
+  			}
+
+  			delta += (m - n) * handledCPCountPlusOne;
+  			n = m;
+
+  			for (j = 0; j < inputLength; ++j) {
+  				currentValue = input[j];
+
+  				if (currentValue < n && ++delta > maxInt) {
+  					error('overflow');
+  				}
+
+  				if (currentValue == n) {
+  					// Represent delta as a generalized variable-length integer
+  					for (q = delta, k = base; /* no condition */; k += base) {
+  						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+  						if (q < t) {
+  							break;
+  						}
+  						qMinusT = q - t;
+  						baseMinusT = base - t;
+  						output.push(
+  							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+  						);
+  						q = floor(qMinusT / baseMinusT);
+  					}
+
+  					output.push(stringFromCharCode(digitToBasic(q, 0)));
+  					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+  					delta = 0;
+  					++handledCPCount;
+  				}
+  			}
+
+  			++delta;
+  			++n;
+
+  		}
+  		return output.join('');
+  	}
+
+  	/**
+  	 * Converts a Punycode string representing a domain name or an email address
+  	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+  	 * it doesn't matter if you call it on a string that has already been
+  	 * converted to Unicode.
+  	 * @memberOf punycode
+  	 * @param {String} input The Punycoded domain name or email address to
+  	 * convert to Unicode.
+  	 * @returns {String} The Unicode representation of the given Punycode
+  	 * string.
+  	 */
+  	function toUnicode(input) {
+  		return mapDomain(input, function(string) {
+  			return regexPunycode.test(string)
+  				? decode(string.slice(4).toLowerCase())
+  				: string;
+  		});
+  	}
+
+  	/**
+  	 * Converts a Unicode string representing a domain name or an email address to
+  	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
+  	 * i.e. it doesn't matter if you call it with a domain that's already in
+  	 * ASCII.
+  	 * @memberOf punycode
+  	 * @param {String} input The domain name or email address to convert, as a
+  	 * Unicode string.
+  	 * @returns {String} The Punycode representation of the given domain name or
+  	 * email address.
+  	 */
+  	function toASCII(input) {
+  		return mapDomain(input, function(string) {
+  			return regexNonASCII.test(string)
+  				? 'xn--' + encode(string)
+  				: string;
+  		});
+  	}
+
+  	/*--------------------------------------------------------------------------*/
+
+  	/** Define the public API */
+  	punycode = {
+  		/**
+  		 * A string representing the current Punycode.js version number.
+  		 * @memberOf punycode
+  		 * @type String
+  		 */
+  		'version': '1.3.2',
+  		/**
+  		 * An object of methods to convert from JavaScript's internal character
+  		 * representation (UCS-2) to Unicode code points, and back.
+  		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+  		 * @memberOf punycode
+  		 * @type Object
+  		 */
+  		'ucs2': {
+  			'decode': ucs2decode,
+  			'encode': ucs2encode
+  		},
+  		'decode': decode,
+  		'encode': encode,
+  		'toASCII': toASCII,
+  		'toUnicode': toUnicode
+  	};
+
+  	/** Expose `punycode` */
+  	// Some AMD build optimizers, like r.js, check for specific condition patterns
+  	// like the following:
+  	if (
+  		typeof undefined == 'function' &&
+  		typeof undefined.amd == 'object' &&
+  		undefined.amd
+  	) {
+  		undefined('punycode', function() {
+  			return punycode;
+  		});
+  	} else if (freeExports && freeModule) {
+  		if (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+
+  			freeModule.exports = punycode;
+  		} else { // in Narwhal or RingoJS v0.7.0-
+  			for (key in punycode) {
+  				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+  			}
+  		}
+  	} else { // in Rhino or a web browser
+  		root.punycode = punycode;
+  	}
+
+  }(commonjsGlobal));
+  });
 
-    'float':    'uniform1fv(location, value)',
+  'use strict';
 
-    'vec2':     'uniform2fv(location, value)',
-    'vec3':     'uniform3fv(location, value)',
-    'vec4':     'uniform4fv(location, value)',
+  var util = {
+    isString: function(arg) {
+      return typeof(arg) === 'string';
+    },
+    isObject: function(arg) {
+      return typeof(arg) === 'object' && arg !== null;
+    },
+    isNull: function(arg) {
+      return arg === null;
+    },
+    isNullOrUndefined: function(arg) {
+      return arg == null;
+    }
+  };
 
-    'int':      'uniform1iv(location, value)',
-    'ivec2':    'uniform2iv(location, value)',
-    'ivec3':    'uniform3iv(location, value)',
-    'ivec4':    'uniform4iv(location, value)',
+  // Copyright Joyent, Inc. and other Node contributors.
+  //
+  // 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.
+
+  'use strict';
+
+  // If obj.hasOwnProperty has been overridden, then calling
+  // obj.hasOwnProperty(prop) will break.
+  // See: https://github.com/joyent/node/issues/1707
+  function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  }
 
-    'bool':     'uniform1iv(location, value)',
-    'bvec2':    'uniform2iv(location, value)',
-    'bvec3':    'uniform3iv(location, value)',
-    'bvec4':    'uniform4iv(location, value)',
+  var decode = function(qs, sep, eq, options) {
+    sep = sep || '&';
+    eq = eq || '=';
+    var obj = {};
 
-    'sampler2D':'uniform1iv(location, value)'
-};
+    if (typeof qs !== 'string' || qs.length === 0) {
+      return obj;
+    }
 
-module.exports = generateUniformAccessObject;
+    var regexp = /\+/g;
+    qs = qs.split(sep);
 
-},{}],19:[function(require,module,exports){
-module.exports = {
-    compileProgram: require('./compileProgram'),
-    defaultValue: require('./defaultValue'),
-    extractAttributes: require('./extractAttributes'),
-    extractUniforms: require('./extractUniforms'),
-    generateUniformAccessObject: require('./generateUniformAccessObject'),
-    setPrecision: require('./setPrecision'),
-    mapSize: require('./mapSize'),
-    mapType: require('./mapType')
-};
-},{"./compileProgram":14,"./defaultValue":15,"./extractAttributes":16,"./extractUniforms":17,"./generateUniformAccessObject":18,"./mapSize":20,"./mapType":21,"./setPrecision":22}],20:[function(require,module,exports){
-/**
- * @class
- * @memberof PIXI.glCore.shader
- * @param type {String}
- * @return {Number}
- */
-var mapSize = function(type) 
-{ 
-    return GLSL_TO_SIZE[type];
-};
+    var maxKeys = 1000;
+    if (options && typeof options.maxKeys === 'number') {
+      maxKeys = options.maxKeys;
+    }
 
+    var len = qs.length;
+    // maxKeys <= 0 means that we should not limit keys count
+    if (maxKeys > 0 && len > maxKeys) {
+      len = maxKeys;
+    }
 
-var GLSL_TO_SIZE = {
-    'float':    1,
-    'vec2':     2,
-    'vec3':     3,
-    'vec4':     4,
+    for (var i = 0; i < len; ++i) {
+      var x = qs[i].replace(regexp, '%20'),
+          idx = x.indexOf(eq),
+          kstr, vstr, k, v;
 
-    'int':      1,
-    'ivec2':    2,
-    'ivec3':    3,
-    'ivec4':    4,
+      if (idx >= 0) {
+        kstr = x.substr(0, idx);
+        vstr = x.substr(idx + 1);
+      } else {
+        kstr = x;
+        vstr = '';
+      }
 
-    'bool':     1,
-    'bvec2':    2,
-    'bvec3':    3,
-    'bvec4':    4,
+      k = decodeURIComponent(kstr);
+      v = decodeURIComponent(vstr);
 
-    'mat2':     4,
-    'mat3':     9,
-    'mat4':     16,
+      if (!hasOwnProperty(obj, k)) {
+        obj[k] = v;
+      } else if (Array.isArray(obj[k])) {
+        obj[k].push(v);
+      } else {
+        obj[k] = [obj[k], v];
+      }
+    }
 
-    'sampler2D':  1
-};
+    return obj;
+  };
 
-module.exports = mapSize;
+  // Copyright Joyent, Inc. and other Node contributors.
+  //
+  // 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.
 
-},{}],21:[function(require,module,exports){
+  'use strict';
 
+  var stringifyPrimitive = function(v) {
+    switch (typeof v) {
+      case 'string':
+        return v;
 
-var mapSize = function(gl, type) 
-{
-    if(!GL_TABLE) 
-    {
-        var typeNames = Object.keys(GL_TO_GLSL_TYPES);
+      case 'boolean':
+        return v ? 'true' : 'false';
 
-        GL_TABLE = {};
+      case 'number':
+        return isFinite(v) ? v : '';
 
-        for(var i = 0; i < typeNames.length; ++i) 
-        {
-            var tn = typeNames[i];
-            GL_TABLE[ gl[tn] ] = GL_TO_GLSL_TYPES[tn];
-        }
+      default:
+        return '';
     }
+  };
 
-  return GL_TABLE[type];
-};
-
-var GL_TABLE = null;
-
-var GL_TO_GLSL_TYPES = {
-  'FLOAT':       'float',
-  'FLOAT_VEC2':  'vec2',
-  'FLOAT_VEC3':  'vec3',
-  'FLOAT_VEC4':  'vec4',
-
-  'INT':         'int',
-  'INT_VEC2':    'ivec2',
-  'INT_VEC3':    'ivec3',
-  'INT_VEC4':    'ivec4',
-  
-  'BOOL':        'bool',
-  'BOOL_VEC2':   'bvec2',
-  'BOOL_VEC3':   'bvec3',
-  'BOOL_VEC4':   'bvec4',
-  
-  'FLOAT_MAT2':  'mat2',
-  'FLOAT_MAT3':  'mat3',
-  'FLOAT_MAT4':  'mat4',
-  
-  'SAMPLER_2D':  'sampler2D'  
-};
-
-module.exports = mapSize;
-
-},{}],22:[function(require,module,exports){
-/**
- * Sets the float precision on the shader. If the precision is already present this function will do nothing
- * @param {string} src       the shader source
- * @param {string} precision The float precision of the shader. Options are 'lowp', 'mediump' or 'highp'.
- *
- * @return {string} modified shader source
- */
-var setPrecision = function(src, precision)
-{
-    if(src.substring(0, 9) !== 'precision')
-    {
-        return 'precision ' + precision + ' float;\n' + src;
+  var encode = function(obj, sep, eq, name) {
+    sep = sep || '&';
+    eq = eq || '=';
+    if (obj === null) {
+      obj = undefined;
     }
 
-    return src;
-};
-
-module.exports = setPrecision;
-
-},{}],23:[function(require,module,exports){
-(function (process){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// 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.
-
-// resolves . and .. elements in a path array with directory names there
-// must be no slashes, empty elements, or device names (c:\) in the array
-// (so also no leading and trailing slashes - it does not distinguish
-// relative and absolute paths)
-function normalizeArray(parts, allowAboveRoot) {
-  // if the path tries to go above the root, `up` ends up > 0
-  var up = 0;
-  for (var i = parts.length - 1; i >= 0; i--) {
-    var last = parts[i];
-    if (last === '.') {
-      parts.splice(i, 1);
-    } else if (last === '..') {
-      parts.splice(i, 1);
-      up++;
-    } else if (up) {
-      parts.splice(i, 1);
-      up--;
+    if (typeof obj === 'object') {
+      return Object.keys(obj).map(function(k) {
+        var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+        if (Array.isArray(obj[k])) {
+          return obj[k].map(function(v) {
+            return ks + encodeURIComponent(stringifyPrimitive(v));
+          }).join(sep);
+        } else {
+          return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+        }
+      }).join(sep);
+
     }
+
+    if (!name) { return ''; }
+    return encodeURIComponent(stringifyPrimitive(name)) + eq +
+           encodeURIComponent(stringifyPrimitive(obj));
+  };
+
+  var querystring = createCommonjsModule(function (module, exports) {
+  'use strict';
+
+  exports.decode = exports.parse = decode;
+  exports.encode = exports.stringify = encode;
+  });
+
+  // Copyright Joyent, Inc. and other Node contributors.
+  //
+  // 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.
+
+  'use strict';
+
+
+
+
+  var parse = urlParse;
+  var resolve = urlResolve;
+  var resolveObject = urlResolveObject;
+  var format = urlFormat;
+
+  var Url_1 = Url;
+
+  function Url() {
+    this.protocol = null;
+    this.slashes = null;
+    this.auth = null;
+    this.host = null;
+    this.port = null;
+    this.hostname = null;
+    this.hash = null;
+    this.search = null;
+    this.query = null;
+    this.pathname = null;
+    this.path = null;
+    this.href = null;
   }
 
-  // if the path is allowed to go above the root, restore leading ..s
-  if (allowAboveRoot) {
-    for (; up--; up) {
-      parts.unshift('..');
-    }
+  // Reference: RFC 3986, RFC 1808, RFC 2396
+
+  // define these here so at least they only have to be
+  // compiled once on the first module load.
+  var protocolPattern = /^([a-z0-9.+-]+:)/i,
+      portPattern = /:[0-9]*$/,
+
+      // Special case for a simple path URL
+      simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+
+      // RFC 2396: characters reserved for delimiting URLs.
+      // We actually just auto-escape these.
+      delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+      // RFC 2396: characters not allowed for various reasons.
+      unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+      // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
+      autoEscape = ['\''].concat(unwise),
+      // Characters that are never ever allowed in a hostname.
+      // Note that any invalid chars are also handled, but these
+      // are the ones that are *expected* to be seen, so we fast-path
+      // them.
+      nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+      hostEndingChars = ['/', '?', '#'],
+      hostnameMaxLen = 255,
+      hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
+      hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+      // protocols that can allow "unsafe" and "unwise" chars.
+      unsafeProtocol = {
+        'javascript': true,
+        'javascript:': true
+      },
+      // protocols that never have a hostname.
+      hostlessProtocol = {
+        'javascript': true,
+        'javascript:': true
+      },
+      // protocols that always contain a // bit.
+      slashedProtocol = {
+        'http': true,
+        'https': true,
+        'ftp': true,
+        'gopher': true,
+        'file': true,
+        'http:': true,
+        'https:': true,
+        'ftp:': true,
+        'gopher:': true,
+        'file:': true
+      };
+
+  function urlParse(url, parseQueryString, slashesDenoteHost) {
+    if (url && util.isObject(url) && url instanceof Url) { return url; }
+
+    var u = new Url;
+    u.parse(url, parseQueryString, slashesDenoteHost);
+    return u;
   }
 
-  return parts;
-}
-
-// Split a filename into [root, dir, basename, ext], unix version
-// 'root' is just a slash, or nothing.
-var splitPathRe =
-    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
-var splitPath = function(filename) {
-  return splitPathRe.exec(filename).slice(1);
-};
-
-// path.resolve([from ...], to)
-// posix version
-exports.resolve = function() {
-  var resolvedPath = '',
-      resolvedAbsolute = false;
-
-  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    var path = (i >= 0) ? arguments[i] : process.cwd();
-
-    // Skip empty and invalid entries
-    if (typeof path !== 'string') {
-      throw new TypeError('Arguments to path.resolve must be strings');
-    } else if (!path) {
-      continue;
+  Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+    if (!util.isString(url)) {
+      throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+    }
+
+    // Copy chrome, IE, opera backslash-handling behavior.
+    // Back slashes before the query string get converted to forward slashes
+    // See: https://code.google.com/p/chromium/issues/detail?id=25916
+    var queryIndex = url.indexOf('?'),
+        splitter =
+            (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
+        uSplit = url.split(splitter),
+        slashRegex = /\\/g;
+    uSplit[0] = uSplit[0].replace(slashRegex, '/');
+    url = uSplit.join(splitter);
+
+    var rest = url;
+
+    // trim before proceeding.
+    // This is to support parse stuff like "  http://foo.com  \n"
+    rest = rest.trim();
+
+    if (!slashesDenoteHost && url.split('#').length === 1) {
+      // Try fast path regexp
+      var simplePath = simplePathPattern.exec(rest);
+      if (simplePath) {
+        this.path = rest;
+        this.href = rest;
+        this.pathname = simplePath[1];
+        if (simplePath[2]) {
+          this.search = simplePath[2];
+          if (parseQueryString) {
+            this.query = querystring.parse(this.search.substr(1));
+          } else {
+            this.query = this.search.substr(1);
+          }
+        } else if (parseQueryString) {
+          this.search = '';
+          this.query = {};
+        }
+        return this;
+      }
     }
 
-    resolvedPath = path + '/' + resolvedPath;
-    resolvedAbsolute = path.charAt(0) === '/';
-  }
+    var proto = protocolPattern.exec(rest);
+    if (proto) {
+      proto = proto[0];
+      var lowerProto = proto.toLowerCase();
+      this.protocol = lowerProto;
+      rest = rest.substr(proto.length);
+    }
 
-  // At this point the path should be resolved to a full absolute path, but
-  // handle relative paths to be safe (might happen when process.cwd() fails)
+    // figure out if it's got a host
+    // user@server is *always* interpreted as a hostname, and url
+    // resolution will treat //foo/bar as host=foo,path=bar because that's
+    // how the browser resolves relative URLs.
+    if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+      var slashes = rest.substr(0, 2) === '//';
+      if (slashes && !(proto && hostlessProtocol[proto])) {
+        rest = rest.substr(2);
+        this.slashes = true;
+      }
+    }
 
-  // Normalize the path
-  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
-    return !!p;
-  }), !resolvedAbsolute).join('/');
+    if (!hostlessProtocol[proto] &&
+        (slashes || (proto && !slashedProtocol[proto]))) {
+
+      // there's a hostname.
+      // the first instance of /, ?, ;, or # ends the host.
+      //
+      // If there is an @ in the hostname, then non-host chars *are* allowed
+      // to the left of the last @ sign, unless some host-ending character
+      // comes *before* the @-sign.
+      // URLs are obnoxious.
+      //
+      // ex:
+      // http://a@b@c/ => user:a@b host:c
+      // http://a@b?@c => user:a host:c path:/?@c
+
+      // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+      // Review our test case against browsers more comprehensively.
+
+      // find the first instance of any hostEndingChars
+      var hostEnd = -1;
+      for (var i = 0; i < hostEndingChars.length; i++) {
+        var hec = rest.indexOf(hostEndingChars[i]);
+        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+          { hostEnd = hec; }
+      }
 
-  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
-};
+      // at this point, either we have an explicit point where the
+      // auth portion cannot go past, or the last @ char is the decider.
+      var auth, atSign;
+      if (hostEnd === -1) {
+        // atSign can be anywhere.
+        atSign = rest.lastIndexOf('@');
+      } else {
+        // atSign must be in auth portion.
+        // http://a@b/c@d => host:b auth:a path:/c@d
+        atSign = rest.lastIndexOf('@', hostEnd);
+      }
 
-// path.normalize(path)
-// posix version
-exports.normalize = function(path) {
-  var isAbsolute = exports.isAbsolute(path),
-      trailingSlash = substr(path, -1) === '/';
+      // Now we have a portion which is definitely the auth.
+      // Pull that off.
+      if (atSign !== -1) {
+        auth = rest.slice(0, atSign);
+        rest = rest.slice(atSign + 1);
+        this.auth = decodeURIComponent(auth);
+      }
 
-  // Normalize the path
-  path = normalizeArray(filter(path.split('/'), function(p) {
-    return !!p;
-  }), !isAbsolute).join('/');
+      // the host is the remaining to the left of the first non-host char
+      hostEnd = -1;
+      for (var i = 0; i < nonHostChars.length; i++) {
+        var hec = rest.indexOf(nonHostChars[i]);
+        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+          { hostEnd = hec; }
+      }
+      // if we still have not hit it, then the entire thing is a host.
+      if (hostEnd === -1)
+        { hostEnd = rest.length; }
+
+      this.host = rest.slice(0, hostEnd);
+      rest = rest.slice(hostEnd);
+
+      // pull out port.
+      this.parseHost();
+
+      // we've indicated that there is a hostname,
+      // so even if it's empty, it has to be present.
+      this.hostname = this.hostname || '';
+
+      // if hostname begins with [ and ends with ]
+      // assume that it's an IPv6 address.
+      var ipv6Hostname = this.hostname[0] === '[' &&
+          this.hostname[this.hostname.length - 1] === ']';
+
+      // validate a little.
+      if (!ipv6Hostname) {
+        var hostparts = this.hostname.split(/\./);
+        for (var i = 0, l = hostparts.length; i < l; i++) {
+          var part = hostparts[i];
+          if (!part) { continue; }
+          if (!part.match(hostnamePartPattern)) {
+            var newpart = '';
+            for (var j = 0, k = part.length; j < k; j++) {
+              if (part.charCodeAt(j) > 127) {
+                // we replace non-ASCII char with a temporary placeholder
+                // we need this to make sure size of hostname is not
+                // broken by replacing non-ASCII by nothing
+                newpart += 'x';
+              } else {
+                newpart += part[j];
+              }
+            }
+            // we test again with ASCII char only
+            if (!newpart.match(hostnamePartPattern)) {
+              var validParts = hostparts.slice(0, i);
+              var notHost = hostparts.slice(i + 1);
+              var bit = part.match(hostnamePartStart);
+              if (bit) {
+                validParts.push(bit[1]);
+                notHost.unshift(bit[2]);
+              }
+              if (notHost.length) {
+                rest = '/' + notHost.join('.') + rest;
+              }
+              this.hostname = validParts.join('.');
+              break;
+            }
+          }
+        }
+      }
 
-  if (!path && !isAbsolute) {
-    path = '.';
-  }
-  if (path && trailingSlash) {
-    path += '/';
-  }
+      if (this.hostname.length > hostnameMaxLen) {
+        this.hostname = '';
+      } else {
+        // hostnames are always lower case.
+        this.hostname = this.hostname.toLowerCase();
+      }
 
-  return (isAbsolute ? '/' : '') + path;
-};
+      if (!ipv6Hostname) {
+        // IDNA Support: Returns a punycoded representation of "domain".
+        // It only converts parts of the domain name that
+        // have non-ASCII characters, i.e. it doesn't matter if
+        // you call it with a domain that already is ASCII-only.
+        this.hostname = punycode.toASCII(this.hostname);
+      }
 
-// posix version
-exports.isAbsolute = function(path) {
-  return path.charAt(0) === '/';
-};
+      var p = this.port ? ':' + this.port : '';
+      var h = this.hostname || '';
+      this.host = h + p;
+      this.href += this.host;
 
-// posix version
-exports.join = function() {
-  var paths = Array.prototype.slice.call(arguments, 0);
-  return exports.normalize(filter(paths, function(p, index) {
-    if (typeof p !== 'string') {
-      throw new TypeError('Arguments to path.join must be strings');
+      // strip [ and ] from the hostname
+      // the host field still retains them, though
+      if (ipv6Hostname) {
+        this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+        if (rest[0] !== '/') {
+          rest = '/' + rest;
+        }
+      }
     }
-    return p;
-  }).join('/'));
-};
 
+    // now rest is set to the post-host stuff.
+    // chop off any delim chars.
+    if (!unsafeProtocol[lowerProto]) {
+
+      // First, make 100% sure that any "autoEscape" chars get
+      // escaped, even if encodeURIComponent doesn't think they
+      // need to be.
+      for (var i = 0, l = autoEscape.length; i < l; i++) {
+        var ae = autoEscape[i];
+        if (rest.indexOf(ae) === -1)
+          { continue; }
+        var esc = encodeURIComponent(ae);
+        if (esc === ae) {
+          esc = escape(ae);
+        }
+        rest = rest.split(ae).join(esc);
+      }
+    }
 
-// path.relative(from, to)
-// posix version
-exports.relative = function(from, to) {
-  from = exports.resolve(from).substr(1);
-  to = exports.resolve(to).substr(1);
 
-  function trim(arr) {
-    var start = 0;
-    for (; start < arr.length; start++) {
-      if (arr[start] !== '') break;
+    // chop off from the tail first.
+    var hash = rest.indexOf('#');
+    if (hash !== -1) {
+      // got a fragment string.
+      this.hash = rest.substr(hash);
+      rest = rest.slice(0, hash);
+    }
+    var qm = rest.indexOf('?');
+    if (qm !== -1) {
+      this.search = rest.substr(qm);
+      this.query = rest.substr(qm + 1);
+      if (parseQueryString) {
+        this.query = querystring.parse(this.query);
+      }
+      rest = rest.slice(0, qm);
+    } else if (parseQueryString) {
+      // no query string, but parseQueryString still requested
+      this.search = '';
+      this.query = {};
+    }
+    if (rest) { this.pathname = rest; }
+    if (slashedProtocol[lowerProto] &&
+        this.hostname && !this.pathname) {
+      this.pathname = '/';
     }
 
-    var end = arr.length - 1;
-    for (; end >= 0; end--) {
-      if (arr[end] !== '') break;
+    //to support http.request
+    if (this.pathname || this.search) {
+      var p = this.pathname || '';
+      var s = this.search || '';
+      this.path = p + s;
     }
 
-    if (start > end) return [];
-    return arr.slice(start, end - start + 1);
+    // finally, reconstruct the href based on what has been validated.
+    this.href = this.format();
+    return this;
+  };
+
+  // format a parsed object into a url string
+  function urlFormat(obj) {
+    // ensure it's an object, and not a string url.
+    // If it's an obj, this is a no-op.
+    // this way, you can call url_format() on strings
+    // to clean up potentially wonky urls.
+    if (util.isString(obj)) { obj = urlParse(obj); }
+    if (!(obj instanceof Url)) { return Url.prototype.format.call(obj); }
+    return obj.format();
   }
 
-  var fromParts = trim(from.split('/'));
-  var toParts = trim(to.split('/'));
+  Url.prototype.format = function() {
+    var auth = this.auth || '';
+    if (auth) {
+      auth = encodeURIComponent(auth);
+      auth = auth.replace(/%3A/i, ':');
+      auth += '@';
+    }
+
+    var protocol = this.protocol || '',
+        pathname = this.pathname || '',
+        hash = this.hash || '',
+        host = false,
+        query = '';
+
+    if (this.host) {
+      host = auth + this.host;
+    } else if (this.hostname) {
+      host = auth + (this.hostname.indexOf(':') === -1 ?
+          this.hostname :
+          '[' + this.hostname + ']');
+      if (this.port) {
+        host += ':' + this.port;
+      }
+    }
 
-  var length = Math.min(fromParts.length, toParts.length);
-  var samePartsLength = length;
-  for (var i = 0; i < length; i++) {
-    if (fromParts[i] !== toParts[i]) {
-      samePartsLength = i;
-      break;
+    if (this.query &&
+        util.isObject(this.query) &&
+        Object.keys(this.query).length) {
+      query = querystring.stringify(this.query);
     }
-  }
 
-  var outputParts = [];
-  for (var i = samePartsLength; i < fromParts.length; i++) {
-    outputParts.push('..');
-  }
+    var search = this.search || (query && ('?' + query)) || '';
 
-  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+    if (protocol && protocol.substr(-1) !== ':') { protocol += ':'; }
 
-  return outputParts.join('/');
-};
+    // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
+    // unless they had them to begin with.
+    if (this.slashes ||
+        (!protocol || slashedProtocol[protocol]) && host !== false) {
+      host = '//' + (host || '');
+      if (pathname && pathname.charAt(0) !== '/') { pathname = '/' + pathname; }
+    } else if (!host) {
+      host = '';
+    }
 
-exports.sep = '/';
-exports.delimiter = ':';
+    if (hash && hash.charAt(0) !== '#') { hash = '#' + hash; }
+    if (search && search.charAt(0) !== '?') { search = '?' + search; }
 
-exports.dirname = function(path) {
-  var result = splitPath(path),
-      root = result[0],
-      dir = result[1];
+    pathname = pathname.replace(/[?#]/g, function(match) {
+      return encodeURIComponent(match);
+    });
+    search = search.replace('#', '%23');
 
-  if (!root && !dir) {
-    // No dirname whatsoever
-    return '.';
-  }
+    return protocol + host + pathname + search + hash;
+  };
 
-  if (dir) {
-    // It has a dirname, strip trailing slash
-    dir = dir.substr(0, dir.length - 1);
+  function urlResolve(source, relative) {
+    return urlParse(source, false, true).resolve(relative);
   }
 
-  return root + dir;
-};
-
+  Url.prototype.resolve = function(relative) {
+    return this.resolveObject(urlParse(relative, false, true)).format();
+  };
 
-exports.basename = function(path, ext) {
-  var f = splitPath(path)[2];
-  // TODO: make this comparison case-insensitive on windows?
-  if (ext && f.substr(-1 * ext.length) === ext) {
-    f = f.substr(0, f.length - ext.length);
+  function urlResolveObject(source, relative) {
+    if (!source) { return relative; }
+    return urlParse(source, false, true).resolveObject(relative);
   }
-  return f;
-};
-
-
-exports.extname = function(path) {
-  return splitPath(path)[3];
-};
 
-function filter (xs, f) {
-    if (xs.filter) return xs.filter(f);
-    var res = [];
-    for (var i = 0; i < xs.length; i++) {
-        if (f(xs[i], i, xs)) res.push(xs[i]);
+  Url.prototype.resolveObject = function(relative) {
+    if (util.isString(relative)) {
+      var rel = new Url();
+      rel.parse(relative, false, true);
+      relative = rel;
     }
-    return res;
-}
-
-// String.prototype.substr - negative index don't work in IE8
-var substr = 'ab'.substr(-1) === 'b'
-    ? function (str, start, len) { return str.substr(start, len) }
-    : function (str, start, len) {
-        if (start < 0) start = str.length + start;
-        return str.substr(start, len);
+
+    var result = new Url();
+    var tkeys = Object.keys(this);
+    for (var tk = 0; tk < tkeys.length; tk++) {
+      var tkey = tkeys[tk];
+      result[tkey] = this[tkey];
     }
-;
 
-}).call(this,require('_process'))
+    // hash is always overridden, no matter what.
+    // even href="" will remove it.
+    result.hash = relative.hash;
 
-},{"_process":24}],24:[function(require,module,exports){
-// shim for using process in browser
-var process = module.exports = {};
+    // if the relative url is empty, then there's nothing left to do here.
+    if (relative.href === '') {
+      result.href = result.format();
+      return result;
+    }
 
-// cached from whatever global is present so that test runners that stub it
-// don't break things.  But we need to wrap it in a try catch in case it is
-// wrapped in strict mode code which doesn't define any globals.  It's inside a
-// function because try/catches deoptimize in certain engines.
+    // hrefs like //foo/bar always cut to the protocol.
+    if (relative.slashes && !relative.protocol) {
+      // take everything except the protocol from relative
+      var rkeys = Object.keys(relative);
+      for (var rk = 0; rk < rkeys.length; rk++) {
+        var rkey = rkeys[rk];
+        if (rkey !== 'protocol')
+          { result[rkey] = relative[rkey]; }
+      }
 
-var cachedSetTimeout;
-var cachedClearTimeout;
+      //urlParse appends trailing / to urls like http://www.example.com
+      if (slashedProtocol[result.protocol] &&
+          result.hostname && !result.pathname) {
+        result.path = result.pathname = '/';
+      }
 
-function defaultSetTimout() {
-    throw new Error('setTimeout has not been defined');
-}
-function defaultClearTimeout () {
-    throw new Error('clearTimeout has not been defined');
-}
-(function () {
-    try {
-        if (typeof setTimeout === 'function') {
-            cachedSetTimeout = setTimeout;
-        } else {
-            cachedSetTimeout = defaultSetTimout;
-        }
-    } catch (e) {
-        cachedSetTimeout = defaultSetTimout;
-    }
-    try {
-        if (typeof clearTimeout === 'function') {
-            cachedClearTimeout = clearTimeout;
-        } else {
-            cachedClearTimeout = defaultClearTimeout;
-        }
-    } catch (e) {
-        cachedClearTimeout = defaultClearTimeout;
-    }
-} ())
-function runTimeout(fun) {
-    if (cachedSetTimeout === setTimeout) {
-        //normal enviroments in sane situations
-        return setTimeout(fun, 0);
-    }
-    // if setTimeout wasn't available but was latter defined
-    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-        cachedSetTimeout = setTimeout;
-        return setTimeout(fun, 0);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedSetTimeout(fun, 0);
-    } catch(e){
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
-            return cachedSetTimeout.call(null, fun, 0);
-        } catch(e){
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
-            return cachedSetTimeout.call(this, fun, 0);
-        }
-    }
-
-
-}
-function runClearTimeout(marker) {
-    if (cachedClearTimeout === clearTimeout) {
-        //normal enviroments in sane situations
-        return clearTimeout(marker);
-    }
-    // if clearTimeout wasn't available but was latter defined
-    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-        cachedClearTimeout = clearTimeout;
-        return clearTimeout(marker);
-    }
-    try {
-        // when when somebody has screwed with setTimeout but no I.E. maddness
-        return cachedClearTimeout(marker);
-    } catch (e){
-        try {
-            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
-            return cachedClearTimeout.call(null, marker);
-        } catch (e){
-            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
-            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
-            return cachedClearTimeout.call(this, marker);
-        }
+      result.href = result.format();
+      return result;
     }
 
+    if (relative.protocol && relative.protocol !== result.protocol) {
+      // if it's a known url protocol, then changing
+      // the protocol does weird things
+      // first, if it's not file:, then we MUST have a host,
+      // and if there was a path
+      // to begin with, then we MUST have a path.
+      // if it is file:, then the host is dropped,
+      // because that's known to be hostless.
+      // anything else is assumed to be absolute.
+      if (!slashedProtocol[relative.protocol]) {
+        var keys = Object.keys(relative);
+        for (var v = 0; v < keys.length; v++) {
+          var k = keys[v];
+          result[k] = relative[k];
+        }
+        result.href = result.format();
+        return result;
+      }
 
-
-}
-var queue = [];
-var draining = false;
-var currentQueue;
-var queueIndex = -1;
-
-function cleanUpNextTick() {
-    if (!draining || !currentQueue) {
-        return;
-    }
-    draining = false;
-    if (currentQueue.length) {
-        queue = currentQueue.concat(queue);
-    } else {
-        queueIndex = -1;
-    }
-    if (queue.length) {
-        drainQueue();
+      result.protocol = relative.protocol;
+      if (!relative.host && !hostlessProtocol[relative.protocol]) {
+        var relPath = (relative.pathname || '').split('/');
+        while (relPath.length && !(relative.host = relPath.shift())){ ; }
+        if (!relative.host) { relative.host = ''; }
+        if (!relative.hostname) { relative.hostname = ''; }
+        if (relPath[0] !== '') { relPath.unshift(''); }
+        if (relPath.length < 2) { relPath.unshift(''); }
+        result.pathname = relPath.join('/');
+      } else {
+        result.pathname = relative.pathname;
+      }
+      result.search = relative.search;
+      result.query = relative.query;
+      result.host = relative.host || '';
+      result.auth = relative.auth;
+      result.hostname = relative.hostname || relative.host;
+      result.port = relative.port;
+      // to support http.request
+      if (result.pathname || result.search) {
+        var p = result.pathname || '';
+        var s = result.search || '';
+        result.path = p + s;
+      }
+      result.slashes = result.slashes || relative.slashes;
+      result.href = result.format();
+      return result;
     }
-}
 
-function drainQueue() {
-    if (draining) {
-        return;
-    }
-    var timeout = runTimeout(cleanUpNextTick);
-    draining = true;
-
-    var len = queue.length;
-    while(len) {
-        currentQueue = queue;
-        queue = [];
-        while (++queueIndex < len) {
-            if (currentQueue) {
-                currentQueue[queueIndex].run();
-            }
-        }
-        queueIndex = -1;
-        len = queue.length;
-    }
-    currentQueue = null;
-    draining = false;
-    runClearTimeout(timeout);
-}
-
-process.nextTick = function (fun) {
-    var args = new Array(arguments.length - 1);
-    if (arguments.length > 1) {
-        for (var i = 1; i < arguments.length; i++) {
-            args[i - 1] = arguments[i];
+    var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
+        isRelAbs = (
+            relative.host ||
+            relative.pathname && relative.pathname.charAt(0) === '/'
+        ),
+        mustEndAbs = (isRelAbs || isSourceAbs ||
+                      (result.host && relative.pathname)),
+        removeAllDots = mustEndAbs,
+        srcPath = result.pathname && result.pathname.split('/') || [],
+        relPath = relative.pathname && relative.pathname.split('/') || [],
+        psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+    // if the url is a non-slashed url, then relative
+    // links like ../.. should be able
+    // to crawl up to the hostname, as well.  This is strange.
+    // result.protocol has already been set by now.
+    // Later on, put the first path part into the host field.
+    if (psychotic) {
+      result.hostname = '';
+      result.port = null;
+      if (result.host) {
+        if (srcPath[0] === '') { srcPath[0] = result.host; }
+        else { srcPath.unshift(result.host); }
+      }
+      result.host = '';
+      if (relative.protocol) {
+        relative.hostname = null;
+        relative.port = null;
+        if (relative.host) {
+          if (relPath[0] === '') { relPath[0] = relative.host; }
+          else { relPath.unshift(relative.host); }
+        }
+        relative.host = null;
+      }
+      mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+    }
+
+    if (isRelAbs) {
+      // it's absolute.
+      result.host = (relative.host || relative.host === '') ?
+                    relative.host : result.host;
+      result.hostname = (relative.hostname || relative.hostname === '') ?
+                        relative.hostname : result.hostname;
+      result.search = relative.search;
+      result.query = relative.query;
+      srcPath = relPath;
+      // fall through to the dot-handling below.
+    } else if (relPath.length) {
+      // it's relative
+      // throw away the existing file, and take the new path instead.
+      if (!srcPath) { srcPath = []; }
+      srcPath.pop();
+      srcPath = srcPath.concat(relPath);
+      result.search = relative.search;
+      result.query = relative.query;
+    } else if (!util.isNullOrUndefined(relative.search)) {
+      // just pull out the search.
+      // like href='?foo'.
+      // Put this after the other two cases because it simplifies the booleans
+      if (psychotic) {
+        result.hostname = result.host = srcPath.shift();
+        //occationaly the auth can get stuck only in host
+        //this especially happens in cases like
+        //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+        var authInHost = result.host && result.host.indexOf('@') > 0 ?
+                         result.host.split('@') : false;
+        if (authInHost) {
+          result.auth = authInHost.shift();
+          result.host = result.hostname = authInHost.shift();
         }
+      }
+      result.search = relative.search;
+      result.query = relative.query;
+      //to support http.request
+      if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+        result.path = (result.pathname ? result.pathname : '') +
+                      (result.search ? result.search : '');
+      }
+      result.href = result.format();
+      return result;
     }
-    queue.push(new Item(fun, args));
-    if (queue.length === 1 && !draining) {
-        runTimeout(drainQueue);
-    }
-};
-
-// v8 likes predictible objects
-function Item(fun, array) {
-    this.fun = fun;
-    this.array = array;
-}
-Item.prototype.run = function () {
-    this.fun.apply(null, this.array);
-};
-process.title = 'browser';
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = ''; // empty string to avoid regexp issues
-process.versions = {};
-
-function noop() {}
-
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-process.prependListener = noop;
-process.prependOnceListener = noop;
-
-process.listeners = function (name) { return [] }
-
-process.binding = function (name) {
-    throw new Error('process.binding is not supported');
-};
-
-process.cwd = function () { return '/' };
-process.chdir = function (dir) {
-    throw new Error('process.chdir is not supported');
-};
-process.umask = function() { return 0; };
-
-},{}],25:[function(require,module,exports){
-(function (global){
-/*! https://mths.be/punycode v1.4.1 by @mathias */
-;(function(root) {
-
-	/** Detect free variables */
-	var freeExports = typeof exports == 'object' && exports &&
-		!exports.nodeType && exports;
-	var freeModule = typeof module == 'object' && module &&
-		!module.nodeType && module;
-	var freeGlobal = typeof global == 'object' && global;
-	if (
-		freeGlobal.global === freeGlobal ||
-		freeGlobal.window === freeGlobal ||
-		freeGlobal.self === freeGlobal
-	) {
-		root = freeGlobal;
-	}
-
-	/**
-	 * The `punycode` object.
-	 * @name punycode
-	 * @type Object
-	 */
-	var punycode,
-
-	/** Highest positive signed 32-bit float value */
-	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
-
-	/** Bootstring parameters */
-	base = 36,
-	tMin = 1,
-	tMax = 26,
-	skew = 38,
-	damp = 700,
-	initialBias = 72,
-	initialN = 128, // 0x80
-	delimiter = '-', // '\x2D'
-
-	/** Regular expressions */
-	regexPunycode = /^xn--/,
-	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
-	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
-
-	/** Error messages */
-	errors = {
-		'overflow': 'Overflow: input needs wider integers to process',
-		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
-		'invalid-input': 'Invalid input'
-	},
-
-	/** Convenience shortcuts */
-	baseMinusTMin = base - tMin,
-	floor = Math.floor,
-	stringFromCharCode = String.fromCharCode,
-
-	/** Temporary variable */
-	key;
-
-	/*--------------------------------------------------------------------------*/
-
-	/**
-	 * A generic error utility function.
-	 * @private
-	 * @param {String} type The error type.
-	 * @returns {Error} Throws a `RangeError` with the applicable error message.
-	 */
-	function error(type) {
-		throw new RangeError(errors[type]);
-	}
-
-	/**
-	 * A generic `Array#map` utility function.
-	 * @private
-	 * @param {Array} array The array to iterate over.
-	 * @param {Function} callback The function that gets called for every array
-	 * item.
-	 * @returns {Array} A new array of values returned by the callback function.
-	 */
-	function map(array, fn) {
-		var length = array.length;
-		var result = [];
-		while (length--) {
-			result[length] = fn(array[length]);
-		}
-		return result;
-	}
-
-	/**
-	 * A simple `Array#map`-like wrapper to work with domain name strings or email
-	 * addresses.
-	 * @private
-	 * @param {String} domain The domain name or email address.
-	 * @param {Function} callback The function that gets called for every
-	 * character.
-	 * @returns {Array} A new string of characters returned by the callback
-	 * function.
-	 */
-	function mapDomain(string, fn) {
-		var parts = string.split('@');
-		var result = '';
-		if (parts.length > 1) {
-			// In email addresses, only the domain name should be punycoded. Leave
-			// the local part (i.e. everything up to `@`) intact.
-			result = parts[0] + '@';
-			string = parts[1];
-		}
-		// Avoid `split(regex)` for IE8 compatibility. See #17.
-		string = string.replace(regexSeparators, '\x2E');
-		var labels = string.split('.');
-		var encoded = map(labels, fn).join('.');
-		return result + encoded;
-	}
-
-	/**
-	 * Creates an array containing the numeric code points of each Unicode
-	 * character in the string. While JavaScript uses UCS-2 internally,
-	 * this function will convert a pair of surrogate halves (each of which
-	 * UCS-2 exposes as separate characters) into a single code point,
-	 * matching UTF-16.
-	 * @see `punycode.ucs2.encode`
-	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
-	 * @memberOf punycode.ucs2
-	 * @name decode
-	 * @param {String} string The Unicode input string (UCS-2).
-	 * @returns {Array} The new array of code points.
-	 */
-	function ucs2decode(string) {
-		var output = [],
-		    counter = 0,
-		    length = string.length,
-		    value,
-		    extra;
-		while (counter < length) {
-			value = string.charCodeAt(counter++);
-			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
-				// high surrogate, and there is a next character
-				extra = string.charCodeAt(counter++);
-				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
-					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-				} else {
-					// unmatched surrogate; only append this code unit, in case the next
-					// code unit is the high surrogate of a surrogate pair
-					output.push(value);
-					counter--;
-				}
-			} else {
-				output.push(value);
-			}
-		}
-		return output;
-	}
-
-	/**
-	 * Creates a string based on an array of numeric code points.
-	 * @see `punycode.ucs2.decode`
-	 * @memberOf punycode.ucs2
-	 * @name encode
-	 * @param {Array} codePoints The array of numeric code points.
-	 * @returns {String} The new Unicode string (UCS-2).
-	 */
-	function ucs2encode(array) {
-		return map(array, function(value) {
-			var output = '';
-			if (value > 0xFFFF) {
-				value -= 0x10000;
-				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
-				value = 0xDC00 | value & 0x3FF;
-			}
-			output += stringFromCharCode(value);
-			return output;
-		}).join('');
-	}
-
-	/**
-	 * Converts a basic code point into a digit/integer.
-	 * @see `digitToBasic()`
-	 * @private
-	 * @param {Number} codePoint The basic numeric code point value.
-	 * @returns {Number} The numeric value of a basic code point (for use in
-	 * representing integers) in the range `0` to `base - 1`, or `base` if
-	 * the code point does not represent a value.
-	 */
-	function basicToDigit(codePoint) {
-		if (codePoint - 48 < 10) {
-			return codePoint - 22;
-		}
-		if (codePoint - 65 < 26) {
-			return codePoint - 65;
-		}
-		if (codePoint - 97 < 26) {
-			return codePoint - 97;
-		}
-		return base;
-	}
-
-	/**
-	 * Converts a digit/integer into a basic code point.
-	 * @see `basicToDigit()`
-	 * @private
-	 * @param {Number} digit The numeric value of a basic code point.
-	 * @returns {Number} The basic code point whose value (when used for
-	 * representing integers) is `digit`, which needs to be in the range
-	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
-	 * used; else, the lowercase form is used. The behavior is undefined
-	 * if `flag` is non-zero and `digit` has no uppercase form.
-	 */
-	function digitToBasic(digit, flag) {
-		//  0..25 map to ASCII a..z or A..Z
-		// 26..35 map to ASCII 0..9
-		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
-	}
-
-	/**
-	 * Bias adaptation function as per section 3.4 of RFC 3492.
-	 * https://tools.ietf.org/html/rfc3492#section-3.4
-	 * @private
-	 */
-	function adapt(delta, numPoints, firstTime) {
-		var k = 0;
-		delta = firstTime ? floor(delta / damp) : delta >> 1;
-		delta += floor(delta / numPoints);
-		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
-			delta = floor(delta / baseMinusTMin);
-		}
-		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
-	}
-
-	/**
-	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
-	 * symbols.
-	 * @memberOf punycode
-	 * @param {String} input The Punycode string of ASCII-only symbols.
-	 * @returns {String} The resulting string of Unicode symbols.
-	 */
-	function decode(input) {
-		// Don't use UCS-2
-		var output = [],
-		    inputLength = input.length,
-		    out,
-		    i = 0,
-		    n = initialN,
-		    bias = initialBias,
-		    basic,
-		    j,
-		    index,
-		    oldi,
-		    w,
-		    k,
-		    digit,
-		    t,
-		    /** Cached calculation results */
-		    baseMinusT;
-
-		// Handle the basic code points: let `basic` be the number of input code
-		// points before the last delimiter, or `0` if there is none, then copy
-		// the first basic code points to the output.
-
-		basic = input.lastIndexOf(delimiter);
-		if (basic < 0) {
-			basic = 0;
-		}
-
-		for (j = 0; j < basic; ++j) {
-			// if it's not a basic code point
-			if (input.charCodeAt(j) >= 0x80) {
-				error('not-basic');
-			}
-			output.push(input.charCodeAt(j));
-		}
-
-		// Main decoding loop: start just after the last delimiter if any basic code
-		// points were copied; start at the beginning otherwise.
-
-		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
-
-			// `index` is the index of the next character to be consumed.
-			// Decode a generalized variable-length integer into `delta`,
-			// which gets added to `i`. The overflow checking is easier
-			// if we increase `i` as we go, then subtract off its starting
-			// value at the end to obtain `delta`.
-			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
-
-				if (index >= inputLength) {
-					error('invalid-input');
-				}
-
-				digit = basicToDigit(input.charCodeAt(index++));
-
-				if (digit >= base || digit > floor((maxInt - i) / w)) {
-					error('overflow');
-				}
-
-				i += digit * w;
-				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-
-				if (digit < t) {
-					break;
-				}
-
-				baseMinusT = base - t;
-				if (w > floor(maxInt / baseMinusT)) {
-					error('overflow');
-				}
-
-				w *= baseMinusT;
-
-			}
-
-			out = output.length + 1;
-			bias = adapt(i - oldi, out, oldi == 0);
-
-			// `i` was supposed to wrap around from `out` to `0`,
-			// incrementing `n` each time, so we'll fix that now:
-			if (floor(i / out) > maxInt - n) {
-				error('overflow');
-			}
-
-			n += floor(i / out);
-			i %= out;
-
-			// Insert `n` at position `i` of the output
-			output.splice(i++, 0, n);
-
-		}
-
-		return ucs2encode(output);
-	}
-
-	/**
-	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
-	 * Punycode string of ASCII-only symbols.
-	 * @memberOf punycode
-	 * @param {String} input The string of Unicode symbols.
-	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
-	 */
-	function encode(input) {
-		var n,
-		    delta,
-		    handledCPCount,
-		    basicLength,
-		    bias,
-		    j,
-		    m,
-		    q,
-		    k,
-		    t,
-		    currentValue,
-		    output = [],
-		    /** `inputLength` will hold the number of code points in `input`. */
-		    inputLength,
-		    /** Cached calculation results */
-		    handledCPCountPlusOne,
-		    baseMinusT,
-		    qMinusT;
-
-		// Convert the input in UCS-2 to Unicode
-		input = ucs2decode(input);
-
-		// Cache the length
-		inputLength = input.length;
-
-		// Initialize the state
-		n = initialN;
-		delta = 0;
-		bias = initialBias;
-
-		// Handle the basic code points
-		for (j = 0; j < inputLength; ++j) {
-			currentValue = input[j];
-			if (currentValue < 0x80) {
-				output.push(stringFromCharCode(currentValue));
-			}
-		}
-
-		handledCPCount = basicLength = output.length;
-
-		// `handledCPCount` is the number of code points that have been handled;
-		// `basicLength` is the number of basic code points.
-
-		// Finish the basic string - if it is not empty - with a delimiter
-		if (basicLength) {
-			output.push(delimiter);
-		}
-
-		// Main encoding loop:
-		while (handledCPCount < inputLength) {
-
-			// All non-basic code points < n have been handled already. Find the next
-			// larger one:
-			for (m = maxInt, j = 0; j < inputLength; ++j) {
-				currentValue = input[j];
-				if (currentValue >= n && currentValue < m) {
-					m = currentValue;
-				}
-			}
-
-			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
-			// but guard against overflow
-			handledCPCountPlusOne = handledCPCount + 1;
-			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
-				error('overflow');
-			}
-
-			delta += (m - n) * handledCPCountPlusOne;
-			n = m;
-
-			for (j = 0; j < inputLength; ++j) {
-				currentValue = input[j];
-
-				if (currentValue < n && ++delta > maxInt) {
-					error('overflow');
-				}
-
-				if (currentValue == n) {
-					// Represent delta as a generalized variable-length integer
-					for (q = delta, k = base; /* no condition */; k += base) {
-						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-						if (q < t) {
-							break;
-						}
-						qMinusT = q - t;
-						baseMinusT = base - t;
-						output.push(
-							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
-						);
-						q = floor(qMinusT / baseMinusT);
-					}
-
-					output.push(stringFromCharCode(digitToBasic(q, 0)));
-					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
-					delta = 0;
-					++handledCPCount;
-				}
-			}
-
-			++delta;
-			++n;
-
-		}
-		return output.join('');
-	}
-
-	/**
-	 * Converts a Punycode string representing a domain name or an email address
-	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
-	 * it doesn't matter if you call it on a string that has already been
-	 * converted to Unicode.
-	 * @memberOf punycode
-	 * @param {String} input The Punycoded domain name or email address to
-	 * convert to Unicode.
-	 * @returns {String} The Unicode representation of the given Punycode
-	 * string.
-	 */
-	function toUnicode(input) {
-		return mapDomain(input, function(string) {
-			return regexPunycode.test(string)
-				? decode(string.slice(4).toLowerCase())
-				: string;
-		});
-	}
-
-	/**
-	 * Converts a Unicode string representing a domain name or an email address to
-	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
-	 * i.e. it doesn't matter if you call it with a domain that's already in
-	 * ASCII.
-	 * @memberOf punycode
-	 * @param {String} input The domain name or email address to convert, as a
-	 * Unicode string.
-	 * @returns {String} The Punycode representation of the given domain name or
-	 * email address.
-	 */
-	function toASCII(input) {
-		return mapDomain(input, function(string) {
-			return regexNonASCII.test(string)
-				? 'xn--' + encode(string)
-				: string;
-		});
-	}
-
-	/*--------------------------------------------------------------------------*/
-
-	/** Define the public API */
-	punycode = {
-		/**
-		 * A string representing the current Punycode.js version number.
-		 * @memberOf punycode
-		 * @type String
-		 */
-		'version': '1.4.1',
-		/**
-		 * An object of methods to convert from JavaScript's internal character
-		 * representation (UCS-2) to Unicode code points, and back.
-		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
-		 * @memberOf punycode
-		 * @type Object
-		 */
-		'ucs2': {
-			'decode': ucs2decode,
-			'encode': ucs2encode
-		},
-		'decode': decode,
-		'encode': encode,
-		'toASCII': toASCII,
-		'toUnicode': toUnicode
-	};
-
-	/** Expose `punycode` */
-	// Some AMD build optimizers, like r.js, check for specific condition patterns
-	// like the following:
-	if (
-		typeof define == 'function' &&
-		typeof define.amd == 'object' &&
-		define.amd
-	) {
-		define('punycode', function() {
-			return punycode;
-		});
-	} else if (freeExports && freeModule) {
-		if (module.exports == freeExports) {
-			// in Node.js, io.js, or RingoJS v0.8.0+
-			freeModule.exports = punycode;
-		} else {
-			// in Narwhal or RingoJS v0.7.0-
-			for (key in punycode) {
-				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
-			}
-		}
-	} else {
-		// in Rhino or a web browser
-		root.punycode = punycode;
-	}
-
-}(this));
-
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-
-},{}],26:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// 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.
-
-'use strict';
-
-// If obj.hasOwnProperty has been overridden, then calling
-// obj.hasOwnProperty(prop) will break.
-// See: https://github.com/joyent/node/issues/1707
-function hasOwnProperty(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-module.exports = function(qs, sep, eq, options) {
-  sep = sep || '&';
-  eq = eq || '=';
-  var obj = {};
-
-  if (typeof qs !== 'string' || qs.length === 0) {
-    return obj;
-  }
-
-  var regexp = /\+/g;
-  qs = qs.split(sep);
-
-  var maxKeys = 1000;
-  if (options && typeof options.maxKeys === 'number') {
-    maxKeys = options.maxKeys;
-  }
-
-  var len = qs.length;
-  // maxKeys <= 0 means that we should not limit keys count
-  if (maxKeys > 0 && len > maxKeys) {
-    len = maxKeys;
-  }
 
-  for (var i = 0; i < len; ++i) {
-    var x = qs[i].replace(regexp, '%20'),
-        idx = x.indexOf(eq),
-        kstr, vstr, k, v;
-
-    if (idx >= 0) {
-      kstr = x.substr(0, idx);
-      vstr = x.substr(idx + 1);
-    } else {
-      kstr = x;
-      vstr = '';
+    if (!srcPath.length) {
+      // no path at all.  easy.
+      // we've already handled the other stuff above.
+      result.pathname = null;
+      //to support http.request
+      if (result.search) {
+        result.path = '/' + result.search;
+      } else {
+        result.path = null;
+      }
+      result.href = result.format();
+      return result;
     }
 
-    k = decodeURIComponent(kstr);
-    v = decodeURIComponent(vstr);
-
-    if (!hasOwnProperty(obj, k)) {
-      obj[k] = v;
-    } else if (isArray(obj[k])) {
-      obj[k].push(v);
-    } else {
-      obj[k] = [obj[k], v];
+    // if a url ENDs in . or .., then it must get a trailing slash.
+    // however, if it ends in anything else non-slashy,
+    // then it must NOT get a trailing slash.
+    var last = srcPath.slice(-1)[0];
+    var hasTrailingSlash = (
+        (result.host || relative.host || srcPath.length > 1) &&
+        (last === '.' || last === '..') || last === '');
+
+    // strip single dots, resolve double dots to parent dir
+    // if the path tries to go above the root, `up` ends up > 0
+    var up = 0;
+    for (var i = srcPath.length; i >= 0; i--) {
+      last = srcPath[i];
+      if (last === '.') {
+        srcPath.splice(i, 1);
+      } else if (last === '..') {
+        srcPath.splice(i, 1);
+        up++;
+      } else if (up) {
+        srcPath.splice(i, 1);
+        up--;
+      }
     }
-  }
-
-  return obj;
-};
-
-var isArray = Array.isArray || function (xs) {
-  return Object.prototype.toString.call(xs) === '[object Array]';
-};
-
-},{}],27:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// 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.
-
-'use strict';
-
-var stringifyPrimitive = function(v) {
-  switch (typeof v) {
-    case 'string':
-      return v;
-
-    case 'boolean':
-      return v ? 'true' : 'false';
-
-    case 'number':
-      return isFinite(v) ? v : '';
-
-    default:
-      return '';
-  }
-};
-
-module.exports = function(obj, sep, eq, name) {
-  sep = sep || '&';
-  eq = eq || '=';
-  if (obj === null) {
-    obj = undefined;
-  }
 
-  if (typeof obj === 'object') {
-    return map(objectKeys(obj), function(k) {
-      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
-      if (isArray(obj[k])) {
-        return map(obj[k], function(v) {
-          return ks + encodeURIComponent(stringifyPrimitive(v));
-        }).join(sep);
-      } else {
-        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+    // if the path is allowed to go above the root, restore leading ..s
+    if (!mustEndAbs && !removeAllDots) {
+      for (; up--; up) {
+        srcPath.unshift('..');
       }
-    }).join(sep);
-
-  }
-
-  if (!name) return '';
-  return encodeURIComponent(stringifyPrimitive(name)) + eq +
-         encodeURIComponent(stringifyPrimitive(obj));
-};
-
-var isArray = Array.isArray || function (xs) {
-  return Object.prototype.toString.call(xs) === '[object Array]';
-};
-
-function map (xs, f) {
-  if (xs.map) return xs.map(f);
-  var res = [];
-  for (var i = 0; i < xs.length; i++) {
-    res.push(f(xs[i], i));
-  }
-  return res;
-}
-
-var objectKeys = Object.keys || function (obj) {
-  var res = [];
-  for (var key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
-  }
-  return res;
-};
-
-},{}],28:[function(require,module,exports){
-'use strict';
-
-exports.decode = exports.parse = require('./decode');
-exports.encode = exports.stringify = require('./encode');
-
-},{"./decode":26,"./encode":27}],29:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// 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.
-
-'use strict';
-
-var punycode = require('punycode');
-var util = require('./util');
-
-exports.parse = urlParse;
-exports.resolve = urlResolve;
-exports.resolveObject = urlResolveObject;
-exports.format = urlFormat;
-
-exports.Url = Url;
-
-function Url() {
-  this.protocol = null;
-  this.slashes = null;
-  this.auth = null;
-  this.host = null;
-  this.port = null;
-  this.hostname = null;
-  this.hash = null;
-  this.search = null;
-  this.query = null;
-  this.pathname = null;
-  this.path = null;
-  this.href = null;
-}
-
-// Reference: RFC 3986, RFC 1808, RFC 2396
-
-// define these here so at least they only have to be
-// compiled once on the first module load.
-var protocolPattern = /^([a-z0-9.+-]+:)/i,
-    portPattern = /:[0-9]*$/,
-
-    // Special case for a simple path URL
-    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
-
-    // RFC 2396: characters reserved for delimiting URLs.
-    // We actually just auto-escape these.
-    delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
-
-    // RFC 2396: characters not allowed for various reasons.
-    unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
-
-    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
-    autoEscape = ['\''].concat(unwise),
-    // Characters that are never ever allowed in a hostname.
-    // Note that any invalid chars are also handled, but these
-    // are the ones that are *expected* to be seen, so we fast-path
-    // them.
-    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
-    hostEndingChars = ['/', '?', '#'],
-    hostnameMaxLen = 255,
-    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
-    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
-    // protocols that can allow "unsafe" and "unwise" chars.
-    unsafeProtocol = {
-      'javascript': true,
-      'javascript:': true
-    },
-    // protocols that never have a hostname.
-    hostlessProtocol = {
-      'javascript': true,
-      'javascript:': true
-    },
-    // protocols that always contain a // bit.
-    slashedProtocol = {
-      'http': true,
-      'https': true,
-      'ftp': true,
-      'gopher': true,
-      'file': true,
-      'http:': true,
-      'https:': true,
-      'ftp:': true,
-      'gopher:': true,
-      'file:': true
-    },
-    querystring = require('querystring');
-
-function urlParse(url, parseQueryString, slashesDenoteHost) {
-  if (url && util.isObject(url) && url instanceof Url) return url;
-
-  var u = new Url;
-  u.parse(url, parseQueryString, slashesDenoteHost);
-  return u;
-}
+    }
 
-Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
-  if (!util.isString(url)) {
-    throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
-  }
+    if (mustEndAbs && srcPath[0] !== '' &&
+        (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+      srcPath.unshift('');
+    }
 
-  // Copy chrome, IE, opera backslash-handling behavior.
-  // Back slashes before the query string get converted to forward slashes
-  // See: https://code.google.com/p/chromium/issues/detail?id=25916
-  var queryIndex = url.indexOf('?'),
-      splitter =
-          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
-      uSplit = url.split(splitter),
-      slashRegex = /\\/g;
-  uSplit[0] = uSplit[0].replace(slashRegex, '/');
-  url = uSplit.join(splitter);
-
-  var rest = url;
-
-  // trim before proceeding.
-  // This is to support parse stuff like "  http://foo.com  \n"
-  rest = rest.trim();
-
-  if (!slashesDenoteHost && url.split('#').length === 1) {
-    // Try fast path regexp
-    var simplePath = simplePathPattern.exec(rest);
-    if (simplePath) {
-      this.path = rest;
-      this.href = rest;
-      this.pathname = simplePath[1];
-      if (simplePath[2]) {
-        this.search = simplePath[2];
-        if (parseQueryString) {
-          this.query = querystring.parse(this.search.substr(1));
-        } else {
-          this.query = this.search.substr(1);
-        }
-      } else if (parseQueryString) {
-        this.search = '';
-        this.query = {};
-      }
-      return this;
+    if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+      srcPath.push('');
     }
-  }
 
-  var proto = protocolPattern.exec(rest);
-  if (proto) {
-    proto = proto[0];
-    var lowerProto = proto.toLowerCase();
-    this.protocol = lowerProto;
-    rest = rest.substr(proto.length);
-  }
+    var isAbsolute = srcPath[0] === '' ||
+        (srcPath[0] && srcPath[0].charAt(0) === '/');
 
-  // figure out if it's got a host
-  // user@server is *always* interpreted as a hostname, and url
-  // resolution will treat //foo/bar as host=foo,path=bar because that's
-  // how the browser resolves relative URLs.
-  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
-    var slashes = rest.substr(0, 2) === '//';
-    if (slashes && !(proto && hostlessProtocol[proto])) {
-      rest = rest.substr(2);
-      this.slashes = true;
+    // put the host back
+    if (psychotic) {
+      result.hostname = result.host = isAbsolute ? '' :
+                                      srcPath.length ? srcPath.shift() : '';
+      //occationaly the auth can get stuck only in host
+      //this especially happens in cases like
+      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+      var authInHost = result.host && result.host.indexOf('@') > 0 ?
+                       result.host.split('@') : false;
+      if (authInHost) {
+        result.auth = authInHost.shift();
+        result.host = result.hostname = authInHost.shift();
+      }
     }
-  }
 
-  if (!hostlessProtocol[proto] &&
-      (slashes || (proto && !slashedProtocol[proto]))) {
+    mustEndAbs = mustEndAbs || (result.host && srcPath.length);
 
-    // there's a hostname.
-    // the first instance of /, ?, ;, or # ends the host.
-    //
-    // If there is an @ in the hostname, then non-host chars *are* allowed
-    // to the left of the last @ sign, unless some host-ending character
-    // comes *before* the @-sign.
-    // URLs are obnoxious.
-    //
-    // ex:
-    // http://a@b@c/ => user:a@b host:c
-    // http://a@b?@c => user:a host:c path:/?@c
-
-    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
-    // Review our test case against browsers more comprehensively.
-
-    // find the first instance of any hostEndingChars
-    var hostEnd = -1;
-    for (var i = 0; i < hostEndingChars.length; i++) {
-      var hec = rest.indexOf(hostEndingChars[i]);
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
-        hostEnd = hec;
+    if (mustEndAbs && !isAbsolute) {
+      srcPath.unshift('');
     }
 
-    // at this point, either we have an explicit point where the
-    // auth portion cannot go past, or the last @ char is the decider.
-    var auth, atSign;
-    if (hostEnd === -1) {
-      // atSign can be anywhere.
-      atSign = rest.lastIndexOf('@');
+    if (!srcPath.length) {
+      result.pathname = null;
+      result.path = null;
     } else {
-      // atSign must be in auth portion.
-      // http://a@b/c@d => host:b auth:a path:/c@d
-      atSign = rest.lastIndexOf('@', hostEnd);
+      result.pathname = srcPath.join('/');
     }
 
-    // Now we have a portion which is definitely the auth.
-    // Pull that off.
-    if (atSign !== -1) {
-      auth = rest.slice(0, atSign);
-      rest = rest.slice(atSign + 1);
-      this.auth = decodeURIComponent(auth);
+    //to support request.http
+    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+      result.path = (result.pathname ? result.pathname : '') +
+                    (result.search ? result.search : '');
     }
+    result.auth = relative.auth || result.auth;
+    result.slashes = result.slashes || relative.slashes;
+    result.href = result.format();
+    return result;
+  };
 
-    // the host is the remaining to the left of the first non-host char
-    hostEnd = -1;
-    for (var i = 0; i < nonHostChars.length; i++) {
-      var hec = rest.indexOf(nonHostChars[i]);
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
-        hostEnd = hec;
-    }
-    // if we still have not hit it, then the entire thing is a host.
-    if (hostEnd === -1)
-      hostEnd = rest.length;
-
-    this.host = rest.slice(0, hostEnd);
-    rest = rest.slice(hostEnd);
-
-    // pull out port.
-    this.parseHost();
-
-    // we've indicated that there is a hostname,
-    // so even if it's empty, it has to be present.
-    this.hostname = this.hostname || '';
-
-    // if hostname begins with [ and ends with ]
-    // assume that it's an IPv6 address.
-    var ipv6Hostname = this.hostname[0] === '[' &&
-        this.hostname[this.hostname.length - 1] === ']';
-
-    // validate a little.
-    if (!ipv6Hostname) {
-      var hostparts = this.hostname.split(/\./);
-      for (var i = 0, l = hostparts.length; i < l; i++) {
-        var part = hostparts[i];
-        if (!part) continue;
-        if (!part.match(hostnamePartPattern)) {
-          var newpart = '';
-          for (var j = 0, k = part.length; j < k; j++) {
-            if (part.charCodeAt(j) > 127) {
-              // we replace non-ASCII char with a temporary placeholder
-              // we need this to make sure size of hostname is not
-              // broken by replacing non-ASCII by nothing
-              newpart += 'x';
-            } else {
-              newpart += part[j];
-            }
-          }
-          // we test again with ASCII char only
-          if (!newpart.match(hostnamePartPattern)) {
-            var validParts = hostparts.slice(0, i);
-            var notHost = hostparts.slice(i + 1);
-            var bit = part.match(hostnamePartStart);
-            if (bit) {
-              validParts.push(bit[1]);
-              notHost.unshift(bit[2]);
-            }
-            if (notHost.length) {
-              rest = '/' + notHost.join('.') + rest;
-            }
-            this.hostname = validParts.join('.');
-            break;
-          }
-        }
+  Url.prototype.parseHost = function() {
+    var host = this.host;
+    var port = portPattern.exec(host);
+    if (port) {
+      port = port[0];
+      if (port !== ':') {
+        this.port = port.substr(1);
       }
+      host = host.substr(0, host.length - port.length);
     }
+    if (host) { this.hostname = host; }
+  };
 
-    if (this.hostname.length > hostnameMaxLen) {
-      this.hostname = '';
-    } else {
-      // hostnames are always lower case.
-      this.hostname = this.hostname.toLowerCase();
-    }
+  var url$1 = {
+  	parse: parse,
+  	resolve: resolve,
+  	resolveObject: resolveObject,
+  	format: format,
+  	Url: Url_1
+  };
 
-    if (!ipv6Hostname) {
-      // IDNA Support: Returns a punycoded representation of "domain".
-      // It only converts parts of the domain name that
-      // have non-ASCII characters, i.e. it doesn't matter if
-      // you call it with a domain that already is ASCII-only.
-      this.hostname = punycode.toASCII(this.hostname);
-    }
+  /*!
+   * @pixi/utils - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/utils is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-    var p = this.port ? ':' + this.port : '';
-    var h = this.hostname || '';
-    this.host = h + p;
-    this.href += this.host;
+  /**
+   * This file contains redeclared types for Node `url` and `querystring` modules. These modules
+   * don't provide their own typings but instead are a part of the full Node typings. The purpose of
+   * this file is to redeclare the required types to avoid having the whole Node types as a
+   * dependency.
+   */
+  var url = {
+      parse: parse,
+      format: format,
+      resolve: resolve,
+  };
 
-    // strip [ and ] from the hostname
-    // the host field still retains them, though
-    if (ipv6Hostname) {
-      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
-      if (rest[0] !== '/') {
-        rest = '/' + rest;
+  function assertPath(path) {
+      if (typeof path !== 'string') {
+          throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
       }
-    }
   }
-
-  // now rest is set to the post-host stuff.
-  // chop off any delim chars.
-  if (!unsafeProtocol[lowerProto]) {
-
-    // First, make 100% sure that any "autoEscape" chars get
-    // escaped, even if encodeURIComponent doesn't think they
-    // need to be.
-    for (var i = 0, l = autoEscape.length; i < l; i++) {
-      var ae = autoEscape[i];
-      if (rest.indexOf(ae) === -1)
-        continue;
-      var esc = encodeURIComponent(ae);
-      if (esc === ae) {
-        esc = escape(ae);
-      }
-      rest = rest.split(ae).join(esc);
-    }
+  function removeUrlParams(url) {
+      var re = url.split('?')[0];
+      return re.split('#')[0];
   }
-
-
-  // chop off from the tail first.
-  var hash = rest.indexOf('#');
-  if (hash !== -1) {
-    // got a fragment string.
-    this.hash = rest.substr(hash);
-    rest = rest.slice(0, hash);
+  function escapeRegExp(string) {
+      return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
   }
-  var qm = rest.indexOf('?');
-  if (qm !== -1) {
-    this.search = rest.substr(qm);
-    this.query = rest.substr(qm + 1);
-    if (parseQueryString) {
-      this.query = querystring.parse(this.query);
-    }
-    rest = rest.slice(0, qm);
-  } else if (parseQueryString) {
-    // no query string, but parseQueryString still requested
-    this.search = '';
-    this.query = {};
+  function replaceAll(str, find, replace) {
+      return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
   }
-  if (rest) this.pathname = rest;
-  if (slashedProtocol[lowerProto] &&
-      this.hostname && !this.pathname) {
-    this.pathname = '/';
+  // Resolves . and .. elements in a path with directory names
+  function normalizeStringPosix(path, allowAboveRoot) {
+      var res = '';
+      var lastSegmentLength = 0;
+      var lastSlash = -1;
+      var dots = 0;
+      var code;
+      for (var i = 0; i <= path.length; ++i) {
+          if (i < path.length) {
+              code = path.charCodeAt(i);
+          }
+          else if (code === 47) {
+              break;
+          }
+          else {
+              code = 47;
+          }
+          if (code === 47) {
+              if (lastSlash === i - 1 || dots === 1) { ; }
+              else if (lastSlash !== i - 1 && dots === 2) {
+                  if (res.length < 2
+                      || lastSegmentLength !== 2
+                      || res.charCodeAt(res.length - 1) !== 46
+                      || res.charCodeAt(res.length - 2) !== 46) {
+                      if (res.length > 2) {
+                          var lastSlashIndex = res.lastIndexOf('/');
+                          if (lastSlashIndex !== res.length - 1) {
+                              if (lastSlashIndex === -1) {
+                                  res = '';
+                                  lastSegmentLength = 0;
+                              }
+                              else {
+                                  res = res.slice(0, lastSlashIndex);
+                                  lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+                              }
+                              lastSlash = i;
+                              dots = 0;
+                              continue;
+                          }
+                      }
+                      else if (res.length === 2 || res.length === 1) {
+                          res = '';
+                          lastSegmentLength = 0;
+                          lastSlash = i;
+                          dots = 0;
+                          continue;
+                      }
+                  }
+                  if (allowAboveRoot) {
+                      if (res.length > 0) {
+                          res += '/..';
+                      }
+                      else {
+                          res = '..';
+                      }
+                      lastSegmentLength = 2;
+                  }
+              }
+              else {
+                  if (res.length > 0) {
+                      res += "/" + path.slice(lastSlash + 1, i);
+                  }
+                  else {
+                      res = path.slice(lastSlash + 1, i);
+                  }
+                  lastSegmentLength = i - lastSlash - 1;
+              }
+              lastSlash = i;
+              dots = 0;
+          }
+          else if (code === 46 && dots !== -1) {
+              ++dots;
+          }
+          else {
+              dots = -1;
+          }
+      }
+      return res;
   }
+  var path = {
+      /**
+       * Converts a path to posix format.
+       * @param path - The path to convert to posix
+       */
+      toPosix: function (path) { return replaceAll(path, '\\', '/'); },
+      /**
+       * Checks if the path is a URL
+       * @param path - The path to check
+       */
+      isUrl: function (path) { return (/^https?:/).test(this.toPosix(path)); },
+      /**
+       * Checks if the path is a data URL
+       * @param path - The path to check
+       */
+      isDataUrl: function (path) {
+          // eslint-disable-next-line max-len
+          return (/^data:([a-z]+\/[a-z0-9-+.]+(;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}()_|~`]+)*)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s<>]*?)$/i)
+              .test(path);
+      },
+      /**
+       * Checks if the path has a protocol e.g. http://
+       * This will return true for windows file paths
+       * @param path - The path to check
+       */
+      hasProtocol: function (path) { return (/^[^/:]+:\//).test(this.toPosix(path)); },
+      /**
+       * Returns the protocol of the path e.g. http://, C:/, file:///
+       * @param path - The path to get the protocol from
+       */
+      getProtocol: function (path) {
+          assertPath(path);
+          path = this.toPosix(path);
+          var protocol = '';
+          var isFile = (/^file:\/\/\//).exec(path);
+          var isHttp = (/^[^/:]+:\/\//).exec(path);
+          var isWindows = (/^[^/:]+:\//).exec(path);
+          if (isFile || isHttp || isWindows) {
+              var arr = (isFile === null || isFile === void 0 ? void 0 : isFile[0]) || (isHttp === null || isHttp === void 0 ? void 0 : isHttp[0]) || (isWindows === null || isWindows === void 0 ? void 0 : isWindows[0]);
+              protocol = arr;
+              path = path.slice(arr.length);
+          }
+          return protocol;
+      },
+      /**
+       * Converts URL to an absolute path.
+       * When loading from a Web Worker, we must use absolute paths.
+       * If the URL is already absolute we return it as is
+       * If it's not, we convert it
+       * @param url - The URL to test
+       * @param customBaseUrl - The base URL to use
+       * @param customRootUrl - The root URL to use
+       */
+      toAbsolute: function (url, customBaseUrl, customRootUrl) {
+          if (this.isDataUrl(url))
+              { return url; }
+          var baseUrl = removeUrlParams(this.toPosix(customBaseUrl !== null && customBaseUrl !== void 0 ? customBaseUrl : settings.ADAPTER.getBaseUrl()));
+          var rootUrl = removeUrlParams(this.toPosix(customRootUrl !== null && customRootUrl !== void 0 ? customRootUrl : this.rootname(baseUrl)));
+          assertPath(url);
+          url = this.toPosix(url);
+          // root relative url
+          if (url.startsWith('/')) {
+              return path.join(rootUrl, url.slice(1));
+          }
+          var absolutePath = this.isAbsolute(url) ? url : this.join(baseUrl, url);
+          return absolutePath;
+      },
+      /**
+       * Normalizes the given path, resolving '..' and '.' segments
+       * @param path - The path to normalize
+       */
+      normalize: function (path) {
+          path = this.toPosix(path);
+          assertPath(path);
+          if (path.length === 0)
+              { return '.'; }
+          var protocol = '';
+          var isAbsolute = path.startsWith('/');
+          if (this.hasProtocol(path)) {
+              protocol = this.rootname(path);
+              path = path.slice(protocol.length);
+          }
+          var trailingSeparator = path.endsWith('/');
+          // Normalize the path
+          path = normalizeStringPosix(path, false);
+          if (path.length > 0 && trailingSeparator)
+              { path += '/'; }
+          if (isAbsolute)
+              { return "/" + path; }
+          return protocol + path;
+      },
+      /**
+       * Determines if path is an absolute path.
+       * Absolute paths can be urls, data urls, or paths on disk
+       * @param path - The path to test
+       */
+      isAbsolute: function (path) {
+          assertPath(path);
+          path = this.toPosix(path);
+          if (this.hasProtocol(path))
+              { return true; }
+          return path.startsWith('/');
+      },
+      /**
+       * Joins all given path segments together using the platform-specific separator as a delimiter,
+       * then normalizes the resulting path
+       * @param segments - The segments of the path to join
+       */
+      join: function () {
+          var arguments$1 = arguments;
 
-  //to support http.request
-  if (this.pathname || this.search) {
-    var p = this.pathname || '';
-    var s = this.search || '';
-    this.path = p + s;
-  }
+          var _a;
+          var segments = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              segments[_i] = arguments$1[_i];
+          }
+          if (segments.length === 0) {
+              return '.';
+          }
+          var joined;
+          for (var i = 0; i < segments.length; ++i) {
+              var arg = segments[i];
+              assertPath(arg);
+              if (arg.length > 0) {
+                  if (joined === undefined)
+                      { joined = arg; }
+                  else {
+                      var prevArg = (_a = segments[i - 1]) !== null && _a !== void 0 ? _a : '';
+                      if (this.extname(prevArg)) {
+                          joined += "/../" + arg;
+                      }
+                      else {
+                          joined += "/" + arg;
+                      }
+                  }
+              }
+          }
+          if (joined === undefined) {
+              return '.';
+          }
+          return this.normalize(joined);
+      },
+      /**
+       * Returns the directory name of a path
+       * @param path - The path to parse
+       */
+      dirname: function (path) {
+          assertPath(path);
+          if (path.length === 0)
+              { return '.'; }
+          path = this.toPosix(path);
+          var code = path.charCodeAt(0);
+          var hasRoot = code === 47;
+          var end = -1;
+          var matchedSlash = true;
+          var proto = this.getProtocol(path);
+          var origpath = path;
+          path = path.slice(proto.length);
+          for (var i = path.length - 1; i >= 1; --i) {
+              code = path.charCodeAt(i);
+              if (code === 47) {
+                  if (!matchedSlash) {
+                      end = i;
+                      break;
+                  }
+              }
+              else {
+                  // We saw the first non-path separator
+                  matchedSlash = false;
+              }
+          }
+          // if end is -1 and its a url then we need to add the path back
+          // eslint-disable-next-line no-nested-ternary
+          if (end === -1)
+              { return hasRoot ? '/' : this.isUrl(origpath) ? proto + path : proto; }
+          if (hasRoot && end === 1)
+              { return '//'; }
+          return proto + path.slice(0, end);
+      },
+      /**
+       * Returns the root of the path e.g. /, C:/, file:///, http://domain.com/
+       * @param path - The path to parse
+       */
+      rootname: function (path) {
+          assertPath(path);
+          path = this.toPosix(path);
+          var root = '';
+          if (path.startsWith('/'))
+              { root = '/'; }
+          else {
+              root = this.getProtocol(path);
+          }
+          if (this.isUrl(path)) {
+              // need to find the first path separator
+              var index = path.indexOf('/', root.length);
+              if (index !== -1) {
+                  root = path.slice(0, index);
+              }
+              else
+                  { root = path; }
+              if (!root.endsWith('/'))
+                  { root += '/'; }
+          }
+          return root;
+      },
+      /**
+       * Returns the last portion of a path
+       * @param path - The path to test
+       * @param ext - Optional extension to remove
+       */
+      basename: function (path, ext) {
+          assertPath(path);
+          if (ext)
+              { assertPath(ext); }
+          path = this.toPosix(path);
+          var start = 0;
+          var end = -1;
+          var matchedSlash = true;
+          var i;
+          if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+              if (ext.length === path.length && ext === path)
+                  { return ''; }
+              var extIdx = ext.length - 1;
+              var firstNonSlashEnd = -1;
+              for (i = path.length - 1; i >= 0; --i) {
+                  var code = path.charCodeAt(i);
+                  if (code === 47) {
+                      // If we reached a path separator that was not part of a set of path
+                      // separators at the end of the string, stop now
+                      if (!matchedSlash) {
+                          start = i + 1;
+                          break;
+                      }
+                  }
+                  else {
+                      if (firstNonSlashEnd === -1) {
+                          // We saw the first non-path separator, remember this index in case
+                          // we need it if the extension ends up not matching
+                          matchedSlash = false;
+                          firstNonSlashEnd = i + 1;
+                      }
+                      if (extIdx >= 0) {
+                          // Try to match the explicit extension
+                          if (code === ext.charCodeAt(extIdx)) {
+                              if (--extIdx === -1) {
+                                  // We matched the extension, so mark this as the end of our path
+                                  // component
+                                  end = i;
+                              }
+                          }
+                          else {
+                              // Extension does not match, so our result is the entire path
+                              // component
+                              extIdx = -1;
+                              end = firstNonSlashEnd;
+                          }
+                      }
+                  }
+              }
+              if (start === end)
+                  { end = firstNonSlashEnd; }
+              else if (end === -1)
+                  { end = path.length; }
+              return path.slice(start, end);
+          }
+          for (i = path.length - 1; i >= 0; --i) {
+              if (path.charCodeAt(i) === 47) {
+                  // If we reached a path separator that was not part of a set of path
+                  // separators at the end of the string, stop now
+                  if (!matchedSlash) {
+                      start = i + 1;
+                      break;
+                  }
+              }
+              else if (end === -1) {
+                  // We saw the first non-path separator, mark this as the end of our
+                  // path component
+                  matchedSlash = false;
+                  end = i + 1;
+              }
+          }
+          if (end === -1)
+              { return ''; }
+          return path.slice(start, end);
+      },
+      /**
+       * Returns the extension of the path, from the last occurrence of the . (period) character to end of string in the last
+       * portion of the path. If there is no . in the last portion of the path, or if there are no . characters other than
+       * the first character of the basename of path, an empty string is returned.
+       * @param path - The path to parse
+       */
+      extname: function (path) {
+          assertPath(path);
+          path = this.toPosix(path);
+          var startDot = -1;
+          var startPart = 0;
+          var end = -1;
+          var matchedSlash = true;
+          // Track the state of characters (if any) we see before our first dot and
+          // after any path separator we find
+          var preDotState = 0;
+          for (var i = path.length - 1; i >= 0; --i) {
+              var code = path.charCodeAt(i);
+              if (code === 47) {
+                  // If we reached a path separator that was not part of a set of path
+                  // separators at the end of the string, stop now
+                  if (!matchedSlash) {
+                      startPart = i + 1;
+                      break;
+                  }
+                  continue;
+              }
+              if (end === -1) {
+                  // We saw the first non-path separator, mark this as the end of our
+                  // extension
+                  matchedSlash = false;
+                  end = i + 1;
+              }
+              if (code === 46) {
+                  // If this is our first dot, mark it as the start of our extension
+                  if (startDot === -1)
+                      { startDot = i; }
+                  else if (preDotState !== 1)
+                      { preDotState = 1; }
+              }
+              else if (startDot !== -1) {
+                  // We saw a non-dot and non-path separator before our dot, so we should
+                  // have a good chance at having a non-empty extension
+                  preDotState = -1;
+              }
+          }
+          if (startDot === -1 || end === -1
+              // We saw a non-dot character immediately before the dot
+              || preDotState === 0
+              // The (right-most) trimmed path component is exactly '..'
+              // eslint-disable-next-line no-mixed-operators
+              || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+              return '';
+          }
+          return path.slice(startDot, end);
+      },
+      /**
+       * Parses a path into an object containing the 'root', `dir`, `base`, `ext`, and `name` properties.
+       * @param path - The path to parse
+       */
+      parse: function (path) {
+          assertPath(path);
+          var ret = { root: '', dir: '', base: '', ext: '', name: '' };
+          if (path.length === 0)
+              { return ret; }
+          path = this.toPosix(path);
+          var code = path.charCodeAt(0);
+          var isAbsolute = this.isAbsolute(path);
+          var start;
+          ret.root = this.rootname(path);
+          if (isAbsolute || this.hasProtocol(path)) {
+              start = 1;
+          }
+          else {
+              start = 0;
+          }
+          var startDot = -1;
+          var startPart = 0;
+          var end = -1;
+          var matchedSlash = true;
+          var i = path.length - 1;
+          // Track the state of characters (if any) we see before our first dot and
+          // after any path separator we find
+          var preDotState = 0;
+          // Get non-dir info
+          for (; i >= start; --i) {
+              code = path.charCodeAt(i);
+              if (code === 47) {
+                  // If we reached a path separator that was not part of a set of path
+                  // separators at the end of the string, stop now
+                  if (!matchedSlash) {
+                      startPart = i + 1;
+                      break;
+                  }
+                  continue;
+              }
+              if (end === -1) {
+                  // We saw the first non-path separator, mark this as the end of our
+                  // extension
+                  matchedSlash = false;
+                  end = i + 1;
+              }
+              if (code === 46) {
+                  // If this is our first dot, mark it as the start of our extension
+                  if (startDot === -1)
+                      { startDot = i; }
+                  else if (preDotState !== 1)
+                      { preDotState = 1; }
+              }
+              else if (startDot !== -1) {
+                  // We saw a non-dot and non-path separator before our dot, so we should
+                  // have a good chance at having a non-empty extension
+                  preDotState = -1;
+              }
+          }
+          if (startDot === -1 || end === -1
+              // We saw a non-dot character immediately before the dot
+              || preDotState === 0
+              // The (right-most) trimmed path component is exactly '..'
+              // eslint-disable-next-line no-mixed-operators
+              || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+              if (end !== -1) {
+                  if (startPart === 0 && isAbsolute)
+                      { ret.base = ret.name = path.slice(1, end); }
+                  else
+                      { ret.base = ret.name = path.slice(startPart, end); }
+              }
+          }
+          else {
+              if (startPart === 0 && isAbsolute) {
+                  ret.name = path.slice(1, startDot);
+                  ret.base = path.slice(1, end);
+              }
+              else {
+                  ret.name = path.slice(startPart, startDot);
+                  ret.base = path.slice(startPart, end);
+              }
+              ret.ext = path.slice(startDot, end);
+          }
+          ret.dir = this.dirname(path);
+          return ret;
+      },
+      sep: '/',
+      delimiter: ':'
+  };
 
-  // finally, reconstruct the href based on what has been validated.
-  this.href = this.format();
-  return this;
-};
-
-// format a parsed object into a url string
-function urlFormat(obj) {
-  // ensure it's an object, and not a string url.
-  // If it's an obj, this is a no-op.
-  // this way, you can call url_format() on strings
-  // to clean up potentially wonky urls.
-  if (util.isString(obj)) obj = urlParse(obj);
-  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
-  return obj.format();
-}
-
-Url.prototype.format = function() {
-  var auth = this.auth || '';
-  if (auth) {
-    auth = encodeURIComponent(auth);
-    auth = auth.replace(/%3A/i, ':');
-    auth += '@';
-  }
+  /**
+   * The prefix that denotes a URL is for a retina asset.
+   * @static
+   * @name RETINA_PREFIX
+   * @memberof PIXI.settings
+   * @type {RegExp}
+   * @default /@([0-9\.]+)x/
+   * @example `@2x`
+   */
+  settings.RETINA_PREFIX = /@([0-9\.]+)x/;
+  /**
+   * Should the `failIfMajorPerformanceCaveat` flag be enabled as a context option used in the `isWebGLSupported` function.
+   * If set to true, a WebGL renderer can fail to be created if the browser thinks there could be performance issues when
+   * using WebGL.
+   *
+   * In PixiJS v6 this has changed from true to false by default, to allow WebGL to work in as many scenarios as possible.
+   * However, some users may have a poor experience, for example, if a user has a gpu or driver version blacklisted by the
+   * browser.
+   *
+   * If your application requires high performance rendering, you may wish to set this to false.
+   * We recommend one of two options if you decide to set this flag to false:
+   *
+   * 1: Use the `pixi.js-legacy` package, which includes a Canvas renderer as a fallback in case high performance WebGL is
+   *    not supported.
+   *
+   * 2: Call `isWebGLSupported` (which if found in the PIXI.utils package) in your code before attempting to create a PixiJS
+   *    renderer, and show an error message to the user if the function returns false, explaining that their device & browser
+   *    combination does not support high performance WebGL.
+   *    This is a much better strategy than trying to create a PixiJS renderer and finding it then fails.
+   * @static
+   * @name FAIL_IF_MAJOR_PERFORMANCE_CAVEAT
+   * @memberof PIXI.settings
+   * @type {boolean}
+   * @default false
+   */
+  settings.FAIL_IF_MAJOR_PERFORMANCE_CAVEAT = false;
 
-  var protocol = this.protocol || '',
-      pathname = this.pathname || '',
-      hash = this.hash || '',
-      host = false,
-      query = '';
-
-  if (this.host) {
-    host = auth + this.host;
-  } else if (this.hostname) {
-    host = auth + (this.hostname.indexOf(':') === -1 ?
-        this.hostname :
-        '[' + this.hostname + ']');
-    if (this.port) {
-      host += ':' + this.port;
-    }
+  var saidHello = false;
+  var VERSION$1 = '6.5.10';
+  /**
+   * Skips the hello message of renderers that are created after this is run.
+   * @function skipHello
+   * @memberof PIXI.utils
+   */
+  function skipHello() {
+      saidHello = true;
   }
-
-  if (this.query &&
-      util.isObject(this.query) &&
-      Object.keys(this.query).length) {
-    query = querystring.stringify(this.query);
+  /**
+   * Logs out the version and renderer information for this running instance of PIXI.
+   * If you don't want to see this message you can run `PIXI.utils.skipHello()` before
+   * creating your renderer. Keep in mind that doing that will forever make you a jerk face.
+   * @static
+   * @function sayHello
+   * @memberof PIXI.utils
+   * @param {string} type - The string renderer type to log.
+   */
+  function sayHello(type) {
+      var _a;
+      if (saidHello) {
+          return;
+      }
+      if (settings.ADAPTER.getNavigator().userAgent.toLowerCase().indexOf('chrome') > -1) {
+          var args = [
+              "\n %c %c %c PixiJS " + VERSION$1 + " - \u2730 " + type + " \u2730  %c  %c  http://www.pixijs.com/  %c %c \u2665%c\u2665%c\u2665 \n\n",
+              'background: #ff66a5; padding:5px 0;',
+              'background: #ff66a5; padding:5px 0;',
+              'color: #ff66a5; background: #030307; padding:5px 0;',
+              'background: #ff66a5; padding:5px 0;',
+              'background: #ffc3dc; padding:5px 0;',
+              'background: #ff66a5; padding:5px 0;',
+              'color: #ff2424; background: #fff; padding:5px 0;',
+              'color: #ff2424; background: #fff; padding:5px 0;',
+              'color: #ff2424; background: #fff; padding:5px 0;' ];
+          (_a = globalThis.console).log.apply(_a, args);
+      }
+      else if (globalThis.console) {
+          globalThis.console.log("PixiJS " + VERSION$1 + " - " + type + " - http://www.pixijs.com/");
+      }
+      saidHello = true;
   }
 
-  var search = this.search || (query && ('?' + query)) || '';
-
-  if (protocol && protocol.substr(-1) !== ':') protocol += ':';
-
-  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
-  // unless they had them to begin with.
-  if (this.slashes ||
-      (!protocol || slashedProtocol[protocol]) && host !== false) {
-    host = '//' + (host || '');
-    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
-  } else if (!host) {
-    host = '';
+  var supported;
+  /**
+   * Helper for checking for WebGL support.
+   * @memberof PIXI.utils
+   * @function isWebGLSupported
+   * @returns {boolean} Is WebGL supported.
+   */
+  function isWebGLSupported() {
+      if (typeof supported === 'undefined') {
+          supported = (function supported() {
+              var contextOptions = {
+                  stencil: true,
+                  failIfMajorPerformanceCaveat: settings.FAIL_IF_MAJOR_PERFORMANCE_CAVEAT,
+              };
+              try {
+                  if (!settings.ADAPTER.getWebGLRenderingContext()) {
+                      return false;
+                  }
+                  var canvas = settings.ADAPTER.createCanvas();
+                  var gl = (canvas.getContext('webgl', contextOptions)
+                      || canvas.getContext('experimental-webgl', contextOptions));
+                  var success = !!(gl && gl.getContextAttributes().stencil);
+                  if (gl) {
+                      var loseContext = gl.getExtension('WEBGL_lose_context');
+                      if (loseContext) {
+                          loseContext.loseContext();
+                      }
+                  }
+                  gl = null;
+                  return success;
+              }
+              catch (e) {
+                  return false;
+              }
+          })();
+      }
+      return supported;
   }
 
-  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
-  if (search && search.charAt(0) !== '?') search = '?' + search;
-
-  pathname = pathname.replace(/[?#]/g, function(match) {
-    return encodeURIComponent(match);
-  });
-  search = search.replace('#', '%23');
-
-  return protocol + host + pathname + search + hash;
-};
-
-function urlResolve(source, relative) {
-  return urlParse(source, false, true).resolve(relative);
-}
-
-Url.prototype.resolve = function(relative) {
-  return this.resolveObject(urlParse(relative, false, true)).format();
-};
-
-function urlResolveObject(source, relative) {
-  if (!source) return relative;
-  return urlParse(source, false, true).resolveObject(relative);
-}
+  var aliceblue = "#f0f8ff";
+  var antiquewhite = "#faebd7";
+  var aqua = "#00ffff";
+  var aquamarine = "#7fffd4";
+  var azure = "#f0ffff";
+  var beige = "#f5f5dc";
+  var bisque = "#ffe4c4";
+  var black = "#000000";
+  var blanchedalmond = "#ffebcd";
+  var blue = "#0000ff";
+  var blueviolet = "#8a2be2";
+  var brown = "#a52a2a";
+  var burlywood = "#deb887";
+  var cadetblue = "#5f9ea0";
+  var chartreuse = "#7fff00";
+  var chocolate = "#d2691e";
+  var coral = "#ff7f50";
+  var cornflowerblue = "#6495ed";
+  var cornsilk = "#fff8dc";
+  var crimson = "#dc143c";
+  var cyan = "#00ffff";
+  var darkblue = "#00008b";
+  var darkcyan = "#008b8b";
+  var darkgoldenrod = "#b8860b";
+  var darkgray = "#a9a9a9";
+  var darkgreen = "#006400";
+  var darkgrey = "#a9a9a9";
+  var darkkhaki = "#bdb76b";
+  var darkmagenta = "#8b008b";
+  var darkolivegreen = "#556b2f";
+  var darkorange = "#ff8c00";
+  var darkorchid = "#9932cc";
+  var darkred = "#8b0000";
+  var darksalmon = "#e9967a";
+  var darkseagreen = "#8fbc8f";
+  var darkslateblue = "#483d8b";
+  var darkslategray = "#2f4f4f";
+  var darkslategrey = "#2f4f4f";
+  var darkturquoise = "#00ced1";
+  var darkviolet = "#9400d3";
+  var deeppink = "#ff1493";
+  var deepskyblue = "#00bfff";
+  var dimgray = "#696969";
+  var dimgrey = "#696969";
+  var dodgerblue = "#1e90ff";
+  var firebrick = "#b22222";
+  var floralwhite = "#fffaf0";
+  var forestgreen = "#228b22";
+  var fuchsia = "#ff00ff";
+  var gainsboro = "#dcdcdc";
+  var ghostwhite = "#f8f8ff";
+  var goldenrod = "#daa520";
+  var gold = "#ffd700";
+  var gray = "#808080";
+  var green = "#008000";
+  var greenyellow = "#adff2f";
+  var grey = "#808080";
+  var honeydew = "#f0fff0";
+  var hotpink = "#ff69b4";
+  var indianred = "#cd5c5c";
+  var indigo = "#4b0082";
+  var ivory = "#fffff0";
+  var khaki = "#f0e68c";
+  var lavenderblush = "#fff0f5";
+  var lavender = "#e6e6fa";
+  var lawngreen = "#7cfc00";
+  var lemonchiffon = "#fffacd";
+  var lightblue = "#add8e6";
+  var lightcoral = "#f08080";
+  var lightcyan = "#e0ffff";
+  var lightgoldenrodyellow = "#fafad2";
+  var lightgray = "#d3d3d3";
+  var lightgreen = "#90ee90";
+  var lightgrey = "#d3d3d3";
+  var lightpink = "#ffb6c1";
+  var lightsalmon = "#ffa07a";
+  var lightseagreen = "#20b2aa";
+  var lightskyblue = "#87cefa";
+  var lightslategray = "#778899";
+  var lightslategrey = "#778899";
+  var lightsteelblue = "#b0c4de";
+  var lightyellow = "#ffffe0";
+  var lime = "#00ff00";
+  var limegreen = "#32cd32";
+  var linen = "#faf0e6";
+  var magenta = "#ff00ff";
+  var maroon = "#800000";
+  var mediumaquamarine = "#66cdaa";
+  var mediumblue = "#0000cd";
+  var mediumorchid = "#ba55d3";
+  var mediumpurple = "#9370db";
+  var mediumseagreen = "#3cb371";
+  var mediumslateblue = "#7b68ee";
+  var mediumspringgreen = "#00fa9a";
+  var mediumturquoise = "#48d1cc";
+  var mediumvioletred = "#c71585";
+  var midnightblue = "#191970";
+  var mintcream = "#f5fffa";
+  var mistyrose = "#ffe4e1";
+  var moccasin = "#ffe4b5";
+  var navajowhite = "#ffdead";
+  var navy = "#000080";
+  var oldlace = "#fdf5e6";
+  var olive = "#808000";
+  var olivedrab = "#6b8e23";
+  var orange = "#ffa500";
+  var orangered = "#ff4500";
+  var orchid = "#da70d6";
+  var palegoldenrod = "#eee8aa";
+  var palegreen = "#98fb98";
+  var paleturquoise = "#afeeee";
+  var palevioletred = "#db7093";
+  var papayawhip = "#ffefd5";
+  var peachpuff = "#ffdab9";
+  var peru = "#cd853f";
+  var pink = "#ffc0cb";
+  var plum = "#dda0dd";
+  var powderblue = "#b0e0e6";
+  var purple = "#800080";
+  var rebeccapurple = "#663399";
+  var red = "#ff0000";
+  var rosybrown = "#bc8f8f";
+  var royalblue = "#4169e1";
+  var saddlebrown = "#8b4513";
+  var salmon = "#fa8072";
+  var sandybrown = "#f4a460";
+  var seagreen = "#2e8b57";
+  var seashell = "#fff5ee";
+  var sienna = "#a0522d";
+  var silver = "#c0c0c0";
+  var skyblue = "#87ceeb";
+  var slateblue = "#6a5acd";
+  var slategray = "#708090";
+  var slategrey = "#708090";
+  var snow = "#fffafa";
+  var springgreen = "#00ff7f";
+  var steelblue = "#4682b4";
+  var tan = "#d2b48c";
+  var teal = "#008080";
+  var thistle = "#d8bfd8";
+  var tomato = "#ff6347";
+  var turquoise = "#40e0d0";
+  var violet = "#ee82ee";
+  var wheat = "#f5deb3";
+  var white = "#ffffff";
+  var whitesmoke = "#f5f5f5";
+  var yellow = "#ffff00";
+  var yellowgreen = "#9acd32";
+  var cssColorNames = {
+  	aliceblue: aliceblue,
+  	antiquewhite: antiquewhite,
+  	aqua: aqua,
+  	aquamarine: aquamarine,
+  	azure: azure,
+  	beige: beige,
+  	bisque: bisque,
+  	black: black,
+  	blanchedalmond: blanchedalmond,
+  	blue: blue,
+  	blueviolet: blueviolet,
+  	brown: brown,
+  	burlywood: burlywood,
+  	cadetblue: cadetblue,
+  	chartreuse: chartreuse,
+  	chocolate: chocolate,
+  	coral: coral,
+  	cornflowerblue: cornflowerblue,
+  	cornsilk: cornsilk,
+  	crimson: crimson,
+  	cyan: cyan,
+  	darkblue: darkblue,
+  	darkcyan: darkcyan,
+  	darkgoldenrod: darkgoldenrod,
+  	darkgray: darkgray,
+  	darkgreen: darkgreen,
+  	darkgrey: darkgrey,
+  	darkkhaki: darkkhaki,
+  	darkmagenta: darkmagenta,
+  	darkolivegreen: darkolivegreen,
+  	darkorange: darkorange,
+  	darkorchid: darkorchid,
+  	darkred: darkred,
+  	darksalmon: darksalmon,
+  	darkseagreen: darkseagreen,
+  	darkslateblue: darkslateblue,
+  	darkslategray: darkslategray,
+  	darkslategrey: darkslategrey,
+  	darkturquoise: darkturquoise,
+  	darkviolet: darkviolet,
+  	deeppink: deeppink,
+  	deepskyblue: deepskyblue,
+  	dimgray: dimgray,
+  	dimgrey: dimgrey,
+  	dodgerblue: dodgerblue,
+  	firebrick: firebrick,
+  	floralwhite: floralwhite,
+  	forestgreen: forestgreen,
+  	fuchsia: fuchsia,
+  	gainsboro: gainsboro,
+  	ghostwhite: ghostwhite,
+  	goldenrod: goldenrod,
+  	gold: gold,
+  	gray: gray,
+  	green: green,
+  	greenyellow: greenyellow,
+  	grey: grey,
+  	honeydew: honeydew,
+  	hotpink: hotpink,
+  	indianred: indianred,
+  	indigo: indigo,
+  	ivory: ivory,
+  	khaki: khaki,
+  	lavenderblush: lavenderblush,
+  	lavender: lavender,
+  	lawngreen: lawngreen,
+  	lemonchiffon: lemonchiffon,
+  	lightblue: lightblue,
+  	lightcoral: lightcoral,
+  	lightcyan: lightcyan,
+  	lightgoldenrodyellow: lightgoldenrodyellow,
+  	lightgray: lightgray,
+  	lightgreen: lightgreen,
+  	lightgrey: lightgrey,
+  	lightpink: lightpink,
+  	lightsalmon: lightsalmon,
+  	lightseagreen: lightseagreen,
+  	lightskyblue: lightskyblue,
+  	lightslategray: lightslategray,
+  	lightslategrey: lightslategrey,
+  	lightsteelblue: lightsteelblue,
+  	lightyellow: lightyellow,
+  	lime: lime,
+  	limegreen: limegreen,
+  	linen: linen,
+  	magenta: magenta,
+  	maroon: maroon,
+  	mediumaquamarine: mediumaquamarine,
+  	mediumblue: mediumblue,
+  	mediumorchid: mediumorchid,
+  	mediumpurple: mediumpurple,
+  	mediumseagreen: mediumseagreen,
+  	mediumslateblue: mediumslateblue,
+  	mediumspringgreen: mediumspringgreen,
+  	mediumturquoise: mediumturquoise,
+  	mediumvioletred: mediumvioletred,
+  	midnightblue: midnightblue,
+  	mintcream: mintcream,
+  	mistyrose: mistyrose,
+  	moccasin: moccasin,
+  	navajowhite: navajowhite,
+  	navy: navy,
+  	oldlace: oldlace,
+  	olive: olive,
+  	olivedrab: olivedrab,
+  	orange: orange,
+  	orangered: orangered,
+  	orchid: orchid,
+  	palegoldenrod: palegoldenrod,
+  	palegreen: palegreen,
+  	paleturquoise: paleturquoise,
+  	palevioletred: palevioletred,
+  	papayawhip: papayawhip,
+  	peachpuff: peachpuff,
+  	peru: peru,
+  	pink: pink,
+  	plum: plum,
+  	powderblue: powderblue,
+  	purple: purple,
+  	rebeccapurple: rebeccapurple,
+  	red: red,
+  	rosybrown: rosybrown,
+  	royalblue: royalblue,
+  	saddlebrown: saddlebrown,
+  	salmon: salmon,
+  	sandybrown: sandybrown,
+  	seagreen: seagreen,
+  	seashell: seashell,
+  	sienna: sienna,
+  	silver: silver,
+  	skyblue: skyblue,
+  	slateblue: slateblue,
+  	slategray: slategray,
+  	slategrey: slategrey,
+  	snow: snow,
+  	springgreen: springgreen,
+  	steelblue: steelblue,
+  	tan: tan,
+  	teal: teal,
+  	thistle: thistle,
+  	tomato: tomato,
+  	turquoise: turquoise,
+  	violet: violet,
+  	wheat: wheat,
+  	white: white,
+  	whitesmoke: whitesmoke,
+  	yellow: yellow,
+  	yellowgreen: yellowgreen
+  };
 
-Url.prototype.resolveObject = function(relative) {
-  if (util.isString(relative)) {
-    var rel = new Url();
-    rel.parse(relative, false, true);
-    relative = rel;
+  /**
+   * Converts a hexadecimal color number to an [R, G, B] array of normalized floats (numbers from 0.0 to 1.0).
+   * @example
+   * PIXI.utils.hex2rgb(0xffffff); // returns [1, 1, 1]
+   * @memberof PIXI.utils
+   * @function hex2rgb
+   * @param {number} hex - The hexadecimal number to convert
+   * @param  {number[]} [out=[]] - If supplied, this array will be used rather than returning a new one
+   * @returns {number[]} An array representing the [R, G, B] of the color where all values are floats.
+   */
+  function hex2rgb(hex, out) {
+      if (out === void 0) { out = []; }
+      out[0] = ((hex >> 16) & 0xFF) / 255;
+      out[1] = ((hex >> 8) & 0xFF) / 255;
+      out[2] = (hex & 0xFF) / 255;
+      return out;
   }
-
-  var result = new Url();
-  var tkeys = Object.keys(this);
-  for (var tk = 0; tk < tkeys.length; tk++) {
-    var tkey = tkeys[tk];
-    result[tkey] = this[tkey];
+  /**
+   * Converts a hexadecimal color number to a string.
+   * @example
+   * PIXI.utils.hex2string(0xffffff); // returns "#ffffff"
+   * @memberof PIXI.utils
+   * @function hex2string
+   * @param {number} hex - Number in hex (e.g., `0xffffff`)
+   * @returns {string} The string color (e.g., `"#ffffff"`).
+   */
+  function hex2string(hex) {
+      var hexString = hex.toString(16);
+      hexString = '000000'.substring(0, 6 - hexString.length) + hexString;
+      return "#" + hexString;
   }
-
-  // hash is always overridden, no matter what.
-  // even href="" will remove it.
-  result.hash = relative.hash;
-
-  // if the relative url is empty, then there's nothing left to do here.
-  if (relative.href === '') {
-    result.href = result.format();
-    return result;
+  /**
+   * Converts a string to a hexadecimal color number.
+   * It can handle:
+   *  hex strings starting with #: "#ffffff"
+   *  hex strings starting with 0x: "0xffffff"
+   *  hex strings without prefix: "ffffff"
+   *  css colors: "black"
+   * @example
+   * PIXI.utils.string2hex("#ffffff"); // returns 0xffffff, which is 16777215 as an integer
+   * @memberof PIXI.utils
+   * @function string2hex
+   * @param {string} string - The string color (e.g., `"#ffffff"`)
+   * @returns {number} Number in hexadecimal.
+   */
+  function string2hex(string) {
+      if (typeof string === 'string') {
+          string = cssColorNames[string.toLowerCase()] || string;
+          if (string[0] === '#') {
+              string = string.slice(1);
+          }
+      }
+      return parseInt(string, 16);
   }
-
-  // hrefs like //foo/bar always cut to the protocol.
-  if (relative.slashes && !relative.protocol) {
-    // take everything except the protocol from relative
-    var rkeys = Object.keys(relative);
-    for (var rk = 0; rk < rkeys.length; rk++) {
-      var rkey = rkeys[rk];
-      if (rkey !== 'protocol')
-        result[rkey] = relative[rkey];
-    }
-
-    //urlParse appends trailing / to urls like http://www.example.com
-    if (slashedProtocol[result.protocol] &&
-        result.hostname && !result.pathname) {
-      result.path = result.pathname = '/';
-    }
-
-    result.href = result.format();
-    return result;
+  /**
+   * Converts a color as an [R, G, B] array of normalized floats to a hexadecimal number.
+   * @example
+   * PIXI.utils.rgb2hex([1, 1, 1]); // returns 0xffffff, which is 16777215 as an integer
+   * @memberof PIXI.utils
+   * @function rgb2hex
+   * @param {number[]} rgb - Array of numbers where all values are normalized floats from 0.0 to 1.0.
+   * @returns {number} Number in hexadecimal.
+   */
+  function rgb2hex(rgb) {
+      return (((rgb[0] * 255) << 16) + ((rgb[1] * 255) << 8) + (rgb[2] * 255 | 0));
   }
 
-  if (relative.protocol && relative.protocol !== result.protocol) {
-    // if it's a known url protocol, then changing
-    // the protocol does weird things
-    // first, if it's not file:, then we MUST have a host,
-    // and if there was a path
-    // to begin with, then we MUST have a path.
-    // if it is file:, then the host is dropped,
-    // because that's known to be hostless.
-    // anything else is assumed to be absolute.
-    if (!slashedProtocol[relative.protocol]) {
-      var keys = Object.keys(relative);
-      for (var v = 0; v < keys.length; v++) {
-        var k = keys[v];
-        result[k] = relative[k];
+  /**
+   * Corrects PixiJS blend, takes premultiplied alpha into account
+   * @memberof PIXI.utils
+   * @function mapPremultipliedBlendModes
+   * @private
+   * @returns {Array<number[]>} Mapped modes.
+   */
+  function mapPremultipliedBlendModes() {
+      var pm = [];
+      var npm = [];
+      for (var i = 0; i < 32; i++) {
+          pm[i] = i;
+          npm[i] = i;
       }
-      result.href = result.format();
-      return result;
-    }
-
-    result.protocol = relative.protocol;
-    if (!relative.host && !hostlessProtocol[relative.protocol]) {
-      var relPath = (relative.pathname || '').split('/');
-      while (relPath.length && !(relative.host = relPath.shift()));
-      if (!relative.host) relative.host = '';
-      if (!relative.hostname) relative.hostname = '';
-      if (relPath[0] !== '') relPath.unshift('');
-      if (relPath.length < 2) relPath.unshift('');
-      result.pathname = relPath.join('/');
-    } else {
-      result.pathname = relative.pathname;
-    }
-    result.search = relative.search;
-    result.query = relative.query;
-    result.host = relative.host || '';
-    result.auth = relative.auth;
-    result.hostname = relative.hostname || relative.host;
-    result.port = relative.port;
-    // to support http.request
-    if (result.pathname || result.search) {
-      var p = result.pathname || '';
-      var s = result.search || '';
-      result.path = p + s;
-    }
-    result.slashes = result.slashes || relative.slashes;
-    result.href = result.format();
-    return result;
+      pm[exports.BLEND_MODES.NORMAL_NPM] = exports.BLEND_MODES.NORMAL;
+      pm[exports.BLEND_MODES.ADD_NPM] = exports.BLEND_MODES.ADD;
+      pm[exports.BLEND_MODES.SCREEN_NPM] = exports.BLEND_MODES.SCREEN;
+      npm[exports.BLEND_MODES.NORMAL] = exports.BLEND_MODES.NORMAL_NPM;
+      npm[exports.BLEND_MODES.ADD] = exports.BLEND_MODES.ADD_NPM;
+      npm[exports.BLEND_MODES.SCREEN] = exports.BLEND_MODES.SCREEN_NPM;
+      var array = [];
+      array.push(npm);
+      array.push(pm);
+      return array;
   }
-
-  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
-      isRelAbs = (
-          relative.host ||
-          relative.pathname && relative.pathname.charAt(0) === '/'
-      ),
-      mustEndAbs = (isRelAbs || isSourceAbs ||
-                    (result.host && relative.pathname)),
-      removeAllDots = mustEndAbs,
-      srcPath = result.pathname && result.pathname.split('/') || [],
-      relPath = relative.pathname && relative.pathname.split('/') || [],
-      psychotic = result.protocol && !slashedProtocol[result.protocol];
-
-  // if the url is a non-slashed url, then relative
-  // links like ../.. should be able
-  // to crawl up to the hostname, as well.  This is strange.
-  // result.protocol has already been set by now.
-  // Later on, put the first path part into the host field.
-  if (psychotic) {
-    result.hostname = '';
-    result.port = null;
-    if (result.host) {
-      if (srcPath[0] === '') srcPath[0] = result.host;
-      else srcPath.unshift(result.host);
-    }
-    result.host = '';
-    if (relative.protocol) {
-      relative.hostname = null;
-      relative.port = null;
-      if (relative.host) {
-        if (relPath[0] === '') relPath[0] = relative.host;
-        else relPath.unshift(relative.host);
-      }
-      relative.host = null;
-    }
-    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+  /**
+   * maps premultiply flag and blendMode to adjusted blendMode
+   * @memberof PIXI.utils
+   * @constant premultiplyBlendMode
+   * @type {Array<number[]>}
+   */
+  var premultiplyBlendMode = mapPremultipliedBlendModes();
+  /**
+   * changes blendMode according to texture format
+   * @memberof PIXI.utils
+   * @function correctBlendMode
+   * @param {number} blendMode - supposed blend mode
+   * @param {boolean} premultiplied - whether source is premultiplied
+   * @returns {number} true blend mode for this texture
+   */
+  function correctBlendMode(blendMode, premultiplied) {
+      return premultiplyBlendMode[premultiplied ? 1 : 0][blendMode];
   }
-
-  if (isRelAbs) {
-    // it's absolute.
-    result.host = (relative.host || relative.host === '') ?
-                  relative.host : result.host;
-    result.hostname = (relative.hostname || relative.hostname === '') ?
-                      relative.hostname : result.hostname;
-    result.search = relative.search;
-    result.query = relative.query;
-    srcPath = relPath;
-    // fall through to the dot-handling below.
-  } else if (relPath.length) {
-    // it's relative
-    // throw away the existing file, and take the new path instead.
-    if (!srcPath) srcPath = [];
-    srcPath.pop();
-    srcPath = srcPath.concat(relPath);
-    result.search = relative.search;
-    result.query = relative.query;
-  } else if (!util.isNullOrUndefined(relative.search)) {
-    // just pull out the search.
-    // like href='?foo'.
-    // Put this after the other two cases because it simplifies the booleans
-    if (psychotic) {
-      result.hostname = result.host = srcPath.shift();
-      //occationaly the auth can get stuck only in host
-      //this especially happens in cases like
-      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
-      var authInHost = result.host && result.host.indexOf('@') > 0 ?
-                       result.host.split('@') : false;
-      if (authInHost) {
-        result.auth = authInHost.shift();
-        result.host = result.hostname = authInHost.shift();
+  /**
+   * combines rgb and alpha to out array
+   * @memberof PIXI.utils
+   * @function premultiplyRgba
+   * @param {Float32Array|number[]} rgb - input rgb
+   * @param {number} alpha - alpha param
+   * @param {Float32Array} [out] - output
+   * @param {boolean} [premultiply=true] - do premultiply it
+   * @returns {Float32Array} vec4 rgba
+   */
+  function premultiplyRgba(rgb, alpha, out, premultiply) {
+      out = out || new Float32Array(4);
+      if (premultiply || premultiply === undefined) {
+          out[0] = rgb[0] * alpha;
+          out[1] = rgb[1] * alpha;
+          out[2] = rgb[2] * alpha;
       }
-    }
-    result.search = relative.search;
-    result.query = relative.query;
-    //to support http.request
-    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
-      result.path = (result.pathname ? result.pathname : '') +
-                    (result.search ? result.search : '');
-    }
-    result.href = result.format();
-    return result;
+      else {
+          out[0] = rgb[0];
+          out[1] = rgb[1];
+          out[2] = rgb[2];
+      }
+      out[3] = alpha;
+      return out;
   }
-
-  if (!srcPath.length) {
-    // no path at all.  easy.
-    // we've already handled the other stuff above.
-    result.pathname = null;
-    //to support http.request
-    if (result.search) {
-      result.path = '/' + result.search;
-    } else {
-      result.path = null;
-    }
-    result.href = result.format();
-    return result;
+  /**
+   * premultiplies tint
+   * @memberof PIXI.utils
+   * @function premultiplyTint
+   * @param {number} tint - integer RGB
+   * @param {number} alpha - floating point alpha (0.0-1.0)
+   * @returns {number} tint multiplied by alpha
+   */
+  function premultiplyTint(tint, alpha) {
+      if (alpha === 1.0) {
+          return (alpha * 255 << 24) + tint;
+      }
+      if (alpha === 0.0) {
+          return 0;
+      }
+      var R = ((tint >> 16) & 0xFF);
+      var G = ((tint >> 8) & 0xFF);
+      var B = (tint & 0xFF);
+      R = ((R * alpha) + 0.5) | 0;
+      G = ((G * alpha) + 0.5) | 0;
+      B = ((B * alpha) + 0.5) | 0;
+      return (alpha * 255 << 24) + (R << 16) + (G << 8) + B;
   }
-
-  // if a url ENDs in . or .., then it must get a trailing slash.
-  // however, if it ends in anything else non-slashy,
-  // then it must NOT get a trailing slash.
-  var last = srcPath.slice(-1)[0];
-  var hasTrailingSlash = (
-      (result.host || relative.host || srcPath.length > 1) &&
-      (last === '.' || last === '..') || last === '');
-
-  // strip single dots, resolve double dots to parent dir
-  // if the path tries to go above the root, `up` ends up > 0
-  var up = 0;
-  for (var i = srcPath.length; i >= 0; i--) {
-    last = srcPath[i];
-    if (last === '.') {
-      srcPath.splice(i, 1);
-    } else if (last === '..') {
-      srcPath.splice(i, 1);
-      up++;
-    } else if (up) {
-      srcPath.splice(i, 1);
-      up--;
-    }
+  /**
+   * converts integer tint and float alpha to vec4 form, premultiplies by default
+   * @memberof PIXI.utils
+   * @function premultiplyTintToRgba
+   * @param {number} tint - input tint
+   * @param {number} alpha - alpha param
+   * @param {Float32Array} [out] - output
+   * @param {boolean} [premultiply=true] - do premultiply it
+   * @returns {Float32Array} vec4 rgba
+   */
+  function premultiplyTintToRgba(tint, alpha, out, premultiply) {
+      out = out || new Float32Array(4);
+      out[0] = ((tint >> 16) & 0xFF) / 255.0;
+      out[1] = ((tint >> 8) & 0xFF) / 255.0;
+      out[2] = (tint & 0xFF) / 255.0;
+      if (premultiply || premultiply === undefined) {
+          out[0] *= alpha;
+          out[1] *= alpha;
+          out[2] *= alpha;
+      }
+      out[3] = alpha;
+      return out;
   }
 
-  // if the path is allowed to go above the root, restore leading ..s
-  if (!mustEndAbs && !removeAllDots) {
-    for (; up--; up) {
-      srcPath.unshift('..');
-    }
+  /**
+   * Generic Mask Stack data structure
+   * @memberof PIXI.utils
+   * @function createIndicesForQuads
+   * @param {number} size - Number of quads
+   * @param {Uint16Array|Uint32Array} [outBuffer] - Buffer for output, length has to be `6 * size`
+   * @returns {Uint16Array|Uint32Array} - Resulting index buffer
+   */
+  function createIndicesForQuads(size, outBuffer) {
+      if (outBuffer === void 0) { outBuffer = null; }
+      // the total number of indices in our array, there are 6 points per quad.
+      var totalIndices = size * 6;
+      outBuffer = outBuffer || new Uint16Array(totalIndices);
+      if (outBuffer.length !== totalIndices) {
+          throw new Error("Out buffer length is incorrect, got " + outBuffer.length + " and expected " + totalIndices);
+      }
+      // fill the indices with the quads to draw
+      for (var i = 0, j = 0; i < totalIndices; i += 6, j += 4) {
+          outBuffer[i + 0] = j + 0;
+          outBuffer[i + 1] = j + 1;
+          outBuffer[i + 2] = j + 2;
+          outBuffer[i + 3] = j + 0;
+          outBuffer[i + 4] = j + 2;
+          outBuffer[i + 5] = j + 3;
+      }
+      return outBuffer;
   }
 
-  if (mustEndAbs && srcPath[0] !== '' &&
-      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
-    srcPath.unshift('');
+  function getBufferType(array) {
+      if (array.BYTES_PER_ELEMENT === 4) {
+          if (array instanceof Float32Array) {
+              return 'Float32Array';
+          }
+          else if (array instanceof Uint32Array) {
+              return 'Uint32Array';
+          }
+          return 'Int32Array';
+      }
+      else if (array.BYTES_PER_ELEMENT === 2) {
+          if (array instanceof Uint16Array) {
+              return 'Uint16Array';
+          }
+      }
+      else if (array.BYTES_PER_ELEMENT === 1) {
+          if (array instanceof Uint8Array) {
+              return 'Uint8Array';
+          }
+      }
+      // TODO map out the rest of the array elements!
+      return null;
   }
 
-  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
-    srcPath.push('');
+  /* eslint-disable object-shorthand */
+  var map$2 = { Float32Array: Float32Array, Uint32Array: Uint32Array, Int32Array: Int32Array, Uint8Array: Uint8Array };
+  function interleaveTypedArrays$1(arrays, sizes) {
+      var outSize = 0;
+      var stride = 0;
+      var views = {};
+      for (var i = 0; i < arrays.length; i++) {
+          stride += sizes[i];
+          outSize += arrays[i].length;
+      }
+      var buffer = new ArrayBuffer(outSize * 4);
+      var out = null;
+      var littleOffset = 0;
+      for (var i = 0; i < arrays.length; i++) {
+          var size = sizes[i];
+          var array = arrays[i];
+          /*
+          @todo This is unsafe casting but consistent with how the code worked previously. Should it stay this way
+                or should and `getBufferTypeUnsafe` function be exposed that throws an Error if unsupported type is passed?
+           */
+          var type = getBufferType(array);
+          if (!views[type]) {
+              views[type] = new map$2[type](buffer);
+          }
+          out = views[type];
+          for (var j = 0; j < array.length; j++) {
+              var indexStart = ((j / size | 0) * stride) + littleOffset;
+              var index = j % size;
+              out[indexStart + index] = array[j];
+          }
+          littleOffset += size;
+      }
+      return new Float32Array(buffer);
   }
 
-  var isAbsolute = srcPath[0] === '' ||
-      (srcPath[0] && srcPath[0].charAt(0) === '/');
-
-  // put the host back
-  if (psychotic) {
-    result.hostname = result.host = isAbsolute ? '' :
-                                    srcPath.length ? srcPath.shift() : '';
-    //occationaly the auth can get stuck only in host
-    //this especially happens in cases like
-    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
-    var authInHost = result.host && result.host.indexOf('@') > 0 ?
-                     result.host.split('@') : false;
-    if (authInHost) {
-      result.auth = authInHost.shift();
-      result.host = result.hostname = authInHost.shift();
-    }
+  // Taken from the bit-twiddle package
+  /**
+   * Rounds to next power of two.
+   * @function nextPow2
+   * @memberof PIXI.utils
+   * @param {number} v - input value
+   * @returns {number} - next rounded power of two
+   */
+  function nextPow2(v) {
+      v += v === 0 ? 1 : 0;
+      --v;
+      v |= v >>> 1;
+      v |= v >>> 2;
+      v |= v >>> 4;
+      v |= v >>> 8;
+      v |= v >>> 16;
+      return v + 1;
+  }
+  /**
+   * Checks if a number is a power of two.
+   * @function isPow2
+   * @memberof PIXI.utils
+   * @param {number} v - input value
+   * @returns {boolean} `true` if value is power of two
+   */
+  function isPow2(v) {
+      return !(v & (v - 1)) && (!!v);
+  }
+  /**
+   * Computes ceil of log base 2
+   * @function log2
+   * @memberof PIXI.utils
+   * @param {number} v - input value
+   * @returns {number} logarithm base 2
+   */
+  function log2(v) {
+      var r = (v > 0xFFFF ? 1 : 0) << 4;
+      v >>>= r;
+      var shift = (v > 0xFF ? 1 : 0) << 3;
+      v >>>= shift;
+      r |= shift;
+      shift = (v > 0xF ? 1 : 0) << 2;
+      v >>>= shift;
+      r |= shift;
+      shift = (v > 0x3 ? 1 : 0) << 1;
+      v >>>= shift;
+      r |= shift;
+      return r | (v >> 1);
   }
 
-  mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+  /**
+   * Remove items from a javascript array without generating garbage
+   * @function removeItems
+   * @memberof PIXI.utils
+   * @param {Array<any>} arr - Array to remove elements from
+   * @param {number} startIdx - starting index
+   * @param {number} removeCount - how many to remove
+   */
+  function removeItems(arr, startIdx, removeCount) {
+      var length = arr.length;
+      var i;
+      if (startIdx >= length || removeCount === 0) {
+          return;
+      }
+      removeCount = (startIdx + removeCount > length ? length - startIdx : removeCount);
+      var len = length - removeCount;
+      for (i = startIdx; i < len; ++i) {
+          arr[i] = arr[i + removeCount];
+      }
+      arr.length = len;
+  }
 
-  if (mustEndAbs && !isAbsolute) {
-    srcPath.unshift('');
+  /**
+   * Returns sign of number
+   * @memberof PIXI.utils
+   * @function sign
+   * @param {number} n - the number to check the sign of
+   * @returns {number} 0 if `n` is 0, -1 if `n` is negative, 1 if `n` is positive
+   */
+  function sign(n) {
+      if (n === 0)
+          { return 0; }
+      return n < 0 ? -1 : 1;
   }
 
-  if (!srcPath.length) {
-    result.pathname = null;
-    result.path = null;
-  } else {
-    result.pathname = srcPath.join('/');
+  var nextUid = 0;
+  /**
+   * Gets the next unique identifier
+   * @memberof PIXI.utils
+   * @function uid
+   * @returns {number} The next unique identifier to use.
+   */
+  function uid() {
+      return ++nextUid;
   }
 
-  //to support request.http
-  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
-    result.path = (result.pathname ? result.pathname : '') +
-                  (result.search ? result.search : '');
+  // A map of warning messages already fired
+  var warnings = {};
+  /**
+   * Helper for warning developers about deprecated features & settings.
+   * A stack track for warnings is given; useful for tracking-down where
+   * deprecated methods/properties/classes are being used within the code.
+   * @memberof PIXI.utils
+   * @function deprecation
+   * @param {string} version - The version where the feature became deprecated
+   * @param {string} message - Message should include what is deprecated, where, and the new solution
+   * @param {number} [ignoreDepth=3] - The number of steps to ignore at the top of the error stack
+   *        this is mostly to ignore internal deprecation calls.
+   */
+  function deprecation(version, message, ignoreDepth) {
+      if (ignoreDepth === void 0) { ignoreDepth = 3; }
+      // Ignore duplicat
+      if (warnings[message]) {
+          return;
+      }
+      /* eslint-disable no-console */
+      var stack = new Error().stack;
+      // Handle IE < 10 and Safari < 6
+      if (typeof stack === 'undefined') {
+          console.warn('PixiJS Deprecation Warning: ', message + "\nDeprecated since v" + version);
+      }
+      else {
+          // chop off the stack trace which includes PixiJS internal calls
+          stack = stack.split('\n').splice(ignoreDepth).join('\n');
+          if (console.groupCollapsed) {
+              console.groupCollapsed('%cPixiJS Deprecation Warning: %c%s', 'color:#614108;background:#fffbe6', 'font-weight:normal;color:#614108;background:#fffbe6', message + "\nDeprecated since v" + version);
+              console.warn(stack);
+              console.groupEnd();
+          }
+          else {
+              console.warn('PixiJS Deprecation Warning: ', message + "\nDeprecated since v" + version);
+              console.warn(stack);
+          }
+      }
+      /* eslint-enable no-console */
+      warnings[message] = true;
   }
-  result.auth = relative.auth || result.auth;
-  result.slashes = result.slashes || relative.slashes;
-  result.href = result.format();
-  return result;
-};
-
-Url.prototype.parseHost = function() {
-  var host = this.host;
-  var port = portPattern.exec(host);
-  if (port) {
-    port = port[0];
-    if (port !== ':') {
-      this.port = port.substr(1);
-    }
-    host = host.substr(0, host.length - port.length);
+
+  /**
+   * @todo Describe property usage
+   * @static
+   * @name ProgramCache
+   * @memberof PIXI.utils
+   * @type {object}
+   */
+  var ProgramCache = {};
+  /**
+   * @todo Describe property usage
+   * @static
+   * @name TextureCache
+   * @memberof PIXI.utils
+   * @type {object}
+   */
+  var TextureCache = Object.create(null);
+  /**
+   * @todo Describe property usage
+   * @static
+   * @name BaseTextureCache
+   * @memberof PIXI.utils
+   * @type {object}
+   */
+  var BaseTextureCache = Object.create(null);
+  /**
+   * Destroys all texture in the cache
+   * @memberof PIXI.utils
+   * @function destroyTextureCache
+   */
+  function destroyTextureCache() {
+      var key;
+      for (key in TextureCache) {
+          TextureCache[key].destroy();
+      }
+      for (key in BaseTextureCache) {
+          BaseTextureCache[key].destroy();
+      }
   }
-  if (host) this.hostname = host;
-};
-
-},{"./util":30,"punycode":25,"querystring":28}],30:[function(require,module,exports){
-'use strict';
-
-module.exports = {
-  isString: function(arg) {
-    return typeof(arg) === 'string';
-  },
-  isObject: function(arg) {
-    return typeof(arg) === 'object' && arg !== null;
-  },
-  isNull: function(arg) {
-    return arg === null;
-  },
-  isNullOrUndefined: function(arg) {
-    return arg == null;
+  /**
+   * Removes all textures from cache, but does not destroy them
+   * @memberof PIXI.utils
+   * @function clearTextureCache
+   */
+  function clearTextureCache() {
+      var key;
+      for (key in TextureCache) {
+          delete TextureCache[key];
+      }
+      for (key in BaseTextureCache) {
+          delete BaseTextureCache[key];
+      }
   }
-};
 
-},{}],31:[function(require,module,exports){
-'use strict'
-
-/**
- * Remove a range of items from an array
- *
- * @function removeItems
- * @param {Array<*>} arr The target array
- * @param {number} startIdx The index to begin removing from (inclusive)
- * @param {number} removeCount How many items to remove
- */
-module.exports = function removeItems(arr, startIdx, removeCount)
-{
-  var i, length = arr.length
+  /**
+   * Creates a Canvas element of the given size to be used as a target for rendering to.
+   * @class
+   * @memberof PIXI.utils
+   */
+  var CanvasRenderTarget = /** @class */ (function () {
+      /**
+       * @param width - the width for the newly created canvas
+       * @param height - the height for the newly created canvas
+       * @param {number} [resolution=PIXI.settings.RESOLUTION] - The resolution / device pixel ratio of the canvas
+       */
+      function CanvasRenderTarget(width, height, resolution) {
+          this.canvas = settings.ADAPTER.createCanvas();
+          this.context = this.canvas.getContext('2d');
+          this.resolution = resolution || settings.RESOLUTION;
+          this.resize(width, height);
+      }
+      /**
+       * Clears the canvas that was created by the CanvasRenderTarget class.
+       * @private
+       */
+      CanvasRenderTarget.prototype.clear = function () {
+          this.context.setTransform(1, 0, 0, 1, 0, 0);
+          this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+      };
+      /**
+       * Resizes the canvas to the specified width and height.
+       * @param desiredWidth - the desired width of the canvas
+       * @param desiredHeight - the desired height of the canvas
+       */
+      CanvasRenderTarget.prototype.resize = function (desiredWidth, desiredHeight) {
+          this.canvas.width = Math.round(desiredWidth * this.resolution);
+          this.canvas.height = Math.round(desiredHeight * this.resolution);
+      };
+      /** Destroys this canvas. */
+      CanvasRenderTarget.prototype.destroy = function () {
+          this.context = null;
+          this.canvas = null;
+      };
+      Object.defineProperty(CanvasRenderTarget.prototype, "width", {
+          /**
+           * The width of the canvas buffer in pixels.
+           * @member {number}
+           */
+          get: function () {
+              return this.canvas.width;
+          },
+          set: function (val) {
+              this.canvas.width = Math.round(val);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(CanvasRenderTarget.prototype, "height", {
+          /**
+           * The height of the canvas buffer in pixels.
+           * @member {number}
+           */
+          get: function () {
+              return this.canvas.height;
+          },
+          set: function (val) {
+              this.canvas.height = Math.round(val);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return CanvasRenderTarget;
+  }());
 
-  if (startIdx >= length || removeCount === 0) {
-    return
+  /**
+   * Trim transparent borders from a canvas
+   * @memberof PIXI.utils
+   * @function trimCanvas
+   * @param {HTMLCanvasElement} canvas - the canvas to trim
+   * @returns {object} Trim data
+   */
+  function trimCanvas(canvas) {
+      // https://gist.github.com/remy/784508
+      var width = canvas.width;
+      var height = canvas.height;
+      var context = canvas.getContext('2d', {
+          willReadFrequently: true,
+      });
+      var imageData = context.getImageData(0, 0, width, height);
+      var pixels = imageData.data;
+      var len = pixels.length;
+      var bound = {
+          top: null,
+          left: null,
+          right: null,
+          bottom: null,
+      };
+      var data = null;
+      var i;
+      var x;
+      var y;
+      for (i = 0; i < len; i += 4) {
+          if (pixels[i + 3] !== 0) {
+              x = (i / 4) % width;
+              y = ~~((i / 4) / width);
+              if (bound.top === null) {
+                  bound.top = y;
+              }
+              if (bound.left === null) {
+                  bound.left = x;
+              }
+              else if (x < bound.left) {
+                  bound.left = x;
+              }
+              if (bound.right === null) {
+                  bound.right = x + 1;
+              }
+              else if (bound.right < x) {
+                  bound.right = x + 1;
+              }
+              if (bound.bottom === null) {
+                  bound.bottom = y;
+              }
+              else if (bound.bottom < y) {
+                  bound.bottom = y;
+              }
+          }
+      }
+      if (bound.top !== null) {
+          width = bound.right - bound.left;
+          height = bound.bottom - bound.top + 1;
+          data = context.getImageData(bound.left, bound.top, width, height);
+      }
+      return {
+          height: height,
+          width: width,
+          data: data,
+      };
   }
 
-  removeCount = (startIdx + removeCount > length ? length - startIdx : removeCount)
-
-  var len = length - removeCount
+  /**
+   * Regexp for data URI.
+   * Based on: {@link https://github.com/ragingwind/data-uri-regex}
+   * @static
+   * @constant {RegExp|string} DATA_URI
+   * @memberof PIXI
+   * @example data:image/png;base64
+   */
+  var DATA_URI = /^\s*data:(?:([\w-]+)\/([\w+.-]+))?(?:;charset=([\w-]+))?(?:;(base64))?,(.*)/i;
 
-  for (i = startIdx; i < len; ++i) {
-    arr[i] = arr[i + removeCount]
+  /**
+   * @memberof PIXI.utils
+   * @interface DecomposedDataUri
+   */
+  /**
+   * type, eg. `image`
+   * @memberof PIXI.utils.DecomposedDataUri#
+   * @member {string} mediaType
+   */
+  /**
+   * Sub type, eg. `png`
+   * @memberof PIXI.utils.DecomposedDataUri#
+   * @member {string} subType
+   */
+  /**
+   * @memberof PIXI.utils.DecomposedDataUri#
+   * @member {string} charset
+   */
+  /**
+   * Data encoding, eg. `base64`
+   * @memberof PIXI.utils.DecomposedDataUri#
+   * @member {string} encoding
+   */
+  /**
+   * The actual data
+   * @memberof PIXI.utils.DecomposedDataUri#
+   * @member {string} data
+   */
+  /**
+   * Split a data URI into components. Returns undefined if
+   * parameter `dataUri` is not a valid data URI.
+   * @memberof PIXI.utils
+   * @function decomposeDataUri
+   * @param {string} dataUri - the data URI to check
+   * @returns {PIXI.utils.DecomposedDataUri|undefined} The decomposed data uri or undefined
+   */
+  function decomposeDataUri(dataUri) {
+      var dataUriMatch = DATA_URI.exec(dataUri);
+      if (dataUriMatch) {
+          return {
+              mediaType: dataUriMatch[1] ? dataUriMatch[1].toLowerCase() : undefined,
+              subType: dataUriMatch[2] ? dataUriMatch[2].toLowerCase() : undefined,
+              charset: dataUriMatch[3] ? dataUriMatch[3].toLowerCase() : undefined,
+              encoding: dataUriMatch[4] ? dataUriMatch[4].toLowerCase() : undefined,
+              data: dataUriMatch[5],
+          };
+      }
+      return undefined;
   }
 
-  arr.length = len
-}
-
-},{}],32:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-var _miniSignals = require('mini-signals');
-
-var _miniSignals2 = _interopRequireDefault(_miniSignals);
-
-var _parseUri = require('parse-uri');
+  var tempAnchor$1;
+  /**
+   * Sets the `crossOrigin` property for this resource based on if the url
+   * for this resource is cross-origin. If crossOrigin was manually set, this
+   * function does nothing.
+   * Nipped from the resource loader!
+   * @ignore
+   * @param {string} url - The url to test.
+   * @param {object} [loc=window.location] - The location object to test against.
+   * @returns {string} The crossOrigin value to use (or empty string for none).
+   */
+  function determineCrossOrigin(url$1, loc) {
+      if (loc === void 0) { loc = globalThis.location; }
+      // data: and javascript: urls are considered same-origin
+      if (url$1.indexOf('data:') === 0) {
+          return '';
+      }
+      // default is window.location
+      loc = loc || globalThis.location;
+      if (!tempAnchor$1) {
+          tempAnchor$1 = document.createElement('a');
+      }
+      // let the browser determine the full href for the url of this resource and then
+      // parse with the node url lib, we can't use the properties of the anchor element
+      // because they don't work in IE9 :(
+      tempAnchor$1.href = url$1;
+      var parsedUrl = url.parse(tempAnchor$1.href);
+      var samePort = (!parsedUrl.port && loc.port === '') || (parsedUrl.port === loc.port);
+      // if cross origin
+      if (parsedUrl.hostname !== loc.hostname || !samePort || parsedUrl.protocol !== loc.protocol) {
+          return 'anonymous';
+      }
+      return '';
+  }
 
-var _parseUri2 = _interopRequireDefault(_parseUri);
+  /**
+   * get the resolution / device pixel ratio of an asset by looking for the prefix
+   * used by spritesheets and image urls
+   * @memberof PIXI.utils
+   * @function getResolutionOfUrl
+   * @param {string} url - the image path
+   * @param {number} [defaultValue=1] - the defaultValue if no filename prefix is set.
+   * @returns {number} resolution / device pixel ratio of an asset
+   */
+  function getResolutionOfUrl(url, defaultValue) {
+      var resolution = settings.RETINA_PREFIX.exec(url);
+      if (resolution) {
+          return parseFloat(resolution[1]);
+      }
+      return defaultValue !== undefined ? defaultValue : 1;
+  }
 
-var _async = require('./async');
+  var utils = {
+    __proto__: null,
+    BaseTextureCache: BaseTextureCache,
+    CanvasRenderTarget: CanvasRenderTarget,
+    DATA_URI: DATA_URI,
+    ProgramCache: ProgramCache,
+    TextureCache: TextureCache,
+    clearTextureCache: clearTextureCache,
+    correctBlendMode: correctBlendMode,
+    createIndicesForQuads: createIndicesForQuads,
+    decomposeDataUri: decomposeDataUri,
+    deprecation: deprecation,
+    destroyTextureCache: destroyTextureCache,
+    determineCrossOrigin: determineCrossOrigin,
+    getBufferType: getBufferType,
+    getResolutionOfUrl: getResolutionOfUrl,
+    hex2rgb: hex2rgb,
+    hex2string: hex2string,
+    interleaveTypedArrays: interleaveTypedArrays$1,
+    isPow2: isPow2,
+    isWebGLSupported: isWebGLSupported,
+    log2: log2,
+    nextPow2: nextPow2,
+    path: path,
+    premultiplyBlendMode: premultiplyBlendMode,
+    premultiplyRgba: premultiplyRgba,
+    premultiplyTint: premultiplyTint,
+    premultiplyTintToRgba: premultiplyTintToRgba,
+    removeItems: removeItems,
+    rgb2hex: rgb2hex,
+    sayHello: sayHello,
+    sign: sign,
+    skipHello: skipHello,
+    string2hex: string2hex,
+    trimCanvas: trimCanvas,
+    uid: uid,
+    url: url,
+    isMobile: isMobile,
+    EventEmitter: eventemitter3,
+    earcut: earcut_1
+  };
 
-var async = _interopRequireWildcard(_async);
+  /*!
+   * @pixi/math - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/math is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
+  /**
+   * Two Pi.
+   * @static
+   * @member {number}
+   * @memberof PIXI
+   */
+  var PI_2 = Math.PI * 2;
+  /**
+   * Conversion factor for converting radians to degrees.
+   * @static
+   * @member {number} RAD_TO_DEG
+   * @memberof PIXI
+   */
+  var RAD_TO_DEG = 180 / Math.PI;
+  /**
+   * Conversion factor for converting degrees to radians.
+   * @static
+   * @member {number}
+   * @memberof PIXI
+   */
+  var DEG_TO_RAD = Math.PI / 180;
+  /**
+   * Constants that identify shapes, mainly to prevent `instanceof` calls.
+   * @static
+   * @memberof PIXI
+   * @enum {number}
+   * @property {number} POLY Polygon
+   * @property {number} RECT Rectangle
+   * @property {number} CIRC Circle
+   * @property {number} ELIP Ellipse
+   * @property {number} RREC Rounded Rectangle
+   */
+  exports.SHAPES = void 0;
+  (function (SHAPES) {
+      SHAPES[SHAPES["POLY"] = 0] = "POLY";
+      SHAPES[SHAPES["RECT"] = 1] = "RECT";
+      SHAPES[SHAPES["CIRC"] = 2] = "CIRC";
+      SHAPES[SHAPES["ELIP"] = 3] = "ELIP";
+      SHAPES[SHAPES["RREC"] = 4] = "RREC";
+  })(exports.SHAPES || (exports.SHAPES = {}));
 
-var _Resource = require('./Resource');
+  /**
+   * The Point object represents a location in a two-dimensional coordinate system, where `x` represents
+   * the position on the horizontal axis and `y` represents the position on the vertical axis
+   * @class
+   * @memberof PIXI
+   * @implements {IPoint}
+   */
+  var Point = /** @class */ (function () {
+      /**
+       * Creates a new `Point`
+       * @param {number} [x=0] - position of the point on the x axis
+       * @param {number} [y=0] - position of the point on the y axis
+       */
+      function Point(x, y) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          /** Position of the point on the x axis */
+          this.x = 0;
+          /** Position of the point on the y axis */
+          this.y = 0;
+          this.x = x;
+          this.y = y;
+      }
+      /**
+       * Creates a clone of this point
+       * @returns A clone of this point
+       */
+      Point.prototype.clone = function () {
+          return new Point(this.x, this.y);
+      };
+      /**
+       * Copies `x` and `y` from the given point into this point
+       * @param p - The point to copy from
+       * @returns The point instance itself
+       */
+      Point.prototype.copyFrom = function (p) {
+          this.set(p.x, p.y);
+          return this;
+      };
+      /**
+       * Copies this point's x and y into the given point (`p`).
+       * @param p - The point to copy to. Can be any of type that is or extends `IPointData`
+       * @returns The point (`p`) with values updated
+       */
+      Point.prototype.copyTo = function (p) {
+          p.set(this.x, this.y);
+          return p;
+      };
+      /**
+       * Accepts another point (`p`) and returns `true` if the given point is equal to this point
+       * @param p - The point to check
+       * @returns Returns `true` if both `x` and `y` are equal
+       */
+      Point.prototype.equals = function (p) {
+          return (p.x === this.x) && (p.y === this.y);
+      };
+      /**
+       * Sets the point to a new `x` and `y` position.
+       * If `y` is omitted, both `x` and `y` will be set to `x`.
+       * @param {number} [x=0] - position of the point on the `x` axis
+       * @param {number} [y=x] - position of the point on the `y` axis
+       * @returns The point instance itself
+       */
+      Point.prototype.set = function (x, y) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = x; }
+          this.x = x;
+          this.y = y;
+          return this;
+      };
+      Point.prototype.toString = function () {
+          return "[@pixi/math:Point x=" + this.x + " y=" + this.y + "]";
+      };
+      return Point;
+  }());
+
+  var tempPoints$1 = [new Point(), new Point(), new Point(), new Point()];
+  /**
+   * Size object, contains width and height
+   * @memberof PIXI
+   * @typedef {object} ISize
+   * @property {number} width - Width component
+   * @property {number} height - Height component
+   */
+  /**
+   * Rectangle object is an area defined by its position, as indicated by its top-left corner
+   * point (x, y) and by its width and its height.
+   * @memberof PIXI
+   */
+  var Rectangle = /** @class */ (function () {
+      /**
+       * @param x - The X coordinate of the upper-left corner of the rectangle
+       * @param y - The Y coordinate of the upper-left corner of the rectangle
+       * @param width - The overall width of the rectangle
+       * @param height - The overall height of the rectangle
+       */
+      function Rectangle(x, y, width, height) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          if (width === void 0) { width = 0; }
+          if (height === void 0) { height = 0; }
+          this.x = Number(x);
+          this.y = Number(y);
+          this.width = Number(width);
+          this.height = Number(height);
+          this.type = exports.SHAPES.RECT;
+      }
+      Object.defineProperty(Rectangle.prototype, "left", {
+          /** Returns the left edge of the rectangle. */
+          get: function () {
+              return this.x;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Rectangle.prototype, "right", {
+          /** Returns the right edge of the rectangle. */
+          get: function () {
+              return this.x + this.width;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Rectangle.prototype, "top", {
+          /** Returns the top edge of the rectangle. */
+          get: function () {
+              return this.y;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Rectangle.prototype, "bottom", {
+          /** Returns the bottom edge of the rectangle. */
+          get: function () {
+              return this.y + this.height;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Rectangle, "EMPTY", {
+          /** A constant empty rectangle. */
+          get: function () {
+              return new Rectangle(0, 0, 0, 0);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Creates a clone of this Rectangle
+       * @returns a copy of the rectangle
+       */
+      Rectangle.prototype.clone = function () {
+          return new Rectangle(this.x, this.y, this.width, this.height);
+      };
+      /**
+       * Copies another rectangle to this one.
+       * @param rectangle - The rectangle to copy from.
+       * @returns Returns itself.
+       */
+      Rectangle.prototype.copyFrom = function (rectangle) {
+          this.x = rectangle.x;
+          this.y = rectangle.y;
+          this.width = rectangle.width;
+          this.height = rectangle.height;
+          return this;
+      };
+      /**
+       * Copies this rectangle to another one.
+       * @param rectangle - The rectangle to copy to.
+       * @returns Returns given parameter.
+       */
+      Rectangle.prototype.copyTo = function (rectangle) {
+          rectangle.x = this.x;
+          rectangle.y = this.y;
+          rectangle.width = this.width;
+          rectangle.height = this.height;
+          return rectangle;
+      };
+      /**
+       * Checks whether the x and y coordinates given are contained within this Rectangle
+       * @param x - The X coordinate of the point to test
+       * @param y - The Y coordinate of the point to test
+       * @returns Whether the x/y coordinates are within this Rectangle
+       */
+      Rectangle.prototype.contains = function (x, y) {
+          if (this.width <= 0 || this.height <= 0) {
+              return false;
+          }
+          if (x >= this.x && x < this.x + this.width) {
+              if (y >= this.y && y < this.y + this.height) {
+                  return true;
+              }
+          }
+          return false;
+      };
+      /**
+       * Determines whether the `other` Rectangle transformed by `transform` intersects with `this` Rectangle object.
+       * Returns true only if the area of the intersection is >0, this means that Rectangles
+       * sharing a side are not overlapping. Another side effect is that an arealess rectangle
+       * (width or height equal to zero) can't intersect any other rectangle.
+       * @param {Rectangle} other - The Rectangle to intersect with `this`.
+       * @param {Matrix} transform - The transformation matrix of `other`.
+       * @returns {boolean} A value of `true` if the transformed `other` Rectangle intersects with `this`; otherwise `false`.
+       */
+      Rectangle.prototype.intersects = function (other, transform) {
+          if (!transform) {
+              var x0_1 = this.x < other.x ? other.x : this.x;
+              var x1_1 = this.right > other.right ? other.right : this.right;
+              if (x1_1 <= x0_1) {
+                  return false;
+              }
+              var y0_1 = this.y < other.y ? other.y : this.y;
+              var y1_1 = this.bottom > other.bottom ? other.bottom : this.bottom;
+              return y1_1 > y0_1;
+          }
+          var x0 = this.left;
+          var x1 = this.right;
+          var y0 = this.top;
+          var y1 = this.bottom;
+          if (x1 <= x0 || y1 <= y0) {
+              return false;
+          }
+          var lt = tempPoints$1[0].set(other.left, other.top);
+          var lb = tempPoints$1[1].set(other.left, other.bottom);
+          var rt = tempPoints$1[2].set(other.right, other.top);
+          var rb = tempPoints$1[3].set(other.right, other.bottom);
+          if (rt.x <= lt.x || lb.y <= lt.y) {
+              return false;
+          }
+          var s = Math.sign((transform.a * transform.d) - (transform.b * transform.c));
+          if (s === 0) {
+              return false;
+          }
+          transform.apply(lt, lt);
+          transform.apply(lb, lb);
+          transform.apply(rt, rt);
+          transform.apply(rb, rb);
+          if (Math.max(lt.x, lb.x, rt.x, rb.x) <= x0
+              || Math.min(lt.x, lb.x, rt.x, rb.x) >= x1
+              || Math.max(lt.y, lb.y, rt.y, rb.y) <= y0
+              || Math.min(lt.y, lb.y, rt.y, rb.y) >= y1) {
+              return false;
+          }
+          var nx = s * (lb.y - lt.y);
+          var ny = s * (lt.x - lb.x);
+          var n00 = (nx * x0) + (ny * y0);
+          var n10 = (nx * x1) + (ny * y0);
+          var n01 = (nx * x0) + (ny * y1);
+          var n11 = (nx * x1) + (ny * y1);
+          if (Math.max(n00, n10, n01, n11) <= (nx * lt.x) + (ny * lt.y)
+              || Math.min(n00, n10, n01, n11) >= (nx * rb.x) + (ny * rb.y)) {
+              return false;
+          }
+          var mx = s * (lt.y - rt.y);
+          var my = s * (rt.x - lt.x);
+          var m00 = (mx * x0) + (my * y0);
+          var m10 = (mx * x1) + (my * y0);
+          var m01 = (mx * x0) + (my * y1);
+          var m11 = (mx * x1) + (my * y1);
+          if (Math.max(m00, m10, m01, m11) <= (mx * lt.x) + (my * lt.y)
+              || Math.min(m00, m10, m01, m11) >= (mx * rb.x) + (my * rb.y)) {
+              return false;
+          }
+          return true;
+      };
+      /**
+       * Pads the rectangle making it grow in all directions.
+       * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
+       * @param paddingX - The horizontal padding amount.
+       * @param paddingY - The vertical padding amount.
+       * @returns Returns itself.
+       */
+      Rectangle.prototype.pad = function (paddingX, paddingY) {
+          if (paddingX === void 0) { paddingX = 0; }
+          if (paddingY === void 0) { paddingY = paddingX; }
+          this.x -= paddingX;
+          this.y -= paddingY;
+          this.width += paddingX * 2;
+          this.height += paddingY * 2;
+          return this;
+      };
+      /**
+       * Fits this rectangle around the passed one.
+       * @param rectangle - The rectangle to fit.
+       * @returns Returns itself.
+       */
+      Rectangle.prototype.fit = function (rectangle) {
+          var x1 = Math.max(this.x, rectangle.x);
+          var x2 = Math.min(this.x + this.width, rectangle.x + rectangle.width);
+          var y1 = Math.max(this.y, rectangle.y);
+          var y2 = Math.min(this.y + this.height, rectangle.y + rectangle.height);
+          this.x = x1;
+          this.width = Math.max(x2 - x1, 0);
+          this.y = y1;
+          this.height = Math.max(y2 - y1, 0);
+          return this;
+      };
+      /**
+       * Enlarges rectangle that way its corners lie on grid
+       * @param resolution - resolution
+       * @param eps - precision
+       * @returns Returns itself.
+       */
+      Rectangle.prototype.ceil = function (resolution, eps) {
+          if (resolution === void 0) { resolution = 1; }
+          if (eps === void 0) { eps = 0.001; }
+          var x2 = Math.ceil((this.x + this.width - eps) * resolution) / resolution;
+          var y2 = Math.ceil((this.y + this.height - eps) * resolution) / resolution;
+          this.x = Math.floor((this.x + eps) * resolution) / resolution;
+          this.y = Math.floor((this.y + eps) * resolution) / resolution;
+          this.width = x2 - this.x;
+          this.height = y2 - this.y;
+          return this;
+      };
+      /**
+       * Enlarges this rectangle to include the passed rectangle.
+       * @param rectangle - The rectangle to include.
+       * @returns Returns itself.
+       */
+      Rectangle.prototype.enlarge = function (rectangle) {
+          var x1 = Math.min(this.x, rectangle.x);
+          var x2 = Math.max(this.x + this.width, rectangle.x + rectangle.width);
+          var y1 = Math.min(this.y, rectangle.y);
+          var y2 = Math.max(this.y + this.height, rectangle.y + rectangle.height);
+          this.x = x1;
+          this.width = x2 - x1;
+          this.y = y1;
+          this.height = y2 - y1;
+          return this;
+      };
+      Rectangle.prototype.toString = function () {
+          return "[@pixi/math:Rectangle x=" + this.x + " y=" + this.y + " width=" + this.width + " height=" + this.height + "]";
+      };
+      return Rectangle;
+  }());
 
-var _Resource2 = _interopRequireDefault(_Resource);
+  /**
+   * The Circle object is used to help draw graphics and can also be used to specify a hit area for displayObjects.
+   * @memberof PIXI
+   */
+  var Circle = /** @class */ (function () {
+      /**
+       * @param x - The X coordinate of the center of this circle
+       * @param y - The Y coordinate of the center of this circle
+       * @param radius - The radius of the circle
+       */
+      function Circle(x, y, radius) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          if (radius === void 0) { radius = 0; }
+          this.x = x;
+          this.y = y;
+          this.radius = radius;
+          this.type = exports.SHAPES.CIRC;
+      }
+      /**
+       * Creates a clone of this Circle instance
+       * @returns A copy of the Circle
+       */
+      Circle.prototype.clone = function () {
+          return new Circle(this.x, this.y, this.radius);
+      };
+      /**
+       * Checks whether the x and y coordinates given are contained within this circle
+       * @param x - The X coordinate of the point to test
+       * @param y - The Y coordinate of the point to test
+       * @returns Whether the x/y coordinates are within this Circle
+       */
+      Circle.prototype.contains = function (x, y) {
+          if (this.radius <= 0) {
+              return false;
+          }
+          var r2 = this.radius * this.radius;
+          var dx = (this.x - x);
+          var dy = (this.y - y);
+          dx *= dx;
+          dy *= dy;
+          return (dx + dy <= r2);
+      };
+      /**
+       * Returns the framing rectangle of the circle as a Rectangle object
+       * @returns The framing rectangle
+       */
+      Circle.prototype.getBounds = function () {
+          return new Rectangle(this.x - this.radius, this.y - this.radius, this.radius * 2, this.radius * 2);
+      };
+      Circle.prototype.toString = function () {
+          return "[@pixi/math:Circle x=" + this.x + " y=" + this.y + " radius=" + this.radius + "]";
+      };
+      return Circle;
+  }());
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+  /**
+   * The Ellipse object is used to help draw graphics and can also be used to specify a hit area for displayObjects.
+   * @memberof PIXI
+   */
+  var Ellipse = /** @class */ (function () {
+      /**
+       * @param x - The X coordinate of the center of this ellipse
+       * @param y - The Y coordinate of the center of this ellipse
+       * @param halfWidth - The half width of this ellipse
+       * @param halfHeight - The half height of this ellipse
+       */
+      function Ellipse(x, y, halfWidth, halfHeight) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          if (halfWidth === void 0) { halfWidth = 0; }
+          if (halfHeight === void 0) { halfHeight = 0; }
+          this.x = x;
+          this.y = y;
+          this.width = halfWidth;
+          this.height = halfHeight;
+          this.type = exports.SHAPES.ELIP;
+      }
+      /**
+       * Creates a clone of this Ellipse instance
+       * @returns {PIXI.Ellipse} A copy of the ellipse
+       */
+      Ellipse.prototype.clone = function () {
+          return new Ellipse(this.x, this.y, this.width, this.height);
+      };
+      /**
+       * Checks whether the x and y coordinates given are contained within this ellipse
+       * @param x - The X coordinate of the point to test
+       * @param y - The Y coordinate of the point to test
+       * @returns Whether the x/y coords are within this ellipse
+       */
+      Ellipse.prototype.contains = function (x, y) {
+          if (this.width <= 0 || this.height <= 0) {
+              return false;
+          }
+          // normalize the coords to an ellipse with center 0,0
+          var normx = ((x - this.x) / this.width);
+          var normy = ((y - this.y) / this.height);
+          normx *= normx;
+          normy *= normy;
+          return (normx + normy <= 1);
+      };
+      /**
+       * Returns the framing rectangle of the ellipse as a Rectangle object
+       * @returns The framing rectangle
+       */
+      Ellipse.prototype.getBounds = function () {
+          return new Rectangle(this.x - this.width, this.y - this.height, this.width, this.height);
+      };
+      Ellipse.prototype.toString = function () {
+          return "[@pixi/math:Ellipse x=" + this.x + " y=" + this.y + " width=" + this.width + " height=" + this.height + "]";
+      };
+      return Ellipse;
+  }());
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  /**
+   * A class to define a shape via user defined coordinates.
+   * @memberof PIXI
+   */
+  var Polygon = /** @class */ (function () {
+      /**
+       * @param {PIXI.IPointData[]|number[]} points - This can be an array of Points
+       *  that form the polygon, a flat array of numbers that will be interpreted as [x,y, x,y, ...], or
+       *  the arguments passed can be all the points of the polygon e.g.
+       *  `new PIXI.Polygon(new PIXI.Point(), new PIXI.Point(), ...)`, or the arguments passed can be flat
+       *  x,y values e.g. `new Polygon(x,y, x,y, x,y, ...)` where `x` and `y` are Numbers.
+       */
+      function Polygon() {
+          var arguments$1 = arguments;
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+          var points = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              points[_i] = arguments$1[_i];
+          }
+          var flat = Array.isArray(points[0]) ? points[0] : points;
+          // if this is an array of points, convert it to a flat array of numbers
+          if (typeof flat[0] !== 'number') {
+              var p = [];
+              for (var i = 0, il = flat.length; i < il; i++) {
+                  p.push(flat[i].x, flat[i].y);
+              }
+              flat = p;
+          }
+          this.points = flat;
+          this.type = exports.SHAPES.POLY;
+          this.closeStroke = true;
+      }
+      /**
+       * Creates a clone of this polygon.
+       * @returns - A copy of the polygon.
+       */
+      Polygon.prototype.clone = function () {
+          var points = this.points.slice();
+          var polygon = new Polygon(points);
+          polygon.closeStroke = this.closeStroke;
+          return polygon;
+      };
+      /**
+       * Checks whether the x and y coordinates passed to this function are contained within this polygon.
+       * @param x - The X coordinate of the point to test.
+       * @param y - The Y coordinate of the point to test.
+       * @returns - Whether the x/y coordinates are within this polygon.
+       */
+      Polygon.prototype.contains = function (x, y) {
+          var inside = false;
+          // use some raycasting to test hits
+          // https://github.com/substack/point-in-polygon/blob/master/index.js
+          var length = this.points.length / 2;
+          for (var i = 0, j = length - 1; i < length; j = i++) {
+              var xi = this.points[i * 2];
+              var yi = this.points[(i * 2) + 1];
+              var xj = this.points[j * 2];
+              var yj = this.points[(j * 2) + 1];
+              var intersect = ((yi > y) !== (yj > y)) && (x < ((xj - xi) * ((y - yi) / (yj - yi))) + xi);
+              if (intersect) {
+                  inside = !inside;
+              }
+          }
+          return inside;
+      };
+      Polygon.prototype.toString = function () {
+          return "[@pixi/math:Polygon"
+              + ("closeStroke=" + this.closeStroke)
+              + ("points=" + this.points.reduce(function (pointsDesc, currentPoint) { return pointsDesc + ", " + currentPoint; }, '') + "]");
+      };
+      return Polygon;
+  }());
 
-// some constants
-var MAX_PROGRESS = 100;
-var rgxExtractUrlHash = /(#[\w-]+)?$/;
+  /**
+   * The Rounded Rectangle object is an area that has nice rounded corners, as indicated by its
+   * top-left corner point (x, y) and by its width and its height and its radius.
+   * @memberof PIXI
+   */
+  var RoundedRectangle = /** @class */ (function () {
+      /**
+       * @param x - The X coordinate of the upper-left corner of the rounded rectangle
+       * @param y - The Y coordinate of the upper-left corner of the rounded rectangle
+       * @param width - The overall width of this rounded rectangle
+       * @param height - The overall height of this rounded rectangle
+       * @param radius - Controls the radius of the rounded corners
+       */
+      function RoundedRectangle(x, y, width, height, radius) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          if (width === void 0) { width = 0; }
+          if (height === void 0) { height = 0; }
+          if (radius === void 0) { radius = 20; }
+          this.x = x;
+          this.y = y;
+          this.width = width;
+          this.height = height;
+          this.radius = radius;
+          this.type = exports.SHAPES.RREC;
+      }
+      /**
+       * Creates a clone of this Rounded Rectangle.
+       * @returns - A copy of the rounded rectangle.
+       */
+      RoundedRectangle.prototype.clone = function () {
+          return new RoundedRectangle(this.x, this.y, this.width, this.height, this.radius);
+      };
+      /**
+       * Checks whether the x and y coordinates given are contained within this Rounded Rectangle
+       * @param x - The X coordinate of the point to test.
+       * @param y - The Y coordinate of the point to test.
+       * @returns - Whether the x/y coordinates are within this Rounded Rectangle.
+       */
+      RoundedRectangle.prototype.contains = function (x, y) {
+          if (this.width <= 0 || this.height <= 0) {
+              return false;
+          }
+          if (x >= this.x && x <= this.x + this.width) {
+              if (y >= this.y && y <= this.y + this.height) {
+                  var radius = Math.max(0, Math.min(this.radius, Math.min(this.width, this.height) / 2));
+                  if ((y >= this.y + radius && y <= this.y + this.height - radius)
+                      || (x >= this.x + radius && x <= this.x + this.width - radius)) {
+                      return true;
+                  }
+                  var dx = x - (this.x + radius);
+                  var dy = y - (this.y + radius);
+                  var radius2 = radius * radius;
+                  if ((dx * dx) + (dy * dy) <= radius2) {
+                      return true;
+                  }
+                  dx = x - (this.x + this.width - radius);
+                  if ((dx * dx) + (dy * dy) <= radius2) {
+                      return true;
+                  }
+                  dy = y - (this.y + this.height - radius);
+                  if ((dx * dx) + (dy * dy) <= radius2) {
+                      return true;
+                  }
+                  dx = x - (this.x + radius);
+                  if ((dx * dx) + (dy * dy) <= radius2) {
+                      return true;
+                  }
+              }
+          }
+          return false;
+      };
+      RoundedRectangle.prototype.toString = function () {
+          return "[@pixi/math:RoundedRectangle x=" + this.x + " y=" + this.y
+              + ("width=" + this.width + " height=" + this.height + " radius=" + this.radius + "]");
+      };
+      return RoundedRectangle;
+  }());
 
-/**
- * Manages the state and loading of multiple resources to load.
- *
- * @class
- */
-
-var Loader = function () {
-    /**
-     * @param {string} [baseUrl=''] - The base url for all resources loaded by this loader.
-     * @param {number} [concurrency=10] - The number of resources to load concurrently.
-     */
-    function Loader() {
-        var _this = this;
-
-        var baseUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-        var concurrency = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
-
-        _classCallCheck(this, Loader);
-
-        /**
-         * The base url for all resources loaded by this loader.
-         *
-         * @member {string}
-         */
-        this.baseUrl = baseUrl;
-
-        /**
-         * The progress percent of the loader going through the queue.
-         *
-         * @member {number}
-         */
-        this.progress = 0;
-
-        /**
-         * Loading state of the loader, true if it is currently loading resources.
-         *
-         * @member {boolean}
-         */
-        this.loading = false;
-
-        /**
-         * A querystring to append to every URL added to the loader.
-         *
-         * This should be a valid query string *without* the question-mark (`?`). The loader will
-         * also *not* escape values for you. Make sure to escape your parameters with
-         * [`encodeURIComponent`](https://mdn.io/encodeURIComponent) before assigning this property.
-         *
-         * @example
-         * const loader = new Loader();
-         *
-         * loader.defaultQueryString = 'user=me&password=secret';
-         *
-         * // This will request 'image.png?user=me&password=secret'
-         * loader.add('image.png').load();
-         *
-         * loader.reset();
-         *
-         * // This will request 'image.png?v=1&user=me&password=secret'
-         * loader.add('iamge.png?v=1').load();
-         */
-        this.defaultQueryString = '';
-
-        /**
-         * The middleware to run before loading each resource.
-         *
-         * @member {function[]}
-         */
-        this._beforeMiddleware = [];
-
-        /**
-         * The middleware to run after loading each resource.
-         *
-         * @member {function[]}
-         */
-        this._afterMiddleware = [];
-
-        /**
-         * The tracks the resources we are currently completing parsing for.
-         *
-         * @member {Resource[]}
-         */
-        this._resourcesParsing = [];
-
-        /**
-         * The `_loadResource` function bound with this object context.
-         *
-         * @private
-         * @member {function}
-         * @param {Resource} r - The resource to load
-         * @param {Function} d - The dequeue function
-         * @return {undefined}
-         */
-        this._boundLoadResource = function (r, d) {
-            return _this._loadResource(r, d);
-        };
-
-        /**
-         * The resources waiting to be loaded.
-         *
-         * @private
-         * @member {Resource[]}
-         */
-        this._queue = async.queue(this._boundLoadResource, concurrency);
-
-        this._queue.pause();
-
-        /**
-         * All the resources for this loader keyed by name.
-         *
-         * @member {object<string, Resource>}
-         */
-        this.resources = {};
-
-        /**
-         * Dispatched once per loaded or errored resource.
-         *
-         * The callback looks like {@link Loader.OnProgressSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onProgress = new _miniSignals2.default();
-
-        /**
-         * Dispatched once per errored resource.
-         *
-         * The callback looks like {@link Loader.OnErrorSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onError = new _miniSignals2.default();
-
-        /**
-         * Dispatched once per loaded resource.
-         *
-         * The callback looks like {@link Loader.OnLoadSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onLoad = new _miniSignals2.default();
-
-        /**
-         * Dispatched when the loader begins to process the queue.
-         *
-         * The callback looks like {@link Loader.OnStartSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onStart = new _miniSignals2.default();
-
-        /**
-         * Dispatched when the queued resources all load.
-         *
-         * The callback looks like {@link Loader.OnCompleteSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onComplete = new _miniSignals2.default();
-
-        /**
-         * When the progress changes the loader and resource are disaptched.
-         *
-         * @memberof Loader
-         * @callback OnProgressSignal
-         * @param {Loader} loader - The loader the progress is advancing on.
-         * @param {Resource} resource - The resource that has completed or failed to cause the progress to advance.
-         */
-
-        /**
-         * When an error occurrs the loader and resource are disaptched.
-         *
-         * @memberof Loader
-         * @callback OnErrorSignal
-         * @param {Loader} loader - The loader the error happened in.
-         * @param {Resource} resource - The resource that caused the error.
-         */
-
-        /**
-         * When a load completes the loader and resource are disaptched.
-         *
-         * @memberof Loader
-         * @callback OnLoadSignal
-         * @param {Loader} loader - The loader that laoded the resource.
-         * @param {Resource} resource - The resource that has completed loading.
-         */
-
-        /**
-         * When the loader starts loading resources it dispatches this callback.
-         *
-         * @memberof Loader
-         * @callback OnStartSignal
-         * @param {Loader} loader - The loader that has started loading resources.
-         */
-
-        /**
-         * When the loader completes loading resources it dispatches this callback.
-         *
-         * @memberof Loader
-         * @callback OnCompleteSignal
-         * @param {Loader} loader - The loader that has finished loading resources.
-         */
-    }
-
-    /**
-     * Adds a resource (or multiple resources) to the loader queue.
-     *
-     * This function can take a wide variety of different parameters. The only thing that is always
-     * required the url to load. All the following will work:
-     *
-     * ```js
-     * loader
-     *     // normal param syntax
-     *     .add('key', 'http://...', function () {})
-     *     .add('http://...', function () {})
-     *     .add('http://...')
-     *
-     *     // object syntax
-     *     .add({
-     *         name: 'key2',
-     *         url: 'http://...'
-     *     }, function () {})
-     *     .add({
-     *         url: 'http://...'
-     *     }, function () {})
-     *     .add({
-     *         name: 'key3',
-     *         url: 'http://...'
-     *         onComplete: function () {}
-     *     })
-     *     .add({
-     *         url: 'https://...',
-     *         onComplete: function () {},
-     *         crossOrigin: true
-     *     })
-     *
-     *     // you can also pass an array of objects or urls or both
-     *     .add([
-     *         { name: 'key4', url: 'http://...', onComplete: function () {} },
-     *         { url: 'http://...', onComplete: function () {} },
-     *         'http://...'
-     *     ])
-     *
-     *     // and you can use both params and options
-     *     .add('key', 'http://...', { crossOrigin: true }, function () {})
-     *     .add('http://...', { crossOrigin: true }, function () {});
-     * ```
-     *
-     * @param {string} [name] - The name of the resource to load, if not passed the url is used.
-     * @param {string} [url] - The url for this resource, relative to the baseUrl of this loader.
-     * @param {object} [options] - The options for the load.
-     * @param {boolean} [options.crossOrigin] - Is this request cross-origin? Default is to determine automatically.
-     * @param {Resource.LOAD_TYPE} [options.loadType=Resource.LOAD_TYPE.XHR] - How should this resource be loaded?
-     * @param {Resource.XHR_RESPONSE_TYPE} [options.xhrType=Resource.XHR_RESPONSE_TYPE.DEFAULT] - How should
-     *      the data being loaded be interpreted when using XHR?
-     * @param {object} [options.metadata] - Extra configuration for middleware and the Resource object.
-     * @param {HTMLImageElement|HTMLAudioElement|HTMLVideoElement} [options.metadata.loadElement=null] - The
-     *      element to use for loading, instead of creating one.
-     * @param {boolean} [options.metadata.skipSource=false] - Skips adding source(s) to the load element. This
-     *      is useful if you want to pass in a `loadElement` that you already added load sources to.
-     * @param {function} [cb] - Function to call when this specific resource completes loading.
-     * @return {Loader} Returns itself.
-     */
-
-
-    Loader.prototype.add = function add(name, url, options, cb) {
-        // special case of an array of objects or urls
-        if (Array.isArray(name)) {
-            for (var i = 0; i < name.length; ++i) {
-                this.add(name[i]);
-            }
-
-            return this;
-        }
-
-        // if an object is passed instead of params
-        if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
-            cb = url || name.callback || name.onComplete;
-            options = name;
-            url = name.url;
-            name = name.name || name.key || name.url;
-        }
-
-        // case where no name is passed shift all args over by one.
-        if (typeof url !== 'string') {
-            cb = options;
-            options = url;
-            url = name;
-        }
-
-        // now that we shifted make sure we have a proper url.
-        if (typeof url !== 'string') {
-            throw new Error('No url passed to add resource to loader.');
-        }
-
-        // options are optional so people might pass a function and no options
-        if (typeof options === 'function') {
-            cb = options;
-            options = null;
-        }
-
-        // if loading already you can only add resources that have a parent.
-        if (this.loading && (!options || !options.parentResource)) {
-            throw new Error('Cannot add resources while the loader is running.');
-        }
-
-        // check if resource already exists.
-        if (this.resources[name]) {
-            throw new Error('Resource named "' + name + '" already exists.');
-        }
-
-        // add base url if this isn't an absolute url
-        url = this._prepareUrl(url);
-
-        // create the store the resource
-        this.resources[name] = new _Resource2.default(name, url, options);
-
-        if (typeof cb === 'function') {
-            this.resources[name].onAfterMiddleware.once(cb);
-        }
-
-        // if actively loading, make sure to adjust progress chunks for that parent and its children
-        if (this.loading) {
-            var parent = options.parentResource;
-            var incompleteChildren = [];
-
-            for (var _i = 0; _i < parent.children.length; ++_i) {
-                if (!parent.children[_i].isComplete) {
-                    incompleteChildren.push(parent.children[_i]);
-                }
-            }
-
-            var fullChunk = parent.progressChunk * (incompleteChildren.length + 1); // +1 for parent
-            var eachChunk = fullChunk / (incompleteChildren.length + 2); // +2 for parent & new child
-
-            parent.children.push(this.resources[name]);
-            parent.progressChunk = eachChunk;
-
-            for (var _i2 = 0; _i2 < incompleteChildren.length; ++_i2) {
-                incompleteChildren[_i2].progressChunk = eachChunk;
-            }
-
-            this.resources[name].progressChunk = eachChunk;
-        }
-
-        // add the resource to the queue
-        this._queue.push(this.resources[name]);
-
-        return this;
-    };
-
-    /**
-     * Sets up a middleware function that will run *before* the
-     * resource is loaded.
-     *
-     * @method before
-     * @param {function} fn - The middleware function to register.
-     * @return {Loader} Returns itself.
-     */
-
-
-    Loader.prototype.pre = function pre(fn) {
-        this._beforeMiddleware.push(fn);
-
-        return this;
-    };
-
-    /**
-     * Sets up a middleware function that will run *after* the
-     * resource is loaded.
-     *
-     * @alias use
-     * @method after
-     * @param {function} fn - The middleware function to register.
-     * @return {Loader} Returns itself.
-     */
-
-
-    Loader.prototype.use = function use(fn) {
-        this._afterMiddleware.push(fn);
-
-        return this;
-    };
-
-    /**
-     * Resets the queue of the loader to prepare for a new load.
-     *
-     * @return {Loader} Returns itself.
-     */
-
-
-    Loader.prototype.reset = function reset() {
-        this.progress = 0;
-        this.loading = false;
-
-        this._queue.kill();
-        this._queue.pause();
-
-        // abort all resource loads
-        for (var k in this.resources) {
-            var res = this.resources[k];
-
-            if (res._onLoadBinding) {
-                res._onLoadBinding.detach();
-            }
-
-            if (res.isLoading) {
-                res.abort();
-            }
-        }
-
-        this.resources = {};
-
-        return this;
-    };
-
-    /**
-     * Starts loading the queued resources.
-     *
-     * @param {function} [cb] - Optional callback that will be bound to the `complete` event.
-     * @return {Loader} Returns itself.
-     */
-
-
-    Loader.prototype.load = function load(cb) {
-        // register complete callback if they pass one
-        if (typeof cb === 'function') {
-            this.onComplete.once(cb);
-        }
-
-        // if the queue has already started we are done here
-        if (this.loading) {
-            return this;
-        }
-
-        // distribute progress chunks
-        var chunk = 100 / this._queue._tasks.length;
-
-        for (var i = 0; i < this._queue._tasks.length; ++i) {
-            this._queue._tasks[i].data.progressChunk = chunk;
-        }
-
-        // update loading state
-        this.loading = true;
-
-        // notify of start
-        this.onStart.dispatch(this);
-
-        // start loading
-        this._queue.resume();
-
-        return this;
-    };
-
-    /**
-     * Prepares a url for usage based on the configuration of this object
-     *
-     * @private
-     * @param {string} url - The url to prepare.
-     * @return {string} The prepared url.
-     */
-
-
-    Loader.prototype._prepareUrl = function _prepareUrl(url) {
-        var parsedUrl = (0, _parseUri2.default)(url, { strictMode: true });
-        var result = void 0;
-
-        // absolute url, just use it as is.
-        if (parsedUrl.protocol || !parsedUrl.path || url.indexOf('//') === 0) {
-            result = url;
-        }
-        // if baseUrl doesn't end in slash and url doesn't start with slash, then add a slash inbetween
-        else if (this.baseUrl.length && this.baseUrl.lastIndexOf('/') !== this.baseUrl.length - 1 && url.charAt(0) !== '/') {
-                result = this.baseUrl + '/' + url;
-            } else {
-                result = this.baseUrl + url;
-            }
-
-        // if we need to add a default querystring, there is a bit more work
-        if (this.defaultQueryString) {
-            var hash = rgxExtractUrlHash.exec(result)[0];
-
-            result = result.substr(0, result.length - hash.length);
-
-            if (result.indexOf('?') !== -1) {
-                result += '&' + this.defaultQueryString;
-            } else {
-                result += '?' + this.defaultQueryString;
-            }
-
-            result += hash;
-        }
-
-        return result;
-    };
-
-    /**
-     * Loads a single resource.
-     *
-     * @private
-     * @param {Resource} resource - The resource to load.
-     * @param {function} dequeue - The function to call when we need to dequeue this item.
-     */
-
-
-    Loader.prototype._loadResource = function _loadResource(resource, dequeue) {
-        var _this2 = this;
-
-        resource._dequeue = dequeue;
-
-        // run before middleware
-        async.eachSeries(this._beforeMiddleware, function (fn, next) {
-            fn.call(_this2, resource, function () {
-                // if the before middleware marks the resource as complete,
-                // break and don't process any more before middleware
-                next(resource.isComplete ? {} : null);
-            });
-        }, function () {
-            if (resource.isComplete) {
-                _this2._onLoad(resource);
-            } else {
-                resource._onLoadBinding = resource.onComplete.once(_this2._onLoad, _this2);
-                resource.load();
-            }
-        }, true);
-    };
-
-    /**
-     * Called once each resource has loaded.
-     *
-     * @private
-     */
-
-
-    Loader.prototype._onComplete = function _onComplete() {
-        this.loading = false;
-
-        this.onComplete.dispatch(this, this.resources);
-    };
-
-    /**
-     * Called each time a resources is loaded.
-     *
-     * @private
-     * @param {Resource} resource - The resource that was loaded
-     */
-
-
-    Loader.prototype._onLoad = function _onLoad(resource) {
-        var _this3 = this;
-
-        resource._onLoadBinding = null;
-
-        // remove this resource from the async queue, and add it to our list of resources that are being parsed
-        this._resourcesParsing.push(resource);
-        resource._dequeue();
-
-        // run all the after middleware for this resource
-        async.eachSeries(this._afterMiddleware, function (fn, next) {
-            fn.call(_this3, resource, next);
-        }, function () {
-            resource.onAfterMiddleware.dispatch(resource);
-
-            _this3.progress += resource.progressChunk;
-            _this3.onProgress.dispatch(_this3, resource);
-
-            if (resource.error) {
-                _this3.onError.dispatch(resource.error, _this3, resource);
-            } else {
-                _this3.onLoad.dispatch(_this3, resource);
-            }
-
-            _this3._resourcesParsing.splice(_this3._resourcesParsing.indexOf(resource), 1);
-
-            // do completion check
-            if (_this3._queue.idle() && _this3._resourcesParsing.length === 0) {
-                _this3.progress = MAX_PROGRESS;
-                _this3._onComplete();
-            }
-        }, true);
-    };
-
-    return Loader;
-}();
-
-exports.default = Loader;
-
-},{"./Resource":33,"./async":34,"mini-signals":38,"parse-uri":39}],33:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _parseUri = require('parse-uri');
-
-var _parseUri2 = _interopRequireDefault(_parseUri);
-
-var _miniSignals = require('mini-signals');
-
-var _miniSignals2 = _interopRequireDefault(_miniSignals);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-// tests is CORS is supported in XHR, if not we need to use XDR
-var useXdr = !!(window.XDomainRequest && !('withCredentials' in new XMLHttpRequest()));
-var tempAnchor = null;
-
-// some status constants
-var STATUS_NONE = 0;
-var STATUS_OK = 200;
-var STATUS_EMPTY = 204;
-var STATUS_IE_BUG_EMPTY = 1223;
-var STATUS_TYPE_OK = 2;
-
-// noop
-function _noop() {} /* empty */
-
-/**
- * Manages the state and loading of a resource and all child resources.
- *
- * @class
- */
-
-var Resource = function () {
-    /**
-     * Sets the load type to be used for a specific extension.
-     *
-     * @static
-     * @param {string} extname - The extension to set the type for, e.g. "png" or "fnt"
-     * @param {Resource.LOAD_TYPE} loadType - The load type to set it to.
-     */
-    Resource.setExtensionLoadType = function setExtensionLoadType(extname, loadType) {
-        setExtMap(Resource._loadTypeMap, extname, loadType);
-    };
-
-    /**
-     * Sets the load type to be used for a specific extension.
-     *
-     * @static
-     * @param {string} extname - The extension to set the type for, e.g. "png" or "fnt"
-     * @param {Resource.XHR_RESPONSE_TYPE} xhrType - The xhr type to set it to.
-     */
-
-
-    Resource.setExtensionXhrType = function setExtensionXhrType(extname, xhrType) {
-        setExtMap(Resource._xhrTypeMap, extname, xhrType);
-    };
-
-    /**
-     * @param {string} name - The name of the resource to load.
-     * @param {string|string[]} url - The url for this resource, for audio/video loads you can pass
-     *      an array of sources.
-     * @param {object} [options] - The options for the load.
-     * @param {string|boolean} [options.crossOrigin] - Is this request cross-origin? Default is to
-     *      determine automatically.
-     * @param {Resource.LOAD_TYPE} [options.loadType=Resource.LOAD_TYPE.XHR] - How should this resource
-     *      be loaded?
-     * @param {Resource.XHR_RESPONSE_TYPE} [options.xhrType=Resource.XHR_RESPONSE_TYPE.DEFAULT] - How
-     *      should the data being loaded be interpreted when using XHR?
-     * @param {object} [options.metadata] - Extra configuration for middleware and the Resource object.
-     * @param {HTMLImageElement|HTMLAudioElement|HTMLVideoElement} [options.metadata.loadElement=null] - The
-     *      element to use for loading, instead of creating one.
-     * @param {boolean} [options.metadata.skipSource=false] - Skips adding source(s) to the load element. This
-     *      is useful if you want to pass in a `loadElement` that you already added load sources to.
-     * @param {string|string[]} [options.metadata.mimeType] - The mime type to use for the source element of a video/audio
-     *      elment. If the urls are an array, you can pass this as an array as well where each index is the mime type to
-     *      use for the corresponding url index.
-     */
-
-
-    function Resource(name, url, options) {
-        _classCallCheck(this, Resource);
-
-        if (typeof name !== 'string' || typeof url !== 'string') {
-            throw new Error('Both name and url are required for constructing a resource.');
-        }
-
-        options = options || {};
-
-        /**
-         * The state flags of this resource.
-         *
-         * @member {number}
-         */
-        this._flags = 0;
-
-        // set data url flag, needs to be set early for some _determineX checks to work.
-        this._setFlag(Resource.STATUS_FLAGS.DATA_URL, url.indexOf('data:') === 0);
-
-        /**
-         * The name of this resource.
-         *
-         * @member {string}
-         * @readonly
-         */
-        this.name = name;
-
-        /**
-         * The url used to load this resource.
-         *
-         * @member {string}
-         * @readonly
-         */
-        this.url = url;
-
-        /**
-         * The extension used to load this resource.
-         *
-         * @member {string}
-         * @readonly
-         */
-        this.extension = this._getExtension();
-
-        /**
-         * The data that was loaded by the resource.
-         *
-         * @member {any}
-         */
-        this.data = null;
-
-        /**
-         * Is this request cross-origin? If unset, determined automatically.
-         *
-         * @member {string}
-         */
-        this.crossOrigin = options.crossOrigin === true ? 'anonymous' : options.crossOrigin;
-
-        /**
-         * The method of loading to use for this resource.
-         *
-         * @member {Resource.LOAD_TYPE}
-         */
-        this.loadType = options.loadType || this._determineLoadType();
-
-        /**
-         * The type used to load the resource via XHR. If unset, determined automatically.
-         *
-         * @member {string}
-         */
-        this.xhrType = options.xhrType;
-
-        /**
-         * Extra info for middleware, and controlling specifics about how the resource loads.
-         *
-         * Note that if you pass in a `loadElement`, the Resource class takes ownership of it.
-         * Meaning it will modify it as it sees fit.
-         *
-         * @member {object}
-         * @property {HTMLImageElement|HTMLAudioElement|HTMLVideoElement} [loadElement=null] - The
-         *  element to use for loading, instead of creating one.
-         * @property {boolean} [skipSource=false] - Skips adding source(s) to the load element. This
-         *  is useful if you want to pass in a `loadElement` that you already added load sources
-         *  to.
-         */
-        this.metadata = options.metadata || {};
-
-        /**
-         * The error that occurred while loading (if any).
-         *
-         * @member {Error}
-         * @readonly
-         */
-        this.error = null;
-
-        /**
-         * The XHR object that was used to load this resource. This is only set
-         * when `loadType` is `Resource.LOAD_TYPE.XHR`.
-         *
-         * @member {XMLHttpRequest}
-         * @readonly
-         */
-        this.xhr = null;
-
-        /**
-         * The child resources this resource owns.
-         *
-         * @member {Resource[]}
-         * @readonly
-         */
-        this.children = [];
-
-        /**
-         * The resource type.
-         *
-         * @member {Resource.TYPE}
-         * @readonly
-         */
-        this.type = Resource.TYPE.UNKNOWN;
-
-        /**
-         * The progress chunk owned by this resource.
-         *
-         * @member {number}
-         * @readonly
-         */
-        this.progressChunk = 0;
-
-        /**
-         * The `dequeue` method that will be used a storage place for the async queue dequeue method
-         * used privately by the loader.
-         *
-         * @private
-         * @member {function}
-         */
-        this._dequeue = _noop;
-
-        /**
-         * Used a storage place for the on load binding used privately by the loader.
-         *
-         * @private
-         * @member {function}
-         */
-        this._onLoadBinding = null;
-
-        /**
-         * The `complete` function bound to this resource's context.
-         *
-         * @private
-         * @member {function}
-         */
-        this._boundComplete = this.complete.bind(this);
-
-        /**
-         * The `_onError` function bound to this resource's context.
-         *
-         * @private
-         * @member {function}
-         */
-        this._boundOnError = this._onError.bind(this);
-
-        /**
-         * The `_onProgress` function bound to this resource's context.
-         *
-         * @private
-         * @member {function}
-         */
-        this._boundOnProgress = this._onProgress.bind(this);
-
-        // xhr callbacks
-        this._boundXhrOnError = this._xhrOnError.bind(this);
-        this._boundXhrOnAbort = this._xhrOnAbort.bind(this);
-        this._boundXhrOnLoad = this._xhrOnLoad.bind(this);
-        this._boundXdrOnTimeout = this._xdrOnTimeout.bind(this);
-
-        /**
-         * Dispatched when the resource beings to load.
-         *
-         * The callback looks like {@link Resource.OnStartSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onStart = new _miniSignals2.default();
-
-        /**
-         * Dispatched each time progress of this resource load updates.
-         * Not all resources types and loader systems can support this event
-         * so sometimes it may not be available. If the resource
-         * is being loaded on a modern browser, using XHR, and the remote server
-         * properly sets Content-Length headers, then this will be available.
-         *
-         * The callback looks like {@link Resource.OnProgressSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onProgress = new _miniSignals2.default();
-
-        /**
-         * Dispatched once this resource has loaded, if there was an error it will
-         * be in the `error` property.
-         *
-         * The callback looks like {@link Resource.OnCompleteSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onComplete = new _miniSignals2.default();
-
-        /**
-         * Dispatched after this resource has had all the *after* middleware run on it.
-         *
-         * The callback looks like {@link Resource.OnCompleteSignal}.
-         *
-         * @member {Signal}
-         */
-        this.onAfterMiddleware = new _miniSignals2.default();
-
-        /**
-         * When the resource starts to load.
-         *
-         * @memberof Resource
-         * @callback OnStartSignal
-         * @param {Resource} resource - The resource that the event happened on.
-         */
-
-        /**
-         * When the resource reports loading progress.
-         *
-         * @memberof Resource
-         * @callback OnProgressSignal
-         * @param {Resource} resource - The resource that the event happened on.
-         * @param {number} percentage - The progress of the load in the range [0, 1].
-         */
-
-        /**
-         * When the resource finishes loading.
-         *
-         * @memberof Resource
-         * @callback OnCompleteSignal
-         * @param {Resource} resource - The resource that the event happened on.
-         */
-    }
-
-    /**
-     * Stores whether or not this url is a data url.
-     *
-     * @member {boolean}
-     * @readonly
-     */
-
-
-    /**
-     * Marks the resource as complete.
-     *
-     */
-    Resource.prototype.complete = function complete() {
-        // TODO: Clean this up in a wrapper or something...gross....
-        if (this.data && this.data.removeEventListener) {
-            this.data.removeEventListener('error', this._boundOnError, false);
-            this.data.removeEventListener('load', this._boundComplete, false);
-            this.data.removeEventListener('progress', this._boundOnProgress, false);
-            this.data.removeEventListener('canplaythrough', this._boundComplete, false);
-        }
-
-        if (this.xhr) {
-            if (this.xhr.removeEventListener) {
-                this.xhr.removeEventListener('error', this._boundXhrOnError, false);
-                this.xhr.removeEventListener('abort', this._boundXhrOnAbort, false);
-                this.xhr.removeEventListener('progress', this._boundOnProgress, false);
-                this.xhr.removeEventListener('load', this._boundXhrOnLoad, false);
-            } else {
-                this.xhr.onerror = null;
-                this.xhr.ontimeout = null;
-                this.xhr.onprogress = null;
-                this.xhr.onload = null;
-            }
-        }
-
-        if (this.isComplete) {
-            throw new Error('Complete called again for an already completed resource.');
-        }
-
-        this._setFlag(Resource.STATUS_FLAGS.COMPLETE, true);
-        this._setFlag(Resource.STATUS_FLAGS.LOADING, false);
-
-        this.onComplete.dispatch(this);
-    };
-
-    /**
-     * Aborts the loading of this resource, with an optional message.
-     *
-     * @param {string} message - The message to use for the error
-     */
-
-
-    Resource.prototype.abort = function abort(message) {
-        // abort can be called multiple times, ignore subsequent calls.
-        if (this.error) {
-            return;
-        }
-
-        // store error
-        this.error = new Error(message);
-
-        // abort the actual loading
-        if (this.xhr) {
-            this.xhr.abort();
-        } else if (this.xdr) {
-            this.xdr.abort();
-        } else if (this.data) {
-            // single source
-            if (this.data.src) {
-                this.data.src = Resource.EMPTY_GIF;
-            }
-            // multi-source
-            else {
-                    while (this.data.firstChild) {
-                        this.data.removeChild(this.data.firstChild);
-                    }
-                }
-        }
-
-        // done now.
-        this.complete();
-    };
-
-    /**
-     * Kicks off loading of this resource. This method is asynchronous.
-     *
-     * @param {function} [cb] - Optional callback to call once the resource is loaded.
-     */
-
-
-    Resource.prototype.load = function load(cb) {
-        var _this = this;
-
-        if (this.isLoading) {
-            return;
-        }
-
-        if (this.isComplete) {
-            if (cb) {
-                setTimeout(function () {
-                    return cb(_this);
-                }, 1);
-            }
-
-            return;
-        } else if (cb) {
-            this.onComplete.once(cb);
-        }
-
-        this._setFlag(Resource.STATUS_FLAGS.LOADING, true);
-
-        this.onStart.dispatch(this);
-
-        // if unset, determine the value
-        if (this.crossOrigin === false || typeof this.crossOrigin !== 'string') {
-            this.crossOrigin = this._determineCrossOrigin(this.url);
-        }
-
-        switch (this.loadType) {
-            case Resource.LOAD_TYPE.IMAGE:
-                this.type = Resource.TYPE.IMAGE;
-                this._loadElement('image');
-                break;
-
-            case Resource.LOAD_TYPE.AUDIO:
-                this.type = Resource.TYPE.AUDIO;
-                this._loadSourceElement('audio');
-                break;
-
-            case Resource.LOAD_TYPE.VIDEO:
-                this.type = Resource.TYPE.VIDEO;
-                this._loadSourceElement('video');
-                break;
-
-            case Resource.LOAD_TYPE.XHR:
-            /* falls through */
-            default:
-                if (useXdr && this.crossOrigin) {
-                    this._loadXdr();
-                } else {
-                    this._loadXhr();
-                }
-                break;
-        }
-    };
-
-    /**
-     * Checks if the flag is set.
-     *
-     * @private
-     * @param {number} flag - The flag to check.
-     * @return {boolean} True if the flag is set.
-     */
-
-
-    Resource.prototype._hasFlag = function _hasFlag(flag) {
-        return !!(this._flags & flag);
-    };
-
-    /**
-     * (Un)Sets the flag.
-     *
-     * @private
-     * @param {number} flag - The flag to (un)set.
-     * @param {boolean} value - Whether to set or (un)set the flag.
-     */
-
-
-    Resource.prototype._setFlag = function _setFlag(flag, value) {
-        this._flags = value ? this._flags | flag : this._flags & ~flag;
-    };
-
-    /**
-     * Loads this resources using an element that has a single source,
-     * like an HTMLImageElement.
-     *
-     * @private
-     * @param {string} type - The type of element to use.
-     */
-
-
-    Resource.prototype._loadElement = function _loadElement(type) {
-        if (this.metadata.loadElement) {
-            this.data = this.metadata.loadElement;
-        } else if (type === 'image' && typeof window.Image !== 'undefined') {
-            this.data = new Image();
-        } else {
-            this.data = document.createElement(type);
-        }
-
-        if (this.crossOrigin) {
-            this.data.crossOrigin = this.crossOrigin;
-        }
-
-        if (!this.metadata.skipSource) {
-            this.data.src = this.url;
-        }
-
-        this.data.addEventListener('error', this._boundOnError, false);
-        this.data.addEventListener('load', this._boundComplete, false);
-        this.data.addEventListener('progress', this._boundOnProgress, false);
-    };
-
-    /**
-     * Loads this resources using an element that has multiple sources,
-     * like an HTMLAudioElement or HTMLVideoElement.
-     *
-     * @private
-     * @param {string} type - The type of element to use.
-     */
-
-
-    Resource.prototype._loadSourceElement = function _loadSourceElement(type) {
-        if (this.metadata.loadElement) {
-            this.data = this.metadata.loadElement;
-        } else if (type === 'audio' && typeof window.Audio !== 'undefined') {
-            this.data = new Audio();
-        } else {
-            this.data = document.createElement(type);
-        }
-
-        if (this.data === null) {
-            this.abort('Unsupported element: ' + type);
-
-            return;
-        }
-
-        if (!this.metadata.skipSource) {
-            // support for CocoonJS Canvas+ runtime, lacks document.createElement('source')
-            if (navigator.isCocoonJS) {
-                this.data.src = Array.isArray(this.url) ? this.url[0] : this.url;
-            } else if (Array.isArray(this.url)) {
-                var mimeTypes = this.metadata.mimeType;
-
-                for (var i = 0; i < this.url.length; ++i) {
-                    this.data.appendChild(this._createSource(type, this.url[i], Array.isArray(mimeTypes) ? mimeTypes[i] : mimeTypes));
-                }
-            } else {
-                var _mimeTypes = this.metadata.mimeType;
-
-                this.data.appendChild(this._createSource(type, this.url, Array.isArray(_mimeTypes) ? _mimeTypes[0] : _mimeTypes));
-            }
-        }
-
-        this.data.addEventListener('error', this._boundOnError, false);
-        this.data.addEventListener('load', this._boundComplete, false);
-        this.data.addEventListener('progress', this._boundOnProgress, false);
-        this.data.addEventListener('canplaythrough', this._boundComplete, false);
-
-        this.data.load();
-    };
-
-    /**
-     * Loads this resources using an XMLHttpRequest.
-     *
-     * @private
-     */
-
-
-    Resource.prototype._loadXhr = function _loadXhr() {
-        // if unset, determine the value
-        if (typeof this.xhrType !== 'string') {
-            this.xhrType = this._determineXhrType();
-        }
-
-        var xhr = this.xhr = new XMLHttpRequest();
-
-        // set the request type and url
-        xhr.open('GET', this.url, true);
-
-        // load json as text and parse it ourselves. We do this because some browsers
-        // *cough* safari *cough* can't deal with it.
-        if (this.xhrType === Resource.XHR_RESPONSE_TYPE.JSON || this.xhrType === Resource.XHR_RESPONSE_TYPE.DOCUMENT) {
-            xhr.responseType = Resource.XHR_RESPONSE_TYPE.TEXT;
-        } else {
-            xhr.responseType = this.xhrType;
-        }
-
-        xhr.addEventListener('error', this._boundXhrOnError, false);
-        xhr.addEventListener('abort', this._boundXhrOnAbort, false);
-        xhr.addEventListener('progress', this._boundOnProgress, false);
-        xhr.addEventListener('load', this._boundXhrOnLoad, false);
-
-        xhr.send();
-    };
-
-    /**
-     * Loads this resources using an XDomainRequest. This is here because we need to support IE9 (gross).
-     *
-     * @private
-     */
-
-
-    Resource.prototype._loadXdr = function _loadXdr() {
-        // if unset, determine the value
-        if (typeof this.xhrType !== 'string') {
-            this.xhrType = this._determineXhrType();
-        }
-
-        var xdr = this.xhr = new XDomainRequest();
-
-        // XDomainRequest has a few quirks. Occasionally it will abort requests
-        // A way to avoid this is to make sure ALL callbacks are set even if not used
-        // More info here: http://stackoverflow.com/questions/15786966/xdomainrequest-aborts-post-on-ie-9
-        xdr.timeout = 5000;
-
-        xdr.onerror = this._boundXhrOnError;
-        xdr.ontimeout = this._boundXdrOnTimeout;
-        xdr.onprogress = this._boundOnProgress;
-        xdr.onload = this._boundXhrOnLoad;
-
-        xdr.open('GET', this.url, true);
-
-        // Note: The xdr.send() call is wrapped in a timeout to prevent an
-        // issue with the interface where some requests are lost if multiple
-        // XDomainRequests are being sent at the same time.
-        // Some info here: https://github.com/photonstorm/phaser/issues/1248
-        setTimeout(function () {
-            return xdr.send();
-        }, 1);
-    };
-
-    /**
-     * Creates a source used in loading via an element.
-     *
-     * @private
-     * @param {string} type - The element type (video or audio).
-     * @param {string} url - The source URL to load from.
-     * @param {string} [mime] - The mime type of the video
-     * @return {HTMLSourceElement} The source element.
-     */
-
-
-    Resource.prototype._createSource = function _createSource(type, url, mime) {
-        if (!mime) {
-            mime = type + '/' + this._getExtension(url);
-        }
-
-        var source = document.createElement('source');
-
-        source.src = url;
-        source.type = mime;
-
-        return source;
-    };
-
-    /**
-     * Called if a load errors out.
-     *
-     * @param {Event} event - The error event from the element that emits it.
-     * @private
-     */
-
-
-    Resource.prototype._onError = function _onError(event) {
-        this.abort('Failed to load element using: ' + event.target.nodeName);
-    };
-
-    /**
-     * Called if a load progress event fires for xhr/xdr.
-     *
-     * @private
-     * @param {XMLHttpRequestProgressEvent|Event} event - Progress event.
-     */
-
-
-    Resource.prototype._onProgress = function _onProgress(event) {
-        if (event && event.lengthComputable) {
-            this.onProgress.dispatch(this, event.loaded / event.total);
-        }
-    };
-
-    /**
-     * Called if an error event fires for xhr/xdr.
-     *
-     * @private
-     * @param {XMLHttpRequestErrorEvent|Event} event - Error event.
-     */
-
-
-    Resource.prototype._xhrOnError = function _xhrOnError() {
-        var xhr = this.xhr;
-
-        this.abort(reqType(xhr) + ' Request failed. Status: ' + xhr.status + ', text: "' + xhr.statusText + '"');
-    };
-
-    /**
-     * Called if an abort event fires for xhr.
-     *
-     * @private
-     * @param {XMLHttpRequestAbortEvent} event - Abort Event
-     */
-
-
-    Resource.prototype._xhrOnAbort = function _xhrOnAbort() {
-        this.abort(reqType(this.xhr) + ' Request was aborted by the user.');
-    };
-
-    /**
-     * Called if a timeout event fires for xdr.
-     *
-     * @private
-     * @param {Event} event - Timeout event.
-     */
-
-
-    Resource.prototype._xdrOnTimeout = function _xdrOnTimeout() {
-        this.abort(reqType(this.xhr) + ' Request timed out.');
-    };
-
-    /**
-     * Called when data successfully loads from an xhr/xdr request.
-     *
-     * @private
-     * @param {XMLHttpRequestLoadEvent|Event} event - Load event
-     */
-
-
-    Resource.prototype._xhrOnLoad = function _xhrOnLoad() {
-        var xhr = this.xhr;
-        var text = '';
-        var status = typeof xhr.status === 'undefined' ? STATUS_OK : xhr.status; // XDR has no `.status`, assume 200.
-
-        // responseText is accessible only if responseType is '' or 'text' and on older browsers
-        if (xhr.responseType === '' || xhr.responseType === 'text' || typeof xhr.responseType === 'undefined') {
-            text = xhr.responseText;
-        }
-
-        // status can be 0 when using the `file://` protocol so we also check if a response is set.
-        // If it has a response, we assume 200; otherwise a 0 status code with no contents is an aborted request.
-        if (status === STATUS_NONE && text.length > 0) {
-            status = STATUS_OK;
-        }
-        // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request
-        else if (status === STATUS_IE_BUG_EMPTY) {
-                status = STATUS_EMPTY;
-            }
-
-        var statusType = status / 100 | 0;
-
-        if (statusType === STATUS_TYPE_OK) {
-            // if text, just return it
-            if (this.xhrType === Resource.XHR_RESPONSE_TYPE.TEXT) {
-                this.data = text;
-                this.type = Resource.TYPE.TEXT;
-            }
-            // if json, parse into json object
-            else if (this.xhrType === Resource.XHR_RESPONSE_TYPE.JSON) {
-                    try {
-                        this.data = JSON.parse(text);
-                        this.type = Resource.TYPE.JSON;
-                    } catch (e) {
-                        this.abort('Error trying to parse loaded json: ' + e);
-
-                        return;
-                    }
-                }
-                // if xml, parse into an xml document or div element
-                else if (this.xhrType === Resource.XHR_RESPONSE_TYPE.DOCUMENT) {
-                        try {
-                            if (window.DOMParser) {
-                                var domparser = new DOMParser();
-
-                                this.data = domparser.parseFromString(text, 'text/xml');
-                            } else {
-                                var div = document.createElement('div');
-
-                                div.innerHTML = text;
-
-                                this.data = div;
-                            }
-
-                            this.type = Resource.TYPE.XML;
-                        } catch (e) {
-                            this.abort('Error trying to parse loaded xml: ' + e);
-
-                            return;
-                        }
-                    }
-                    // other types just return the response
-                    else {
-                            this.data = xhr.response || text;
-                        }
-        } else {
-            this.abort('[' + xhr.status + '] ' + xhr.statusText + ': ' + xhr.responseURL);
-
-            return;
-        }
-
-        this.complete();
-    };
-
-    /**
-     * Sets the `crossOrigin` property for this resource based on if the url
-     * for this resource is cross-origin. If crossOrigin was manually set, this
-     * function does nothing.
-     *
-     * @private
-     * @param {string} url - The url to test.
-     * @param {object} [loc=window.location] - The location object to test against.
-     * @return {string} The crossOrigin value to use (or empty string for none).
-     */
-
-
-    Resource.prototype._determineCrossOrigin = function _determineCrossOrigin(url, loc) {
-        // data: and javascript: urls are considered same-origin
-        if (url.indexOf('data:') === 0) {
-            return '';
-        }
-
-        // default is window.location
-        loc = loc || window.location;
-
-        if (!tempAnchor) {
-            tempAnchor = document.createElement('a');
-        }
-
-        // let the browser determine the full href for the url of this resource and then
-        // parse with the node url lib, we can't use the properties of the anchor element
-        // because they don't work in IE9 :(
-        tempAnchor.href = url;
-        url = (0, _parseUri2.default)(tempAnchor.href, { strictMode: true });
-
-        var samePort = !url.port && loc.port === '' || url.port === loc.port;
-        var protocol = url.protocol ? url.protocol + ':' : '';
-
-        // if cross origin
-        if (url.host !== loc.hostname || !samePort || protocol !== loc.protocol) {
-            return 'anonymous';
-        }
-
-        return '';
-    };
-
-    /**
-     * Determines the responseType of an XHR request based on the extension of the
-     * resource being loaded.
-     *
-     * @private
-     * @return {Resource.XHR_RESPONSE_TYPE} The responseType to use.
-     */
-
-
-    Resource.prototype._determineXhrType = function _determineXhrType() {
-        return Resource._xhrTypeMap[this.extension] || Resource.XHR_RESPONSE_TYPE.TEXT;
-    };
-
-    /**
-     * Determines the loadType of a resource based on the extension of the
-     * resource being loaded.
-     *
-     * @private
-     * @return {Resource.LOAD_TYPE} The loadType to use.
-     */
-
-
-    Resource.prototype._determineLoadType = function _determineLoadType() {
-        return Resource._loadTypeMap[this.extension] || Resource.LOAD_TYPE.XHR;
-    };
-
-    /**
-     * Extracts the extension (sans '.') of the file being loaded by the resource.
-     *
-     * @private
-     * @return {string} The extension.
-     */
-
-
-    Resource.prototype._getExtension = function _getExtension() {
-        var url = this.url;
-        var ext = '';
-
-        if (this.isDataUrl) {
-            var slashIndex = url.indexOf('/');
-
-            ext = url.substring(slashIndex + 1, url.indexOf(';', slashIndex));
-        } else {
-            var queryStart = url.indexOf('?');
-            var hashStart = url.indexOf('#');
-            var index = Math.min(queryStart > -1 ? queryStart : url.length, hashStart > -1 ? hashStart : url.length);
-
-            url = url.substring(0, index);
-            ext = url.substring(url.lastIndexOf('.') + 1);
-        }
-
-        return ext.toLowerCase();
-    };
-
-    /**
-     * Determines the mime type of an XHR request based on the responseType of
-     * resource being loaded.
-     *
-     * @private
-     * @param {Resource.XHR_RESPONSE_TYPE} type - The type to get a mime type for.
-     * @return {string} The mime type to use.
-     */
-
-
-    Resource.prototype._getMimeFromXhrType = function _getMimeFromXhrType(type) {
-        switch (type) {
-            case Resource.XHR_RESPONSE_TYPE.BUFFER:
-                return 'application/octet-binary';
-
-            case Resource.XHR_RESPONSE_TYPE.BLOB:
-                return 'application/blob';
-
-            case Resource.XHR_RESPONSE_TYPE.DOCUMENT:
-                return 'application/xml';
-
-            case Resource.XHR_RESPONSE_TYPE.JSON:
-                return 'application/json';
-
-            case Resource.XHR_RESPONSE_TYPE.DEFAULT:
-            case Resource.XHR_RESPONSE_TYPE.TEXT:
-            /* falls through */
-            default:
-                return 'text/plain';
-
-        }
-    };
-
-    _createClass(Resource, [{
-        key: 'isDataUrl',
-        get: function get() {
-            return this._hasFlag(Resource.STATUS_FLAGS.DATA_URL);
-        }
-
-        /**
-         * Describes if this resource has finished loading. Is true when the resource has completely
-         * loaded.
-         *
-         * @member {boolean}
-         * @readonly
-         */
-
-    }, {
-        key: 'isComplete',
-        get: function get() {
-            return this._hasFlag(Resource.STATUS_FLAGS.COMPLETE);
-        }
-
-        /**
-         * Describes if this resource is currently loading. Is true when the resource starts loading,
-         * and is false again when complete.
-         *
-         * @member {boolean}
-         * @readonly
-         */
-
-    }, {
-        key: 'isLoading',
-        get: function get() {
-            return this._hasFlag(Resource.STATUS_FLAGS.LOADING);
-        }
-    }]);
-
-    return Resource;
-}();
-
-/**
- * The types of resources a resource could represent.
- *
- * @static
- * @readonly
- * @enum {number}
- */
-
-
-exports.default = Resource;
-Resource.STATUS_FLAGS = {
-    NONE: 0,
-    DATA_URL: 1 << 0,
-    COMPLETE: 1 << 1,
-    LOADING: 1 << 2
-};
-
-/**
- * The types of resources a resource could represent.
- *
- * @static
- * @readonly
- * @enum {number}
- */
-Resource.TYPE = {
-    UNKNOWN: 0,
-    JSON: 1,
-    XML: 2,
-    IMAGE: 3,
-    AUDIO: 4,
-    VIDEO: 5,
-    TEXT: 6
-};
-
-/**
- * The types of loading a resource can use.
- *
- * @static
- * @readonly
- * @enum {number}
- */
-Resource.LOAD_TYPE = {
-    /** Uses XMLHttpRequest to load the resource. */
-    XHR: 1,
-    /** Uses an `Image` object to load the resource. */
-    IMAGE: 2,
-    /** Uses an `Audio` object to load the resource. */
-    AUDIO: 3,
-    /** Uses a `Video` object to load the resource. */
-    VIDEO: 4
-};
-
-/**
- * The XHR ready states, used internally.
- *
- * @static
- * @readonly
- * @enum {string}
- */
-Resource.XHR_RESPONSE_TYPE = {
-    /** string */
-    DEFAULT: 'text',
-    /** ArrayBuffer */
-    BUFFER: 'arraybuffer',
-    /** Blob */
-    BLOB: 'blob',
-    /** Document */
-    DOCUMENT: 'document',
-    /** Object */
-    JSON: 'json',
-    /** String */
-    TEXT: 'text'
-};
-
-Resource._loadTypeMap = {
-    // images
-    gif: Resource.LOAD_TYPE.IMAGE,
-    png: Resource.LOAD_TYPE.IMAGE,
-    bmp: Resource.LOAD_TYPE.IMAGE,
-    jpg: Resource.LOAD_TYPE.IMAGE,
-    jpeg: Resource.LOAD_TYPE.IMAGE,
-    tif: Resource.LOAD_TYPE.IMAGE,
-    tiff: Resource.LOAD_TYPE.IMAGE,
-    webp: Resource.LOAD_TYPE.IMAGE,
-    tga: Resource.LOAD_TYPE.IMAGE,
-    svg: Resource.LOAD_TYPE.IMAGE,
-    'svg+xml': Resource.LOAD_TYPE.IMAGE, // for SVG data urls
-
-    // audio
-    mp3: Resource.LOAD_TYPE.AUDIO,
-    ogg: Resource.LOAD_TYPE.AUDIO,
-    wav: Resource.LOAD_TYPE.AUDIO,
-
-    // videos
-    mp4: Resource.LOAD_TYPE.VIDEO,
-    webm: Resource.LOAD_TYPE.VIDEO
-};
-
-Resource._xhrTypeMap = {
-    // xml
-    xhtml: Resource.XHR_RESPONSE_TYPE.DOCUMENT,
-    html: Resource.XHR_RESPONSE_TYPE.DOCUMENT,
-    htm: Resource.XHR_RESPONSE_TYPE.DOCUMENT,
-    xml: Resource.XHR_RESPONSE_TYPE.DOCUMENT,
-    tmx: Resource.XHR_RESPONSE_TYPE.DOCUMENT,
-    svg: Resource.XHR_RESPONSE_TYPE.DOCUMENT,
-
-    // This was added to handle Tiled Tileset XML, but .tsx is also a TypeScript React Component.
-    // Since it is way less likely for people to be loading TypeScript files instead of Tiled files,
-    // this should probably be fine.
-    tsx: Resource.XHR_RESPONSE_TYPE.DOCUMENT,
-
-    // images
-    gif: Resource.XHR_RESPONSE_TYPE.BLOB,
-    png: Resource.XHR_RESPONSE_TYPE.BLOB,
-    bmp: Resource.XHR_RESPONSE_TYPE.BLOB,
-    jpg: Resource.XHR_RESPONSE_TYPE.BLOB,
-    jpeg: Resource.XHR_RESPONSE_TYPE.BLOB,
-    tif: Resource.XHR_RESPONSE_TYPE.BLOB,
-    tiff: Resource.XHR_RESPONSE_TYPE.BLOB,
-    webp: Resource.XHR_RESPONSE_TYPE.BLOB,
-    tga: Resource.XHR_RESPONSE_TYPE.BLOB,
-
-    // json
-    json: Resource.XHR_RESPONSE_TYPE.JSON,
-
-    // text
-    text: Resource.XHR_RESPONSE_TYPE.TEXT,
-    txt: Resource.XHR_RESPONSE_TYPE.TEXT,
-
-    // fonts
-    ttf: Resource.XHR_RESPONSE_TYPE.BUFFER,
-    otf: Resource.XHR_RESPONSE_TYPE.BUFFER
-};
-
-// We can't set the `src` attribute to empty string, so on abort we set it to this 1px transparent gif
-Resource.EMPTY_GIF = 'data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
-
-/**
- * Quick helper to set a value on one of the extension maps. Ensures there is no
- * dot at the start of the extension.
- *
- * @ignore
- * @param {object} map - The map to set on.
- * @param {string} extname - The extension (or key) to set.
- * @param {number} val - The value to set.
- */
-function setExtMap(map, extname, val) {
-    if (extname && extname.indexOf('.') === 0) {
-        extname = extname.substring(1);
-    }
-
-    if (!extname) {
-        return;
-    }
-
-    map[extname] = val;
-}
-
-/**
- * Quick helper to get string xhr type.
- *
- * @ignore
- * @param {XMLHttpRequest|XDomainRequest} xhr - The request to check.
- * @return {string} The type.
- */
-function reqType(xhr) {
-    return xhr.toString().replace('object ', '');
-}
-
-},{"mini-signals":38,"parse-uri":39}],34:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.eachSeries = eachSeries;
-exports.queue = queue;
-/**
- * Smaller version of the async library constructs.
- *
- */
-function _noop() {} /* empty */
-
-/**
- * Iterates an array in series.
- *
- * @param {Array.<*>} array - Array to iterate.
- * @param {function} iterator - Function to call for each element.
- * @param {function} callback - Function to call when done, or on error.
- * @param {boolean} [deferNext=false] - Break synchronous each loop by calling next with a setTimeout of 1.
- */
-function eachSeries(array, iterator, callback, deferNext) {
-    var i = 0;
-    var len = array.length;
-
-    (function next(err) {
-        if (err || i === len) {
-            if (callback) {
-                callback(err);
-            }
-
-            return;
-        }
-
-        if (deferNext) {
-            setTimeout(function () {
-                iterator(array[i++], next);
-            }, 1);
-        } else {
-            iterator(array[i++], next);
-        }
-    })();
-}
-
-/**
- * Ensures a function is only called once.
- *
- * @param {function} fn - The function to wrap.
- * @return {function} The wrapping function.
- */
-function onlyOnce(fn) {
-    return function onceWrapper() {
-        if (fn === null) {
-            throw new Error('Callback was already called.');
-        }
-
-        var callFn = fn;
-
-        fn = null;
-        callFn.apply(this, arguments);
-    };
-}
-
-/**
- * Async queue implementation,
- *
- * @param {function} worker - The worker function to call for each task.
- * @param {number} concurrency - How many workers to run in parrallel.
- * @return {*} The async queue object.
- */
-function queue(worker, concurrency) {
-    if (concurrency == null) {
-        // eslint-disable-line no-eq-null,eqeqeq
-        concurrency = 1;
-    } else if (concurrency === 0) {
-        throw new Error('Concurrency must not be zero');
-    }
-
-    var workers = 0;
-    var q = {
-        _tasks: [],
-        concurrency: concurrency,
-        saturated: _noop,
-        unsaturated: _noop,
-        buffer: concurrency / 4,
-        empty: _noop,
-        drain: _noop,
-        error: _noop,
-        started: false,
-        paused: false,
-        push: function push(data, callback) {
-            _insert(data, false, callback);
-        },
-        kill: function kill() {
-            workers = 0;
-            q.drain = _noop;
-            q.started = false;
-            q._tasks = [];
-        },
-        unshift: function unshift(data, callback) {
-            _insert(data, true, callback);
-        },
-        process: function process() {
-            while (!q.paused && workers < q.concurrency && q._tasks.length) {
-                var task = q._tasks.shift();
-
-                if (q._tasks.length === 0) {
-                    q.empty();
-                }
-
-                workers += 1;
-
-                if (workers === q.concurrency) {
-                    q.saturated();
-                }
-
-                worker(task.data, onlyOnce(_next(task)));
-            }
-        },
-        length: function length() {
-            return q._tasks.length;
-        },
-        running: function running() {
-            return workers;
-        },
-        idle: function idle() {
-            return q._tasks.length + workers === 0;
-        },
-        pause: function pause() {
-            if (q.paused === true) {
-                return;
-            }
-
-            q.paused = true;
-        },
-        resume: function resume() {
-            if (q.paused === false) {
-                return;
-            }
-
-            q.paused = false;
-
-            // Need to call q.process once per concurrent
-            // worker to preserve full concurrency after pause
-            for (var w = 1; w <= q.concurrency; w++) {
-                q.process();
-            }
-        }
-    };
-
-    function _insert(data, insertAtFront, callback) {
-        if (callback != null && typeof callback !== 'function') {
-            // eslint-disable-line no-eq-null,eqeqeq
-            throw new Error('task callback must be a function');
-        }
-
-        q.started = true;
-
-        if (data == null && q.idle()) {
-            // eslint-disable-line no-eq-null,eqeqeq
-            // call drain immediately if there are no tasks
-            setTimeout(function () {
-                return q.drain();
-            }, 1);
-
-            return;
-        }
-
-        var item = {
-            data: data,
-            callback: typeof callback === 'function' ? callback : _noop
-        };
-
-        if (insertAtFront) {
-            q._tasks.unshift(item);
-        } else {
-            q._tasks.push(item);
-        }
-
-        setTimeout(function () {
-            return q.process();
-        }, 1);
-    }
-
-    function _next(task) {
-        return function next() {
-            workers -= 1;
-
-            task.callback.apply(task, arguments);
-
-            if (arguments[0] != null) {
-                // eslint-disable-line no-eq-null,eqeqeq
-                q.error(arguments[0], task.data);
-            }
-
-            if (workers <= q.concurrency - q.buffer) {
-                q.unsaturated();
-            }
-
-            if (q.idle()) {
-                q.drain();
-            }
-
-            q.process();
-        };
-    }
-
-    return q;
-}
-
-},{}],35:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.encodeBinary = encodeBinary;
-var _keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-
-function encodeBinary(input) {
-    var output = '';
-    var inx = 0;
-
-    while (inx < input.length) {
-        // Fill byte buffer array
-        var bytebuffer = [0, 0, 0];
-        var encodedCharIndexes = [0, 0, 0, 0];
-
-        for (var jnx = 0; jnx < bytebuffer.length; ++jnx) {
-            if (inx < input.length) {
-                // throw away high-order byte, as documented at:
-                // https://developer.mozilla.org/En/Using_XMLHttpRequest#Handling_binary_data
-                bytebuffer[jnx] = input.charCodeAt(inx++) & 0xff;
-            } else {
-                bytebuffer[jnx] = 0;
-            }
-        }
-
-        // Get each encoded character, 6 bits at a time
-        // index 1: first 6 bits
-        encodedCharIndexes[0] = bytebuffer[0] >> 2;
-
-        // index 2: second 6 bits (2 least significant bits from input byte 1 + 4 most significant bits from byte 2)
-        encodedCharIndexes[1] = (bytebuffer[0] & 0x3) << 4 | bytebuffer[1] >> 4;
-
-        // index 3: third 6 bits (4 least significant bits from input byte 2 + 2 most significant bits from byte 3)
-        encodedCharIndexes[2] = (bytebuffer[1] & 0x0f) << 2 | bytebuffer[2] >> 6;
-
-        // index 3: forth 6 bits (6 least significant bits from input byte 3)
-        encodedCharIndexes[3] = bytebuffer[2] & 0x3f;
-
-        // Determine whether padding happened, and adjust accordingly
-        var paddingBytes = inx - (input.length - 1);
-
-        switch (paddingBytes) {
-            case 2:
-                // Set last 2 characters to padding char
-                encodedCharIndexes[3] = 64;
-                encodedCharIndexes[2] = 64;
-                break;
-
-            case 1:
-                // Set last character to padding char
-                encodedCharIndexes[3] = 64;
-                break;
-
-            default:
-                break; // No padding - proceed
-        }
-
-        // Now we will grab each appropriate character out of our keystring
-        // based on our index array and append it to the output string
-        for (var _jnx = 0; _jnx < encodedCharIndexes.length; ++_jnx) {
-            output += _keyStr.charAt(encodedCharIndexes[_jnx]);
-        }
-    }
-
-    return output;
-}
-
-},{}],36:[function(require,module,exports){
-'use strict';
-
-// import Loader from './Loader';
-// import Resource from './Resource';
-// import * as async from './async';
-// import * as b64 from './b64';
-
-/* eslint-disable no-undef */
-
-var Loader = require('./Loader').default;
-var Resource = require('./Resource').default;
-var async = require('./async');
-var b64 = require('./b64');
-
-Loader.Resource = Resource;
-Loader.async = async;
-Loader.base64 = b64;
-
-// export manually, and also as default
-module.exports = Loader;
-// export default Loader;
-module.exports.default = Loader;
-
-},{"./Loader":32,"./Resource":33,"./async":34,"./b64":35}],37:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-exports.blobMiddlewareFactory = blobMiddlewareFactory;
-
-var _Resource = require('../../Resource');
-
-var _Resource2 = _interopRequireDefault(_Resource);
-
-var _b = require('../../b64');
-
-var _b2 = _interopRequireDefault(_b);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var Url = window.URL || window.webkitURL;
-
-// a middleware for transforming XHR loaded Blobs into more useful objects
-function blobMiddlewareFactory() {
-    return function blobMiddleware(resource, next) {
-        if (!resource.data) {
-            next();
-
-            return;
-        }
-
-        // if this was an XHR load of a blob
-        if (resource.xhr && resource.xhrType === _Resource2.default.XHR_RESPONSE_TYPE.BLOB) {
-            // if there is no blob support we probably got a binary string back
-            if (!window.Blob || typeof resource.data === 'string') {
-                var type = resource.xhr.getResponseHeader('content-type');
-
-                // this is an image, convert the binary string into a data url
-                if (type && type.indexOf('image') === 0) {
-                    resource.data = new Image();
-                    resource.data.src = 'data:' + type + ';base64,' + _b2.default.encodeBinary(resource.xhr.responseText);
-
-                    resource.type = _Resource2.default.TYPE.IMAGE;
-
-                    // wait until the image loads and then callback
-                    resource.data.onload = function () {
-                        resource.data.onload = null;
-
-                        next();
-                    };
-
-                    // next will be called on load
-                    return;
-                }
-            }
-            // if content type says this is an image, then we should transform the blob into an Image object
-            else if (resource.data.type.indexOf('image') === 0) {
-                    var _ret = function () {
-                        var src = Url.createObjectURL(resource.data);
-
-                        resource.blob = resource.data;
-                        resource.data = new Image();
-                        resource.data.src = src;
-
-                        resource.type = _Resource2.default.TYPE.IMAGE;
-
-                        // cleanup the no longer used blob after the image loads
-                        // TODO: Is this correct? Will the image be invalid after revoking?
-                        resource.data.onload = function () {
-                            Url.revokeObjectURL(src);
-                            resource.data.onload = null;
-
-                            next();
-                        };
-
-                        // next will be called on load.
-                        return {
-                            v: void 0
-                        };
-                    }();
-
-                    if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
-                }
-        }
-
-        next();
-    };
-}
-
-},{"../../Resource":33,"../../b64":35}],38:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-
-var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
-
-var MiniSignalBinding = (function () {
-  function MiniSignalBinding(fn, once, thisArg) {
-    if (once === undefined) once = false;
-
-    _classCallCheck(this, MiniSignalBinding);
-
-    this._fn = fn;
-    this._once = once;
-    this._thisArg = thisArg;
-    this._next = this._prev = this._owner = null;
-  }
-
-  _createClass(MiniSignalBinding, [{
-    key: 'detach',
-    value: function detach() {
-      if (this._owner === null) return false;
-      this._owner.detach(this);
-      return true;
-    }
-  }]);
-
-  return MiniSignalBinding;
-})();
-
-function _addMiniSignalBinding(self, node) {
-  if (!self._head) {
-    self._head = node;
-    self._tail = node;
-  } else {
-    self._tail._next = node;
-    node._prev = self._tail;
-    self._tail = node;
-  }
-
-  node._owner = self;
-
-  return node;
-}
-
-var MiniSignal = (function () {
-  function MiniSignal() {
-    _classCallCheck(this, MiniSignal);
-
-    this._head = this._tail = undefined;
-  }
-
-  _createClass(MiniSignal, [{
-    key: 'handlers',
-    value: function handlers() {
-      var exists = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];
-
-      var node = this._head;
-
-      if (exists) return !!node;
-
-      var ee = [];
-
-      while (node) {
-        ee.push(node);
-        node = node._next;
-      }
-
-      return ee;
-    }
-  }, {
-    key: 'has',
-    value: function has(node) {
-      if (!(node instanceof MiniSignalBinding)) {
-        throw new Error('MiniSignal#has(): First arg must be a MiniSignalBinding object.');
-      }
-
-      return node._owner === this;
-    }
-  }, {
-    key: 'dispatch',
-    value: function dispatch() {
-      var node = this._head;
-
-      if (!node) return false;
-
-      while (node) {
-        if (node._once) this.detach(node);
-        node._fn.apply(node._thisArg, arguments);
-        node = node._next;
-      }
-
-      return true;
-    }
-  }, {
-    key: 'add',
-    value: function add(fn) {
-      var thisArg = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
-
-      if (typeof fn !== 'function') {
-        throw new Error('MiniSignal#add(): First arg must be a Function.');
-      }
-      return _addMiniSignalBinding(this, new MiniSignalBinding(fn, false, thisArg));
-    }
-  }, {
-    key: 'once',
-    value: function once(fn) {
-      var thisArg = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
-
-      if (typeof fn !== 'function') {
-        throw new Error('MiniSignal#once(): First arg must be a Function.');
-      }
-      return _addMiniSignalBinding(this, new MiniSignalBinding(fn, true, thisArg));
-    }
-  }, {
-    key: 'detach',
-    value: function detach(node) {
-      if (!(node instanceof MiniSignalBinding)) {
-        throw new Error('MiniSignal#detach(): First arg must be a MiniSignalBinding object.');
-      }
-      if (node._owner !== this) return this;
-
-      if (node._prev) node._prev._next = node._next;
-      if (node._next) node._next._prev = node._prev;
-
-      if (node === this._head) {
-        this._head = node._next;
-        if (node._next === null) {
-          this._tail = null;
-        }
-      } else if (node === this._tail) {
-        this._tail = node._prev;
-        this._tail._next = null;
-      }
-
-      node._owner = null;
-      return this;
-    }
-  }, {
-    key: 'detachAll',
-    value: function detachAll() {
-      var node = this._head;
-      if (!node) return this;
-
-      this._head = this._tail = null;
-
-      while (node) {
-        node._owner = null;
-        node = node._next;
-      }
-      return this;
-    }
-  }]);
-
-  return MiniSignal;
-})();
-
-MiniSignal.MiniSignalBinding = MiniSignalBinding;
-
-exports['default'] = MiniSignal;
-module.exports = exports['default'];
-
-},{}],39:[function(require,module,exports){
-'use strict'
-
-module.exports = function parseURI (str, opts) {
-  opts = opts || {}
-
-  var o = {
-    key: ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'],
-    q: {
-      name: 'queryKey',
-      parser: /(?:^|&)([^&=]*)=?([^&]*)/g
-    },
-    parser: {
-      strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
-      loose: /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
-    }
-  }
-
-  var m = o.parser[opts.strictMode ? 'strict' : 'loose'].exec(str)
-  var uri = {}
-  var i = 14
-
-  while (i--) uri[o.key[i]] = m[i] || ''
-
-  uri[o.q.name] = {}
-  uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
-    if ($1) uri[o.q.name][$1] = $2
-  })
-
-  return uri
-}
-
-},{}],40:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _ismobilejs = require('ismobilejs');
-
-var _ismobilejs2 = _interopRequireDefault(_ismobilejs);
-
-var _accessibleTarget = require('./accessibleTarget');
-
-var _accessibleTarget2 = _interopRequireDefault(_accessibleTarget);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-// add some extra variables to the container..
-core.utils.mixins.delayMixin(core.DisplayObject.prototype, _accessibleTarget2.default);
-
-var KEY_CODE_TAB = 9;
-
-var DIV_TOUCH_SIZE = 100;
-var DIV_TOUCH_POS_X = 0;
-var DIV_TOUCH_POS_Y = 0;
-var DIV_TOUCH_ZINDEX = 2;
-
-var DIV_HOOK_SIZE = 1;
-var DIV_HOOK_POS_X = -1000;
-var DIV_HOOK_POS_Y = -1000;
-var DIV_HOOK_ZINDEX = 2;
-
-/**
- * The Accessibility manager 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 pixi
- * content.
- *
- * Much like interaction any DisplayObject can be made accessible. 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.plugins.accessibility
- *
- * @class
- * @memberof PIXI.accessibility
- */
-
-var AccessibilityManager = function () {
-    /**
-     * @param {PIXI.CanvasRenderer|PIXI.WebGLRenderer} renderer - A reference to the current renderer
-     */
-    function AccessibilityManager(renderer) {
-        _classCallCheck(this, AccessibilityManager);
-
-        if ((_ismobilejs2.default.tablet || _ismobilejs2.default.phone) && !navigator.isCocoonJS) {
-            this.createTouchHook();
-        }
-
-        // first we create a div that will sit over the PixiJS element. This is where the div overlays will go.
-        var 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;
-
-        /**
-         * This is the dom element that will sit over the PixiJS element. This is where the div overlays will go.
-         *
-         * @type {HTMLElement}
-         * @private
-         */
-        this.div = div;
-
-        /**
-         * A simple pool for storing divs.
-         *
-         * @type {*}
-         * @private
-         */
-        this.pool = [];
-
-        /**
-         * This is a tick used to check if an object is no longer being rendered.
-         *
-         * @type {Number}
-         * @private
-         */
-        this.renderId = 0;
-
-        /**
-         * Setting this to true will visually show the divs.
-         *
-         * @type {boolean}
-         */
-        this.debug = false;
-
-        /**
-         * The renderer this accessibility manager works for.
-         *
-         * @member {PIXI.SystemRenderer}
-         */
-        this.renderer = renderer;
-
-        /**
-         * The array of currently active accessible items.
-         *
-         * @member {Array<*>}
-         * @private
-         */
-        this.children = [];
-
-        /**
-         * pre-bind the functions
-         *
-         * @private
-         */
-        this._onKeyDown = this._onKeyDown.bind(this);
-        this._onMouseMove = this._onMouseMove.bind(this);
-
-        /**
-         * stores the state of the manager. If there are no accessible objects or the mouse is moving, this will be false.
-         *
-         * @member {Array<*>}
-         * @private
-         */
-        this.isActive = false;
-        this.isMobileAccessabillity = false;
-
-        // let listen for tab.. once pressed we can fire up and show the accessibility layer
-        window.addEventListener('keydown', this._onKeyDown, false);
-    }
-
-    /**
-     * Creates the touch hooks.
-     *
-     */
-
-
-    AccessibilityManager.prototype.createTouchHook = function createTouchHook() {
-        var _this = this;
-
-        var 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;
-        hookDiv.style.backgroundColor = '#FF0000';
-        hookDiv.title = 'HOOK DIV';
-
-        hookDiv.addEventListener('focus', function () {
-            _this.isMobileAccessabillity = true;
-            _this.activate();
-            document.body.removeChild(hookDiv);
-        });
-
-        document.body.appendChild(hookDiv);
-    };
-
-    /**
-     * Activating will cause the Accessibility layer to be shown. This is called when a user
-     * preses the tab key.
-     *
-     * @private
-     */
-
-
-    AccessibilityManager.prototype.activate = function activate() {
-        if (this.isActive) {
-            return;
-        }
-
-        this.isActive = true;
-
-        window.document.addEventListener('mousemove', this._onMouseMove, true);
-        window.removeEventListener('keydown', this._onKeyDown, false);
-
-        this.renderer.on('postrender', this.update, this);
-
-        if (this.renderer.view.parentNode) {
-            this.renderer.view.parentNode.appendChild(this.div);
-        }
-    };
-
-    /**
-     * Deactivating will cause the Accessibility layer to be hidden. This is called when a user moves
-     * the mouse.
-     *
-     * @private
-     */
-
-
-    AccessibilityManager.prototype.deactivate = function deactivate() {
-        if (!this.isActive || this.isMobileAccessabillity) {
-            return;
-        }
-
-        this.isActive = false;
-
-        window.document.removeEventListener('mousemove', this._onMouseMove);
-        window.addEventListener('keydown', this._onKeyDown, false);
-
-        this.renderer.off('postrender', this.update);
-
-        if (this.div.parentNode) {
-            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 {PIXI.Container} displayObject - The DisplayObject to check.
-     */
-
-
-    AccessibilityManager.prototype.updateAccessibleObjects = function updateAccessibleObjects(displayObject) {
-        if (!displayObject.visible) {
-            return;
-        }
-
-        if (displayObject.accessible && displayObject.interactive) {
-            if (!displayObject._accessibleActive) {
-                this.addChild(displayObject);
-            }
-
-            displayObject.renderId = this.renderId;
-        }
-
-        var children = displayObject.children;
-
-        for (var i = children.length - 1; i >= 0; i--) {
-            this.updateAccessibleObjects(children[i]);
-        }
-    };
-
-    /**
-     * Before each render this function will ensure that all divs are mapped correctly to their DisplayObjects.
-     *
-     * @private
-     */
-
-
-    AccessibilityManager.prototype.update = function update() {
-        if (!this.renderer.renderingToScreen) {
-            return;
-        }
-
-        // update children...
-        this.updateAccessibleObjects(this.renderer._lastObjectRendered);
-
-        var rect = this.renderer.view.getBoundingClientRect();
-        var sx = rect.width / this.renderer.width;
-        var sy = rect.height / this.renderer.height;
-
-        var div = this.div;
-
-        div.style.left = rect.left + 'px';
-        div.style.top = rect.top + 'px';
-        div.style.width = this.renderer.width + 'px';
-        div.style.height = this.renderer.height + 'px';
-
-        for (var i = 0; i < this.children.length; i++) {
-            var child = this.children[i];
-
-            if (child.renderId !== this.renderId) {
-                child._accessibleActive = false;
-
-                core.utils.removeItems(this.children, i, 1);
-                this.div.removeChild(child._accessibleDiv);
-                this.pool.push(child._accessibleDiv);
-                child._accessibleDiv = null;
-
-                i--;
-
-                if (this.children.length === 0) {
-                    this.deactivate();
-                }
-            } else {
-                // map div to display..
-                div = child._accessibleDiv;
-                var hitArea = child.hitArea;
-                var 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();
-
-                    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';
-                }
-            }
-        }
-
-        // increment the render id..
-        this.renderId++;
-    };
-
-    /**
-     * TODO: docs.
-     *
-     * @param {Rectangle} hitArea - TODO docs
-     */
-
-
-    AccessibilityManager.prototype.capHitArea = function capHitArea(hitArea) {
-        if (hitArea.x < 0) {
-            hitArea.width += hitArea.x;
-            hitArea.x = 0;
-        }
-
-        if (hitArea.y < 0) {
-            hitArea.height += hitArea.y;
-            hitArea.y = 0;
-        }
-
-        if (hitArea.x + hitArea.width > this.renderer.width) {
-            hitArea.width = this.renderer.width - hitArea.x;
-        }
-
-        if (hitArea.y + hitArea.height > this.renderer.height) {
-            hitArea.height = this.renderer.height - hitArea.y;
-        }
-    };
-
-    /**
-     * Adds a DisplayObject to the accessibility manager
-     *
-     * @private
-     * @param {DisplayObject} displayObject - The child to make accessible.
-     */
-
-
-    AccessibilityManager.prototype.addChild = function addChild(displayObject) {
-        //    this.activate();
-
-        var 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,0,0,0.5)' : 'transparent';
-            div.style.position = 'absolute';
-            div.style.zIndex = DIV_TOUCH_ZINDEX;
-            div.style.borderStyle = 'none';
-
-            div.addEventListener('click', this._onClick.bind(this));
-            div.addEventListener('focus', this._onFocus.bind(this));
-            div.addEventListener('focusout', this._onFocusOut.bind(this));
-        }
-
-        if (displayObject.accessibleTitle) {
-            div.title = displayObject.accessibleTitle;
-        } else if (!displayObject.accessibleTitle && !displayObject.accessibleHint) {
-            div.title = 'displayObject ' + this.tabIndex;
-        }
-
-        if (displayObject.accessibleHint) {
-            div.setAttribute('aria-label', displayObject.accessibleHint);
-        }
-
-        //
-
-        displayObject._accessibleActive = true;
-        displayObject._accessibleDiv = div;
-        div.displayObject = displayObject;
-
-        this.children.push(displayObject);
-        this.div.appendChild(displayObject._accessibleDiv);
-        displayObject._accessibleDiv.tabIndex = displayObject.tabIndex;
-    };
-
-    /**
-     * Maps the div button press to pixi's InteractionManager (click)
-     *
-     * @private
-     * @param {MouseEvent} e - The click event.
-     */
-
-
-    AccessibilityManager.prototype._onClick = function _onClick(e) {
-        var interactionManager = this.renderer.plugins.interaction;
-
-        interactionManager.dispatchEvent(e.target.displayObject, 'click', interactionManager.eventData);
-    };
-
-    /**
-     * Maps the div focus events to pixi's InteractionManager (mouseover)
-     *
-     * @private
-     * @param {FocusEvent} e - The focus event.
-     */
-
-
-    AccessibilityManager.prototype._onFocus = function _onFocus(e) {
-        var interactionManager = this.renderer.plugins.interaction;
-
-        interactionManager.dispatchEvent(e.target.displayObject, 'mouseover', interactionManager.eventData);
-    };
-
-    /**
-     * Maps the div focus events to pixi's InteractionManager (mouseout)
-     *
-     * @private
-     * @param {FocusEvent} e - The focusout event.
-     */
-
-
-    AccessibilityManager.prototype._onFocusOut = function _onFocusOut(e) {
-        var interactionManager = this.renderer.plugins.interaction;
-
-        interactionManager.dispatchEvent(e.target.displayObject, 'mouseout', interactionManager.eventData);
-    };
-
-    /**
-     * Is called when a key is pressed
-     *
-     * @private
-     * @param {KeyboardEvent} e - The keydown event.
-     */
-
-
-    AccessibilityManager.prototype._onKeyDown = function _onKeyDown(e) {
-        if (e.keyCode !== KEY_CODE_TAB) {
-            return;
-        }
-
-        this.activate();
-    };
-
-    /**
-     * Is called when the mouse moves across the renderer element
-     *
-     * @private
-     */
-
-
-    AccessibilityManager.prototype._onMouseMove = function _onMouseMove() {
-        this.deactivate();
-    };
-
-    /**
-     * Destroys the accessibility manager
-     *
-     */
-
-
-    AccessibilityManager.prototype.destroy = function destroy() {
-        this.div = null;
-
-        for (var i = 0; i < this.children.length; i++) {
-            this.children[i].div = null;
-        }
-
-        window.document.removeEventListener('mousemove', this._onMouseMove);
-        window.removeEventListener('keydown', this._onKeyDown);
-
-        this.pool = null;
-        this.children = null;
-        this.renderer = null;
-    };
-
-    return AccessibilityManager;
-}();
-
-exports.default = AccessibilityManager;
-
-
-core.WebGLRenderer.registerPlugin('accessibility', AccessibilityManager);
-core.CanvasRenderer.registerPlugin('accessibility', AccessibilityManager);
-
-},{"../core":65,"./accessibleTarget":41,"ismobilejs":4}],41:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-/**
- * Default property values of accessible objects
- * used by {@link PIXI.accessibility.AccessibilityManager}.
- *
- * @function accessibleTarget
- * @memberof PIXI.accessibility
- * @example
- *      function MyObject() {}
- *
- *      Object.assign(
- *          MyObject.prototype,
- *          PIXI.accessibility.accessibleTarget
- *      );
- */
-exports.default = {
-  /**
-   *  Flag for if the object is accessible. If true AccessibilityManager will overlay a
-   *   shadow div with attributes set
-   *
-   * @member {boolean}
-   */
-  accessible: false,
-
-  /**
-   * Sets the title attribute of the shadow div
-   * If accessibleTitle AND accessibleHint has not been this will default to 'displayObject [tabIndex]'
-   *
-   * @member {string}
-   */
-  accessibleTitle: null,
-
-  /**
-   * Sets the aria-label attribute of the shadow div
-   *
-   * @member {string}
-   */
-  accessibleHint: null,
-
-  /**
-   * @todo Needs docs.
-   */
-  tabIndex: 0,
-
-  /**
-   * @todo Needs docs.
-   */
-  _accessibleActive: false,
-
-  /**
-   * @todo Needs docs.
-   */
-  _accessibleDiv: false
-};
-
-},{}],42:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _accessibleTarget = require('./accessibleTarget');
-
-Object.defineProperty(exports, 'accessibleTarget', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_accessibleTarget).default;
-  }
-});
-
-var _AccessibilityManager = require('./AccessibilityManager');
-
-Object.defineProperty(exports, 'AccessibilityManager', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_AccessibilityManager).default;
-  }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./AccessibilityManager":40,"./accessibleTarget":41}],43:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _autoDetectRenderer = require('./autoDetectRenderer');
-
-var _Container = require('./display/Container');
-
-var _Container2 = _interopRequireDefault(_Container);
-
-var _ticker = require('./ticker');
-
-var _settings = require('./settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _const = require('./const');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Convenience class to create a new PIXI application.
- * This class automatically creates the renderer, ticker
- * and root container.
- *
- * @example
- * // Create the application
- * const app = new PIXI.Application();
- *
- * // Add the view to the DOM
- * document.body.appendChild(app.view);
- *
- * // ex, add display objects
- * app.stage.addChild(PIXI.Sprite.fromImage('something.png'));
- *
- * @class
- * @memberof PIXI
- */
-var Application = function () {
-    // eslint-disable-next-line valid-jsdoc
-    /**
-     * @param {object} [options] - The optional renderer parameters
-     * @param {number} [options.width=800] - the width of the renderers view
-     * @param {number} [options.height=600] - the height of the renderers view
-     * @param {HTMLCanvasElement} [options.view] - the canvas to use as a view, optional
-     * @param {boolean} [options.transparent=false] - If the render view is transparent, default false
-     * @param {boolean} [options.antialias=false] - sets antialias (only applicable in chrome at the moment)
-     * @param {boolean} [options.preserveDrawingBuffer=false] - enables drawing buffer preservation, enable this if you
-     *  need to call toDataUrl on the webgl context
-     * @param {number} [options.resolution=1] - The resolution / device pixel ratio of the renderer, retina would be 2
-     * @param {boolean} [options.forceCanvas=false] - prevents selection of WebGL renderer, even if such is present
-     * @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area
-     *  (shown if not transparent).
-     * @param {boolean} [options.clearBeforeRender=true] - This sets if the renderer will clear the canvas or
-     *   not before the new render pass.
-     * @param {boolean} [options.roundPixels=false] - If true PixiJS will Math.floor() x/y values when rendering,
-     *  stopping pixel interpolation.
-     * @param {boolean} [options.forceFXAA=false] - forces FXAA antialiasing to be used over native.
-     *  FXAA is faster, but may not always look as great **webgl only**
-     * @param {boolean} [options.legacy=false] - `true` to ensure compatibility with older / less advanced devices.
-     *  If you experience unexplained flickering try setting this to true. **webgl only**
-     * @param {boolean} [options.sharedTicker=false] - `true` to use PIXI.ticker.shared, `false` to create new ticker.
-     * @param {boolean} [options.sharedLoader=false] - `true` to use PIXI.loaders.shared, `false` to create new Loader.
-     */
-    function Application(options, arg2, arg3, arg4, arg5) {
-        _classCallCheck(this, Application);
-
-        // Support for constructor(width, height, options, noWebGL, useSharedTicker)
-        if (typeof options === 'number') {
-            options = Object.assign({
-                width: options,
-                height: arg2 || _settings2.default.RENDER_OPTIONS.height,
-                forceCanvas: !!arg4,
-                sharedTicker: !!arg5
-            }, arg3);
-        }
-
-        /**
-         * The default options, so we mixin functionality later.
-         * @member {object}
-         * @protected
-         */
-        this._options = options = Object.assign({
-            sharedTicker: false,
-            forceCanvas: false,
-            sharedLoader: false
-        }, options);
-
-        /**
-         * WebGL renderer if available, otherwise CanvasRenderer
-         * @member {PIXI.WebGLRenderer|PIXI.CanvasRenderer}
-         */
-        this.renderer = (0, _autoDetectRenderer.autoDetectRenderer)(options);
-
-        /**
-         * The root display container that's rendered.
-         * @member {PIXI.Container}
-         */
-        this.stage = new _Container2.default();
-
-        /**
-         * Internal reference to the ticker
-         * @member {PIXI.ticker.Ticker}
-         * @private
-         */
-        this._ticker = null;
-
-        /**
-         * Ticker for doing render updates.
-         * @member {PIXI.ticker.Ticker}
-         * @default PIXI.ticker.shared
-         */
-        this.ticker = options.sharedTicker ? _ticker.shared : new _ticker.Ticker();
-
-        // Start the rendering
-        this.start();
-    }
-
-    /**
-     * Render the current stage.
-     */
-    Application.prototype.render = function render() {
-        this.renderer.render(this.stage);
-    };
-
-    /**
-     * Convenience method for stopping the render.
-     */
-
-
-    Application.prototype.stop = function stop() {
-        this._ticker.stop();
-    };
-
-    /**
-     * Convenience method for starting the render.
-     */
-
-
-    Application.prototype.start = function start() {
-        this._ticker.start();
-    };
-
-    /**
-     * Reference to the renderer's canvas element.
-     * @member {HTMLCanvasElement}
-     * @readonly
-     */
-
-
-    /**
-     * Destroy and don't use after this.
-     * @param {Boolean} [removeView=false] Automatically remove canvas from DOM.
-     */
-    Application.prototype.destroy = function destroy(removeView) {
-        var oldTicker = this._ticker;
-
-        this.ticker = null;
-
-        oldTicker.destroy();
-
-        this.stage.destroy();
-        this.stage = null;
-
-        this.renderer.destroy(removeView);
-        this.renderer = null;
-
-        this._options = null;
-    };
-
-    _createClass(Application, [{
-        key: 'ticker',
-        set: function set(ticker) // eslint-disable-line require-jsdoc
-        {
-            if (this._ticker) {
-                this._ticker.remove(this.render, this);
-            }
-            this._ticker = ticker;
-            if (ticker) {
-                ticker.add(this.render, this, _const.UPDATE_PRIORITY.LOW);
-            }
-        },
-        get: function get() // eslint-disable-line require-jsdoc
-        {
-            return this._ticker;
-        }
-    }, {
-        key: 'view',
-        get: function get() {
-            return this.renderer.view;
-        }
-
-        /**
-         * Reference to the renderer's screen rectangle. Its safe to use as filterArea or hitArea for whole screen
-         * @member {PIXI.Rectangle}
-         * @readonly
-         */
-
-    }, {
-        key: 'screen',
-        get: function get() {
-            return this.renderer.screen;
-        }
-    }]);
-
-    return Application;
-}();
-
-exports.default = Application;
-
-},{"./autoDetectRenderer":45,"./const":46,"./display/Container":48,"./settings":101,"./ticker":120}],44:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _settings = require('./settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-function checkPrecision(src, def) {
-    if (src instanceof Array) {
-        if (src[0].substring(0, 9) !== 'precision') {
-            var copy = src.slice(0);
-
-            copy.unshift('precision ' + def + ' float;');
-
-            return copy;
-        }
-    } else if (src.substring(0, 9) !== 'precision') {
-        return 'precision ' + def + ' float;\n' + src;
-    }
-
-    return src;
-}
-
-/**
- * Wrapper class, webGL Shader for Pixi.
- * Adds precision string if vertexSrc or fragmentSrc have no mention of it.
- *
- * @class
- * @extends GLShader
- * @memberof PIXI
- */
-
-var Shader = function (_GLShader) {
-    _inherits(Shader, _GLShader);
-
-    /**
-     *
-     * @param {WebGLRenderingContext} gl - The current WebGL rendering context
-     * @param {string|string[]} vertexSrc - The vertex shader source as an array of strings.
-     * @param {string|string[]} fragmentSrc - The fragment shader source as an array of strings.
-     */
-    function Shader(gl, vertexSrc, fragmentSrc) {
-        _classCallCheck(this, Shader);
-
-        return _possibleConstructorReturn(this, _GLShader.call(this, gl, checkPrecision(vertexSrc, _settings2.default.PRECISION_VERTEX), checkPrecision(fragmentSrc, _settings2.default.PRECISION_FRAGMENT)));
-    }
-
-    return Shader;
-}(_pixiGlCore.GLShader);
-
-exports.default = Shader;
-
-},{"./settings":101,"pixi-gl-core":12}],45:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.autoDetectRenderer = autoDetectRenderer;
-
-var _utils = require('./utils');
-
-var utils = _interopRequireWildcard(_utils);
-
-var _CanvasRenderer = require('./renderers/canvas/CanvasRenderer');
-
-var _CanvasRenderer2 = _interopRequireDefault(_CanvasRenderer);
-
-var _WebGLRenderer = require('./renderers/webgl/WebGLRenderer');
-
-var _WebGLRenderer2 = _interopRequireDefault(_WebGLRenderer);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-// eslint-disable-next-line valid-jsdoc
-/**
- * This helper function will automatically detect which renderer you should be using.
- * WebGL is the preferred renderer as it is a lot faster. If webGL is not supported by
- * the browser then this function will return a canvas renderer
- *
- * @memberof PIXI
- * @function autoDetectRenderer
- * @param {object} [options] - The optional renderer parameters
- * @param {number} [options.width=800] - the width of the renderers view
- * @param {number} [options.height=600] - the height of the renderers view
- * @param {HTMLCanvasElement} [options.view] - the canvas to use as a view, optional
- * @param {boolean} [options.transparent=false] - If the render view is transparent, default false
- * @param {boolean} [options.antialias=false] - sets antialias (only applicable in chrome at the moment)
- * @param {boolean} [options.preserveDrawingBuffer=false] - enables drawing buffer preservation, enable this if you
- *  need to call toDataUrl on the webgl context
- * @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area
- *  (shown if not transparent).
- * @param {boolean} [options.clearBeforeRender=true] - This sets if the renderer will clear the canvas or
- *   not before the new render pass.
- * @param {number} [options.resolution=1] - The resolution / device pixel ratio of the renderer, retina would be 2
- * @param {boolean} [options.forceCanvas=false] - prevents selection of WebGL renderer, even if such is present
- * @param {boolean} [options.roundPixels=false] - If true PixiJS will Math.floor() x/y values when rendering,
- *  stopping pixel interpolation.
- * @param {boolean} [options.forceFXAA=false] - forces FXAA antialiasing to be used over native.
- *  FXAA is faster, but may not always look as great **webgl only**
- * @param {boolean} [options.legacy=false] - `true` to ensure compatibility with older / less advanced devices.
- *  If you experience unexplained flickering try setting this to true. **webgl only**
- * @return {PIXI.WebGLRenderer|PIXI.CanvasRenderer} Returns WebGL renderer if available, otherwise CanvasRenderer
- */
-function autoDetectRenderer(options, arg1, arg2, arg3) {
-    // Backward-compatible support for noWebGL option
-    var forceCanvas = options && options.forceCanvas;
-
-    if (arg3 !== undefined) {
-        forceCanvas = arg3;
-    }
-
-    if (!forceCanvas && utils.isWebGLSupported()) {
-        return new _WebGLRenderer2.default(options, arg1, arg2);
-    }
-
-    return new _CanvasRenderer2.default(options, arg1, arg2);
-}
-
-},{"./renderers/canvas/CanvasRenderer":77,"./renderers/webgl/WebGLRenderer":84,"./utils":124}],46:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-/**
- * String of the current PIXI version.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @name VERSION
- * @type {string}
- */
-var VERSION = exports.VERSION = '4.5.4';
-
-/**
- * Two Pi.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @type {number}
- */
-var PI_2 = exports.PI_2 = Math.PI * 2;
-
-/**
- * Conversion factor for converting radians to degrees.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @type {number}
- */
-var RAD_TO_DEG = exports.RAD_TO_DEG = 180 / Math.PI;
-
-/**
- * Conversion factor for converting degrees to radians.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @type {number}
- */
-var DEG_TO_RAD = exports.DEG_TO_RAD = Math.PI / 180;
-
-/**
- * Constant to identify the Renderer Type.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @name RENDERER_TYPE
- * @type {object}
- * @property {number} UNKNOWN - Unknown render type.
- * @property {number} WEBGL - WebGL render type.
- * @property {number} CANVAS - Canvas render type.
- */
-var RENDERER_TYPE = exports.RENDERER_TYPE = {
-  UNKNOWN: 0,
-  WEBGL: 1,
-  CANVAS: 2
-};
-
-/**
- * Various blend modes supported by PIXI.
- *
- * IMPORTANT - The WebGL renderer only supports the NORMAL, ADD, MULTIPLY and SCREEN blend modes.
- * Anything else will silently act like NORMAL.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @name BLEND_MODES
- * @type {object}
- * @property {number} NORMAL
- * @property {number} ADD
- * @property {number} MULTIPLY
- * @property {number} SCREEN
- * @property {number} OVERLAY
- * @property {number} DARKEN
- * @property {number} LIGHTEN
- * @property {number} COLOR_DODGE
- * @property {number} COLOR_BURN
- * @property {number} HARD_LIGHT
- * @property {number} SOFT_LIGHT
- * @property {number} DIFFERENCE
- * @property {number} EXCLUSION
- * @property {number} HUE
- * @property {number} SATURATION
- * @property {number} COLOR
- * @property {number} LUMINOSITY
- */
-var BLEND_MODES = exports.BLEND_MODES = {
-  NORMAL: 0,
-  ADD: 1,
-  MULTIPLY: 2,
-  SCREEN: 3,
-  OVERLAY: 4,
-  DARKEN: 5,
-  LIGHTEN: 6,
-  COLOR_DODGE: 7,
-  COLOR_BURN: 8,
-  HARD_LIGHT: 9,
-  SOFT_LIGHT: 10,
-  DIFFERENCE: 11,
-  EXCLUSION: 12,
-  HUE: 13,
-  SATURATION: 14,
-  COLOR: 15,
-  LUMINOSITY: 16,
-  NORMAL_NPM: 17,
-  ADD_NPM: 18,
-  SCREEN_NPM: 19
-};
-
-/**
- * Various webgl draw modes. These can be used to specify which GL drawMode to use
- * under certain situations and renderers.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @name DRAW_MODES
- * @type {object}
- * @property {number} POINTS
- * @property {number} LINES
- * @property {number} LINE_LOOP
- * @property {number} LINE_STRIP
- * @property {number} TRIANGLES
- * @property {number} TRIANGLE_STRIP
- * @property {number} TRIANGLE_FAN
- */
-var DRAW_MODES = exports.DRAW_MODES = {
-  POINTS: 0,
-  LINES: 1,
-  LINE_LOOP: 2,
-  LINE_STRIP: 3,
-  TRIANGLES: 4,
-  TRIANGLE_STRIP: 5,
-  TRIANGLE_FAN: 6
-};
-
-/**
- * The scale modes that are supported by pixi.
- *
- * The {@link PIXI.settings.SCALE_MODE} scale mode affects the default scaling mode of future operations.
- * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @name SCALE_MODES
- * @type {object}
- * @property {number} LINEAR Smooth scaling
- * @property {number} NEAREST Pixelating scaling
- */
-var SCALE_MODES = exports.SCALE_MODES = {
-  LINEAR: 0,
-  NEAREST: 1
-};
-
-/**
- * The wrap modes that are supported by pixi.
- *
- * The {@link PIXI.settings.WRAP_MODE} wrap mode affects the default wraping mode of future operations.
- * It can be re-assigned to either CLAMP or REPEAT, depending upon suitability.
- * If the texture is non power of two then clamp will be used regardless as webGL can
- * only use REPEAT if the texture is po2.
- *
- * This property only affects WebGL.
- *
- * @static
- * @constant
- * @name WRAP_MODES
- * @memberof PIXI
- * @type {object}
- * @property {number} CLAMP - The textures uvs are clamped
- * @property {number} REPEAT - The texture uvs tile and repeat
- * @property {number} MIRRORED_REPEAT - The texture uvs tile and repeat with mirroring
- */
-var WRAP_MODES = exports.WRAP_MODES = {
-  CLAMP: 0,
-  REPEAT: 1,
-  MIRRORED_REPEAT: 2
-};
-
-/**
- * The gc modes that are supported by pixi.
- *
- * The {@link PIXI.settings.GC_MODE} Garbage Collection mode for PixiJS textures is AUTO
- * If set to GC_MODE, the renderer will occasionally check textures usage. If they are not
- * used for a specified period of time they will be removed from the GPU. They will of course
- * be uploaded again when they are required. This is a silent behind the scenes process that
- * should ensure that the GPU does not  get filled up.
- *
- * Handy for mobile devices!
- * This property only affects WebGL.
- *
- * @static
- * @constant
- * @name GC_MODES
- * @memberof PIXI
- * @type {object}
- * @property {number} AUTO - Garbage collection will happen periodically automatically
- * @property {number} MANUAL - Garbage collection will need to be called manually
- */
-var GC_MODES = exports.GC_MODES = {
-  AUTO: 0,
-  MANUAL: 1
-};
-
-/**
- * Regexp for image type by extension.
- *
- * @static
- * @constant
- * @memberof PIXI
- * @type {RegExp|string}
- * @example `image.png`
- */
-var URL_FILE_EXTENSION = exports.URL_FILE_EXTENSION = /\.(\w{3,4})(?:$|\?|#)/i;
-
-/**
- * Regexp for data URI.
- * Based on: {@link https://github.com/ragingwind/data-uri-regex}
- *
- * @static
- * @constant
- * @name DATA_URI
- * @memberof PIXI
- * @type {RegExp|string}
- * @example data:image/png;base64
- */
-var DATA_URI = exports.DATA_URI = /^\s*data:(?:([\w-]+)\/([\w+.-]+))?(?:;(charset=[\w-]+|base64))?,(.*)/i;
-
-/**
- * Regexp for SVG size.
- *
- * @static
- * @constant
- * @name SVG_SIZE
- * @memberof PIXI
- * @type {RegExp|string}
- * @example &lt;svg width="100" height="100"&gt;&lt;/svg&gt;
- */
-var SVG_SIZE = exports.SVG_SIZE = /<svg[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*>/i; // eslint-disable-line max-len
-
-/**
- * Constants that identify shapes, mainly to prevent `instanceof` calls.
- *
- * @static
- * @constant
- * @name SHAPES
- * @memberof PIXI
- * @type {object}
- * @property {number} POLY Polygon
- * @property {number} RECT Rectangle
- * @property {number} CIRC Circle
- * @property {number} ELIP Ellipse
- * @property {number} RREC Rounded Rectangle
- */
-var SHAPES = exports.SHAPES = {
-  POLY: 0,
-  RECT: 1,
-  CIRC: 2,
-  ELIP: 3,
-  RREC: 4
-};
-
-/**
- * Constants that specify float precision in shaders.
- *
- * @static
- * @constant
- * @name PRECISION
- * @memberof PIXI
- * @type {object}
- * @property {string} LOW='lowp'
- * @property {string} MEDIUM='mediump'
- * @property {string} HIGH='highp'
- */
-var PRECISION = exports.PRECISION = {
-  LOW: 'lowp',
-  MEDIUM: 'mediump',
-  HIGH: 'highp'
-};
-
-/**
- * Constants that specify the transform type.
- *
- * @static
- * @constant
- * @name TRANSFORM_MODE
- * @memberof PIXI
- * @type {object}
- * @property {number} STATIC
- * @property {number} DYNAMIC
- */
-var TRANSFORM_MODE = exports.TRANSFORM_MODE = {
-  STATIC: 0,
-  DYNAMIC: 1
-};
-
-/**
- * Constants that define the type of gradient on text.
- *
- * @static
- * @constant
- * @name TEXT_GRADIENT
- * @memberof PIXI
- * @type {object}
- * @property {number} LINEAR_VERTICAL Vertical gradient
- * @property {number} LINEAR_HORIZONTAL Linear gradient
- */
-var TEXT_GRADIENT = exports.TEXT_GRADIENT = {
-  LINEAR_VERTICAL: 0,
-  LINEAR_HORIZONTAL: 1
-};
-
-/**
- * Represents the update priorities used by internal PIXI classes when registered with
- * the {@link PIXI.ticker.Ticker} object. Higher priority items are updated first and lower
- * priority items, such as render, should go later.
- *
- * @static
- * @constant
- * @name UPDATE_PRIORITY
- * @memberof PIXI
- * @type {object}
- * @property {number} INTERACTION=50 Highest priority, used for {@link PIXI.interaction.InteractionManager}
- * @property {number} HIGH=25 High priority updating, {@link PIXI.VideoBaseTexture} and {@link PIXI.extras.AnimatedSprite}
- * @property {number} NORMAL=0 Default priority for ticker events, see {@link PIXI.ticker.Ticker#add}.
- * @property {number} LOW=-25 Low priority used for {@link PIXI.Application} rendering.
- * @property {number} UTILITY=-50 Lowest priority used for {@link PIXI.prepare.BasePrepare} utility.
- */
-var UPDATE_PRIORITY = exports.UPDATE_PRIORITY = {
-  INTERACTION: 50,
-  HIGH: 25,
-  NORMAL: 0,
-  LOW: -25,
-  UTILITY: -50
-};
-
-},{}],47:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _math = require('../math');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * 'Builder' pattern for bounds rectangles
- * Axis-Aligned Bounding Box
- * It is not a shape! Its mutable thing, no 'EMPTY' or that kind of problems
- *
- * @class
- * @memberof PIXI
- */
-var Bounds = function () {
-    /**
-     *
-     */
-    function Bounds() {
-        _classCallCheck(this, Bounds);
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.minX = Infinity;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.minY = Infinity;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.maxX = -Infinity;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.maxY = -Infinity;
-
-        this.rect = null;
-    }
-
-    /**
-     * Checks if bounds are empty.
-     *
-     * @return {boolean} True if empty.
-     */
-
-
-    Bounds.prototype.isEmpty = function isEmpty() {
-        return this.minX > this.maxX || this.minY > this.maxY;
-    };
-
-    /**
-     * Clears the bounds and resets.
-     *
-     */
-
-
-    Bounds.prototype.clear = function clear() {
-        this.updateID++;
-
-        this.minX = Infinity;
-        this.minY = Infinity;
-        this.maxX = -Infinity;
-        this.maxY = -Infinity;
-    };
-
-    /**
-     * Can return Rectangle.EMPTY constant, either construct new rectangle, either use your rectangle
-     * It is not guaranteed that it will return tempRect
-     *
-     * @param {PIXI.Rectangle} rect - temporary object will be used if AABB is not empty
-     * @returns {PIXI.Rectangle} A rectangle of the bounds
-     */
-
-
-    Bounds.prototype.getRectangle = function getRectangle(rect) {
-        if (this.minX > this.maxX || this.minY > this.maxY) {
-            return _math.Rectangle.EMPTY;
-        }
-
-        rect = rect || new _math.Rectangle(0, 0, 1, 1);
-
-        rect.x = this.minX;
-        rect.y = this.minY;
-        rect.width = this.maxX - this.minX;
-        rect.height = this.maxY - this.minY;
-
-        return rect;
-    };
-
-    /**
-     * This function should be inlined when its possible.
-     *
-     * @param {PIXI.Point} point - The point to add.
-     */
-
-
-    Bounds.prototype.addPoint = function addPoint(point) {
-        this.minX = Math.min(this.minX, point.x);
-        this.maxX = Math.max(this.maxX, point.x);
-        this.minY = Math.min(this.minY, point.y);
-        this.maxY = Math.max(this.maxY, point.y);
-    };
-
-    /**
-     * Adds a quad, not transformed
-     *
-     * @param {Float32Array} vertices - The verts to add.
-     */
-
-
-    Bounds.prototype.addQuad = function addQuad(vertices) {
-        var minX = this.minX;
-        var minY = this.minY;
-        var maxX = this.maxX;
-        var maxY = this.maxY;
-
-        var x = vertices[0];
-        var y = vertices[1];
-
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        x = vertices[2];
-        y = vertices[3];
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        x = vertices[4];
-        y = vertices[5];
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        x = vertices[6];
-        y = vertices[7];
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        this.minX = minX;
-        this.minY = minY;
-        this.maxX = maxX;
-        this.maxY = maxY;
-    };
-
-    /**
-     * Adds sprite frame, transformed.
-     *
-     * @param {PIXI.TransformBase} transform - TODO
-     * @param {number} x0 - TODO
-     * @param {number} y0 - TODO
-     * @param {number} x1 - TODO
-     * @param {number} y1 - TODO
-     */
-
-
-    Bounds.prototype.addFrame = function addFrame(transform, x0, y0, x1, y1) {
-        var matrix = transform.worldTransform;
-        var a = matrix.a;
-        var b = matrix.b;
-        var c = matrix.c;
-        var d = matrix.d;
-        var tx = matrix.tx;
-        var ty = matrix.ty;
-
-        var minX = this.minX;
-        var minY = this.minY;
-        var maxX = this.maxX;
-        var maxY = this.maxY;
-
-        var x = a * x0 + c * y0 + tx;
-        var y = b * x0 + d * y0 + ty;
-
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        x = a * x1 + c * y0 + tx;
-        y = b * x1 + d * y0 + ty;
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        x = a * x0 + c * y1 + tx;
-        y = b * x0 + d * y1 + ty;
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        x = a * x1 + c * y1 + tx;
-        y = b * x1 + d * y1 + ty;
-        minX = x < minX ? x : minX;
-        minY = y < minY ? y : minY;
-        maxX = x > maxX ? x : maxX;
-        maxY = y > maxY ? y : maxY;
-
-        this.minX = minX;
-        this.minY = minY;
-        this.maxX = maxX;
-        this.maxY = maxY;
-    };
-
-    /**
-     * Add an array of vertices
-     *
-     * @param {PIXI.TransformBase} transform - TODO
-     * @param {Float32Array} vertices - TODO
-     * @param {number} beginOffset - TODO
-     * @param {number} endOffset - TODO
-     */
-
-
-    Bounds.prototype.addVertices = function addVertices(transform, vertices, beginOffset, endOffset) {
-        var matrix = transform.worldTransform;
-        var a = matrix.a;
-        var b = matrix.b;
-        var c = matrix.c;
-        var d = matrix.d;
-        var tx = matrix.tx;
-        var ty = matrix.ty;
-
-        var minX = this.minX;
-        var minY = this.minY;
-        var maxX = this.maxX;
-        var maxY = this.maxY;
-
-        for (var i = beginOffset; i < endOffset; i += 2) {
-            var rawX = vertices[i];
-            var rawY = vertices[i + 1];
-            var x = a * rawX + c * rawY + tx;
-            var y = d * rawY + b * rawX + ty;
-
-            minX = x < minX ? x : minX;
-            minY = y < minY ? y : minY;
-            maxX = x > maxX ? x : maxX;
-            maxY = y > maxY ? y : maxY;
-        }
-
-        this.minX = minX;
-        this.minY = minY;
-        this.maxX = maxX;
-        this.maxY = maxY;
-    };
-
-    /**
-     * Adds other Bounds
-     *
-     * @param {PIXI.Bounds} bounds - TODO
-     */
-
-
-    Bounds.prototype.addBounds = function addBounds(bounds) {
-        var minX = this.minX;
-        var minY = this.minY;
-        var maxX = this.maxX;
-        var maxY = this.maxY;
-
-        this.minX = bounds.minX < minX ? bounds.minX : minX;
-        this.minY = bounds.minY < minY ? bounds.minY : minY;
-        this.maxX = bounds.maxX > maxX ? bounds.maxX : maxX;
-        this.maxY = bounds.maxY > maxY ? bounds.maxY : maxY;
-    };
-
-    /**
-     * Adds other Bounds, masked with Bounds
-     *
-     * @param {PIXI.Bounds} bounds - TODO
-     * @param {PIXI.Bounds} mask - TODO
-     */
-
-
-    Bounds.prototype.addBoundsMask = function addBoundsMask(bounds, mask) {
-        var _minX = bounds.minX > mask.minX ? bounds.minX : mask.minX;
-        var _minY = bounds.minY > mask.minY ? bounds.minY : mask.minY;
-        var _maxX = bounds.maxX < mask.maxX ? bounds.maxX : mask.maxX;
-        var _maxY = bounds.maxY < mask.maxY ? bounds.maxY : mask.maxY;
-
-        if (_minX <= _maxX && _minY <= _maxY) {
-            var minX = this.minX;
-            var minY = this.minY;
-            var maxX = this.maxX;
-            var maxY = this.maxY;
-
-            this.minX = _minX < minX ? _minX : minX;
-            this.minY = _minY < minY ? _minY : minY;
-            this.maxX = _maxX > maxX ? _maxX : maxX;
-            this.maxY = _maxY > maxY ? _maxY : maxY;
-        }
-    };
-
-    /**
-     * Adds other Bounds, masked with Rectangle
-     *
-     * @param {PIXI.Bounds} bounds - TODO
-     * @param {PIXI.Rectangle} area - TODO
-     */
-
-
-    Bounds.prototype.addBoundsArea = function addBoundsArea(bounds, area) {
-        var _minX = bounds.minX > area.x ? bounds.minX : area.x;
-        var _minY = bounds.minY > area.y ? bounds.minY : area.y;
-        var _maxX = bounds.maxX < area.x + area.width ? bounds.maxX : area.x + area.width;
-        var _maxY = bounds.maxY < area.y + area.height ? bounds.maxY : area.y + area.height;
-
-        if (_minX <= _maxX && _minY <= _maxY) {
-            var minX = this.minX;
-            var minY = this.minY;
-            var maxX = this.maxX;
-            var maxY = this.maxY;
-
-            this.minX = _minX < minX ? _minX : minX;
-            this.minY = _minY < minY ? _minY : minY;
-            this.maxX = _maxX > maxX ? _maxX : maxX;
-            this.maxY = _maxY > maxY ? _maxY : maxY;
-        }
-    };
-
-    return Bounds;
-}();
-
-exports.default = Bounds;
-
-},{"../math":70}],48:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _utils = require('../utils');
-
-var _DisplayObject2 = require('./DisplayObject');
-
-var _DisplayObject3 = _interopRequireDefault(_DisplayObject2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * A Container represents a collection of display objects.
- * It is the base class of all display objects that act as a container for other objects.
- *
- *```js
- * let container = new PIXI.Container();
- * container.addChild(sprite);
- * ```
- *
- * @class
- * @extends PIXI.DisplayObject
- * @memberof PIXI
- */
-var Container = function (_DisplayObject) {
-    _inherits(Container, _DisplayObject);
-
-    /**
-     *
-     */
-    function Container() {
-        _classCallCheck(this, Container);
-
-        /**
-         * The array of children of this container.
-         *
-         * @member {PIXI.DisplayObject[]}
-         * @readonly
-         */
-        var _this = _possibleConstructorReturn(this, _DisplayObject.call(this));
-
-        _this.children = [];
-        return _this;
-    }
-
-    /**
-     * Overridable method that can be used by Container subclasses whenever the children array is modified
-     *
-     * @private
-     */
-
-
-    Container.prototype.onChildrenChange = function onChildrenChange() {}
-    /* empty */
-
-
-    /**
-     * Adds one or more children to the container.
-     *
-     * Multiple items can be added like so: `myContainer.addChild(thingOne, thingTwo, thingThree)`
-     *
-     * @param {...PIXI.DisplayObject} child - The DisplayObject(s) to add to the container
-     * @return {PIXI.DisplayObject} The first child that was added.
-     */
-    ;
-
-    Container.prototype.addChild = function addChild(child) {
-        var argumentsLength = arguments.length;
-
-        // if there is only one argument we can bypass looping through the them
-        if (argumentsLength > 1) {
-            // loop through the arguments property and add all children
-            // use it the right way (.length and [i]) so that this function can still be optimised by JS runtimes
-            for (var i = 0; i < argumentsLength; i++) {
-                this.addChild(arguments[i]);
-            }
-        } else {
-            // if the child has a parent then lets remove it as PixiJS objects can only exist in one place
-            if (child.parent) {
-                child.parent.removeChild(child);
-            }
-
-            child.parent = this;
-            // ensure child transform will be recalculated
-            child.transform._parentID = -1;
-
-            this.children.push(child);
-
-            // ensure bounds will be recalculated
-            this._boundsID++;
-
-            // TODO - lets either do all callbacks or all events.. not both!
-            this.onChildrenChange(this.children.length - 1);
-            child.emit('added', this);
-        }
-
-        return child;
-    };
-
-    /**
-     * Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
-     *
-     * @param {PIXI.DisplayObject} child - The child to add
-     * @param {number} index - The index to place the child in
-     * @return {PIXI.DisplayObject} The child that was added.
-     */
-
-
-    Container.prototype.addChildAt = function addChildAt(child, index) {
-        if (index < 0 || index > this.children.length) {
-            throw new Error(child + 'addChildAt: The index ' + index + ' supplied is out of bounds ' + this.children.length);
-        }
-
-        if (child.parent) {
-            child.parent.removeChild(child);
-        }
-
-        child.parent = this;
-        // ensure child transform will be recalculated
-        child.transform._parentID = -1;
-
-        this.children.splice(index, 0, child);
-
-        // ensure bounds will be recalculated
-        this._boundsID++;
-
-        // TODO - lets either do all callbacks or all events.. not both!
-        this.onChildrenChange(index);
-        child.emit('added', this);
-
-        return child;
-    };
-
-    /**
-     * Swaps the position of 2 Display Objects within this container.
-     *
-     * @param {PIXI.DisplayObject} child - First display object to swap
-     * @param {PIXI.DisplayObject} child2 - Second display object to swap
-     */
-
-
-    Container.prototype.swapChildren = function swapChildren(child, child2) {
-        if (child === child2) {
-            return;
-        }
-
-        var index1 = this.getChildIndex(child);
-        var index2 = this.getChildIndex(child2);
-
-        this.children[index1] = child2;
-        this.children[index2] = child;
-        this.onChildrenChange(index1 < index2 ? index1 : index2);
-    };
-
-    /**
-     * Returns the index position of a child DisplayObject instance
-     *
-     * @param {PIXI.DisplayObject} child - The DisplayObject instance to identify
-     * @return {number} The index position of the child display object to identify
-     */
-
-
-    Container.prototype.getChildIndex = function getChildIndex(child) {
-        var index = this.children.indexOf(child);
-
-        if (index === -1) {
-            throw new Error('The supplied DisplayObject must be a child of the caller');
-        }
-
-        return index;
-    };
-
-    /**
-     * Changes the position of an existing child in the display object container
-     *
-     * @param {PIXI.DisplayObject} child - The child DisplayObject instance for which you want to change the index number
-     * @param {number} index - The resulting index number for the child display object
-     */
-
-
-    Container.prototype.setChildIndex = function setChildIndex(child, index) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('The supplied index is out of bounds');
-        }
-
-        var currentIndex = this.getChildIndex(child);
-
-        (0, _utils.removeItems)(this.children, currentIndex, 1); // remove from old position
-        this.children.splice(index, 0, child); // add at new position
-
-        this.onChildrenChange(index);
-    };
-
-    /**
-     * Returns the child at the specified index
-     *
-     * @param {number} index - The index to get the child at
-     * @return {PIXI.DisplayObject} The child at the given index, if any.
-     */
-
-
-    Container.prototype.getChildAt = function getChildAt(index) {
-        if (index < 0 || index >= this.children.length) {
-            throw new Error('getChildAt: Index (' + index + ') does not exist.');
-        }
-
-        return this.children[index];
-    };
-
-    /**
-     * Removes one or more children from the container.
-     *
-     * @param {...PIXI.DisplayObject} child - The DisplayObject(s) to remove
-     * @return {PIXI.DisplayObject} The first child that was removed.
-     */
-
-
-    Container.prototype.removeChild = function removeChild(child) {
-        var argumentsLength = arguments.length;
-
-        // if there is only one argument we can bypass looping through the them
-        if (argumentsLength > 1) {
-            // loop through the arguments property and add all children
-            // use it the right way (.length and [i]) so that this function can still be optimised by JS runtimes
-            for (var i = 0; i < argumentsLength; i++) {
-                this.removeChild(arguments[i]);
-            }
-        } else {
-            var index = this.children.indexOf(child);
-
-            if (index === -1) return null;
-
-            child.parent = null;
-            // ensure child transform will be recalculated
-            child.transform._parentID = -1;
-            (0, _utils.removeItems)(this.children, index, 1);
-
-            // ensure bounds will be recalculated
-            this._boundsID++;
-
-            // TODO - lets either do all callbacks or all events.. not both!
-            this.onChildrenChange(index);
-            child.emit('removed', this);
-        }
-
-        return child;
-    };
-
-    /**
-     * Removes a child from the specified index position.
-     *
-     * @param {number} index - The index to get the child from
-     * @return {PIXI.DisplayObject} The child that was removed.
-     */
-
-
-    Container.prototype.removeChildAt = function removeChildAt(index) {
-        var child = this.getChildAt(index);
-
-        // ensure child transform will be recalculated..
-        child.parent = null;
-        child.transform._parentID = -1;
-        (0, _utils.removeItems)(this.children, index, 1);
-
-        // ensure bounds will be recalculated
-        this._boundsID++;
-
-        // TODO - lets either do all callbacks or all events.. not both!
-        this.onChildrenChange(index);
-        child.emit('removed', this);
-
-        return child;
-    };
-
-    /**
-     * Removes all children from this container that are within the begin and end indexes.
-     *
-     * @param {number} [beginIndex=0] - The beginning position.
-     * @param {number} [endIndex=this.children.length] - The ending position. Default value is size of the container.
-     * @returns {DisplayObject[]} List of removed children
-     */
-
-
-    Container.prototype.removeChildren = function removeChildren() {
-        var beginIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var endIndex = arguments[1];
-
-        var begin = beginIndex;
-        var end = typeof endIndex === 'number' ? endIndex : this.children.length;
-        var range = end - begin;
-        var removed = void 0;
-
-        if (range > 0 && range <= end) {
-            removed = this.children.splice(begin, range);
-
-            for (var i = 0; i < removed.length; ++i) {
-                removed[i].parent = null;
-                if (removed[i].transform) {
-                    removed[i].transform._parentID = -1;
-                }
-            }
-
-            this._boundsID++;
-
-            this.onChildrenChange(beginIndex);
-
-            for (var _i = 0; _i < removed.length; ++_i) {
-                removed[_i].emit('removed', this);
-            }
-
-            return removed;
-        } else if (range === 0 && this.children.length === 0) {
-            return [];
-        }
-
-        throw new RangeError('removeChildren: numeric values are outside the acceptable range.');
-    };
-
-    /**
-     * Updates the transform on all children of this container for rendering
-     */
-
-
-    Container.prototype.updateTransform = function updateTransform() {
-        this._boundsID++;
-
-        this.transform.updateTransform(this.parent.transform);
-
-        // TODO: check render flags, how to process stuff here
-        this.worldAlpha = this.alpha * this.parent.worldAlpha;
-
-        for (var i = 0, j = this.children.length; i < j; ++i) {
-            var child = this.children[i];
-
-            if (child.visible) {
-                child.updateTransform();
-            }
-        }
-    };
-
-    /**
-     * Recalculates the bounds of the container.
-     *
-     */
-
-
-    Container.prototype.calculateBounds = function calculateBounds() {
-        this._bounds.clear();
-
-        this._calculateBounds();
-
-        for (var i = 0; i < this.children.length; i++) {
-            var child = this.children[i];
-
-            if (!child.visible || !child.renderable) {
-                continue;
-            }
-
-            child.calculateBounds();
-
-            // TODO: filter+mask, need to mask both somehow
-            if (child._mask) {
-                child._mask.calculateBounds();
-                this._bounds.addBoundsMask(child._bounds, child._mask._bounds);
-            } else if (child.filterArea) {
-                this._bounds.addBoundsArea(child._bounds, child.filterArea);
-            } else {
-                this._bounds.addBounds(child._bounds);
-            }
-        }
-
-        this._lastBoundsID = this._boundsID;
-    };
-
-    /**
-     * Recalculates the bounds of the object. Override this to
-     * calculate the bounds of the specific object (not including children).
-     *
-     */
-
-
-    Container.prototype._calculateBounds = function _calculateBounds() {}
-    // FILL IN//
-
-
-    /**
-     * Renders the object using the WebGL renderer
-     *
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-    ;
-
-    Container.prototype.renderWebGL = function renderWebGL(renderer) {
-        // if the object is not visible or the alpha is 0 then no need to render this element
-        if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
-            return;
-        }
-
-        // do a quick check to see if this element has a mask or a filter.
-        if (this._mask || this._filters) {
-            this.renderAdvancedWebGL(renderer);
-        } else {
-            this._renderWebGL(renderer);
-
-            // simple render children!
-            for (var i = 0, j = this.children.length; i < j; ++i) {
-                this.children[i].renderWebGL(renderer);
-            }
-        }
-    };
-
-    /**
-     * Render the object using the WebGL renderer and advanced features.
-     *
-     * @private
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-
-
-    Container.prototype.renderAdvancedWebGL = function renderAdvancedWebGL(renderer) {
-        renderer.flush();
-
-        var filters = this._filters;
-        var mask = this._mask;
-
-        // push filter first as we need to ensure the stencil buffer is correct for any masking
-        if (filters) {
-            if (!this._enabledFilters) {
-                this._enabledFilters = [];
-            }
-
-            this._enabledFilters.length = 0;
-
-            for (var i = 0; i < filters.length; i++) {
-                if (filters[i].enabled) {
-                    this._enabledFilters.push(filters[i]);
-                }
-            }
-
-            if (this._enabledFilters.length) {
-                renderer.filterManager.pushFilter(this, this._enabledFilters);
-            }
-        }
-
-        if (mask) {
-            renderer.maskManager.pushMask(this, this._mask);
-        }
-
-        // add this object to the batch, only rendered if it has a texture.
-        this._renderWebGL(renderer);
-
-        // now loop through the children and make sure they get rendered
-        for (var _i2 = 0, j = this.children.length; _i2 < j; _i2++) {
-            this.children[_i2].renderWebGL(renderer);
-        }
-
-        renderer.flush();
-
-        if (mask) {
-            renderer.maskManager.popMask(this, this._mask);
-        }
-
-        if (filters && this._enabledFilters && this._enabledFilters.length) {
-            renderer.filterManager.popFilter();
-        }
-    };
-
-    /**
-     * To be overridden by the subclasses.
-     *
-     * @private
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-
-
-    Container.prototype._renderWebGL = function _renderWebGL(renderer) // eslint-disable-line no-unused-vars
-    {}
-    // this is where content itself gets rendered...
-
-
-    /**
-     * To be overridden by the subclass
-     *
-     * @private
-     * @param {PIXI.CanvasRenderer} renderer - The renderer
-     */
-    ;
-
-    Container.prototype._renderCanvas = function _renderCanvas(renderer) // eslint-disable-line no-unused-vars
-    {}
-    // this is where content itself gets rendered...
-
-
-    /**
-     * Renders the object using the Canvas renderer
-     *
-     * @param {PIXI.CanvasRenderer} renderer - The renderer
-     */
-    ;
-
-    Container.prototype.renderCanvas = function renderCanvas(renderer) {
-        // if not visible or the alpha is 0 then no need to render this
-        if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
-            return;
-        }
-
-        if (this._mask) {
-            renderer.maskManager.pushMask(this._mask);
-        }
-
-        this._renderCanvas(renderer);
-        for (var i = 0, j = this.children.length; i < j; ++i) {
-            this.children[i].renderCanvas(renderer);
-        }
-
-        if (this._mask) {
-            renderer.maskManager.popMask(renderer);
-        }
-    };
-
-    /**
-     * Removes all internal references and listeners as well as removes children from the display list.
-     * Do not use a Container after calling `destroy`.
-     *
-     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-     *  have been set to that value
-     * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
-     *  method called as well. 'options' will be passed on to those calls.
-     * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
-     *  Should it destroy the texture of the child sprite
-     * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
-     *  Should it destroy the base texture of the child sprite
-     */
-
-
-    Container.prototype.destroy = function destroy(options) {
-        _DisplayObject.prototype.destroy.call(this);
-
-        var destroyChildren = typeof options === 'boolean' ? options : options && options.children;
-
-        var oldChildren = this.removeChildren(0, this.children.length);
-
-        if (destroyChildren) {
-            for (var i = 0; i < oldChildren.length; ++i) {
-                oldChildren[i].destroy(options);
-            }
-        }
-    };
-
-    /**
-     * The width of the Container, setting this will actually modify the scale to achieve the value set
-     *
-     * @member {number}
-     */
-
-
-    _createClass(Container, [{
-        key: 'width',
-        get: function get() {
-            return this.scale.x * this.getLocalBounds().width;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            var width = this.getLocalBounds().width;
-
-            if (width !== 0) {
-                this.scale.x = value / width;
-            } else {
-                this.scale.x = 1;
-            }
-
-            this._width = value;
-        }
-
-        /**
-         * The height of the Container, setting this will actually modify the scale to achieve the value set
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'height',
-        get: function get() {
-            return this.scale.y * this.getLocalBounds().height;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            var height = this.getLocalBounds().height;
-
-            if (height !== 0) {
-                this.scale.y = value / height;
-            } else {
-                this.scale.y = 1;
-            }
-
-            this._height = value;
-        }
-    }]);
-
-    return Container;
-}(_DisplayObject3.default);
-
-// performance increase to avoid using call.. (10x faster)
-
-
-exports.default = Container;
-Container.prototype.containerUpdateTransform = Container.prototype.updateTransform;
-
-},{"../utils":124,"./DisplayObject":49}],49:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _eventemitter = require('eventemitter3');
-
-var _eventemitter2 = _interopRequireDefault(_eventemitter);
-
-var _const = require('../const');
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _TransformStatic = require('./TransformStatic');
-
-var _TransformStatic2 = _interopRequireDefault(_TransformStatic);
-
-var _Transform = require('./Transform');
-
-var _Transform2 = _interopRequireDefault(_Transform);
-
-var _Bounds = require('./Bounds');
-
-var _Bounds2 = _interopRequireDefault(_Bounds);
-
-var _math = require('../math');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-// _tempDisplayObjectParent = new DisplayObject();
-
-/**
- * The base class for all objects that are rendered on the screen.
- * This is an abstract class and should not be used on its own rather it should be extended.
- *
- * @class
- * @extends EventEmitter
- * @memberof PIXI
- */
-var DisplayObject = function (_EventEmitter) {
-    _inherits(DisplayObject, _EventEmitter);
-
-    /**
-     *
-     */
-    function DisplayObject() {
-        _classCallCheck(this, DisplayObject);
-
-        var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
-
-        var TransformClass = _settings2.default.TRANSFORM_MODE === _const.TRANSFORM_MODE.STATIC ? _TransformStatic2.default : _Transform2.default;
-
-        _this.tempDisplayObjectParent = null;
-
-        // TODO: need to create Transform from factory
-        /**
-         * World transform and local transform of this object.
-         * This will become read-only later, please do not assign anything there unless you know what are you doing
-         *
-         * @member {PIXI.TransformBase}
-         */
-        _this.transform = new TransformClass();
-
-        /**
-         * The opacity of the object.
-         *
-         * @member {number}
-         */
-        _this.alpha = 1;
-
-        /**
-         * The visibility of the object. If false the object will not be drawn, and
-         * the updateTransform function will not be called.
-         *
-         * Only affects recursive calls from parent. You can ask for bounds or call updateTransform manually
-         *
-         * @member {boolean}
-         */
-        _this.visible = true;
-
-        /**
-         * Can this object be rendered, if false the object will not be drawn but the updateTransform
-         * methods will still be called.
-         *
-         * Only affects recursive calls from parent. You can ask for bounds manually
-         *
-         * @member {boolean}
-         */
-        _this.renderable = true;
-
-        /**
-         * The display object container that contains this display object.
-         *
-         * @member {PIXI.Container}
-         * @readonly
-         */
-        _this.parent = null;
-
-        /**
-         * The multiplied alpha of the displayObject
-         *
-         * @member {number}
-         * @readonly
-         */
-        _this.worldAlpha = 1;
-
-        /**
-         * The area the filter is applied to. This is used as more of an optimisation
-         * rather than figuring out the dimensions of the displayObject each frame you can set this rectangle
-         *
-         * Also works as an interaction mask
-         *
-         * @member {PIXI.Rectangle}
-         */
-        _this.filterArea = null;
-
-        _this._filters = null;
-        _this._enabledFilters = null;
-
-        /**
-         * The bounds object, this is used to calculate and store the bounds of the displayObject
-         *
-         * @member {PIXI.Rectangle}
-         * @private
-         */
-        _this._bounds = new _Bounds2.default();
-        _this._boundsID = 0;
-        _this._lastBoundsID = -1;
-        _this._boundsRect = null;
-        _this._localBoundsRect = null;
-
-        /**
-         * The original, cached mask of the object
-         *
-         * @member {PIXI.Graphics|PIXI.Sprite}
-         * @private
-         */
-        _this._mask = null;
-
-        /**
-         * If the object has been destroyed via destroy(). If true, it should not be used.
-         *
-         * @member {boolean}
-         * @private
-         * @readonly
-         */
-        _this._destroyed = false;
-
-        /**
-         * Fired when this DisplayObject is added to a Container.
-         *
-         * @event PIXI.DisplayObject#added
-         * @param {PIXI.Container} container - The container added to.
-         */
-
-        /**
-         * Fired when this DisplayObject is removed from a Container.
-         *
-         * @event PIXI.DisplayObject#removed
-         * @param {PIXI.Container} container - The container removed from.
-         */
-        return _this;
-    }
-
-    /**
-     * @private
-     * @member {PIXI.DisplayObject}
-     */
-
-
-    /**
-     * Updates the object transform for rendering
-     *
-     * TODO - Optimization pass!
-     */
-    DisplayObject.prototype.updateTransform = function updateTransform() {
-        this.transform.updateTransform(this.parent.transform);
-        // multiply the alphas..
-        this.worldAlpha = this.alpha * this.parent.worldAlpha;
-
-        this._bounds.updateID++;
-    };
-
-    /**
-     * recursively updates transform of all objects from the root to this one
-     * internal function for toLocal()
-     */
-
-
-    DisplayObject.prototype._recursivePostUpdateTransform = function _recursivePostUpdateTransform() {
-        if (this.parent) {
-            this.parent._recursivePostUpdateTransform();
-            this.transform.updateTransform(this.parent.transform);
-        } else {
-            this.transform.updateTransform(this._tempDisplayObjectParent.transform);
-        }
-    };
-
-    /**
-     * Retrieves the bounds of the displayObject as a rectangle object.
-     *
-     * @param {boolean} skipUpdate - setting to true will stop the transforms of the scene graph from
-     *  being updated. This means the calculation returned MAY be out of date BUT will give you a
-     *  nice performance boost
-     * @param {PIXI.Rectangle} rect - Optional rectangle to store the result of the bounds calculation
-     * @return {PIXI.Rectangle} the rectangular bounding area
-     */
-
-
-    DisplayObject.prototype.getBounds = function getBounds(skipUpdate, rect) {
-        if (!skipUpdate) {
-            if (!this.parent) {
-                this.parent = this._tempDisplayObjectParent;
-                this.updateTransform();
-                this.parent = null;
-            } else {
-                this._recursivePostUpdateTransform();
-                this.updateTransform();
-            }
-        }
-
-        if (this._boundsID !== this._lastBoundsID) {
-            this.calculateBounds();
-        }
-
-        if (!rect) {
-            if (!this._boundsRect) {
-                this._boundsRect = new _math.Rectangle();
-            }
-
-            rect = this._boundsRect;
-        }
-
-        return this._bounds.getRectangle(rect);
-    };
-
-    /**
-     * Retrieves the local bounds of the displayObject as a rectangle object
-     *
-     * @param {PIXI.Rectangle} [rect] - Optional rectangle to store the result of the bounds calculation
-     * @return {PIXI.Rectangle} the rectangular bounding area
-     */
-
-
-    DisplayObject.prototype.getLocalBounds = function getLocalBounds(rect) {
-        var transformRef = this.transform;
-        var parentRef = this.parent;
-
-        this.parent = null;
-        this.transform = this._tempDisplayObjectParent.transform;
-
-        if (!rect) {
-            if (!this._localBoundsRect) {
-                this._localBoundsRect = new _math.Rectangle();
-            }
-
-            rect = this._localBoundsRect;
-        }
-
-        var bounds = this.getBounds(false, rect);
-
-        this.parent = parentRef;
-        this.transform = transformRef;
-
-        return bounds;
-    };
-
-    /**
-     * Calculates the global position of the display object
-     *
-     * @param {PIXI.Point} position - The world origin to calculate from
-     * @param {PIXI.Point} [point] - A Point object in which to store the value, optional
-     *  (otherwise will create a new Point)
-     * @param {boolean} [skipUpdate=false] - Should we skip the update transform.
-     * @return {PIXI.Point} A point object representing the position of this object
-     */
-
-
-    DisplayObject.prototype.toGlobal = function toGlobal(position, point) {
-        var skipUpdate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-        if (!skipUpdate) {
-            this._recursivePostUpdateTransform();
-
-            // this parent check is for just in case the item is a root object.
-            // If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
-            // this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
-            if (!this.parent) {
-                this.parent = this._tempDisplayObjectParent;
-                this.displayObjectUpdateTransform();
-                this.parent = null;
-            } else {
-                this.displayObjectUpdateTransform();
-            }
-        }
-
-        // don't need to update the lot
-        return this.worldTransform.apply(position, point);
-    };
-
-    /**
-     * Calculates the local position of the display object relative to another point
-     *
-     * @param {PIXI.Point} position - The world origin to calculate from
-     * @param {PIXI.DisplayObject} [from] - The DisplayObject to calculate the global position from
-     * @param {PIXI.Point} [point] - A Point object in which to store the value, optional
-     *  (otherwise will create a new Point)
-     * @param {boolean} [skipUpdate=false] - Should we skip the update transform
-     * @return {PIXI.Point} A point object representing the position of this object
-     */
-
-
-    DisplayObject.prototype.toLocal = function toLocal(position, from, point, skipUpdate) {
-        if (from) {
-            position = from.toGlobal(position, point, skipUpdate);
-        }
-
-        if (!skipUpdate) {
-            this._recursivePostUpdateTransform();
-
-            // this parent check is for just in case the item is a root object.
-            // If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
-            // this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
-            if (!this.parent) {
-                this.parent = this._tempDisplayObjectParent;
-                this.displayObjectUpdateTransform();
-                this.parent = null;
-            } else {
-                this.displayObjectUpdateTransform();
-            }
-        }
-
-        // simply apply the matrix..
-        return this.worldTransform.applyInverse(position, point);
-    };
-
-    /**
-     * Renders the object using the WebGL renderer
-     *
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-
-
-    DisplayObject.prototype.renderWebGL = function renderWebGL(renderer) // eslint-disable-line no-unused-vars
-    {}
-    // OVERWRITE;
-
-
-    /**
-     * Renders the object using the Canvas renderer
-     *
-     * @param {PIXI.CanvasRenderer} renderer - The renderer
-     */
-    ;
-
-    DisplayObject.prototype.renderCanvas = function renderCanvas(renderer) // eslint-disable-line no-unused-vars
-    {}
-    // OVERWRITE;
-
-
-    /**
-     * Set the parent Container of this DisplayObject
-     *
-     * @param {PIXI.Container} container - The Container to add this DisplayObject to
-     * @return {PIXI.Container} The Container that this DisplayObject was added to
-     */
-    ;
-
-    DisplayObject.prototype.setParent = function setParent(container) {
-        if (!container || !container.addChild) {
-            throw new Error('setParent: Argument must be a Container');
-        }
-
-        container.addChild(this);
-
-        return container;
-    };
-
-    /**
-     * Convenience function to set the position, scale, skew and pivot at once.
-     *
-     * @param {number} [x=0] - The X position
-     * @param {number} [y=0] - The Y position
-     * @param {number} [scaleX=1] - The X scale value
-     * @param {number} [scaleY=1] - The Y scale value
-     * @param {number} [rotation=0] - The rotation
-     * @param {number} [skewX=0] - The X skew value
-     * @param {number} [skewY=0] - The Y skew value
-     * @param {number} [pivotX=0] - The X pivot value
-     * @param {number} [pivotY=0] - The Y pivot value
-     * @return {PIXI.DisplayObject} The DisplayObject instance
-     */
-
-
-    DisplayObject.prototype.setTransform = function setTransform() {
-        var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-        var scaleX = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-        var scaleY = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-        var rotation = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
-        var skewX = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
-        var skewY = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
-        var pivotX = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 0;
-        var pivotY = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 0;
-
-        this.position.x = x;
-        this.position.y = y;
-        this.scale.x = !scaleX ? 1 : scaleX;
-        this.scale.y = !scaleY ? 1 : scaleY;
-        this.rotation = rotation;
-        this.skew.x = skewX;
-        this.skew.y = skewY;
-        this.pivot.x = pivotX;
-        this.pivot.y = pivotY;
-
-        return this;
-    };
-
-    /**
-     * Base destroy method for generic display objects. This will automatically
-     * remove the display object from its parent Container as well as remove
-     * all current event listeners and internal references. Do not use a DisplayObject
-     * after calling `destroy`.
-     *
-     */
-
-
-    DisplayObject.prototype.destroy = function destroy() {
-        this.removeAllListeners();
-        if (this.parent) {
-            this.parent.removeChild(this);
-        }
-        this.transform = null;
-
-        this.parent = null;
-
-        this._bounds = null;
-        this._currentBounds = null;
-        this._mask = null;
-
-        this.filterArea = null;
-
-        this.interactive = false;
-        this.interactiveChildren = false;
-
-        this._destroyed = true;
-    };
-
-    /**
-     * The position of the displayObject on the x axis relative to the local coordinates of the parent.
-     * An alias to position.x
-     *
-     * @member {number}
-     */
-
-
-    _createClass(DisplayObject, [{
-        key: '_tempDisplayObjectParent',
-        get: function get() {
-            if (this.tempDisplayObjectParent === null) {
-                this.tempDisplayObjectParent = new DisplayObject();
-            }
-
-            return this.tempDisplayObjectParent;
-        }
-    }, {
-        key: 'x',
-        get: function get() {
-            return this.position.x;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.transform.position.x = value;
-        }
-
-        /**
-         * The position of the displayObject on the y axis relative to the local coordinates of the parent.
-         * An alias to position.y
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'y',
-        get: function get() {
-            return this.position.y;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.transform.position.y = value;
-        }
-
-        /**
-         * Current transform of the object based on world (parent) factors
-         *
-         * @member {PIXI.Matrix}
-         * @readonly
-         */
-
-    }, {
-        key: 'worldTransform',
-        get: function get() {
-            return this.transform.worldTransform;
-        }
-
-        /**
-         * Current transform of the object based on local factors: position, scale, other stuff
-         *
-         * @member {PIXI.Matrix}
-         * @readonly
-         */
-
-    }, {
-        key: 'localTransform',
-        get: function get() {
-            return this.transform.localTransform;
-        }
-
-        /**
-         * The coordinate of the object relative to the local coordinates of the parent.
-         * Assignment by value since pixi-v4.
-         *
-         * @member {PIXI.Point|PIXI.ObservablePoint}
-         */
-
-    }, {
-        key: 'position',
-        get: function get() {
-            return this.transform.position;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.transform.position.copy(value);
-        }
-
-        /**
-         * The scale factor of the object.
-         * Assignment by value since pixi-v4.
-         *
-         * @member {PIXI.Point|PIXI.ObservablePoint}
-         */
-
-    }, {
-        key: 'scale',
-        get: function get() {
-            return this.transform.scale;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.transform.scale.copy(value);
-        }
-
-        /**
-         * The pivot point of the displayObject that it rotates around
-         * Assignment by value since pixi-v4.
-         *
-         * @member {PIXI.Point|PIXI.ObservablePoint}
-         */
-
-    }, {
-        key: 'pivot',
-        get: function get() {
-            return this.transform.pivot;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.transform.pivot.copy(value);
-        }
-
-        /**
-         * The skew factor for the object in radians.
-         * Assignment by value since pixi-v4.
-         *
-         * @member {PIXI.ObservablePoint}
-         */
-
-    }, {
-        key: 'skew',
-        get: function get() {
-            return this.transform.skew;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.transform.skew.copy(value);
-        }
-
-        /**
-         * The rotation of the object in radians.
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'rotation',
-        get: function get() {
-            return this.transform.rotation;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.transform.rotation = value;
-        }
-
-        /**
-         * Indicates if the object is globally visible.
-         *
-         * @member {boolean}
-         * @readonly
-         */
-
-    }, {
-        key: 'worldVisible',
-        get: function get() {
-            var item = this;
-
-            do {
-                if (!item.visible) {
-                    return false;
-                }
-
-                item = item.parent;
-            } while (item);
-
-            return true;
-        }
-
-        /**
-         * Sets a mask for the displayObject. A mask is an object that limits the visibility of an
-         * object to the shape of the mask applied to it. In PIXI a regular mask must be a
-         * PIXI.Graphics or a PIXI.Sprite object. This allows for much faster masking in canvas as it
-         * utilises shape clipping. To remove a mask, set this property to null.
-         *
-         * @todo For the moment, PIXI.CanvasRenderer doesn't support PIXI.Sprite as mask.
-         *
-         * @member {PIXI.Graphics|PIXI.Sprite}
-         */
-
-    }, {
-        key: 'mask',
-        get: function get() {
-            return this._mask;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (this._mask) {
-                this._mask.renderable = true;
-            }
-
-            this._mask = value;
-
-            if (this._mask) {
-                this._mask.renderable = false;
-            }
-        }
-
-        /**
-         * Sets the filters for the displayObject.
-         * * IMPORTANT: This is a webGL only feature and will be ignored by the canvas renderer.
-         * To remove filters simply set this property to 'null'
-         *
-         * @member {PIXI.Filter[]}
-         */
-
-    }, {
-        key: 'filters',
-        get: function get() {
-            return this._filters && this._filters.slice();
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._filters = value && value.slice();
-        }
-    }]);
-
-    return DisplayObject;
-}(_eventemitter2.default);
-
-// performance increase to avoid using call.. (10x faster)
-
-
-exports.default = DisplayObject;
-DisplayObject.prototype.displayObjectUpdateTransform = DisplayObject.prototype.updateTransform;
-
-},{"../const":46,"../math":70,"../settings":101,"./Bounds":47,"./Transform":50,"./TransformStatic":52,"eventemitter3":3}],50:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _math = require('../math');
-
-var _TransformBase2 = require('./TransformBase');
-
-var _TransformBase3 = _interopRequireDefault(_TransformBase2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * Generic class to deal with traditional 2D matrix transforms
- * local transformation is calculated from position,scale,skew and rotation
- *
- * @class
- * @extends PIXI.TransformBase
- * @memberof PIXI
- */
-var Transform = function (_TransformBase) {
-  _inherits(Transform, _TransformBase);
-
-  /**
-   *
-   */
-  function Transform() {
-    _classCallCheck(this, Transform);
-
-    /**
-    * The coordinate of the object relative to the local coordinates of the parent.
-    *
-    * @member {PIXI.Point}
-    */
-    var _this = _possibleConstructorReturn(this, _TransformBase.call(this));
-
-    _this.position = new _math.Point(0, 0);
-
-    /**
-     * The scale factor of the object.
-     *
-     * @member {PIXI.Point}
-     */
-    _this.scale = new _math.Point(1, 1);
-
-    /**
-     * The skew amount, on the x and y axis.
-     *
-     * @member {PIXI.ObservablePoint}
-     */
-    _this.skew = new _math.ObservablePoint(_this.updateSkew, _this, 0, 0);
-
-    /**
-     * The pivot point of the displayObject that it rotates around
-     *
-     * @member {PIXI.Point}
-     */
-    _this.pivot = new _math.Point(0, 0);
-
-    /**
-     * The rotation value of the object, in radians
-     *
-     * @member {Number}
-     * @private
-     */
-    _this._rotation = 0;
-
-    _this._cx = 1; // cos rotation + skewY;
-    _this._sx = 0; // sin rotation + skewY;
-    _this._cy = 0; // cos rotation + Math.PI/2 - skewX;
-    _this._sy = 1; // sin rotation + Math.PI/2 - skewX;
-    return _this;
-  }
-
-  /**
-   * Updates the skew values when the skew or rotation changes.
-   *
-   * @private
-   */
-
-
-  Transform.prototype.updateSkew = function updateSkew() {
-    this._cx = Math.cos(this._rotation + this.skew._y);
-    this._sx = Math.sin(this._rotation + this.skew._y);
-    this._cy = -Math.sin(this._rotation - this.skew._x); // cos, added PI/2
-    this._sy = Math.cos(this._rotation - this.skew._x); // sin, added PI/2
-  };
-
-  /**
-   * Updates only local matrix
-   */
-
-
-  Transform.prototype.updateLocalTransform = function updateLocalTransform() {
-    var lt = this.localTransform;
-
-    lt.a = this._cx * this.scale.x;
-    lt.b = this._sx * this.scale.x;
-    lt.c = this._cy * this.scale.y;
-    lt.d = this._sy * this.scale.y;
-
-    lt.tx = this.position.x - (this.pivot.x * lt.a + this.pivot.y * lt.c);
-    lt.ty = this.position.y - (this.pivot.x * lt.b + this.pivot.y * lt.d);
-  };
-
-  /**
-   * Updates the values of the object and applies the parent's transform.
-   *
-   * @param {PIXI.Transform} parentTransform - The transform of the parent of this object
-   */
-
-
-  Transform.prototype.updateTransform = function updateTransform(parentTransform) {
-    var lt = this.localTransform;
-
-    lt.a = this._cx * this.scale.x;
-    lt.b = this._sx * this.scale.x;
-    lt.c = this._cy * this.scale.y;
-    lt.d = this._sy * this.scale.y;
-
-    lt.tx = this.position.x - (this.pivot.x * lt.a + this.pivot.y * lt.c);
-    lt.ty = this.position.y - (this.pivot.x * lt.b + this.pivot.y * lt.d);
-
-    // concat the parent matrix with the objects transform.
-    var pt = parentTransform.worldTransform;
-    var wt = this.worldTransform;
-
-    wt.a = lt.a * pt.a + lt.b * pt.c;
-    wt.b = lt.a * pt.b + lt.b * pt.d;
-    wt.c = lt.c * pt.a + lt.d * pt.c;
-    wt.d = lt.c * pt.b + lt.d * pt.d;
-    wt.tx = lt.tx * pt.a + lt.ty * pt.c + pt.tx;
-    wt.ty = lt.tx * pt.b + lt.ty * pt.d + pt.ty;
-
-    this._worldID++;
-  };
-
-  /**
-   * Decomposes a matrix and sets the transforms properties based on it.
-   *
-   * @param {PIXI.Matrix} matrix - The matrix to decompose
-   */
-
-
-  Transform.prototype.setFromMatrix = function setFromMatrix(matrix) {
-    matrix.decompose(this);
-  };
-
-  /**
-   * The rotation of the object in radians.
-   *
-   * @member {number}
-   */
-
-
-  _createClass(Transform, [{
-    key: 'rotation',
-    get: function get() {
-      return this._rotation;
-    },
-    set: function set(value) // eslint-disable-line require-jsdoc
-    {
-      this._rotation = value;
-      this.updateSkew();
-    }
-  }]);
-
-  return Transform;
-}(_TransformBase3.default);
-
-exports.default = Transform;
-
-},{"../math":70,"./TransformBase":51}],51:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _math = require('../math');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Generic class to deal with traditional 2D matrix transforms
- *
- * @class
- * @memberof PIXI
- */
-var TransformBase = function () {
-  /**
-   *
-   */
-  function TransformBase() {
-    _classCallCheck(this, TransformBase);
-
-    /**
-     * The global matrix transform. It can be swapped temporarily by some functions like getLocalBounds()
-     *
-     * @member {PIXI.Matrix}
-     */
-    this.worldTransform = new _math.Matrix();
-
-    /**
-     * The local matrix transform
-     *
-     * @member {PIXI.Matrix}
-     */
-    this.localTransform = new _math.Matrix();
-
-    this._worldID = 0;
-    this._parentID = 0;
-  }
-
-  /**
-   * TransformBase does not have decomposition, so this function wont do anything
-   */
-
-
-  TransformBase.prototype.updateLocalTransform = function updateLocalTransform() {}
-  // empty
-
-
-  /**
-   * Updates the values of the object and applies the parent's transform.
-   *
-   * @param {PIXI.TransformBase} parentTransform - The transform of the parent of this object
-   */
-  ;
-
-  TransformBase.prototype.updateTransform = function updateTransform(parentTransform) {
-    var pt = parentTransform.worldTransform;
-    var wt = this.worldTransform;
-    var lt = this.localTransform;
-
-    // concat the parent matrix with the objects transform.
-    wt.a = lt.a * pt.a + lt.b * pt.c;
-    wt.b = lt.a * pt.b + lt.b * pt.d;
-    wt.c = lt.c * pt.a + lt.d * pt.c;
-    wt.d = lt.c * pt.b + lt.d * pt.d;
-    wt.tx = lt.tx * pt.a + lt.ty * pt.c + pt.tx;
-    wt.ty = lt.tx * pt.b + lt.ty * pt.d + pt.ty;
-
-    this._worldID++;
-  };
-
-  return TransformBase;
-}();
-
-/**
- * Updates the values of the object and applies the parent's transform.
- * @param  parentTransform {PIXI.Transform} The transform of the parent of this object
- *
- */
-
-
-exports.default = TransformBase;
-TransformBase.prototype.updateWorldTransform = TransformBase.prototype.updateTransform;
-
-TransformBase.IDENTITY = new TransformBase();
-
-},{"../math":70}],52:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _math = require('../math');
-
-var _TransformBase2 = require('./TransformBase');
-
-var _TransformBase3 = _interopRequireDefault(_TransformBase2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * Transform that takes care about its versions
- *
- * @class
- * @extends PIXI.TransformBase
- * @memberof PIXI
- */
-var TransformStatic = function (_TransformBase) {
-    _inherits(TransformStatic, _TransformBase);
-
-    /**
-     *
-     */
-    function TransformStatic() {
-        _classCallCheck(this, TransformStatic);
-
-        /**
-        * The coordinate of the object relative to the local coordinates of the parent.
-        *
-        * @member {PIXI.ObservablePoint}
-        */
-        var _this = _possibleConstructorReturn(this, _TransformBase.call(this));
-
-        _this.position = new _math.ObservablePoint(_this.onChange, _this, 0, 0);
-
-        /**
-         * The scale factor of the object.
-         *
-         * @member {PIXI.ObservablePoint}
-         */
-        _this.scale = new _math.ObservablePoint(_this.onChange, _this, 1, 1);
-
-        /**
-         * The pivot point of the displayObject that it rotates around
-         *
-         * @member {PIXI.ObservablePoint}
-         */
-        _this.pivot = new _math.ObservablePoint(_this.onChange, _this, 0, 0);
-
-        /**
-         * The skew amount, on the x and y axis.
-         *
-         * @member {PIXI.ObservablePoint}
-         */
-        _this.skew = new _math.ObservablePoint(_this.updateSkew, _this, 0, 0);
-
-        _this._rotation = 0;
-
-        _this._cx = 1; // cos rotation + skewY;
-        _this._sx = 0; // sin rotation + skewY;
-        _this._cy = 0; // cos rotation + Math.PI/2 - skewX;
-        _this._sy = 1; // sin rotation + Math.PI/2 - skewX;
-
-        _this._localID = 0;
-        _this._currentLocalID = 0;
-        return _this;
-    }
-
-    /**
-     * Called when a value changes.
-     *
-     * @private
-     */
-
-
-    TransformStatic.prototype.onChange = function onChange() {
-        this._localID++;
-    };
-
-    /**
-     * Called when skew or rotation changes
-     *
-     * @private
-     */
-
-
-    TransformStatic.prototype.updateSkew = function updateSkew() {
-        this._cx = Math.cos(this._rotation + this.skew._y);
-        this._sx = Math.sin(this._rotation + this.skew._y);
-        this._cy = -Math.sin(this._rotation - this.skew._x); // cos, added PI/2
-        this._sy = Math.cos(this._rotation - this.skew._x); // sin, added PI/2
-
-        this._localID++;
-    };
-
-    /**
-     * Updates only local matrix
-     */
-
-
-    TransformStatic.prototype.updateLocalTransform = function updateLocalTransform() {
-        var lt = this.localTransform;
-
-        if (this._localID !== this._currentLocalID) {
-            // get the matrix values of the displayobject based on its transform properties..
-            lt.a = this._cx * this.scale._x;
-            lt.b = this._sx * this.scale._x;
-            lt.c = this._cy * this.scale._y;
-            lt.d = this._sy * this.scale._y;
-
-            lt.tx = this.position._x - (this.pivot._x * lt.a + this.pivot._y * lt.c);
-            lt.ty = this.position._y - (this.pivot._x * lt.b + this.pivot._y * lt.d);
-            this._currentLocalID = this._localID;
-
-            // force an update..
-            this._parentID = -1;
-        }
-    };
-
-    /**
-     * Updates the values of the object and applies the parent's transform.
-     *
-     * @param {PIXI.Transform} parentTransform - The transform of the parent of this object
-     */
-
-
-    TransformStatic.prototype.updateTransform = function updateTransform(parentTransform) {
-        var lt = this.localTransform;
-
-        if (this._localID !== this._currentLocalID) {
-            // get the matrix values of the displayobject based on its transform properties..
-            lt.a = this._cx * this.scale._x;
-            lt.b = this._sx * this.scale._x;
-            lt.c = this._cy * this.scale._y;
-            lt.d = this._sy * this.scale._y;
-
-            lt.tx = this.position._x - (this.pivot._x * lt.a + this.pivot._y * lt.c);
-            lt.ty = this.position._y - (this.pivot._x * lt.b + this.pivot._y * lt.d);
-            this._currentLocalID = this._localID;
-
-            // force an update..
-            this._parentID = -1;
-        }
-
-        if (this._parentID !== parentTransform._worldID) {
-            // concat the parent matrix with the objects transform.
-            var pt = parentTransform.worldTransform;
-            var wt = this.worldTransform;
-
-            wt.a = lt.a * pt.a + lt.b * pt.c;
-            wt.b = lt.a * pt.b + lt.b * pt.d;
-            wt.c = lt.c * pt.a + lt.d * pt.c;
-            wt.d = lt.c * pt.b + lt.d * pt.d;
-            wt.tx = lt.tx * pt.a + lt.ty * pt.c + pt.tx;
-            wt.ty = lt.tx * pt.b + lt.ty * pt.d + pt.ty;
-
-            this._parentID = parentTransform._worldID;
-
-            // update the id of the transform..
-            this._worldID++;
-        }
-    };
-
-    /**
-     * Decomposes a matrix and sets the transforms properties based on it.
-     *
-     * @param {PIXI.Matrix} matrix - The matrix to decompose
-     */
-
-
-    TransformStatic.prototype.setFromMatrix = function setFromMatrix(matrix) {
-        matrix.decompose(this);
-        this._localID++;
-    };
-
-    /**
-     * The rotation of the object in radians.
-     *
-     * @member {number}
-     */
-
-
-    _createClass(TransformStatic, [{
-        key: 'rotation',
-        get: function get() {
-            return this._rotation;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._rotation = value;
-            this.updateSkew();
-        }
-    }]);
-
-    return TransformStatic;
-}(_TransformBase3.default);
-
-exports.default = TransformStatic;
-
-},{"../math":70,"./TransformBase":51}],53:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Container2 = require('../display/Container');
-
-var _Container3 = _interopRequireDefault(_Container2);
-
-var _RenderTexture = require('../textures/RenderTexture');
-
-var _RenderTexture2 = _interopRequireDefault(_RenderTexture);
-
-var _Texture = require('../textures/Texture');
-
-var _Texture2 = _interopRequireDefault(_Texture);
-
-var _GraphicsData = require('./GraphicsData');
-
-var _GraphicsData2 = _interopRequireDefault(_GraphicsData);
-
-var _Sprite = require('../sprites/Sprite');
-
-var _Sprite2 = _interopRequireDefault(_Sprite);
-
-var _math = require('../math');
-
-var _utils = require('../utils');
-
-var _const = require('../const');
-
-var _Bounds = require('../display/Bounds');
-
-var _Bounds2 = _interopRequireDefault(_Bounds);
-
-var _bezierCurveTo2 = require('./utils/bezierCurveTo');
-
-var _bezierCurveTo3 = _interopRequireDefault(_bezierCurveTo2);
-
-var _CanvasRenderer = require('../renderers/canvas/CanvasRenderer');
-
-var _CanvasRenderer2 = _interopRequireDefault(_CanvasRenderer);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var canvasRenderer = void 0;
-var tempMatrix = new _math.Matrix();
-var tempPoint = new _math.Point();
-var tempColor1 = new Float32Array(4);
-var tempColor2 = new Float32Array(4);
-
-/**
- * The Graphics class contains methods used to draw primitive shapes such as lines, circles and
- * rectangles to the display, and to color and fill them.
- *
- * @class
- * @extends PIXI.Container
- * @memberof PIXI
- */
-
-var Graphics = function (_Container) {
-    _inherits(Graphics, _Container);
-
-    /**
-     *
-     * @param {boolean} [nativeLines=false] - If true the lines will be draw using LINES instead of TRIANGLE_STRIP
-     */
-    function Graphics() {
-        var nativeLines = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-        _classCallCheck(this, Graphics);
-
-        /**
-         * The alpha value used when filling the Graphics object.
-         *
-         * @member {number}
-         * @default 1
-         */
-        var _this = _possibleConstructorReturn(this, _Container.call(this));
-
-        _this.fillAlpha = 1;
-
-        /**
-         * The width (thickness) of any lines drawn.
-         *
-         * @member {number}
-         * @default 0
-         */
-        _this.lineWidth = 0;
-
-        /**
-         * If true the lines will be draw using LINES instead of TRIANGLE_STRIP
-         *
-         * @member {boolean}
-         */
-        _this.nativeLines = nativeLines;
-
-        /**
-         * The color of any lines drawn.
-         *
-         * @member {string}
-         * @default 0
-         */
-        _this.lineColor = 0;
-
-        /**
-         * Graphics data
-         *
-         * @member {PIXI.GraphicsData[]}
-         * @private
-         */
-        _this.graphicsData = [];
-
-        /**
-         * The tint applied to the graphic shape. This is a hex value. Apply a value of 0xFFFFFF to
-         * reset the tint.
-         *
-         * @member {number}
-         * @default 0xFFFFFF
-         */
-        _this.tint = 0xFFFFFF;
-
-        /**
-         * The previous tint applied to the graphic shape. Used to compare to the current tint and
-         * check if theres change.
-         *
-         * @member {number}
-         * @private
-         * @default 0xFFFFFF
-         */
-        _this._prevTint = 0xFFFFFF;
-
-        /**
-         * The blend mode to be applied to the graphic shape. Apply a value of
-         * `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.
-         *
-         * @member {number}
-         * @default PIXI.BLEND_MODES.NORMAL;
-         * @see PIXI.BLEND_MODES
-         */
-        _this.blendMode = _const.BLEND_MODES.NORMAL;
-
-        /**
-         * Current path
-         *
-         * @member {PIXI.GraphicsData}
-         * @private
-         */
-        _this.currentPath = null;
-
-        /**
-         * Array containing some WebGL-related properties used by the WebGL renderer.
-         *
-         * @member {object<number, object>}
-         * @private
-         */
-        // TODO - _webgl should use a prototype object, not a random undocumented object...
-        _this._webGL = {};
-
-        /**
-         * Whether this shape is being used as a mask.
-         *
-         * @member {boolean}
-         */
-        _this.isMask = false;
-
-        /**
-         * The bounds' padding used for bounds calculation.
-         *
-         * @member {number}
-         */
-        _this.boundsPadding = 0;
-
-        /**
-         * A cache of the local bounds to prevent recalculation.
-         *
-         * @member {PIXI.Rectangle}
-         * @private
-         */
-        _this._localBounds = new _Bounds2.default();
-
-        /**
-         * Used to detect if the graphics object has changed. If this is set to true then the graphics
-         * object will be recalculated.
-         *
-         * @member {boolean}
-         * @private
-         */
-        _this.dirty = 0;
-
-        /**
-         * Used to detect if we need to do a fast rect check using the id compare method
-         * @type {Number}
-         */
-        _this.fastRectDirty = -1;
-
-        /**
-         * Used to detect if we clear the graphics webGL data
-         * @type {Number}
-         */
-        _this.clearDirty = 0;
-
-        /**
-         * Used to detect if we we need to recalculate local bounds
-         * @type {Number}
-         */
-        _this.boundsDirty = -1;
-
-        /**
-         * Used to detect if the cached sprite object needs to be updated.
-         *
-         * @member {boolean}
-         * @private
-         */
-        _this.cachedSpriteDirty = false;
-
-        _this._spriteRect = null;
-        _this._fastRect = false;
-
-        /**
-         * When cacheAsBitmap is set to true the graphics object will be rendered as if it was a sprite.
-         * This is useful if your graphics element does not change often, as it will speed up the rendering
-         * of the object in exchange for taking up texture memory. It is also useful if you need the graphics
-         * object to be anti-aliased, because it will be rendered using canvas. This is not recommended if
-         * you are constantly redrawing the graphics element.
-         *
-         * @name cacheAsBitmap
-         * @member {boolean}
-         * @memberof PIXI.Graphics#
-         * @default false
-         */
-        return _this;
-    }
-
-    /**
-     * Creates a new Graphics object with the same values as this one.
-     * Note that the only the properties of the object are cloned, not its transform (position,scale,etc)
-     *
-     * @return {PIXI.Graphics} A clone of the graphics object
-     */
-
-
-    Graphics.prototype.clone = function clone() {
-        var clone = new Graphics();
-
-        clone.renderable = this.renderable;
-        clone.fillAlpha = this.fillAlpha;
-        clone.lineWidth = this.lineWidth;
-        clone.lineColor = this.lineColor;
-        clone.tint = this.tint;
-        clone.blendMode = this.blendMode;
-        clone.isMask = this.isMask;
-        clone.boundsPadding = this.boundsPadding;
-        clone.dirty = 0;
-        clone.cachedSpriteDirty = this.cachedSpriteDirty;
-
-        // copy graphics data
-        for (var i = 0; i < this.graphicsData.length; ++i) {
-            clone.graphicsData.push(this.graphicsData[i].clone());
-        }
-
-        clone.currentPath = clone.graphicsData[clone.graphicsData.length - 1];
-
-        clone.updateLocalBounds();
-
-        return clone;
-    };
-
-    /**
-     * Specifies the line style used for subsequent calls to Graphics methods such as the lineTo()
-     * method or the drawCircle() method.
-     *
-     * @param {number} [lineWidth=0] - width of the line to draw, will update the objects stored style
-     * @param {number} [color=0] - color of the line to draw, will update the objects stored style
-     * @param {number} [alpha=1] - alpha of the line to draw, will update the objects stored style
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.lineStyle = function lineStyle() {
-        var lineWidth = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var color = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-        var alpha = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-
-        this.lineWidth = lineWidth;
-        this.lineColor = color;
-        this.lineAlpha = alpha;
-
-        if (this.currentPath) {
-            if (this.currentPath.shape.points.length) {
-                // halfway through a line? start a new one!
-                var shape = new _math.Polygon(this.currentPath.shape.points.slice(-2));
-
-                shape.closed = false;
-
-                this.drawShape(shape);
-            } else {
-                // otherwise its empty so lets just set the line properties
-                this.currentPath.lineWidth = this.lineWidth;
-                this.currentPath.lineColor = this.lineColor;
-                this.currentPath.lineAlpha = this.lineAlpha;
-            }
-        }
-
-        return this;
-    };
-
-    /**
-     * Moves the current drawing position to x, y.
-     *
-     * @param {number} x - the X coordinate to move to
-     * @param {number} y - the Y coordinate to move to
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.moveTo = function moveTo(x, y) {
-        var shape = new _math.Polygon([x, y]);
-
-        shape.closed = false;
-        this.drawShape(shape);
-
-        return this;
-    };
-
-    /**
-     * Draws a line using the current line style from the current drawing position to (x, y);
-     * The current drawing position is then set to (x, y).
-     *
-     * @param {number} x - the X coordinate to draw to
-     * @param {number} y - the Y coordinate to draw to
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.lineTo = function lineTo(x, y) {
-        this.currentPath.shape.points.push(x, y);
-        this.dirty++;
-
-        return this;
-    };
-
-    /**
-     * Calculate the points for a quadratic bezier curve and then draws it.
-     * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
-     *
-     * @param {number} cpX - Control point x
-     * @param {number} cpY - Control point y
-     * @param {number} toX - Destination point x
-     * @param {number} toY - Destination point y
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.quadraticCurveTo = function quadraticCurveTo(cpX, cpY, toX, toY) {
-        if (this.currentPath) {
-            if (this.currentPath.shape.points.length === 0) {
-                this.currentPath.shape.points = [0, 0];
-            }
-        } else {
-            this.moveTo(0, 0);
-        }
-
-        var n = 20;
-        var points = this.currentPath.shape.points;
-        var xa = 0;
-        var ya = 0;
-
-        if (points.length === 0) {
-            this.moveTo(0, 0);
-        }
-
-        var fromX = points[points.length - 2];
-        var fromY = points[points.length - 1];
-
-        for (var i = 1; i <= n; ++i) {
-            var j = i / n;
-
-            xa = fromX + (cpX - fromX) * j;
-            ya = fromY + (cpY - fromY) * j;
-
-            points.push(xa + (cpX + (toX - cpX) * j - xa) * j, ya + (cpY + (toY - cpY) * j - ya) * j);
-        }
-
-        this.dirty++;
-
-        return this;
-    };
-
-    /**
-     * Calculate the points for a bezier curve and then draws it.
-     *
-     * @param {number} cpX - Control point x
-     * @param {number} cpY - Control point y
-     * @param {number} cpX2 - Second Control point x
-     * @param {number} cpY2 - Second Control point y
-     * @param {number} toX - Destination point x
-     * @param {number} toY - Destination point y
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.bezierCurveTo = function bezierCurveTo(cpX, cpY, cpX2, cpY2, toX, toY) {
-        if (this.currentPath) {
-            if (this.currentPath.shape.points.length === 0) {
-                this.currentPath.shape.points = [0, 0];
-            }
-        } else {
-            this.moveTo(0, 0);
-        }
-
-        var points = this.currentPath.shape.points;
-
-        var fromX = points[points.length - 2];
-        var fromY = points[points.length - 1];
-
-        points.length -= 2;
-
-        (0, _bezierCurveTo3.default)(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY, points);
-
-        this.dirty++;
-
-        return this;
-    };
-
-    /**
-     * The arcTo() method creates an arc/curve between two tangents on the canvas.
-     *
-     * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
-     *
-     * @param {number} x1 - The x-coordinate of the beginning of the arc
-     * @param {number} y1 - The y-coordinate of the beginning of the arc
-     * @param {number} x2 - The x-coordinate of the end of the arc
-     * @param {number} y2 - The y-coordinate of the end of the arc
-     * @param {number} radius - The radius of the arc
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.arcTo = function arcTo(x1, y1, x2, y2, radius) {
-        if (this.currentPath) {
-            if (this.currentPath.shape.points.length === 0) {
-                this.currentPath.shape.points.push(x1, y1);
-            }
-        } else {
-            this.moveTo(x1, y1);
-        }
-
-        var points = this.currentPath.shape.points;
-        var fromX = points[points.length - 2];
-        var fromY = points[points.length - 1];
-        var a1 = fromY - y1;
-        var b1 = fromX - x1;
-        var a2 = y2 - y1;
-        var b2 = x2 - x1;
-        var mm = Math.abs(a1 * b2 - b1 * a2);
-
-        if (mm < 1.0e-8 || radius === 0) {
-            if (points[points.length - 2] !== x1 || points[points.length - 1] !== y1) {
-                points.push(x1, y1);
-            }
-        } else {
-            var dd = a1 * a1 + b1 * b1;
-            var cc = a2 * a2 + b2 * b2;
-            var tt = a1 * a2 + b1 * b2;
-            var k1 = radius * Math.sqrt(dd) / mm;
-            var k2 = radius * Math.sqrt(cc) / mm;
-            var j1 = k1 * tt / dd;
-            var j2 = k2 * tt / cc;
-            var cx = k1 * b2 + k2 * b1;
-            var cy = k1 * a2 + k2 * a1;
-            var px = b1 * (k2 + j1);
-            var py = a1 * (k2 + j1);
-            var qx = b2 * (k1 + j2);
-            var qy = a2 * (k1 + j2);
-            var startAngle = Math.atan2(py - cy, px - cx);
-            var endAngle = Math.atan2(qy - cy, qx - cx);
-
-            this.arc(cx + x1, cy + y1, radius, startAngle, endAngle, b1 * a2 > b2 * a1);
-        }
-
-        this.dirty++;
-
-        return this;
-    };
-
-    /**
-     * The arc method creates an arc/curve (used to create circles, or parts of circles).
-     *
-     * @param {number} cx - The x-coordinate of the center of the circle
-     * @param {number} cy - The y-coordinate of the center of the circle
-     * @param {number} radius - The radius of the circle
-     * @param {number} startAngle - The starting angle, in radians (0 is at the 3 o'clock position
-     *  of the arc's circle)
-     * @param {number} endAngle - The ending angle, in radians
-     * @param {boolean} [anticlockwise=false] - Specifies whether the drawing should be
-     *  counter-clockwise or clockwise. False is default, and indicates clockwise, while true
-     *  indicates counter-clockwise.
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.arc = function arc(cx, cy, radius, startAngle, endAngle) {
-        var anticlockwise = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
-
-        if (startAngle === endAngle) {
-            return this;
-        }
-
-        if (!anticlockwise && endAngle <= startAngle) {
-            endAngle += Math.PI * 2;
-        } else if (anticlockwise && startAngle <= endAngle) {
-            startAngle += Math.PI * 2;
-        }
-
-        var sweep = endAngle - startAngle;
-        var segs = Math.ceil(Math.abs(sweep) / (Math.PI * 2)) * 40;
-
-        if (sweep === 0) {
-            return this;
-        }
-
-        var startX = cx + Math.cos(startAngle) * radius;
-        var startY = cy + Math.sin(startAngle) * radius;
-
-        // If the currentPath exists, take its points. Otherwise call `moveTo` to start a path.
-        var points = this.currentPath ? this.currentPath.shape.points : null;
-
-        if (points) {
-            if (points[points.length - 2] !== startX || points[points.length - 1] !== startY) {
-                points.push(startX, startY);
-            }
-        } else {
-            this.moveTo(startX, startY);
-            points = this.currentPath.shape.points;
-        }
-
-        var theta = sweep / (segs * 2);
-        var theta2 = theta * 2;
-
-        var cTheta = Math.cos(theta);
-        var sTheta = Math.sin(theta);
-
-        var segMinus = segs - 1;
-
-        var remainder = segMinus % 1 / segMinus;
-
-        for (var i = 0; i <= segMinus; ++i) {
-            var real = i + remainder * i;
-
-            var angle = theta + startAngle + theta2 * real;
-
-            var c = Math.cos(angle);
-            var s = -Math.sin(angle);
-
-            points.push((cTheta * c + sTheta * s) * radius + cx, (cTheta * -s + sTheta * c) * radius + cy);
-        }
-
-        this.dirty++;
-
-        return this;
-    };
-
-    /**
-     * Specifies a simple one-color fill that subsequent calls to other Graphics methods
-     * (such as lineTo() or drawCircle()) use when drawing.
-     *
-     * @param {number} [color=0] - the color of the fill
-     * @param {number} [alpha=1] - the alpha of the fill
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.beginFill = function beginFill() {
-        var color = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-
-        this.filling = true;
-        this.fillColor = color;
-        this.fillAlpha = alpha;
-
-        if (this.currentPath) {
-            if (this.currentPath.shape.points.length <= 2) {
-                this.currentPath.fill = this.filling;
-                this.currentPath.fillColor = this.fillColor;
-                this.currentPath.fillAlpha = this.fillAlpha;
-            }
-        }
-
-        return this;
-    };
-
-    /**
-     * Applies a fill to the lines and shapes that were added since the last call to the beginFill() method.
-     *
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.endFill = function endFill() {
-        this.filling = false;
-        this.fillColor = null;
-        this.fillAlpha = 1;
-
-        return this;
-    };
-
-    /**
-     *
-     * @param {number} x - The X coord of the top-left of the rectangle
-     * @param {number} y - The Y coord of the top-left of the rectangle
-     * @param {number} width - The width of the rectangle
-     * @param {number} height - The height of the rectangle
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.drawRect = function drawRect(x, y, width, height) {
-        this.drawShape(new _math.Rectangle(x, y, width, height));
-
-        return this;
-    };
-
-    /**
-     *
-     * @param {number} x - The X coord of the top-left of the rectangle
-     * @param {number} y - The Y coord of the top-left of the rectangle
-     * @param {number} width - The width of the rectangle
-     * @param {number} height - The height of the rectangle
-     * @param {number} radius - Radius of the rectangle corners
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.drawRoundedRect = function drawRoundedRect(x, y, width, height, radius) {
-        this.drawShape(new _math.RoundedRectangle(x, y, width, height, radius));
-
-        return this;
-    };
-
-    /**
-     * Draws a circle.
-     *
-     * @param {number} x - The X coordinate of the center of the circle
-     * @param {number} y - The Y coordinate of the center of the circle
-     * @param {number} radius - The radius of the circle
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.drawCircle = function drawCircle(x, y, radius) {
-        this.drawShape(new _math.Circle(x, y, radius));
-
-        return this;
-    };
-
-    /**
-     * Draws an ellipse.
-     *
-     * @param {number} x - The X coordinate of the center of the ellipse
-     * @param {number} y - The Y coordinate of the center of the ellipse
-     * @param {number} width - The half width of the ellipse
-     * @param {number} height - The half height of the ellipse
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.drawEllipse = function drawEllipse(x, y, width, height) {
-        this.drawShape(new _math.Ellipse(x, y, width, height));
-
-        return this;
-    };
-
-    /**
-     * Draws a polygon using the given path.
-     *
-     * @param {number[]|PIXI.Point[]} path - The path data used to construct the polygon.
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.drawPolygon = function drawPolygon(path) {
-        // prevents an argument assignment deopt
-        // see section 3.1: https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments
-        var points = path;
-
-        var closed = true;
-
-        if (points instanceof _math.Polygon) {
-            closed = points.closed;
-            points = points.points;
-        }
-
-        if (!Array.isArray(points)) {
-            // prevents an argument leak deopt
-            // see section 3.2: https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments
-            points = new Array(arguments.length);
-
-            for (var i = 0; i < points.length; ++i) {
-                points[i] = arguments[i]; // eslint-disable-line prefer-rest-params
-            }
-        }
-
-        var shape = new _math.Polygon(points);
-
-        shape.closed = closed;
-
-        this.drawShape(shape);
-
-        return this;
-    };
-
-    /**
-     * Clears the graphics that were drawn to this Graphics object, and resets fill and line style settings.
-     *
-     * @return {PIXI.Graphics} This Graphics object. Good for chaining method calls
-     */
-
-
-    Graphics.prototype.clear = function clear() {
-        if (this.lineWidth || this.filling || this.graphicsData.length > 0) {
-            this.lineWidth = 0;
-            this.filling = false;
-
-            this.boundsDirty = -1;
-            this.dirty++;
-            this.clearDirty++;
-            this.graphicsData.length = 0;
-        }
-
-        this.currentPath = null;
-        this._spriteRect = null;
-
-        return this;
-    };
-
-    /**
-     * True if graphics consists of one rectangle, and thus, can be drawn like a Sprite and
-     * masked with gl.scissor.
-     *
-     * @returns {boolean} True if only 1 rect.
-     */
-
-
-    Graphics.prototype.isFastRect = function isFastRect() {
-        return this.graphicsData.length === 1 && this.graphicsData[0].shape.type === _const.SHAPES.RECT && !this.graphicsData[0].lineWidth;
-    };
-
-    /**
-     * Renders the object using the WebGL renderer
-     *
-     * @private
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-
-
-    Graphics.prototype._renderWebGL = function _renderWebGL(renderer) {
-        // if the sprite is not visible or the alpha is 0 then no need to render this element
-        if (this.dirty !== this.fastRectDirty) {
-            this.fastRectDirty = this.dirty;
-            this._fastRect = this.isFastRect();
-        }
-
-        // TODO this check can be moved to dirty?
-        if (this._fastRect) {
-            this._renderSpriteRect(renderer);
-        } else {
-            renderer.setObjectRenderer(renderer.plugins.graphics);
-            renderer.plugins.graphics.render(this);
-        }
-    };
-
-    /**
-     * Renders a sprite rectangle.
-     *
-     * @private
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-
-
-    Graphics.prototype._renderSpriteRect = function _renderSpriteRect(renderer) {
-        var rect = this.graphicsData[0].shape;
-
-        if (!this._spriteRect) {
-            this._spriteRect = new _Sprite2.default(new _Texture2.default(_Texture2.default.WHITE));
-        }
-
-        var sprite = this._spriteRect;
-
-        if (this.tint === 0xffffff) {
-            sprite.tint = this.graphicsData[0].fillColor;
-        } else {
-            var t1 = tempColor1;
-            var t2 = tempColor2;
-
-            (0, _utils.hex2rgb)(this.graphicsData[0].fillColor, t1);
-            (0, _utils.hex2rgb)(this.tint, t2);
-
-            t1[0] *= t2[0];
-            t1[1] *= t2[1];
-            t1[2] *= t2[2];
-
-            sprite.tint = (0, _utils.rgb2hex)(t1);
-        }
-        sprite.alpha = this.graphicsData[0].fillAlpha;
-        sprite.worldAlpha = this.worldAlpha * sprite.alpha;
-        sprite.blendMode = this.blendMode;
-
-        sprite._texture._frame.width = rect.width;
-        sprite._texture._frame.height = rect.height;
-
-        sprite.transform.worldTransform = this.transform.worldTransform;
-
-        sprite.anchor.set(-rect.x / rect.width, -rect.y / rect.height);
-        sprite._onAnchorUpdate();
-
-        sprite._renderWebGL(renderer);
-    };
-
-    /**
-     * Renders the object using the Canvas renderer
-     *
-     * @private
-     * @param {PIXI.CanvasRenderer} renderer - The renderer
-     */
-
-
-    Graphics.prototype._renderCanvas = function _renderCanvas(renderer) {
-        if (this.isMask === true) {
-            return;
-        }
-
-        renderer.plugins.graphics.render(this);
-    };
-
-    /**
-     * Retrieves the bounds of the graphic shape as a rectangle object
-     *
-     * @private
-     */
-
-
-    Graphics.prototype._calculateBounds = function _calculateBounds() {
-        if (this.boundsDirty !== this.dirty) {
-            this.boundsDirty = this.dirty;
-            this.updateLocalBounds();
-
-            this.cachedSpriteDirty = true;
-        }
-
-        var lb = this._localBounds;
-
-        this._bounds.addFrame(this.transform, lb.minX, lb.minY, lb.maxX, lb.maxY);
-    };
-
-    /**
-     * Tests if a point is inside this graphics object
-     *
-     * @param {PIXI.Point} point - the point to test
-     * @return {boolean} the result of the test
-     */
-
-
-    Graphics.prototype.containsPoint = function containsPoint(point) {
-        this.worldTransform.applyInverse(point, tempPoint);
-
-        var graphicsData = this.graphicsData;
-
-        for (var i = 0; i < graphicsData.length; ++i) {
-            var data = graphicsData[i];
-
-            if (!data.fill) {
-                continue;
-            }
-
-            // only deal with fills..
-            if (data.shape) {
-                if (data.shape.contains(tempPoint.x, tempPoint.y)) {
-                    if (data.holes) {
-                        for (var _i = 0; _i < data.holes.length; _i++) {
-                            var hole = data.holes[_i];
-
-                            if (hole.contains(tempPoint.x, tempPoint.y)) {
-                                return false;
-                            }
-                        }
-                    }
-
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    };
-
-    /**
-     * Update the bounds of the object
-     *
-     */
-
-
-    Graphics.prototype.updateLocalBounds = function updateLocalBounds() {
-        var minX = Infinity;
-        var maxX = -Infinity;
-
-        var minY = Infinity;
-        var maxY = -Infinity;
-
-        if (this.graphicsData.length) {
-            var shape = 0;
-            var x = 0;
-            var y = 0;
-            var w = 0;
-            var h = 0;
-
-            for (var i = 0; i < this.graphicsData.length; i++) {
-                var data = this.graphicsData[i];
-                var type = data.type;
-                var lineWidth = data.lineWidth;
-
-                shape = data.shape;
-
-                if (type === _const.SHAPES.RECT || type === _const.SHAPES.RREC) {
-                    x = shape.x - lineWidth / 2;
-                    y = shape.y - lineWidth / 2;
-                    w = shape.width + lineWidth;
-                    h = shape.height + lineWidth;
-
-                    minX = x < minX ? x : minX;
-                    maxX = x + w > maxX ? x + w : maxX;
-
-                    minY = y < minY ? y : minY;
-                    maxY = y + h > maxY ? y + h : maxY;
-                } else if (type === _const.SHAPES.CIRC) {
-                    x = shape.x;
-                    y = shape.y;
-                    w = shape.radius + lineWidth / 2;
-                    h = shape.radius + lineWidth / 2;
-
-                    minX = x - w < minX ? x - w : minX;
-                    maxX = x + w > maxX ? x + w : maxX;
-
-                    minY = y - h < minY ? y - h : minY;
-                    maxY = y + h > maxY ? y + h : maxY;
-                } else if (type === _const.SHAPES.ELIP) {
-                    x = shape.x;
-                    y = shape.y;
-                    w = shape.width + lineWidth / 2;
-                    h = shape.height + lineWidth / 2;
-
-                    minX = x - w < minX ? x - w : minX;
-                    maxX = x + w > maxX ? x + w : maxX;
-
-                    minY = y - h < minY ? y - h : minY;
-                    maxY = y + h > maxY ? y + h : maxY;
-                } else {
-                    // POLY
-                    var points = shape.points;
-                    var x2 = 0;
-                    var y2 = 0;
-                    var dx = 0;
-                    var dy = 0;
-                    var rw = 0;
-                    var rh = 0;
-                    var cx = 0;
-                    var cy = 0;
-
-                    for (var j = 0; j + 2 < points.length; j += 2) {
-                        x = points[j];
-                        y = points[j + 1];
-                        x2 = points[j + 2];
-                        y2 = points[j + 3];
-                        dx = Math.abs(x2 - x);
-                        dy = Math.abs(y2 - y);
-                        h = lineWidth;
-                        w = Math.sqrt(dx * dx + dy * dy);
-
-                        if (w < 1e-9) {
-                            continue;
-                        }
-
-                        rw = (h / w * dy + dx) / 2;
-                        rh = (h / w * dx + dy) / 2;
-                        cx = (x2 + x) / 2;
-                        cy = (y2 + y) / 2;
-
-                        minX = cx - rw < minX ? cx - rw : minX;
-                        maxX = cx + rw > maxX ? cx + rw : maxX;
-
-                        minY = cy - rh < minY ? cy - rh : minY;
-                        maxY = cy + rh > maxY ? cy + rh : maxY;
-                    }
-                }
-            }
-        } else {
-            minX = 0;
-            maxX = 0;
-            minY = 0;
-            maxY = 0;
-        }
-
-        var padding = this.boundsPadding;
-
-        this._localBounds.minX = minX - padding;
-        this._localBounds.maxX = maxX + padding;
-
-        this._localBounds.minY = minY - padding;
-        this._localBounds.maxY = maxY + padding;
-    };
-
-    /**
-     * Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
-     *
-     * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - The shape object to draw.
-     * @return {PIXI.GraphicsData} The generated GraphicsData object.
-     */
-
-
-    Graphics.prototype.drawShape = function drawShape(shape) {
-        if (this.currentPath) {
-            // check current path!
-            if (this.currentPath.shape.points.length <= 2) {
-                this.graphicsData.pop();
-            }
-        }
-
-        this.currentPath = null;
-
-        var data = new _GraphicsData2.default(this.lineWidth, this.lineColor, this.lineAlpha, this.fillColor, this.fillAlpha, this.filling, this.nativeLines, shape);
-
-        this.graphicsData.push(data);
-
-        if (data.type === _const.SHAPES.POLY) {
-            data.shape.closed = data.shape.closed || this.filling;
-            this.currentPath = data;
-        }
-
-        this.dirty++;
-
-        return data;
-    };
-
-    /**
-     * Generates a canvas texture.
-     *
-     * @param {number} scaleMode - The scale mode of the texture.
-     * @param {number} resolution - The resolution of the texture.
-     * @return {PIXI.Texture} The new texture.
-     */
-
-
-    Graphics.prototype.generateCanvasTexture = function generateCanvasTexture(scaleMode) {
-        var resolution = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-
-        var bounds = this.getLocalBounds();
-
-        var canvasBuffer = _RenderTexture2.default.create(bounds.width, bounds.height, scaleMode, resolution);
-
-        if (!canvasRenderer) {
-            canvasRenderer = new _CanvasRenderer2.default();
-        }
-
-        this.transform.updateLocalTransform();
-        this.transform.localTransform.copy(tempMatrix);
-
-        tempMatrix.invert();
-
-        tempMatrix.tx -= bounds.x;
-        tempMatrix.ty -= bounds.y;
-
-        canvasRenderer.render(this, canvasBuffer, true, tempMatrix);
-
-        var texture = _Texture2.default.fromCanvas(canvasBuffer.baseTexture._canvasRenderTarget.canvas, scaleMode, 'graphics');
-
-        texture.baseTexture.resolution = resolution;
-        texture.baseTexture.update();
-
-        return texture;
-    };
-
-    /**
-     * Closes the current path.
-     *
-     * @return {PIXI.Graphics} Returns itself.
-     */
-
-
-    Graphics.prototype.closePath = function closePath() {
-        // ok so close path assumes next one is a hole!
-        var currentPath = this.currentPath;
-
-        if (currentPath && currentPath.shape) {
-            currentPath.shape.close();
-        }
-
-        return this;
-    };
-
-    /**
-     * Adds a hole in the current path.
-     *
-     * @return {PIXI.Graphics} Returns itself.
-     */
-
-
-    Graphics.prototype.addHole = function addHole() {
-        // this is a hole!
-        var hole = this.graphicsData.pop();
-
-        this.currentPath = this.graphicsData[this.graphicsData.length - 1];
-
-        this.currentPath.addHole(hole.shape);
-        this.currentPath = null;
-
-        return this;
-    };
-
-    /**
-     * Destroys the Graphics object.
-     *
-     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all
-     *  options have been set to that value
-     * @param {boolean} [options.children=false] - if set to true, all the children will have
-     *  their destroy method called as well. 'options' will be passed on to those calls.
-     * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
-     *  Should it destroy the texture of the child sprite
-     * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
-     *  Should it destroy the base texture of the child sprite
-     */
-
-
-    Graphics.prototype.destroy = function destroy(options) {
-        _Container.prototype.destroy.call(this, options);
-
-        // destroy each of the GraphicsData objects
-        for (var i = 0; i < this.graphicsData.length; ++i) {
-            this.graphicsData[i].destroy();
-        }
-
-        // for each webgl data entry, destroy the WebGLGraphicsData
-        for (var id in this._webgl) {
-            for (var j = 0; j < this._webgl[id].data.length; ++j) {
-                this._webgl[id].data[j].destroy();
-            }
-        }
-
-        if (this._spriteRect) {
-            this._spriteRect.destroy();
-        }
-
-        this.graphicsData = null;
-
-        this.currentPath = null;
-        this._webgl = null;
-        this._localBounds = null;
-    };
-
-    return Graphics;
-}(_Container3.default);
-
-exports.default = Graphics;
-
-
-Graphics._SPRITE_TEXTURE = null;
-
-},{"../const":46,"../display/Bounds":47,"../display/Container":48,"../math":70,"../renderers/canvas/CanvasRenderer":77,"../sprites/Sprite":102,"../textures/RenderTexture":113,"../textures/Texture":115,"../utils":124,"./GraphicsData":54,"./utils/bezierCurveTo":56}],54:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * A GraphicsData object.
- *
- * @class
- * @memberof PIXI
- */
-var GraphicsData = function () {
-  /**
-   *
-   * @param {number} lineWidth - the width of the line to draw
-   * @param {number} lineColor - the color of the line to draw
-   * @param {number} lineAlpha - the alpha of the line to draw
-   * @param {number} fillColor - the color of the fill
-   * @param {number} fillAlpha - the alpha of the fill
-   * @param {boolean} fill - whether or not the shape is filled with a colour
-   * @param {boolean} nativeLines - the method for drawing lines
-   * @param {PIXI.Circle|PIXI.Rectangle|PIXI.Ellipse|PIXI.Polygon} shape - The shape object to draw.
-   */
-  function GraphicsData(lineWidth, lineColor, lineAlpha, fillColor, fillAlpha, fill, nativeLines, shape) {
-    _classCallCheck(this, GraphicsData);
-
-    /**
-     * @member {number} the width of the line to draw
-     */
-    this.lineWidth = lineWidth;
-    /**
-     * @member {boolean} if true the liens will be draw using LINES instead of TRIANGLE_STRIP
-     */
-    this.nativeLines = nativeLines;
-
-    /**
-     * @member {number} the color of the line to draw
-     */
-    this.lineColor = lineColor;
-
-    /**
-     * @member {number} the alpha of the line to draw
-     */
-    this.lineAlpha = lineAlpha;
-
-    /**
-     * @member {number} cached tint of the line to draw
-     */
-    this._lineTint = lineColor;
-
-    /**
-     * @member {number} the color of the fill
-     */
-    this.fillColor = fillColor;
-
-    /**
-     * @member {number} the alpha of the fill
-     */
-    this.fillAlpha = fillAlpha;
-
-    /**
-     * @member {number} cached tint of the fill
-     */
-    this._fillTint = fillColor;
-
-    /**
-     * @member {boolean} whether or not the shape is filled with a colour
-     */
-    this.fill = fill;
-
-    this.holes = [];
-
-    /**
-     * @member {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} The shape object to draw.
-     */
-    this.shape = shape;
-
-    /**
-     * @member {number} The type of the shape, see the Const.Shapes file for all the existing types,
-     */
-    this.type = shape.type;
-  }
-
-  /**
-   * Creates a new GraphicsData object with the same values as this one.
-   *
-   * @return {PIXI.GraphicsData} Cloned GraphicsData object
-   */
-
-
-  GraphicsData.prototype.clone = function clone() {
-    return new GraphicsData(this.lineWidth, this.lineColor, this.lineAlpha, this.fillColor, this.fillAlpha, this.fill, this.nativeLines, this.shape);
-  };
-
-  /**
-   * Adds a hole to the shape.
-   *
-   * @param {PIXI.Rectangle|PIXI.Circle} shape - The shape of the hole.
-   */
-
-
-  GraphicsData.prototype.addHole = function addHole(shape) {
-    this.holes.push(shape);
-  };
-
-  /**
-   * Destroys the Graphics data.
-   */
-
-
-  GraphicsData.prototype.destroy = function destroy() {
-    this.shape = null;
-    this.holes = null;
-  };
-
-  return GraphicsData;
-}();
-
-exports.default = GraphicsData;
-
-},{}],55:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _CanvasRenderer = require('../../renderers/canvas/CanvasRenderer');
-
-var _CanvasRenderer2 = _interopRequireDefault(_CanvasRenderer);
-
-var _const = require('../../const');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @author Mat Groves
- *
- * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
- * for creating the original PixiJS version!
- * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they
- * now share 4 bytes on the vertex buffer
- *
- * Heavily inspired by LibGDX's CanvasGraphicsRenderer:
- * https://github.com/libgdx/libgdx/blob/1.0.0/gdx/src/com/badlogic/gdx/graphics/glutils/ShapeRenderer.java
- */
-
-/**
- * Renderer dedicated to drawing and batching graphics objects.
- *
- * @class
- * @private
- * @memberof PIXI
- */
-var CanvasGraphicsRenderer = function () {
-    /**
-     * @param {PIXI.CanvasRenderer} renderer - The current PIXI renderer.
-     */
-    function CanvasGraphicsRenderer(renderer) {
-        _classCallCheck(this, CanvasGraphicsRenderer);
-
-        this.renderer = renderer;
-    }
-
-    /**
-     * Renders a Graphics object to a canvas.
-     *
-     * @param {PIXI.Graphics} graphics - the actual graphics object to render
-     */
-
-
-    CanvasGraphicsRenderer.prototype.render = function render(graphics) {
-        var renderer = this.renderer;
-        var context = renderer.context;
-        var worldAlpha = graphics.worldAlpha;
-        var transform = graphics.transform.worldTransform;
-        var resolution = renderer.resolution;
-
-        // if the tint has changed, set the graphics object to dirty.
-        if (this._prevTint !== this.tint) {
-            this.dirty = true;
-        }
-
-        context.setTransform(transform.a * resolution, transform.b * resolution, transform.c * resolution, transform.d * resolution, transform.tx * resolution, transform.ty * resolution);
-
-        if (graphics.dirty) {
-            this.updateGraphicsTint(graphics);
-            graphics.dirty = false;
-        }
-
-        renderer.setBlendMode(graphics.blendMode);
-
-        for (var i = 0; i < graphics.graphicsData.length; i++) {
-            var data = graphics.graphicsData[i];
-            var shape = data.shape;
-
-            var fillColor = data._fillTint;
-            var lineColor = data._lineTint;
-
-            context.lineWidth = data.lineWidth;
-
-            if (data.type === _const.SHAPES.POLY) {
-                context.beginPath();
-
-                this.renderPolygon(shape.points, shape.closed, context);
-
-                for (var j = 0; j < data.holes.length; j++) {
-                    this.renderPolygon(data.holes[j].points, true, context);
-                }
-
-                if (data.fill) {
-                    context.globalAlpha = data.fillAlpha * worldAlpha;
-                    context.fillStyle = '#' + ('00000' + (fillColor | 0).toString(16)).substr(-6);
-                    context.fill();
-                }
-                if (data.lineWidth) {
-                    context.globalAlpha = data.lineAlpha * worldAlpha;
-                    context.strokeStyle = '#' + ('00000' + (lineColor | 0).toString(16)).substr(-6);
-                    context.stroke();
-                }
-            } else if (data.type === _const.SHAPES.RECT) {
-                if (data.fillColor || data.fillColor === 0) {
-                    context.globalAlpha = data.fillAlpha * worldAlpha;
-                    context.fillStyle = '#' + ('00000' + (fillColor | 0).toString(16)).substr(-6);
-                    context.fillRect(shape.x, shape.y, shape.width, shape.height);
-                }
-                if (data.lineWidth) {
-                    context.globalAlpha = data.lineAlpha * worldAlpha;
-                    context.strokeStyle = '#' + ('00000' + (lineColor | 0).toString(16)).substr(-6);
-                    context.strokeRect(shape.x, shape.y, shape.width, shape.height);
-                }
-            } else if (data.type === _const.SHAPES.CIRC) {
-                // TODO - need to be Undefined!
-                context.beginPath();
-                context.arc(shape.x, shape.y, shape.radius, 0, 2 * Math.PI);
-                context.closePath();
-
-                if (data.fill) {
-                    context.globalAlpha = data.fillAlpha * worldAlpha;
-                    context.fillStyle = '#' + ('00000' + (fillColor | 0).toString(16)).substr(-6);
-                    context.fill();
-                }
-                if (data.lineWidth) {
-                    context.globalAlpha = data.lineAlpha * worldAlpha;
-                    context.strokeStyle = '#' + ('00000' + (lineColor | 0).toString(16)).substr(-6);
-                    context.stroke();
-                }
-            } else if (data.type === _const.SHAPES.ELIP) {
-                // ellipse code taken from: http://stackoverflow.com/questions/2172798/how-to-draw-an-oval-in-html5-canvas
-
-                var w = shape.width * 2;
-                var h = shape.height * 2;
-
-                var x = shape.x - w / 2;
-                var y = shape.y - h / 2;
-
-                context.beginPath();
-
-                var kappa = 0.5522848;
-                var ox = w / 2 * kappa; // control point offset horizontal
-                var oy = h / 2 * kappa; // control point offset vertical
-                var xe = x + w; // x-end
-                var ye = y + h; // y-end
-                var xm = x + w / 2; // x-middle
-                var ym = y + h / 2; // y-middle
-
-                context.moveTo(x, ym);
-                context.bezierCurveTo(x, ym - oy, xm - ox, y, xm, y);
-                context.bezierCurveTo(xm + ox, y, xe, ym - oy, xe, ym);
-                context.bezierCurveTo(xe, ym + oy, xm + ox, ye, xm, ye);
-                context.bezierCurveTo(xm - ox, ye, x, ym + oy, x, ym);
-
-                context.closePath();
-
-                if (data.fill) {
-                    context.globalAlpha = data.fillAlpha * worldAlpha;
-                    context.fillStyle = '#' + ('00000' + (fillColor | 0).toString(16)).substr(-6);
-                    context.fill();
-                }
-                if (data.lineWidth) {
-                    context.globalAlpha = data.lineAlpha * worldAlpha;
-                    context.strokeStyle = '#' + ('00000' + (lineColor | 0).toString(16)).substr(-6);
-                    context.stroke();
-                }
-            } else if (data.type === _const.SHAPES.RREC) {
-                var rx = shape.x;
-                var ry = shape.y;
-                var width = shape.width;
-                var height = shape.height;
-                var radius = shape.radius;
-
-                var maxRadius = Math.min(width, height) / 2 | 0;
-
-                radius = radius > maxRadius ? maxRadius : radius;
-
-                context.beginPath();
-                context.moveTo(rx, ry + radius);
-                context.lineTo(rx, ry + height - radius);
-                context.quadraticCurveTo(rx, ry + height, rx + radius, ry + height);
-                context.lineTo(rx + width - radius, ry + height);
-                context.quadraticCurveTo(rx + width, ry + height, rx + width, ry + height - radius);
-                context.lineTo(rx + width, ry + radius);
-                context.quadraticCurveTo(rx + width, ry, rx + width - radius, ry);
-                context.lineTo(rx + radius, ry);
-                context.quadraticCurveTo(rx, ry, rx, ry + radius);
-                context.closePath();
-
-                if (data.fillColor || data.fillColor === 0) {
-                    context.globalAlpha = data.fillAlpha * worldAlpha;
-                    context.fillStyle = '#' + ('00000' + (fillColor | 0).toString(16)).substr(-6);
-                    context.fill();
-                }
-
-                if (data.lineWidth) {
-                    context.globalAlpha = data.lineAlpha * worldAlpha;
-                    context.strokeStyle = '#' + ('00000' + (lineColor | 0).toString(16)).substr(-6);
-                    context.stroke();
-                }
-            }
-        }
-    };
-
-    /**
-     * Updates the tint of a graphics object
-     *
-     * @private
-     * @param {PIXI.Graphics} graphics - the graphics that will have its tint updated
-     */
-
-
-    CanvasGraphicsRenderer.prototype.updateGraphicsTint = function updateGraphicsTint(graphics) {
-        graphics._prevTint = graphics.tint;
-
-        var tintR = (graphics.tint >> 16 & 0xFF) / 255;
-        var tintG = (graphics.tint >> 8 & 0xFF) / 255;
-        var tintB = (graphics.tint & 0xFF) / 255;
-
-        for (var i = 0; i < graphics.graphicsData.length; ++i) {
-            var data = graphics.graphicsData[i];
-
-            var fillColor = data.fillColor | 0;
-            var lineColor = data.lineColor | 0;
-
-            // super inline cos im an optimization NAZI :)
-            data._fillTint = ((fillColor >> 16 & 0xFF) / 255 * tintR * 255 << 16) + ((fillColor >> 8 & 0xFF) / 255 * tintG * 255 << 8) + (fillColor & 0xFF) / 255 * tintB * 255;
-
-            data._lineTint = ((lineColor >> 16 & 0xFF) / 255 * tintR * 255 << 16) + ((lineColor >> 8 & 0xFF) / 255 * tintG * 255 << 8) + (lineColor & 0xFF) / 255 * tintB * 255;
-        }
-    };
-
-    /**
-     * Renders a polygon.
-     *
-     * @param {PIXI.Point[]} points - The points to render
-     * @param {boolean} close - Should the polygon be closed
-     * @param {CanvasRenderingContext2D} context - The rendering context to use
-     */
-
-
-    CanvasGraphicsRenderer.prototype.renderPolygon = function renderPolygon(points, close, context) {
-        context.moveTo(points[0], points[1]);
-
-        for (var j = 1; j < points.length / 2; ++j) {
-            context.lineTo(points[j * 2], points[j * 2 + 1]);
-        }
-
-        if (close) {
-            context.closePath();
-        }
-    };
-
-    /**
-     * destroy graphics object
-     *
-     */
-
-
-    CanvasGraphicsRenderer.prototype.destroy = function destroy() {
-        this.renderer = null;
-    };
-
-    return CanvasGraphicsRenderer;
-}();
-
-exports.default = CanvasGraphicsRenderer;
-
-
-_CanvasRenderer2.default.registerPlugin('graphics', CanvasGraphicsRenderer);
-
-},{"../../const":46,"../../renderers/canvas/CanvasRenderer":77}],56:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-exports.default = bezierCurveTo;
-/**
- * Calculate the points for a bezier curve and then draws it.
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @param {number} fromX - Starting point x
- * @param {number} fromY - Starting point y
- * @param {number} cpX - Control point x
- * @param {number} cpY - Control point y
- * @param {number} cpX2 - Second Control point x
- * @param {number} cpY2 - Second Control point y
- * @param {number} toX - Destination point x
- * @param {number} toY - Destination point y
- * @param {number[]} [path=[]] - Path array to push points into
- * @return {number[]} Array of points of the curve
- */
-function bezierCurveTo(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
-    var path = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : [];
-
-    var n = 20;
-    var dt = 0;
-    var dt2 = 0;
-    var dt3 = 0;
-    var t2 = 0;
-    var t3 = 0;
-
-    path.push(fromX, fromY);
-
-    for (var i = 1, j = 0; i <= n; ++i) {
-        j = i / n;
-
-        dt = 1 - j;
-        dt2 = dt * dt;
-        dt3 = dt2 * dt;
-
-        t2 = j * j;
-        t3 = t2 * j;
-
-        path.push(dt3 * fromX + 3 * dt2 * j * cpX + 3 * dt * t2 * cpX2 + t3 * toX, dt3 * fromY + 3 * dt2 * j * cpY + 3 * dt * t2 * cpY2 + t3 * toY);
-    }
-
-    return path;
-}
-
-},{}],57:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _utils = require('../../utils');
-
-var _const = require('../../const');
-
-var _ObjectRenderer2 = require('../../renderers/webgl/utils/ObjectRenderer');
-
-var _ObjectRenderer3 = _interopRequireDefault(_ObjectRenderer2);
-
-var _WebGLRenderer = require('../../renderers/webgl/WebGLRenderer');
-
-var _WebGLRenderer2 = _interopRequireDefault(_WebGLRenderer);
-
-var _WebGLGraphicsData = require('./WebGLGraphicsData');
-
-var _WebGLGraphicsData2 = _interopRequireDefault(_WebGLGraphicsData);
-
-var _PrimitiveShader = require('./shaders/PrimitiveShader');
-
-var _PrimitiveShader2 = _interopRequireDefault(_PrimitiveShader);
-
-var _buildPoly = require('./utils/buildPoly');
-
-var _buildPoly2 = _interopRequireDefault(_buildPoly);
-
-var _buildRectangle = require('./utils/buildRectangle');
-
-var _buildRectangle2 = _interopRequireDefault(_buildRectangle);
-
-var _buildRoundedRectangle = require('./utils/buildRoundedRectangle');
-
-var _buildRoundedRectangle2 = _interopRequireDefault(_buildRoundedRectangle);
-
-var _buildCircle = require('./utils/buildCircle');
-
-var _buildCircle2 = _interopRequireDefault(_buildCircle);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * Renders the graphics object.
- *
- * @class
- * @memberof PIXI
- * @extends PIXI.ObjectRenderer
- */
-var GraphicsRenderer = function (_ObjectRenderer) {
-    _inherits(GraphicsRenderer, _ObjectRenderer);
-
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - The renderer this object renderer works for.
-     */
-    function GraphicsRenderer(renderer) {
-        _classCallCheck(this, GraphicsRenderer);
-
-        var _this = _possibleConstructorReturn(this, _ObjectRenderer.call(this, renderer));
-
-        _this.graphicsDataPool = [];
-
-        _this.primitiveShader = null;
-
-        _this.gl = renderer.gl;
-
-        // easy access!
-        _this.CONTEXT_UID = 0;
-        return _this;
-    }
-
-    /**
-     * Called when there is a WebGL context change
-     *
-     * @private
-     *
-     */
-
-
-    GraphicsRenderer.prototype.onContextChange = function onContextChange() {
-        this.gl = this.renderer.gl;
-        this.CONTEXT_UID = this.renderer.CONTEXT_UID;
-        this.primitiveShader = new _PrimitiveShader2.default(this.gl);
-    };
-
-    /**
-     * Destroys this renderer.
-     *
-     */
-
-
-    GraphicsRenderer.prototype.destroy = function destroy() {
-        _ObjectRenderer3.default.prototype.destroy.call(this);
-
-        for (var i = 0; i < this.graphicsDataPool.length; ++i) {
-            this.graphicsDataPool[i].destroy();
-        }
-
-        this.graphicsDataPool = null;
-    };
-
-    /**
-     * Renders a graphics object.
-     *
-     * @param {PIXI.Graphics} graphics - The graphics object to render.
-     */
-
-
-    GraphicsRenderer.prototype.render = function render(graphics) {
-        var renderer = this.renderer;
-        var gl = renderer.gl;
-
-        var webGLData = void 0;
-        var webGL = graphics._webGL[this.CONTEXT_UID];
-
-        if (!webGL || graphics.dirty !== webGL.dirty) {
-            this.updateGraphics(graphics);
-
-            webGL = graphics._webGL[this.CONTEXT_UID];
-        }
-
-        // This  could be speeded up for sure!
-        var shader = this.primitiveShader;
-
-        renderer.bindShader(shader);
-        renderer.state.setBlendMode(graphics.blendMode);
-
-        for (var i = 0, n = webGL.data.length; i < n; i++) {
-            webGLData = webGL.data[i];
-            var shaderTemp = webGLData.shader;
-
-            renderer.bindShader(shaderTemp);
-            shaderTemp.uniforms.translationMatrix = graphics.transform.worldTransform.toArray(true);
-            shaderTemp.uniforms.tint = (0, _utils.hex2rgb)(graphics.tint);
-            shaderTemp.uniforms.alpha = graphics.worldAlpha;
-
-            renderer.bindVao(webGLData.vao);
-
-            if (webGLData.nativeLines) {
-                gl.drawArrays(gl.LINES, 0, webGLData.points.length / 6);
-            } else {
-                webGLData.vao.draw(gl.TRIANGLE_STRIP, webGLData.indices.length);
-            }
-        }
-    };
-
-    /**
-     * Updates the graphics object
-     *
-     * @private
-     * @param {PIXI.Graphics} graphics - The graphics object to update
-     */
-
-
-    GraphicsRenderer.prototype.updateGraphics = function updateGraphics(graphics) {
-        var gl = this.renderer.gl;
-
-        // get the contexts graphics object
-        var webGL = graphics._webGL[this.CONTEXT_UID];
-
-        // if the graphics object does not exist in the webGL context time to create it!
-        if (!webGL) {
-            webGL = graphics._webGL[this.CONTEXT_UID] = { lastIndex: 0, data: [], gl: gl, clearDirty: -1, dirty: -1 };
-        }
-
-        // flag the graphics as not dirty as we are about to update it...
-        webGL.dirty = graphics.dirty;
-
-        // if the user cleared the graphics object we will need to clear every object
-        if (graphics.clearDirty !== webGL.clearDirty) {
-            webGL.clearDirty = graphics.clearDirty;
-
-            // loop through and return all the webGLDatas to the object pool so than can be reused later on
-            for (var i = 0; i < webGL.data.length; i++) {
-                this.graphicsDataPool.push(webGL.data[i]);
-            }
-
-            // clear the array and reset the index..
-            webGL.data.length = 0;
-            webGL.lastIndex = 0;
-        }
-
-        var webGLData = void 0;
-        var webGLDataNativeLines = void 0;
-
-        // loop through the graphics datas and construct each one..
-        // if the object is a complex fill then the new stencil buffer technique will be used
-        // other wise graphics objects will be pushed into a batch..
-        for (var _i = webGL.lastIndex; _i < graphics.graphicsData.length; _i++) {
-            var data = graphics.graphicsData[_i];
-
-            // TODO - this can be simplified
-            webGLData = this.getWebGLData(webGL, 0);
-
-            if (data.nativeLines && data.lineWidth) {
-                webGLDataNativeLines = this.getWebGLData(webGL, 0, true);
-                webGL.lastIndex++;
-            }
-
-            if (data.type === _const.SHAPES.POLY) {
-                (0, _buildPoly2.default)(data, webGLData, webGLDataNativeLines);
-            }
-            if (data.type === _const.SHAPES.RECT) {
-                (0, _buildRectangle2.default)(data, webGLData, webGLDataNativeLines);
-            } else if (data.type === _const.SHAPES.CIRC || data.type === _const.SHAPES.ELIP) {
-                (0, _buildCircle2.default)(data, webGLData, webGLDataNativeLines);
-            } else if (data.type === _const.SHAPES.RREC) {
-                (0, _buildRoundedRectangle2.default)(data, webGLData, webGLDataNativeLines);
-            }
-
-            webGL.lastIndex++;
-        }
-
-        this.renderer.bindVao(null);
-
-        // upload all the dirty data...
-        for (var _i2 = 0; _i2 < webGL.data.length; _i2++) {
-            webGLData = webGL.data[_i2];
-
-            if (webGLData.dirty) {
-                webGLData.upload();
-            }
-        }
-    };
-
-    /**
-     *
-     * @private
-     * @param {WebGLRenderingContext} gl - the current WebGL drawing context
-     * @param {number} type - TODO @Alvin
-     * @param {number} nativeLines - indicate whether the webGLData use for nativeLines.
-     * @return {*} TODO
-     */
-
-
-    GraphicsRenderer.prototype.getWebGLData = function getWebGLData(gl, type, nativeLines) {
-        var webGLData = gl.data[gl.data.length - 1];
-
-        if (!webGLData || webGLData.nativeLines !== nativeLines || webGLData.points.length > 320000) {
-            webGLData = this.graphicsDataPool.pop() || new _WebGLGraphicsData2.default(this.renderer.gl, this.primitiveShader, this.renderer.state.attribsState);
-            webGLData.nativeLines = nativeLines;
-            webGLData.reset(type);
-            gl.data.push(webGLData);
-        }
-
-        webGLData.dirty = true;
-
-        return webGLData;
-    };
-
-    return GraphicsRenderer;
-}(_ObjectRenderer3.default);
-
-exports.default = GraphicsRenderer;
-
-
-_WebGLRenderer2.default.registerPlugin('graphics', GraphicsRenderer);
-
-},{"../../const":46,"../../renderers/webgl/WebGLRenderer":84,"../../renderers/webgl/utils/ObjectRenderer":94,"../../utils":124,"./WebGLGraphicsData":58,"./shaders/PrimitiveShader":59,"./utils/buildCircle":60,"./utils/buildPoly":62,"./utils/buildRectangle":63,"./utils/buildRoundedRectangle":64}],58:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * An object containing WebGL specific properties to be used by the WebGL renderer
- *
- * @class
- * @private
- * @memberof PIXI
- */
-var WebGLGraphicsData = function () {
-  /**
-   * @param {WebGLRenderingContext} gl - The current WebGL drawing context
-   * @param {PIXI.Shader} shader - The shader
-   * @param {object} attribsState - The state for the VAO
-   */
-  function WebGLGraphicsData(gl, shader, attribsState) {
-    _classCallCheck(this, WebGLGraphicsData);
-
-    /**
-     * The current WebGL drawing context
-     *
-     * @member {WebGLRenderingContext}
-     */
-    this.gl = gl;
-
-    // TODO does this need to be split before uploading??
-    /**
-     * An array of color components (r,g,b)
-     * @member {number[]}
-     */
-    this.color = [0, 0, 0]; // color split!
-
-    /**
-     * An array of points to draw
-     * @member {PIXI.Point[]}
-     */
-    this.points = [];
-
-    /**
-     * The indices of the vertices
-     * @member {number[]}
-     */
-    this.indices = [];
-    /**
-     * The main buffer
-     * @member {WebGLBuffer}
-     */
-    this.buffer = _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl);
-
-    /**
-     * The index buffer
-     * @member {WebGLBuffer}
-     */
-    this.indexBuffer = _pixiGlCore2.default.GLBuffer.createIndexBuffer(gl);
-
-    /**
-     * Whether this graphics is dirty or not
-     * @member {boolean}
-     */
-    this.dirty = true;
-
-    /**
-     * Whether this graphics is nativeLines or not
-     * @member {boolean}
-     */
-    this.nativeLines = false;
-
-    this.glPoints = null;
-    this.glIndices = null;
-
-    /**
-     *
-     * @member {PIXI.Shader}
-     */
-    this.shader = shader;
-
-    this.vao = new _pixiGlCore2.default.VertexArrayObject(gl, attribsState).addIndex(this.indexBuffer).addAttribute(this.buffer, shader.attributes.aVertexPosition, gl.FLOAT, false, 4 * 6, 0).addAttribute(this.buffer, shader.attributes.aColor, gl.FLOAT, false, 4 * 6, 2 * 4);
-  }
-
-  /**
-   * Resets the vertices and the indices
-   */
-
-
-  WebGLGraphicsData.prototype.reset = function reset() {
-    this.points.length = 0;
-    this.indices.length = 0;
-  };
-
-  /**
-   * Binds the buffers and uploads the data
-   */
-
-
-  WebGLGraphicsData.prototype.upload = function upload() {
-    this.glPoints = new Float32Array(this.points);
-    this.buffer.upload(this.glPoints);
-
-    this.glIndices = new Uint16Array(this.indices);
-    this.indexBuffer.upload(this.glIndices);
-
-    this.dirty = false;
-  };
-
-  /**
-   * Empties all the data
-   */
-
-
-  WebGLGraphicsData.prototype.destroy = function destroy() {
-    this.color = null;
-    this.points = null;
-    this.indices = null;
-
-    this.vao.destroy();
-    this.buffer.destroy();
-    this.indexBuffer.destroy();
-
-    this.gl = null;
-
-    this.buffer = null;
-    this.indexBuffer = null;
-
-    this.glPoints = null;
-    this.glIndices = null;
-  };
-
-  return WebGLGraphicsData;
-}();
-
-exports.default = WebGLGraphicsData;
-
-},{"pixi-gl-core":12}],59:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Shader2 = require('../../../Shader');
-
-var _Shader3 = _interopRequireDefault(_Shader2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * This shader is used to draw simple primitive shapes for {@link PIXI.Graphics}.
- *
- * @class
- * @memberof PIXI
- * @extends PIXI.Shader
- */
-var PrimitiveShader = function (_Shader) {
-    _inherits(PrimitiveShader, _Shader);
-
-    /**
-     * @param {WebGLRenderingContext} gl - The webgl shader manager this shader works for.
-     */
-    function PrimitiveShader(gl) {
-        _classCallCheck(this, PrimitiveShader);
-
-        return _possibleConstructorReturn(this, _Shader.call(this, gl,
-        // vertex shader
-        ['attribute vec2 aVertexPosition;', 'attribute vec4 aColor;', 'uniform mat3 translationMatrix;', 'uniform mat3 projectionMatrix;', 'uniform float alpha;', 'uniform vec3 tint;', 'varying vec4 vColor;', 'void main(void){', '   gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);', '   vColor = aColor * vec4(tint * alpha, alpha);', '}'].join('\n'),
-        // fragment shader
-        ['varying vec4 vColor;', 'void main(void){', '   gl_FragColor = vColor;', '}'].join('\n')));
-    }
-
-    return PrimitiveShader;
-}(_Shader3.default);
-
-exports.default = PrimitiveShader;
-
-},{"../../../Shader":44}],60:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = buildCircle;
-
-var _buildLine = require('./buildLine');
-
-var _buildLine2 = _interopRequireDefault(_buildLine);
-
-var _const = require('../../../const');
-
-var _utils = require('../../../utils');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Builds a circle to draw
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object to draw
- * @param {object} webGLData - an object containing all the webGL-specific information to create this shape
- * @param {object} webGLDataNativeLines - an object containing all the webGL-specific information to create nativeLines
- */
-function buildCircle(graphicsData, webGLData, webGLDataNativeLines) {
-    // need to convert points to a nice regular data
-    var circleData = graphicsData.shape;
-    var x = circleData.x;
-    var y = circleData.y;
-    var width = void 0;
-    var height = void 0;
-
-    // TODO - bit hacky??
-    if (graphicsData.type === _const.SHAPES.CIRC) {
-        width = circleData.radius;
-        height = circleData.radius;
-    } else {
-        width = circleData.width;
-        height = circleData.height;
-    }
-
-    if (width === 0 || height === 0) {
-        return;
-    }
-
-    var totalSegs = Math.floor(30 * Math.sqrt(circleData.radius)) || Math.floor(15 * Math.sqrt(circleData.width + circleData.height));
-
-    var seg = Math.PI * 2 / totalSegs;
-
-    if (graphicsData.fill) {
-        var color = (0, _utils.hex2rgb)(graphicsData.fillColor);
-        var alpha = graphicsData.fillAlpha;
-
-        var r = color[0] * alpha;
-        var g = color[1] * alpha;
-        var b = color[2] * alpha;
-
-        var verts = webGLData.points;
-        var indices = webGLData.indices;
-
-        var vecPos = verts.length / 6;
-
-        indices.push(vecPos);
-
-        for (var i = 0; i < totalSegs + 1; i++) {
-            verts.push(x, y, r, g, b, alpha);
-
-            verts.push(x + Math.sin(seg * i) * width, y + Math.cos(seg * i) * height, r, g, b, alpha);
-
-            indices.push(vecPos++, vecPos++);
-        }
-
-        indices.push(vecPos - 1);
-    }
-
-    if (graphicsData.lineWidth) {
-        var tempPoints = graphicsData.points;
-
-        graphicsData.points = [];
-
-        for (var _i = 0; _i < totalSegs + 1; _i++) {
-            graphicsData.points.push(x + Math.sin(seg * _i) * width, y + Math.cos(seg * _i) * height);
-        }
-
-        (0, _buildLine2.default)(graphicsData, webGLData, webGLDataNativeLines);
-
-        graphicsData.points = tempPoints;
-    }
-}
-
-},{"../../../const":46,"../../../utils":124,"./buildLine":61}],61:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-exports.default = function (graphicsData, webGLData, webGLDataNativeLines) {
-    if (graphicsData.nativeLines) {
-        buildNativeLine(graphicsData, webGLDataNativeLines);
-    } else {
-        buildLine(graphicsData, webGLData);
-    }
-};
-
-var _math = require('../../../math');
-
-var _utils = require('../../../utils');
-
-/**
- * Builds a line to draw using the poligon method.
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
- * @param {object} webGLData - an object containing all the webGL-specific information to create this shape
- */
-function buildLine(graphicsData, webGLData) {
-    // TODO OPTIMISE!
-    var points = graphicsData.points;
-
-    if (points.length === 0) {
-        return;
-    }
-    // if the line width is an odd number add 0.5 to align to a whole pixel
-    // commenting this out fixes #711 and #1620
-    // if (graphicsData.lineWidth%2)
-    // {
-    //     for (i = 0; i < points.length; i++)
-    //     {
-    //         points[i] += 0.5;
-    //     }
-    // }
-
-    // get first and last point.. figure out the middle!
-    var firstPoint = new _math.Point(points[0], points[1]);
-    var lastPoint = new _math.Point(points[points.length - 2], points[points.length - 1]);
-
-    // if the first point is the last point - gonna have issues :)
-    if (firstPoint.x === lastPoint.x && firstPoint.y === lastPoint.y) {
-        // need to clone as we are going to slightly modify the shape..
-        points = points.slice();
-
-        points.pop();
-        points.pop();
-
-        lastPoint = new _math.Point(points[points.length - 2], points[points.length - 1]);
-
-        var midPointX = lastPoint.x + (firstPoint.x - lastPoint.x) * 0.5;
-        var midPointY = lastPoint.y + (firstPoint.y - lastPoint.y) * 0.5;
-
-        points.unshift(midPointX, midPointY);
-        points.push(midPointX, midPointY);
-    }
-
-    var verts = webGLData.points;
-    var indices = webGLData.indices;
-    var length = points.length / 2;
-    var indexCount = points.length;
-    var indexStart = verts.length / 6;
-
-    // DRAW the Line
-    var width = graphicsData.lineWidth / 2;
-
-    // sort color
-    var color = (0, _utils.hex2rgb)(graphicsData.lineColor);
-    var alpha = graphicsData.lineAlpha;
-    var r = color[0] * alpha;
-    var g = color[1] * alpha;
-    var b = color[2] * alpha;
-
-    var p1x = points[0];
-    var p1y = points[1];
-    var p2x = points[2];
-    var p2y = points[3];
-    var p3x = 0;
-    var p3y = 0;
-
-    var perpx = -(p1y - p2y);
-    var perpy = p1x - p2x;
-    var perp2x = 0;
-    var perp2y = 0;
-    var perp3x = 0;
-    var perp3y = 0;
-
-    var dist = Math.sqrt(perpx * perpx + perpy * perpy);
-
-    perpx /= dist;
-    perpy /= dist;
-    perpx *= width;
-    perpy *= width;
-
-    // start
-    verts.push(p1x - perpx, p1y - perpy, r, g, b, alpha);
-
-    verts.push(p1x + perpx, p1y + perpy, r, g, b, alpha);
-
-    for (var i = 1; i < length - 1; ++i) {
-        p1x = points[(i - 1) * 2];
-        p1y = points[(i - 1) * 2 + 1];
-
-        p2x = points[i * 2];
-        p2y = points[i * 2 + 1];
-
-        p3x = points[(i + 1) * 2];
-        p3y = points[(i + 1) * 2 + 1];
-
-        perpx = -(p1y - p2y);
-        perpy = p1x - p2x;
-
-        dist = Math.sqrt(perpx * perpx + perpy * perpy);
-        perpx /= dist;
-        perpy /= dist;
-        perpx *= width;
-        perpy *= width;
-
-        perp2x = -(p2y - p3y);
-        perp2y = p2x - p3x;
-
-        dist = Math.sqrt(perp2x * perp2x + perp2y * perp2y);
-        perp2x /= dist;
-        perp2y /= dist;
-        perp2x *= width;
-        perp2y *= width;
-
-        var a1 = -perpy + p1y - (-perpy + p2y);
-        var b1 = -perpx + p2x - (-perpx + p1x);
-        var c1 = (-perpx + p1x) * (-perpy + p2y) - (-perpx + p2x) * (-perpy + p1y);
-        var a2 = -perp2y + p3y - (-perp2y + p2y);
-        var b2 = -perp2x + p2x - (-perp2x + p3x);
-        var c2 = (-perp2x + p3x) * (-perp2y + p2y) - (-perp2x + p2x) * (-perp2y + p3y);
-
-        var denom = a1 * b2 - a2 * b1;
-
-        if (Math.abs(denom) < 0.1) {
-            denom += 10.1;
-            verts.push(p2x - perpx, p2y - perpy, r, g, b, alpha);
-
-            verts.push(p2x + perpx, p2y + perpy, r, g, b, alpha);
-
-            continue;
-        }
-
-        var px = (b1 * c2 - b2 * c1) / denom;
-        var py = (a2 * c1 - a1 * c2) / denom;
-        var pdist = (px - p2x) * (px - p2x) + (py - p2y) * (py - p2y);
-
-        if (pdist > 196 * width * width) {
-            perp3x = perpx - perp2x;
-            perp3y = perpy - perp2y;
-
-            dist = Math.sqrt(perp3x * perp3x + perp3y * perp3y);
-            perp3x /= dist;
-            perp3y /= dist;
-            perp3x *= width;
-            perp3y *= width;
-
-            verts.push(p2x - perp3x, p2y - perp3y);
-            verts.push(r, g, b, alpha);
-
-            verts.push(p2x + perp3x, p2y + perp3y);
-            verts.push(r, g, b, alpha);
-
-            verts.push(p2x - perp3x, p2y - perp3y);
-            verts.push(r, g, b, alpha);
-
-            indexCount++;
-        } else {
-            verts.push(px, py);
-            verts.push(r, g, b, alpha);
-
-            verts.push(p2x - (px - p2x), p2y - (py - p2y));
-            verts.push(r, g, b, alpha);
-        }
-    }
-
-    p1x = points[(length - 2) * 2];
-    p1y = points[(length - 2) * 2 + 1];
-
-    p2x = points[(length - 1) * 2];
-    p2y = points[(length - 1) * 2 + 1];
-
-    perpx = -(p1y - p2y);
-    perpy = p1x - p2x;
-
-    dist = Math.sqrt(perpx * perpx + perpy * perpy);
-    perpx /= dist;
-    perpy /= dist;
-    perpx *= width;
-    perpy *= width;
-
-    verts.push(p2x - perpx, p2y - perpy);
-    verts.push(r, g, b, alpha);
-
-    verts.push(p2x + perpx, p2y + perpy);
-    verts.push(r, g, b, alpha);
-
-    indices.push(indexStart);
-
-    for (var _i = 0; _i < indexCount; ++_i) {
-        indices.push(indexStart++);
-    }
-
-    indices.push(indexStart - 1);
-}
-
-/**
- * Builds a line to draw using the gl.drawArrays(gl.LINES) method
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
- * @param {object} webGLData - an object containing all the webGL-specific information to create this shape
- */
-
-
-/**
- * Builds a line to draw
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
- * @param {object} webGLData - an object containing all the webGL-specific information to create this shape
- * @param {object} webGLDataNativeLines - an object containing all the webGL-specific information to create nativeLines
- */
-function buildNativeLine(graphicsData, webGLData) {
-    var i = 0;
-    var points = graphicsData.points;
-
-    if (points.length === 0) return;
-
-    var verts = webGLData.points;
-    var length = points.length / 2;
-
-    // sort color
-    var color = (0, _utils.hex2rgb)(graphicsData.lineColor);
-    var alpha = graphicsData.lineAlpha;
-    var r = color[0] * alpha;
-    var g = color[1] * alpha;
-    var b = color[2] * alpha;
-
-    for (i = 1; i < length; i++) {
-        var p1x = points[(i - 1) * 2];
-        var p1y = points[(i - 1) * 2 + 1];
-
-        var p2x = points[i * 2];
-        var p2y = points[i * 2 + 1];
-
-        verts.push(p1x, p1y);
-        verts.push(r, g, b, alpha);
-
-        verts.push(p2x, p2y);
-        verts.push(r, g, b, alpha);
-    }
-}
-
-},{"../../../math":70,"../../../utils":124}],62:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = buildPoly;
-
-var _buildLine = require('./buildLine');
-
-var _buildLine2 = _interopRequireDefault(_buildLine);
-
-var _utils = require('../../../utils');
-
-var _earcut = require('earcut');
-
-var _earcut2 = _interopRequireDefault(_earcut);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Builds a polygon to draw
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
- * @param {object} webGLData - an object containing all the webGL-specific information to create this shape
- * @param {object} webGLDataNativeLines - an object containing all the webGL-specific information to create nativeLines
- */
-function buildPoly(graphicsData, webGLData, webGLDataNativeLines) {
-    graphicsData.points = graphicsData.shape.points.slice();
-
-    var points = graphicsData.points;
-
-    if (graphicsData.fill && points.length >= 6) {
-        var holeArray = [];
-        // Process holes..
-        var holes = graphicsData.holes;
-
-        for (var i = 0; i < holes.length; i++) {
-            var hole = holes[i];
-
-            holeArray.push(points.length / 2);
-
-            points = points.concat(hole.points);
-        }
-
-        // get first and last point.. figure out the middle!
-        var verts = webGLData.points;
-        var indices = webGLData.indices;
-
-        var length = points.length / 2;
-
-        // sort color
-        var color = (0, _utils.hex2rgb)(graphicsData.fillColor);
-        var alpha = graphicsData.fillAlpha;
-        var r = color[0] * alpha;
-        var g = color[1] * alpha;
-        var b = color[2] * alpha;
-
-        var triangles = (0, _earcut2.default)(points, holeArray, 2);
-
-        if (!triangles) {
-            return;
-        }
-
-        var vertPos = verts.length / 6;
-
-        for (var _i = 0; _i < triangles.length; _i += 3) {
-            indices.push(triangles[_i] + vertPos);
-            indices.push(triangles[_i] + vertPos);
-            indices.push(triangles[_i + 1] + vertPos);
-            indices.push(triangles[_i + 2] + vertPos);
-            indices.push(triangles[_i + 2] + vertPos);
-        }
-
-        for (var _i2 = 0; _i2 < length; _i2++) {
-            verts.push(points[_i2 * 2], points[_i2 * 2 + 1], r, g, b, alpha);
-        }
-    }
-
-    if (graphicsData.lineWidth > 0) {
-        (0, _buildLine2.default)(graphicsData, webGLData, webGLDataNativeLines);
-    }
-}
-
-},{"../../../utils":124,"./buildLine":61,"earcut":2}],63:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = buildRectangle;
-
-var _buildLine = require('./buildLine');
-
-var _buildLine2 = _interopRequireDefault(_buildLine);
-
-var _utils = require('../../../utils');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Builds a rectangle to draw
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
- * @param {object} webGLData - an object containing all the webGL-specific information to create this shape
- * @param {object} webGLDataNativeLines - an object containing all the webGL-specific information to create nativeLines
- */
-function buildRectangle(graphicsData, webGLData, webGLDataNativeLines) {
-    // --- //
-    // need to convert points to a nice regular data
-    //
-    var rectData = graphicsData.shape;
-    var x = rectData.x;
-    var y = rectData.y;
-    var width = rectData.width;
-    var height = rectData.height;
-
-    if (graphicsData.fill) {
-        var color = (0, _utils.hex2rgb)(graphicsData.fillColor);
-        var alpha = graphicsData.fillAlpha;
-
-        var r = color[0] * alpha;
-        var g = color[1] * alpha;
-        var b = color[2] * alpha;
-
-        var verts = webGLData.points;
-        var indices = webGLData.indices;
-
-        var vertPos = verts.length / 6;
-
-        // start
-        verts.push(x, y);
-        verts.push(r, g, b, alpha);
-
-        verts.push(x + width, y);
-        verts.push(r, g, b, alpha);
-
-        verts.push(x, y + height);
-        verts.push(r, g, b, alpha);
-
-        verts.push(x + width, y + height);
-        verts.push(r, g, b, alpha);
-
-        // insert 2 dead triangles..
-        indices.push(vertPos, vertPos, vertPos + 1, vertPos + 2, vertPos + 3, vertPos + 3);
-    }
-
-    if (graphicsData.lineWidth) {
-        var tempPoints = graphicsData.points;
-
-        graphicsData.points = [x, y, x + width, y, x + width, y + height, x, y + height, x, y];
-
-        (0, _buildLine2.default)(graphicsData, webGLData, webGLDataNativeLines);
-
-        graphicsData.points = tempPoints;
-    }
-}
-
-},{"../../../utils":124,"./buildLine":61}],64:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = buildRoundedRectangle;
-
-var _earcut = require('earcut');
-
-var _earcut2 = _interopRequireDefault(_earcut);
-
-var _buildLine = require('./buildLine');
-
-var _buildLine2 = _interopRequireDefault(_buildLine);
-
-var _utils = require('../../../utils');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Builds a rounded rectangle to draw
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
- * @param {object} webGLData - an object containing all the webGL-specific information to create this shape
- * @param {object} webGLDataNativeLines - an object containing all the webGL-specific information to create nativeLines
- */
-function buildRoundedRectangle(graphicsData, webGLData, webGLDataNativeLines) {
-    var rrectData = graphicsData.shape;
-    var x = rrectData.x;
-    var y = rrectData.y;
-    var width = rrectData.width;
-    var height = rrectData.height;
-
-    var radius = rrectData.radius;
-
-    var recPoints = [];
-
-    recPoints.push(x, y + radius);
-    quadraticBezierCurve(x, y + height - radius, x, y + height, x + radius, y + height, recPoints);
-    quadraticBezierCurve(x + width - radius, y + height, x + width, y + height, x + width, y + height - radius, recPoints);
-    quadraticBezierCurve(x + width, y + radius, x + width, y, x + width - radius, y, recPoints);
-    quadraticBezierCurve(x + radius, y, x, y, x, y + radius + 0.0000000001, recPoints);
-
-    // this tiny number deals with the issue that occurs when points overlap and earcut fails to triangulate the item.
-    // TODO - fix this properly, this is not very elegant.. but it works for now.
-
-    if (graphicsData.fill) {
-        var color = (0, _utils.hex2rgb)(graphicsData.fillColor);
-        var alpha = graphicsData.fillAlpha;
-
-        var r = color[0] * alpha;
-        var g = color[1] * alpha;
-        var b = color[2] * alpha;
-
-        var verts = webGLData.points;
-        var indices = webGLData.indices;
-
-        var vecPos = verts.length / 6;
-
-        var triangles = (0, _earcut2.default)(recPoints, null, 2);
-
-        for (var i = 0, j = triangles.length; i < j; i += 3) {
-            indices.push(triangles[i] + vecPos);
-            indices.push(triangles[i] + vecPos);
-            indices.push(triangles[i + 1] + vecPos);
-            indices.push(triangles[i + 2] + vecPos);
-            indices.push(triangles[i + 2] + vecPos);
-        }
-
-        for (var _i = 0, _j = recPoints.length; _i < _j; _i++) {
-            verts.push(recPoints[_i], recPoints[++_i], r, g, b, alpha);
-        }
-    }
-
-    if (graphicsData.lineWidth) {
-        var tempPoints = graphicsData.points;
-
-        graphicsData.points = recPoints;
-
-        (0, _buildLine2.default)(graphicsData, webGLData, webGLDataNativeLines);
-
-        graphicsData.points = tempPoints;
-    }
-}
-
-/**
- * Calculate a single point for a quadratic bezier curve.
- * Utility function used by quadraticBezierCurve.
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {number} n1 - first number
- * @param {number} n2 - second number
- * @param {number} perc - percentage
- * @return {number} the result
- *
- */
-function getPt(n1, n2, perc) {
-    var diff = n2 - n1;
-
-    return n1 + diff * perc;
-}
-
-/**
- * Calculate the points for a quadratic bezier curve. (helper function..)
- * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
- *
- * Ignored from docs since it is not directly exposed.
- *
- * @ignore
- * @private
- * @param {number} fromX - Origin point x
- * @param {number} fromY - Origin point x
- * @param {number} cpX - Control point x
- * @param {number} cpY - Control point y
- * @param {number} toX - Destination point x
- * @param {number} toY - Destination point y
- * @param {number[]} [out=[]] - The output array to add points into. If not passed, a new array is created.
- * @return {number[]} an array of points
- */
-function quadraticBezierCurve(fromX, fromY, cpX, cpY, toX, toY) {
-    var out = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [];
-
-    var n = 20;
-    var points = out;
-
-    var xa = 0;
-    var ya = 0;
-    var xb = 0;
-    var yb = 0;
-    var x = 0;
-    var y = 0;
-
-    for (var i = 0, j = 0; i <= n; ++i) {
-        j = i / n;
-
-        // The Green Line
-        xa = getPt(fromX, cpX, j);
-        ya = getPt(fromY, cpY, j);
-        xb = getPt(cpX, toX, j);
-        yb = getPt(cpY, toY, j);
-
-        // The Black Dot
-        x = getPt(xa, xb, j);
-        y = getPt(ya, yb, j);
-
-        points.push(x, y);
-    }
-
-    return points;
-}
-
-},{"../../../utils":124,"./buildLine":61,"earcut":2}],65:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.autoDetectRenderer = exports.Application = exports.Filter = exports.SpriteMaskFilter = exports.Quad = exports.RenderTarget = exports.ObjectRenderer = exports.WebGLManager = exports.Shader = exports.CanvasRenderTarget = exports.TextureUvs = exports.VideoBaseTexture = exports.BaseRenderTexture = exports.RenderTexture = exports.BaseTexture = exports.Texture = exports.Spritesheet = exports.CanvasGraphicsRenderer = exports.GraphicsRenderer = exports.GraphicsData = exports.Graphics = exports.TextMetrics = exports.TextStyle = exports.Text = exports.SpriteRenderer = exports.CanvasTinter = exports.CanvasSpriteRenderer = exports.Sprite = exports.TransformBase = exports.TransformStatic = exports.Transform = exports.Container = exports.DisplayObject = exports.Bounds = exports.glCore = exports.WebGLRenderer = exports.CanvasRenderer = exports.ticker = exports.utils = exports.settings = undefined;
-
-var _const = require('./const');
-
-Object.keys(_const).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _const[key];
-    }
-  });
-});
-
-var _math = require('./math');
-
-Object.keys(_math).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _math[key];
-    }
-  });
-});
-
-var _pixiGlCore = require('pixi-gl-core');
-
-Object.defineProperty(exports, 'glCore', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_pixiGlCore).default;
-  }
-});
-
-var _Bounds = require('./display/Bounds');
-
-Object.defineProperty(exports, 'Bounds', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Bounds).default;
-  }
-});
-
-var _DisplayObject = require('./display/DisplayObject');
-
-Object.defineProperty(exports, 'DisplayObject', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_DisplayObject).default;
-  }
-});
-
-var _Container = require('./display/Container');
-
-Object.defineProperty(exports, 'Container', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Container).default;
-  }
-});
-
-var _Transform = require('./display/Transform');
-
-Object.defineProperty(exports, 'Transform', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Transform).default;
-  }
-});
-
-var _TransformStatic = require('./display/TransformStatic');
-
-Object.defineProperty(exports, 'TransformStatic', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TransformStatic).default;
-  }
-});
-
-var _TransformBase = require('./display/TransformBase');
-
-Object.defineProperty(exports, 'TransformBase', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TransformBase).default;
-  }
-});
-
-var _Sprite = require('./sprites/Sprite');
-
-Object.defineProperty(exports, 'Sprite', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Sprite).default;
-  }
-});
-
-var _CanvasSpriteRenderer = require('./sprites/canvas/CanvasSpriteRenderer');
-
-Object.defineProperty(exports, 'CanvasSpriteRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CanvasSpriteRenderer).default;
-  }
-});
-
-var _CanvasTinter = require('./sprites/canvas/CanvasTinter');
-
-Object.defineProperty(exports, 'CanvasTinter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CanvasTinter).default;
-  }
-});
-
-var _SpriteRenderer = require('./sprites/webgl/SpriteRenderer');
-
-Object.defineProperty(exports, 'SpriteRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_SpriteRenderer).default;
-  }
-});
-
-var _Text = require('./text/Text');
-
-Object.defineProperty(exports, 'Text', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Text).default;
-  }
-});
-
-var _TextStyle = require('./text/TextStyle');
-
-Object.defineProperty(exports, 'TextStyle', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TextStyle).default;
-  }
-});
-
-var _TextMetrics = require('./text/TextMetrics');
-
-Object.defineProperty(exports, 'TextMetrics', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TextMetrics).default;
-  }
-});
-
-var _Graphics = require('./graphics/Graphics');
-
-Object.defineProperty(exports, 'Graphics', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Graphics).default;
-  }
-});
-
-var _GraphicsData = require('./graphics/GraphicsData');
-
-Object.defineProperty(exports, 'GraphicsData', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_GraphicsData).default;
-  }
-});
-
-var _GraphicsRenderer = require('./graphics/webgl/GraphicsRenderer');
-
-Object.defineProperty(exports, 'GraphicsRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_GraphicsRenderer).default;
-  }
-});
-
-var _CanvasGraphicsRenderer = require('./graphics/canvas/CanvasGraphicsRenderer');
-
-Object.defineProperty(exports, 'CanvasGraphicsRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CanvasGraphicsRenderer).default;
-  }
-});
-
-var _Spritesheet = require('./textures/Spritesheet');
-
-Object.defineProperty(exports, 'Spritesheet', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Spritesheet).default;
-  }
-});
-
-var _Texture = require('./textures/Texture');
-
-Object.defineProperty(exports, 'Texture', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Texture).default;
-  }
-});
-
-var _BaseTexture = require('./textures/BaseTexture');
-
-Object.defineProperty(exports, 'BaseTexture', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_BaseTexture).default;
-  }
-});
-
-var _RenderTexture = require('./textures/RenderTexture');
-
-Object.defineProperty(exports, 'RenderTexture', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_RenderTexture).default;
-  }
-});
-
-var _BaseRenderTexture = require('./textures/BaseRenderTexture');
-
-Object.defineProperty(exports, 'BaseRenderTexture', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_BaseRenderTexture).default;
-  }
-});
-
-var _VideoBaseTexture = require('./textures/VideoBaseTexture');
-
-Object.defineProperty(exports, 'VideoBaseTexture', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_VideoBaseTexture).default;
-  }
-});
-
-var _TextureUvs = require('./textures/TextureUvs');
-
-Object.defineProperty(exports, 'TextureUvs', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TextureUvs).default;
-  }
-});
-
-var _CanvasRenderTarget = require('./renderers/canvas/utils/CanvasRenderTarget');
-
-Object.defineProperty(exports, 'CanvasRenderTarget', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CanvasRenderTarget).default;
-  }
-});
-
-var _Shader = require('./Shader');
-
-Object.defineProperty(exports, 'Shader', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Shader).default;
-  }
-});
-
-var _WebGLManager = require('./renderers/webgl/managers/WebGLManager');
-
-Object.defineProperty(exports, 'WebGLManager', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_WebGLManager).default;
-  }
-});
-
-var _ObjectRenderer = require('./renderers/webgl/utils/ObjectRenderer');
-
-Object.defineProperty(exports, 'ObjectRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_ObjectRenderer).default;
-  }
-});
-
-var _RenderTarget = require('./renderers/webgl/utils/RenderTarget');
-
-Object.defineProperty(exports, 'RenderTarget', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_RenderTarget).default;
-  }
-});
-
-var _Quad = require('./renderers/webgl/utils/Quad');
-
-Object.defineProperty(exports, 'Quad', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Quad).default;
-  }
-});
-
-var _SpriteMaskFilter = require('./renderers/webgl/filters/spriteMask/SpriteMaskFilter');
-
-Object.defineProperty(exports, 'SpriteMaskFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_SpriteMaskFilter).default;
-  }
-});
-
-var _Filter = require('./renderers/webgl/filters/Filter');
-
-Object.defineProperty(exports, 'Filter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Filter).default;
-  }
-});
-
-var _Application = require('./Application');
-
-Object.defineProperty(exports, 'Application', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Application).default;
-  }
-});
-
-var _autoDetectRenderer = require('./autoDetectRenderer');
-
-Object.defineProperty(exports, 'autoDetectRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _autoDetectRenderer.autoDetectRenderer;
-  }
-});
-
-var _utils = require('./utils');
-
-var utils = _interopRequireWildcard(_utils);
-
-var _ticker = require('./ticker');
-
-var ticker = _interopRequireWildcard(_ticker);
-
-var _settings = require('./settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _CanvasRenderer = require('./renderers/canvas/CanvasRenderer');
-
-var _CanvasRenderer2 = _interopRequireDefault(_CanvasRenderer);
-
-var _WebGLRenderer = require('./renderers/webgl/WebGLRenderer');
-
-var _WebGLRenderer2 = _interopRequireDefault(_WebGLRenderer);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-exports.settings = _settings2.default;
-exports.utils = utils;
-exports.ticker = ticker;
-exports.CanvasRenderer = _CanvasRenderer2.default;
-exports.WebGLRenderer = _WebGLRenderer2.default; /**
-                                                  * @namespace PIXI
-                                                  */
-
-},{"./Application":43,"./Shader":44,"./autoDetectRenderer":45,"./const":46,"./display/Bounds":47,"./display/Container":48,"./display/DisplayObject":49,"./display/Transform":50,"./display/TransformBase":51,"./display/TransformStatic":52,"./graphics/Graphics":53,"./graphics/GraphicsData":54,"./graphics/canvas/CanvasGraphicsRenderer":55,"./graphics/webgl/GraphicsRenderer":57,"./math":70,"./renderers/canvas/CanvasRenderer":77,"./renderers/canvas/utils/CanvasRenderTarget":79,"./renderers/webgl/WebGLRenderer":84,"./renderers/webgl/filters/Filter":86,"./renderers/webgl/filters/spriteMask/SpriteMaskFilter":89,"./renderers/webgl/managers/WebGLManager":93,"./renderers/webgl/utils/ObjectRenderer":94,"./renderers/webgl/utils/Quad":95,"./renderers/webgl/utils/RenderTarget":96,"./settings":101,"./sprites/Sprite":102,"./sprites/canvas/CanvasSpriteRenderer":103,"./sprites/canvas/CanvasTinter":104,"./sprites/webgl/SpriteRenderer":106,"./text/Text":108,"./text/TextMetrics":109,"./text/TextStyle":110,"./textures/BaseRenderTexture":111,"./textures/BaseTexture":112,"./textures/RenderTexture":113,"./textures/Spritesheet":114,"./textures/Texture":115,"./textures/TextureUvs":116,"./textures/VideoBaseTexture":117,"./ticker":120,"./utils":124,"pixi-gl-core":12}],66:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Matrix = require('./Matrix');
-
-var _Matrix2 = _interopRequireDefault(_Matrix);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var ux = [1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1]; // Your friendly neighbour https://en.wikipedia.org/wiki/Dihedral_group of order 16
-
-var uy = [0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1];
-var vx = [0, -1, -1, -1, 0, 1, 1, 1, 0, 1, 1, 1, 0, -1, -1, -1];
-var vy = [1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, 1, 1, 1, 0, -1];
-var tempMatrices = [];
-
-var mul = [];
-
-function signum(x) {
-    if (x < 0) {
-        return -1;
-    }
-    if (x > 0) {
-        return 1;
-    }
-
-    return 0;
-}
-
-function init() {
-    for (var i = 0; i < 16; i++) {
-        var row = [];
-
-        mul.push(row);
-
-        for (var j = 0; j < 16; j++) {
-            var _ux = signum(ux[i] * ux[j] + vx[i] * uy[j]);
-            var _uy = signum(uy[i] * ux[j] + vy[i] * uy[j]);
-            var _vx = signum(ux[i] * vx[j] + vx[i] * vy[j]);
-            var _vy = signum(uy[i] * vx[j] + vy[i] * vy[j]);
-
-            for (var k = 0; k < 16; k++) {
-                if (ux[k] === _ux && uy[k] === _uy && vx[k] === _vx && vy[k] === _vy) {
-                    row.push(k);
-                    break;
-                }
-            }
-        }
-    }
-
-    for (var _i = 0; _i < 16; _i++) {
-        var mat = new _Matrix2.default();
-
-        mat.set(ux[_i], uy[_i], vx[_i], vy[_i], 0, 0);
-        tempMatrices.push(mat);
-    }
-}
-
-init();
-
-/**
- * Implements Dihedral Group D_8, see [group D4]{@link http://mathworld.wolfram.com/DihedralGroupD4.html},
- * D8 is the same but with diagonals. Used for texture rotations.
- *
- * Vector xX(i), xY(i) is U-axis of sprite with rotation i
- * Vector yY(i), yY(i) is V-axis of sprite with rotation i
- * Rotations: 0 grad (0), 90 grad (2), 180 grad (4), 270 grad (6)
- * Mirrors: vertical (8), main diagonal (10), horizontal (12), reverse diagonal (14)
- * This is the small part of gameofbombs.com portal system. It works.
- *
- * @author Ivan @ivanpopelyshev
- * @class
- * @memberof PIXI
- */
-var GroupD8 = {
-    E: 0,
-    SE: 1,
-    S: 2,
-    SW: 3,
-    W: 4,
-    NW: 5,
-    N: 6,
-    NE: 7,
-    MIRROR_VERTICAL: 8,
-    MIRROR_HORIZONTAL: 12,
-    uX: function uX(ind) {
-        return ux[ind];
-    },
-    uY: function uY(ind) {
-        return uy[ind];
-    },
-    vX: function vX(ind) {
-        return vx[ind];
-    },
-    vY: function vY(ind) {
-        return vy[ind];
-    },
-    inv: function inv(rotation) {
-        if (rotation & 8) {
-            return rotation & 15;
-        }
-
-        return -rotation & 7;
-    },
-    add: function add(rotationSecond, rotationFirst) {
-        return mul[rotationSecond][rotationFirst];
-    },
-    sub: function sub(rotationSecond, rotationFirst) {
-        return mul[rotationSecond][GroupD8.inv(rotationFirst)];
-    },
-
-    /**
-     * Adds 180 degrees to rotation. Commutative operation.
-     *
-     * @memberof PIXI.GroupD8
-     * @param {number} rotation - The number to rotate.
-     * @returns {number} rotated number
-     */
-    rotate180: function rotate180(rotation) {
-        return rotation ^ 4;
-    },
-
-    /**
-     * I dont know why sometimes width and heights needs to be swapped. We'll fix it later.
-     *
-     * @memberof PIXI.GroupD8
-     * @param {number} rotation - The number to check.
-     * @returns {boolean} Whether or not the width/height should be swapped.
-     */
-    isSwapWidthHeight: function isSwapWidthHeight(rotation) {
-        return (rotation & 3) === 2;
-    },
-
-    /**
-     * @memberof PIXI.GroupD8
-     * @param {number} dx - TODO
-     * @param {number} dy - TODO
-     *
-     * @return {number} TODO
-     */
-    byDirection: function byDirection(dx, dy) {
-        if (Math.abs(dx) * 2 <= Math.abs(dy)) {
-            if (dy >= 0) {
-                return GroupD8.S;
-            }
-
-            return GroupD8.N;
-        } else if (Math.abs(dy) * 2 <= Math.abs(dx)) {
-            if (dx > 0) {
-                return GroupD8.E;
-            }
-
-            return GroupD8.W;
-        } else if (dy > 0) {
-            if (dx > 0) {
-                return GroupD8.SE;
-            }
-
-            return GroupD8.SW;
-        } else if (dx > 0) {
-            return GroupD8.NE;
-        }
-
-        return GroupD8.NW;
-    },
-
-    /**
-     * Helps sprite to compensate texture packer rotation.
-     *
-     * @memberof PIXI.GroupD8
-     * @param {PIXI.Matrix} matrix - sprite world matrix
-     * @param {number} rotation - The rotation factor to use.
-     * @param {number} tx - sprite anchoring
-     * @param {number} ty - sprite anchoring
-     */
-    matrixAppendRotationInv: function matrixAppendRotationInv(matrix, rotation) {
-        var tx = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-        var ty = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-
-        // Packer used "rotation", we use "inv(rotation)"
-        var mat = tempMatrices[GroupD8.inv(rotation)];
-
-        mat.tx = tx;
-        mat.ty = ty;
-        matrix.append(mat);
-    }
-};
-
-exports.default = GroupD8;
-
-},{"./Matrix":67}],67:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _Point = require('./Point');
-
-var _Point2 = _interopRequireDefault(_Point);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * The PixiJS Matrix class as an object, which makes it a lot faster,
- * here is a representation of it :
- * | a | b | tx|
- * | c | d | ty|
- * | 0 | 0 | 1 |
- *
- * @class
- * @memberof PIXI
- */
-var Matrix = function () {
-    /**
-     * @param {number} [a=1] - x scale
-     * @param {number} [b=0] - y skew
-     * @param {number} [c=0] - x skew
-     * @param {number} [d=1] - y scale
-     * @param {number} [tx=0] - x translation
-     * @param {number} [ty=0] - y translation
-     */
-    function Matrix() {
-        var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-        var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-        var c = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-        var d = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-        var tx = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
-        var ty = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
-
-        _classCallCheck(this, Matrix);
-
-        /**
-         * @member {number}
-         * @default 1
-         */
-        this.a = a;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.b = b;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.c = c;
-
-        /**
-         * @member {number}
-         * @default 1
-         */
-        this.d = d;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.tx = tx;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.ty = ty;
-
-        this.array = null;
-    }
-
-    /**
-     * Creates a Matrix object based on the given array. The Element to Matrix mapping order is as follows:
-     *
-     * a = array[0]
-     * b = array[1]
-     * c = array[3]
-     * d = array[4]
-     * tx = array[2]
-     * ty = array[5]
-     *
-     * @param {number[]} array - The array that the matrix will be populated from.
-     */
-
-
-    Matrix.prototype.fromArray = function fromArray(array) {
-        this.a = array[0];
-        this.b = array[1];
-        this.c = array[3];
-        this.d = array[4];
-        this.tx = array[2];
-        this.ty = array[5];
-    };
-
-    /**
-     * sets the matrix properties
-     *
-     * @param {number} a - Matrix component
-     * @param {number} b - Matrix component
-     * @param {number} c - Matrix component
-     * @param {number} d - Matrix component
-     * @param {number} tx - Matrix component
-     * @param {number} ty - Matrix component
-     *
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.set = function set(a, b, c, d, tx, ty) {
-        this.a = a;
-        this.b = b;
-        this.c = c;
-        this.d = d;
-        this.tx = tx;
-        this.ty = ty;
-
-        return this;
-    };
-
-    /**
-     * Creates an array from the current Matrix object.
-     *
-     * @param {boolean} transpose - Whether we need to transpose the matrix or not
-     * @param {Float32Array} [out=new Float32Array(9)] - If provided the array will be assigned to out
-     * @return {number[]} the newly created array which contains the matrix
-     */
-
-
-    Matrix.prototype.toArray = function toArray(transpose, out) {
-        if (!this.array) {
-            this.array = new Float32Array(9);
-        }
-
-        var array = out || this.array;
-
-        if (transpose) {
-            array[0] = this.a;
-            array[1] = this.b;
-            array[2] = 0;
-            array[3] = this.c;
-            array[4] = this.d;
-            array[5] = 0;
-            array[6] = this.tx;
-            array[7] = this.ty;
-            array[8] = 1;
-        } else {
-            array[0] = this.a;
-            array[1] = this.c;
-            array[2] = this.tx;
-            array[3] = this.b;
-            array[4] = this.d;
-            array[5] = this.ty;
-            array[6] = 0;
-            array[7] = 0;
-            array[8] = 1;
-        }
-
-        return array;
-    };
-
-    /**
-     * Get a new position with the current transformation applied.
-     * Can be used to go from a child's coordinate space to the world coordinate space. (e.g. rendering)
-     *
-     * @param {PIXI.Point} pos - The origin
-     * @param {PIXI.Point} [newPos] - The point that the new position is assigned to (allowed to be same as input)
-     * @return {PIXI.Point} The new point, transformed through this matrix
-     */
-
-
-    Matrix.prototype.apply = function apply(pos, newPos) {
-        newPos = newPos || new _Point2.default();
-
-        var x = pos.x;
-        var y = pos.y;
-
-        newPos.x = this.a * x + this.c * y + this.tx;
-        newPos.y = this.b * x + this.d * y + this.ty;
-
-        return newPos;
-    };
-
-    /**
-     * Get a new position with the inverse of the current transformation applied.
-     * Can be used to go from the world coordinate space to a child's coordinate space. (e.g. input)
-     *
-     * @param {PIXI.Point} pos - The origin
-     * @param {PIXI.Point} [newPos] - The point that the new position is assigned to (allowed to be same as input)
-     * @return {PIXI.Point} The new point, inverse-transformed through this matrix
-     */
-
-
-    Matrix.prototype.applyInverse = function applyInverse(pos, newPos) {
-        newPos = newPos || new _Point2.default();
-
-        var id = 1 / (this.a * this.d + this.c * -this.b);
-
-        var x = pos.x;
-        var y = pos.y;
-
-        newPos.x = this.d * id * x + -this.c * id * y + (this.ty * this.c - this.tx * this.d) * id;
-        newPos.y = this.a * id * y + -this.b * id * x + (-this.ty * this.a + this.tx * this.b) * id;
-
-        return newPos;
-    };
-
-    /**
-     * Translates the matrix on the x and y.
-     *
-     * @param {number} x How much to translate x by
-     * @param {number} y How much to translate y by
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.translate = function translate(x, y) {
-        this.tx += x;
-        this.ty += y;
-
-        return this;
-    };
-
-    /**
-     * Applies a scale transformation to the matrix.
-     *
-     * @param {number} x The amount to scale horizontally
-     * @param {number} y The amount to scale vertically
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.scale = function scale(x, y) {
-        this.a *= x;
-        this.d *= y;
-        this.c *= x;
-        this.b *= y;
-        this.tx *= x;
-        this.ty *= y;
-
-        return this;
-    };
-
-    /**
-     * Applies a rotation transformation to the matrix.
-     *
-     * @param {number} angle - The angle in radians.
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.rotate = function rotate(angle) {
-        var cos = Math.cos(angle);
-        var sin = Math.sin(angle);
-
-        var a1 = this.a;
-        var c1 = this.c;
-        var tx1 = this.tx;
-
-        this.a = a1 * cos - this.b * sin;
-        this.b = a1 * sin + this.b * cos;
-        this.c = c1 * cos - this.d * sin;
-        this.d = c1 * sin + this.d * cos;
-        this.tx = tx1 * cos - this.ty * sin;
-        this.ty = tx1 * sin + this.ty * cos;
-
-        return this;
-    };
-
-    /**
-     * Appends the given Matrix to this Matrix.
-     *
-     * @param {PIXI.Matrix} matrix - The matrix to append.
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.append = function append(matrix) {
-        var a1 = this.a;
-        var b1 = this.b;
-        var c1 = this.c;
-        var d1 = this.d;
-
-        this.a = matrix.a * a1 + matrix.b * c1;
-        this.b = matrix.a * b1 + matrix.b * d1;
-        this.c = matrix.c * a1 + matrix.d * c1;
-        this.d = matrix.c * b1 + matrix.d * d1;
-
-        this.tx = matrix.tx * a1 + matrix.ty * c1 + this.tx;
-        this.ty = matrix.tx * b1 + matrix.ty * d1 + this.ty;
-
-        return this;
-    };
-
-    /**
-     * Sets the matrix based on all the available properties
-     *
-     * @param {number} x - Position on the x axis
-     * @param {number} y - Position on the y axis
-     * @param {number} pivotX - Pivot on the x axis
-     * @param {number} pivotY - Pivot on the y axis
-     * @param {number} scaleX - Scale on the x axis
-     * @param {number} scaleY - Scale on the y axis
-     * @param {number} rotation - Rotation in radians
-     * @param {number} skewX - Skew on the x axis
-     * @param {number} skewY - Skew on the y axis
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.setTransform = function setTransform(x, y, pivotX, pivotY, scaleX, scaleY, rotation, skewX, skewY) {
-        var sr = Math.sin(rotation);
-        var cr = Math.cos(rotation);
-        var cy = Math.cos(skewY);
-        var sy = Math.sin(skewY);
-        var nsx = -Math.sin(skewX);
-        var cx = Math.cos(skewX);
-
-        var a = cr * scaleX;
-        var b = sr * scaleX;
-        var c = -sr * scaleY;
-        var d = cr * scaleY;
-
-        this.a = cy * a + sy * c;
-        this.b = cy * b + sy * d;
-        this.c = nsx * a + cx * c;
-        this.d = nsx * b + cx * d;
-
-        this.tx = x + (pivotX * a + pivotY * c);
-        this.ty = y + (pivotX * b + pivotY * d);
-
-        return this;
-    };
-
-    /**
-     * Prepends the given Matrix to this Matrix.
-     *
-     * @param {PIXI.Matrix} matrix - The matrix to prepend
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.prepend = function prepend(matrix) {
-        var tx1 = this.tx;
-
-        if (matrix.a !== 1 || matrix.b !== 0 || matrix.c !== 0 || matrix.d !== 1) {
-            var a1 = this.a;
-            var c1 = this.c;
-
-            this.a = a1 * matrix.a + this.b * matrix.c;
-            this.b = a1 * matrix.b + this.b * matrix.d;
-            this.c = c1 * matrix.a + this.d * matrix.c;
-            this.d = c1 * matrix.b + this.d * matrix.d;
-        }
-
-        this.tx = tx1 * matrix.a + this.ty * matrix.c + matrix.tx;
-        this.ty = tx1 * matrix.b + this.ty * matrix.d + matrix.ty;
-
-        return this;
-    };
-
-    /**
-     * Decomposes the matrix (x, y, scaleX, scaleY, and rotation) and sets the properties on to a transform.
-     *
-     * @param {PIXI.Transform|PIXI.TransformStatic} transform - The transform to apply the properties to.
-     * @return {PIXI.Transform|PIXI.TransformStatic} The transform with the newly applied properties
-     */
-
-
-    Matrix.prototype.decompose = function decompose(transform) {
-        // sort out rotation / skew..
-        var a = this.a;
-        var b = this.b;
-        var c = this.c;
-        var d = this.d;
-
-        var skewX = -Math.atan2(-c, d);
-        var skewY = Math.atan2(b, a);
-
-        var delta = Math.abs(skewX + skewY);
-
-        if (delta < 0.00001) {
-            transform.rotation = skewY;
-
-            if (a < 0 && d >= 0) {
-                transform.rotation += transform.rotation <= 0 ? Math.PI : -Math.PI;
-            }
-
-            transform.skew.x = transform.skew.y = 0;
-        } else {
-            transform.skew.x = skewX;
-            transform.skew.y = skewY;
-        }
-
-        // next set scale
-        transform.scale.x = Math.sqrt(a * a + b * b);
-        transform.scale.y = Math.sqrt(c * c + d * d);
-
-        // next set position
-        transform.position.x = this.tx;
-        transform.position.y = this.ty;
-
-        return transform;
-    };
-
-    /**
-     * Inverts this matrix
-     *
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.invert = function invert() {
-        var a1 = this.a;
-        var b1 = this.b;
-        var c1 = this.c;
-        var d1 = this.d;
-        var tx1 = this.tx;
-        var n = a1 * d1 - b1 * c1;
-
-        this.a = d1 / n;
-        this.b = -b1 / n;
-        this.c = -c1 / n;
-        this.d = a1 / n;
-        this.tx = (c1 * this.ty - d1 * tx1) / n;
-        this.ty = -(a1 * this.ty - b1 * tx1) / n;
-
-        return this;
-    };
-
-    /**
-     * Resets this Matix to an identity (default) matrix.
-     *
-     * @return {PIXI.Matrix} This matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.identity = function identity() {
-        this.a = 1;
-        this.b = 0;
-        this.c = 0;
-        this.d = 1;
-        this.tx = 0;
-        this.ty = 0;
-
-        return this;
-    };
-
-    /**
-     * Creates a new Matrix object with the same values as this one.
-     *
-     * @return {PIXI.Matrix} A copy of this matrix. Good for chaining method calls.
-     */
-
-
-    Matrix.prototype.clone = function clone() {
-        var matrix = new Matrix();
-
-        matrix.a = this.a;
-        matrix.b = this.b;
-        matrix.c = this.c;
-        matrix.d = this.d;
-        matrix.tx = this.tx;
-        matrix.ty = this.ty;
-
-        return matrix;
-    };
-
-    /**
-     * Changes the values of the given matrix to be the same as the ones in this matrix
-     *
-     * @param {PIXI.Matrix} matrix - The matrix to copy from.
-     * @return {PIXI.Matrix} The matrix given in parameter with its values updated.
-     */
-
-
-    Matrix.prototype.copy = function copy(matrix) {
-        matrix.a = this.a;
-        matrix.b = this.b;
-        matrix.c = this.c;
-        matrix.d = this.d;
-        matrix.tx = this.tx;
-        matrix.ty = this.ty;
-
-        return matrix;
-    };
-
-    /**
-     * A default (identity) matrix
-     *
-     * @static
-     * @const
-     */
-
-
-    _createClass(Matrix, null, [{
-        key: 'IDENTITY',
-        get: function get() {
-            return new Matrix();
-        }
-
-        /**
-         * A temp matrix
-         *
-         * @static
-         * @const
-         */
-
-    }, {
-        key: 'TEMP_MATRIX',
-        get: function get() {
-            return new Matrix();
-        }
-    }]);
-
-    return Matrix;
-}();
-
-exports.default = Matrix;
-
-},{"./Point":69}],68:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * The Point object represents a location in a two-dimensional coordinate system, where x represents
- * the horizontal axis and y represents the vertical axis.
- * An observable point is a point that triggers a callback when the point's position is changed.
- *
- * @class
- * @memberof PIXI
- */
-var ObservablePoint = function () {
-    /**
-     * @param {Function} cb - callback when changed
-     * @param {object} scope - owner of callback
-     * @param {number} [x=0] - position of the point on the x axis
-     * @param {number} [y=0] - position of the point on the y axis
-     */
-    function ObservablePoint(cb, scope) {
-        var x = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-        var y = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-
-        _classCallCheck(this, ObservablePoint);
-
-        this._x = x;
-        this._y = y;
-
-        this.cb = cb;
-        this.scope = scope;
-    }
-
-    /**
-     * Sets the point to a new x and y position.
-     * If y is omitted, both x and y will be set to x.
-     *
-     * @param {number} [x=0] - position of the point on the x axis
-     * @param {number} [y=0] - position of the point on the y axis
-     */
-
-
-    ObservablePoint.prototype.set = function set(x, y) {
-        var _x = x || 0;
-        var _y = y || (y !== 0 ? _x : 0);
-
-        if (this._x !== _x || this._y !== _y) {
-            this._x = _x;
-            this._y = _y;
-            this.cb.call(this.scope);
-        }
-    };
-
-    /**
-     * Copies the data from another point
-     *
-     * @param {PIXI.Point|PIXI.ObservablePoint} point - point to copy from
-     */
-
-
-    ObservablePoint.prototype.copy = function copy(point) {
-        if (this._x !== point.x || this._y !== point.y) {
-            this._x = point.x;
-            this._y = point.y;
-            this.cb.call(this.scope);
-        }
-    };
-
-    /**
-     * The position of the displayObject on the x axis relative to the local coordinates of the parent.
-     *
-     * @member {number}
-     */
-
-
-    _createClass(ObservablePoint, [{
-        key: "x",
-        get: function get() {
-            return this._x;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (this._x !== value) {
-                this._x = value;
-                this.cb.call(this.scope);
-            }
-        }
-
-        /**
-         * The position of the displayObject on the x axis relative to the local coordinates of the parent.
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: "y",
-        get: function get() {
-            return this._y;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (this._y !== value) {
-                this._y = value;
-                this.cb.call(this.scope);
-            }
-        }
-    }]);
-
-    return ObservablePoint;
-}();
-
-exports.default = ObservablePoint;
-
-},{}],69:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * The Point object represents a location in a two-dimensional coordinate system, where x represents
- * the horizontal axis and y represents the vertical axis.
- *
- * @class
- * @memberof PIXI
- */
-var Point = function () {
-  /**
-   * @param {number} [x=0] - position of the point on the x axis
-   * @param {number} [y=0] - position of the point on the y axis
-   */
-  function Point() {
-    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-
-    _classCallCheck(this, Point);
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.x = x;
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.y = y;
-  }
-
-  /**
-   * Creates a clone of this point
-   *
-   * @return {PIXI.Point} a copy of the point
-   */
-
-
-  Point.prototype.clone = function clone() {
-    return new Point(this.x, this.y);
-  };
-
-  /**
-   * Copies x and y from the given point
-   *
-   * @param {PIXI.Point} p - The point to copy.
-   */
-
-
-  Point.prototype.copy = function copy(p) {
-    this.set(p.x, p.y);
-  };
-
-  /**
-   * Returns true if the given point is equal to this point
-   *
-   * @param {PIXI.Point} p - The point to check
-   * @returns {boolean} Whether the given point equal to this point
-   */
-
-
-  Point.prototype.equals = function equals(p) {
-    return p.x === this.x && p.y === this.y;
-  };
-
-  /**
-   * Sets the point to a new x and y position.
-   * If y is omitted, both x and y will be set to x.
-   *
-   * @param {number} [x=0] - position of the point on the x axis
-   * @param {number} [y=0] - position of the point on the y axis
-   */
-
-
-  Point.prototype.set = function set(x, y) {
-    this.x = x || 0;
-    this.y = y || (y !== 0 ? this.x : 0);
-  };
-
-  return Point;
-}();
-
-exports.default = Point;
-
-},{}],70:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Point = require('./Point');
-
-Object.defineProperty(exports, 'Point', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Point).default;
-  }
-});
-
-var _ObservablePoint = require('./ObservablePoint');
-
-Object.defineProperty(exports, 'ObservablePoint', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_ObservablePoint).default;
-  }
-});
-
-var _Matrix = require('./Matrix');
-
-Object.defineProperty(exports, 'Matrix', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Matrix).default;
-  }
-});
-
-var _GroupD = require('./GroupD8');
-
-Object.defineProperty(exports, 'GroupD8', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_GroupD).default;
-  }
-});
-
-var _Circle = require('./shapes/Circle');
-
-Object.defineProperty(exports, 'Circle', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Circle).default;
-  }
-});
-
-var _Ellipse = require('./shapes/Ellipse');
-
-Object.defineProperty(exports, 'Ellipse', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Ellipse).default;
-  }
-});
-
-var _Polygon = require('./shapes/Polygon');
-
-Object.defineProperty(exports, 'Polygon', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Polygon).default;
-  }
-});
-
-var _Rectangle = require('./shapes/Rectangle');
-
-Object.defineProperty(exports, 'Rectangle', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Rectangle).default;
-  }
-});
-
-var _RoundedRectangle = require('./shapes/RoundedRectangle');
-
-Object.defineProperty(exports, 'RoundedRectangle', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_RoundedRectangle).default;
-  }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./GroupD8":66,"./Matrix":67,"./ObservablePoint":68,"./Point":69,"./shapes/Circle":71,"./shapes/Ellipse":72,"./shapes/Polygon":73,"./shapes/Rectangle":74,"./shapes/RoundedRectangle":75}],71:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Rectangle = require('./Rectangle');
-
-var _Rectangle2 = _interopRequireDefault(_Rectangle);
-
-var _const = require('../../const');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * The Circle object can be used to specify a hit area for displayObjects
- *
- * @class
- * @memberof PIXI
- */
-var Circle = function () {
-  /**
-   * @param {number} [x=0] - The X coordinate of the center of this circle
-   * @param {number} [y=0] - The Y coordinate of the center of this circle
-   * @param {number} [radius=0] - The radius of the circle
-   */
-  function Circle() {
-    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    var radius = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-
-    _classCallCheck(this, Circle);
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.x = x;
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.y = y;
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.radius = radius;
-
-    /**
-     * The type of the object, mainly used to avoid `instanceof` checks
-     *
-     * @member {number}
-     * @readOnly
-     * @default PIXI.SHAPES.CIRC
-     * @see PIXI.SHAPES
-     */
-    this.type = _const.SHAPES.CIRC;
-  }
-
-  /**
-   * Creates a clone of this Circle instance
-   *
-   * @return {PIXI.Circle} a copy of the Circle
-   */
-
-
-  Circle.prototype.clone = function clone() {
-    return new Circle(this.x, this.y, this.radius);
-  };
-
-  /**
-   * Checks whether the x and y coordinates given are contained within this circle
-   *
-   * @param {number} x - The X coordinate of the point to test
-   * @param {number} y - The Y coordinate of the point to test
-   * @return {boolean} Whether the x/y coordinates are within this Circle
-   */
-
-
-  Circle.prototype.contains = function contains(x, y) {
-    if (this.radius <= 0) {
-      return false;
-    }
-
-    var r2 = this.radius * this.radius;
-    var dx = this.x - x;
-    var dy = this.y - y;
-
-    dx *= dx;
-    dy *= dy;
-
-    return dx + dy <= r2;
-  };
-
-  /**
-  * Returns the framing rectangle of the circle as a Rectangle object
-  *
-  * @return {PIXI.Rectangle} the framing rectangle
-  */
-
-
-  Circle.prototype.getBounds = function getBounds() {
-    return new _Rectangle2.default(this.x - this.radius, this.y - this.radius, this.radius * 2, this.radius * 2);
-  };
-
-  return Circle;
-}();
-
-exports.default = Circle;
-
-},{"../../const":46,"./Rectangle":74}],72:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Rectangle = require('./Rectangle');
-
-var _Rectangle2 = _interopRequireDefault(_Rectangle);
-
-var _const = require('../../const');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * The Ellipse object can be used to specify a hit area for displayObjects
- *
- * @class
- * @memberof PIXI
- */
-var Ellipse = function () {
-  /**
-   * @param {number} [x=0] - The X coordinate of the center of this circle
-   * @param {number} [y=0] - The Y coordinate of the center of this circle
-   * @param {number} [width=0] - The half width of this ellipse
-   * @param {number} [height=0] - The half height of this ellipse
-   */
-  function Ellipse() {
-    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    var width = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    var height = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-
-    _classCallCheck(this, Ellipse);
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.x = x;
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.y = y;
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.width = width;
-
-    /**
-     * @member {number}
-     * @default 0
-     */
-    this.height = height;
-
-    /**
-     * The type of the object, mainly used to avoid `instanceof` checks
-     *
-     * @member {number}
-     * @readOnly
-     * @default PIXI.SHAPES.ELIP
-     * @see PIXI.SHAPES
-     */
-    this.type = _const.SHAPES.ELIP;
-  }
-
-  /**
-   * Creates a clone of this Ellipse instance
-   *
-   * @return {PIXI.Ellipse} a copy of the ellipse
-   */
-
-
-  Ellipse.prototype.clone = function clone() {
-    return new Ellipse(this.x, this.y, this.width, this.height);
-  };
-
-  /**
-   * Checks whether the x and y coordinates given are contained within this ellipse
-   *
-   * @param {number} x - The X coordinate of the point to test
-   * @param {number} y - The Y coordinate of the point to test
-   * @return {boolean} Whether the x/y coords are within this ellipse
-   */
-
-
-  Ellipse.prototype.contains = function contains(x, y) {
-    if (this.width <= 0 || this.height <= 0) {
-      return false;
-    }
-
-    // normalize the coords to an ellipse with center 0,0
-    var normx = (x - this.x) / this.width;
-    var normy = (y - this.y) / this.height;
-
-    normx *= normx;
-    normy *= normy;
-
-    return normx + normy <= 1;
-  };
-
-  /**
-   * Returns the framing rectangle of the ellipse as a Rectangle object
-   *
-   * @return {PIXI.Rectangle} the framing rectangle
-   */
-
-
-  Ellipse.prototype.getBounds = function getBounds() {
-    return new _Rectangle2.default(this.x - this.width, this.y - this.height, this.width, this.height);
-  };
-
-  return Ellipse;
-}();
-
-exports.default = Ellipse;
-
-},{"../../const":46,"./Rectangle":74}],73:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Point = require('../Point');
-
-var _Point2 = _interopRequireDefault(_Point);
-
-var _const = require('../../const');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @class
- * @memberof PIXI
- */
-var Polygon = function () {
-    /**
-     * @param {PIXI.Point[]|number[]} points - This can be an array of Points
-     *  that form the polygon, a flat array of numbers that will be interpreted as [x,y, x,y, ...], or
-     *  the arguments passed can be all the points of the polygon e.g.
-     *  `new PIXI.Polygon(new PIXI.Point(), new PIXI.Point(), ...)`, or the arguments passed can be flat
-     *  x,y values e.g. `new Polygon(x,y, x,y, x,y, ...)` where `x` and `y` are Numbers.
-     */
-    function Polygon() {
-        for (var _len = arguments.length, points = Array(_len), _key = 0; _key < _len; _key++) {
-            points[_key] = arguments[_key];
-        }
-
-        _classCallCheck(this, Polygon);
-
-        if (Array.isArray(points[0])) {
-            points = points[0];
-        }
-
-        // if this is an array of points, convert it to a flat array of numbers
-        if (points[0] instanceof _Point2.default) {
-            var p = [];
-
-            for (var i = 0, il = points.length; i < il; i++) {
-                p.push(points[i].x, points[i].y);
-            }
-
-            points = p;
-        }
-
-        this.closed = true;
-
-        /**
-         * An array of the points of this polygon
-         *
-         * @member {number[]}
-         */
-        this.points = points;
-
-        /**
-         * The type of the object, mainly used to avoid `instanceof` checks
-         *
-         * @member {number}
-         * @readOnly
-         * @default PIXI.SHAPES.POLY
-         * @see PIXI.SHAPES
-         */
-        this.type = _const.SHAPES.POLY;
-    }
-
-    /**
-     * Creates a clone of this polygon
-     *
-     * @return {PIXI.Polygon} a copy of the polygon
-     */
-
-
-    Polygon.prototype.clone = function clone() {
-        return new Polygon(this.points.slice());
-    };
-
-    /**
-     * Closes the polygon, adding points if necessary.
-     *
-     */
-
-
-    Polygon.prototype.close = function close() {
-        var points = this.points;
-
-        // close the poly if the value is true!
-        if (points[0] !== points[points.length - 2] || points[1] !== points[points.length - 1]) {
-            points.push(points[0], points[1]);
-        }
-    };
-
-    /**
-     * Checks whether the x and y coordinates passed to this function are contained within this polygon
-     *
-     * @param {number} x - The X coordinate of the point to test
-     * @param {number} y - The Y coordinate of the point to test
-     * @return {boolean} Whether the x/y coordinates are within this polygon
-     */
-
-
-    Polygon.prototype.contains = function contains(x, y) {
-        var inside = false;
-
-        // use some raycasting to test hits
-        // https://github.com/substack/point-in-polygon/blob/master/index.js
-        var length = this.points.length / 2;
-
-        for (var i = 0, j = length - 1; i < length; j = i++) {
-            var xi = this.points[i * 2];
-            var yi = this.points[i * 2 + 1];
-            var xj = this.points[j * 2];
-            var yj = this.points[j * 2 + 1];
-            var intersect = yi > y !== yj > y && x < (xj - xi) * ((y - yi) / (yj - yi)) + xi;
-
-            if (intersect) {
-                inside = !inside;
-            }
-        }
-
-        return inside;
-    };
-
-    return Polygon;
-}();
-
-exports.default = Polygon;
-
-},{"../../const":46,"../Point":69}],74:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _const = require('../../const');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Rectangle object is an area defined by its position, as indicated by its top-left corner
- * point (x, y) and by its width and its height.
- *
- * @class
- * @memberof PIXI
- */
-var Rectangle = function () {
-    /**
-     * @param {number} [x=0] - The X coordinate of the upper-left corner of the rectangle
-     * @param {number} [y=0] - The Y coordinate of the upper-left corner of the rectangle
-     * @param {number} [width=0] - The overall width of this rectangle
-     * @param {number} [height=0] - The overall height of this rectangle
-     */
-    function Rectangle() {
-        var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-        var width = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-        var height = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-
-        _classCallCheck(this, Rectangle);
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.x = Number(x);
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.y = Number(y);
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.width = Number(width);
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.height = Number(height);
-
-        /**
-         * The type of the object, mainly used to avoid `instanceof` checks
-         *
-         * @member {number}
-         * @readOnly
-         * @default PIXI.SHAPES.RECT
-         * @see PIXI.SHAPES
-         */
-        this.type = _const.SHAPES.RECT;
-    }
-
-    /**
-     * returns the left edge of the rectangle
-     *
-     * @member {number}
-     */
-
-
-    /**
-     * Creates a clone of this Rectangle
-     *
-     * @return {PIXI.Rectangle} a copy of the rectangle
-     */
-    Rectangle.prototype.clone = function clone() {
-        return new Rectangle(this.x, this.y, this.width, this.height);
-    };
-
-    /**
-     * Copies another rectangle to this one.
-     *
-     * @param {PIXI.Rectangle} rectangle - The rectangle to copy.
-     * @return {PIXI.Rectangle} Returns itself.
-     */
-
-
-    Rectangle.prototype.copy = function copy(rectangle) {
-        this.x = rectangle.x;
-        this.y = rectangle.y;
-        this.width = rectangle.width;
-        this.height = rectangle.height;
-
-        return this;
-    };
-
-    /**
-     * Checks whether the x and y coordinates given are contained within this Rectangle
-     *
-     * @param {number} x - The X coordinate of the point to test
-     * @param {number} y - The Y coordinate of the point to test
-     * @return {boolean} Whether the x/y coordinates are within this Rectangle
-     */
-
-
-    Rectangle.prototype.contains = function contains(x, y) {
-        if (this.width <= 0 || this.height <= 0) {
-            return false;
-        }
-
-        if (x >= this.x && x < this.x + this.width) {
-            if (y >= this.y && y < this.y + this.height) {
-                return true;
-            }
-        }
-
-        return false;
-    };
-
-    /**
-     * Pads the rectangle making it grow in all directions.
-     *
-     * @param {number} paddingX - The horizontal padding amount.
-     * @param {number} paddingY - The vertical padding amount.
-     */
-
-
-    Rectangle.prototype.pad = function pad(paddingX, paddingY) {
-        paddingX = paddingX || 0;
-        paddingY = paddingY || (paddingY !== 0 ? paddingX : 0);
-
-        this.x -= paddingX;
-        this.y -= paddingY;
-
-        this.width += paddingX * 2;
-        this.height += paddingY * 2;
-    };
-
-    /**
-     * Fits this rectangle around the passed one.
-     *
-     * @param {PIXI.Rectangle} rectangle - The rectangle to fit.
-     */
-
-
-    Rectangle.prototype.fit = function fit(rectangle) {
-        if (this.x < rectangle.x) {
-            this.width += this.x;
-            if (this.width < 0) {
-                this.width = 0;
-            }
-
-            this.x = rectangle.x;
-        }
-
-        if (this.y < rectangle.y) {
-            this.height += this.y;
-            if (this.height < 0) {
-                this.height = 0;
-            }
-            this.y = rectangle.y;
-        }
-
-        if (this.x + this.width > rectangle.x + rectangle.width) {
-            this.width = rectangle.width - this.x;
-            if (this.width < 0) {
-                this.width = 0;
-            }
-        }
-
-        if (this.y + this.height > rectangle.y + rectangle.height) {
-            this.height = rectangle.height - this.y;
-            if (this.height < 0) {
-                this.height = 0;
-            }
-        }
-    };
-
-    /**
-     * Enlarges this rectangle to include the passed rectangle.
-     *
-     * @param {PIXI.Rectangle} rectangle - The rectangle to include.
-     */
-
-
-    Rectangle.prototype.enlarge = function enlarge(rectangle) {
-        var x1 = Math.min(this.x, rectangle.x);
-        var x2 = Math.max(this.x + this.width, rectangle.x + rectangle.width);
-        var y1 = Math.min(this.y, rectangle.y);
-        var y2 = Math.max(this.y + this.height, rectangle.y + rectangle.height);
-
-        this.x = x1;
-        this.width = x2 - x1;
-        this.y = y1;
-        this.height = y2 - y1;
-    };
-
-    _createClass(Rectangle, [{
-        key: 'left',
-        get: function get() {
-            return this.x;
-        }
-
-        /**
-         * returns the right edge of the rectangle
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'right',
-        get: function get() {
-            return this.x + this.width;
-        }
-
-        /**
-         * returns the top edge of the rectangle
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'top',
-        get: function get() {
-            return this.y;
-        }
-
-        /**
-         * returns the bottom edge of the rectangle
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'bottom',
-        get: function get() {
-            return this.y + this.height;
-        }
-
-        /**
-         * A constant empty rectangle.
-         *
-         * @static
-         * @constant
-         */
-
-    }], [{
-        key: 'EMPTY',
-        get: function get() {
-            return new Rectangle(0, 0, 0, 0);
-        }
-    }]);
-
-    return Rectangle;
-}();
-
-exports.default = Rectangle;
-
-},{"../../const":46}],75:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _const = require('../../const');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * The Rounded Rectangle object is an area that has nice rounded corners, as indicated by its
- * top-left corner point (x, y) and by its width and its height and its radius.
- *
- * @class
- * @memberof PIXI
- */
-var RoundedRectangle = function () {
-    /**
-     * @param {number} [x=0] - The X coordinate of the upper-left corner of the rounded rectangle
-     * @param {number} [y=0] - The Y coordinate of the upper-left corner of the rounded rectangle
-     * @param {number} [width=0] - The overall width of this rounded rectangle
-     * @param {number} [height=0] - The overall height of this rounded rectangle
-     * @param {number} [radius=20] - Controls the radius of the rounded corners
-     */
-    function RoundedRectangle() {
-        var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-        var width = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-        var height = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-        var radius = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 20;
-
-        _classCallCheck(this, RoundedRectangle);
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.x = x;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.y = y;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.width = width;
-
-        /**
-         * @member {number}
-         * @default 0
-         */
-        this.height = height;
-
-        /**
-         * @member {number}
-         * @default 20
-         */
-        this.radius = radius;
-
-        /**
-         * The type of the object, mainly used to avoid `instanceof` checks
-         *
-         * @member {number}
-         * @readonly
-         * @default PIXI.SHAPES.RREC
-         * @see PIXI.SHAPES
-         */
-        this.type = _const.SHAPES.RREC;
-    }
-
-    /**
-     * Creates a clone of this Rounded Rectangle
-     *
-     * @return {PIXI.RoundedRectangle} a copy of the rounded rectangle
-     */
-
-
-    RoundedRectangle.prototype.clone = function clone() {
-        return new RoundedRectangle(this.x, this.y, this.width, this.height, this.radius);
-    };
-
-    /**
-     * Checks whether the x and y coordinates given are contained within this Rounded Rectangle
-     *
-     * @param {number} x - The X coordinate of the point to test
-     * @param {number} y - The Y coordinate of the point to test
-     * @return {boolean} Whether the x/y coordinates are within this Rounded Rectangle
-     */
-
-
-    RoundedRectangle.prototype.contains = function contains(x, y) {
-        if (this.width <= 0 || this.height <= 0) {
-            return false;
-        }
-        if (x >= this.x && x <= this.x + this.width) {
-            if (y >= this.y && y <= this.y + this.height) {
-                if (y >= this.y + this.radius && y <= this.y + this.height - this.radius || x >= this.x + this.radius && x <= this.x + this.width - this.radius) {
-                    return true;
-                }
-                var dx = x - (this.x + this.radius);
-                var dy = y - (this.y + this.radius);
-                var radius2 = this.radius * this.radius;
-
-                if (dx * dx + dy * dy <= radius2) {
-                    return true;
-                }
-                dx = x - (this.x + this.width - this.radius);
-                if (dx * dx + dy * dy <= radius2) {
-                    return true;
-                }
-                dy = y - (this.y + this.height - this.radius);
-                if (dx * dx + dy * dy <= radius2) {
-                    return true;
-                }
-                dx = x - (this.x + this.radius);
-                if (dx * dx + dy * dy <= radius2) {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    };
-
-    return RoundedRectangle;
-}();
-
-exports.default = RoundedRectangle;
-
-},{"../../const":46}],76:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _utils = require('../utils');
-
-var _math = require('../math');
-
-var _const = require('../const');
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _Container = require('../display/Container');
-
-var _Container2 = _interopRequireDefault(_Container);
-
-var _RenderTexture = require('../textures/RenderTexture');
-
-var _RenderTexture2 = _interopRequireDefault(_RenderTexture);
-
-var _eventemitter = require('eventemitter3');
-
-var _eventemitter2 = _interopRequireDefault(_eventemitter);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var tempMatrix = new _math.Matrix();
-
-/**
- * The SystemRenderer is the base for a PixiJS Renderer. It is extended by the {@link PIXI.CanvasRenderer}
- * and {@link PIXI.WebGLRenderer} which can be used for rendering a PixiJS scene.
- *
- * @abstract
- * @class
- * @extends EventEmitter
- * @memberof PIXI
- */
-
-var SystemRenderer = function (_EventEmitter) {
-  _inherits(SystemRenderer, _EventEmitter);
-
-  // eslint-disable-next-line valid-jsdoc
-  /**
-   * @param {string} system - The name of the system this renderer is for.
-   * @param {object} [options] - The optional renderer parameters
-   * @param {number} [options.width=800] - the width of the screen
-   * @param {number} [options.height=600] - the height of the screen
-   * @param {HTMLCanvasElement} [options.view] - the canvas to use as a view, optional
-   * @param {boolean} [options.transparent=false] - If the render view is transparent, default false
-   * @param {boolean} [options.autoResize=false] - If the render view is automatically resized, default false
-   * @param {boolean} [options.antialias=false] - sets antialias (only applicable in chrome at the moment)
-   * @param {number} [options.resolution=1] - The resolution / device pixel ratio of the renderer. The
-   *  resolution of the renderer retina would be 2.
-   * @param {boolean} [options.preserveDrawingBuffer=false] - enables drawing buffer preservation,
-   *  enable this if you need to call toDataUrl on the webgl context.
-   * @param {boolean} [options.clearBeforeRender=true] - This sets if the renderer will clear the canvas or
-   *      not before the new render pass.
-   * @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area
-   *  (shown if not transparent).
-   * @param {boolean} [options.roundPixels=false] - If true PixiJS will Math.floor() x/y values when rendering,
-   *  stopping pixel interpolation.
-   */
-  function SystemRenderer(system, options, arg2, arg3) {
-    _classCallCheck(this, SystemRenderer);
-
-    var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
-
-    (0, _utils.sayHello)(system);
-
-    // Support for constructor(system, screenWidth, screenHeight, options)
-    if (typeof options === 'number') {
-      options = Object.assign({
-        width: options,
-        height: arg2 || _settings2.default.RENDER_OPTIONS.height
-      }, arg3);
-    }
-
-    // Add the default render options
-    options = Object.assign({}, _settings2.default.RENDER_OPTIONS, options);
-
-    /**
-     * The supplied constructor options.
-     *
-     * @member {Object}
-     * @readOnly
-     */
-    _this.options = options;
-
-    /**
-     * The type of the renderer.
-     *
-     * @member {number}
-     * @default PIXI.RENDERER_TYPE.UNKNOWN
-     * @see PIXI.RENDERER_TYPE
-     */
-    _this.type = _const.RENDERER_TYPE.UNKNOWN;
-
-    /**
-     * Measurements of the screen. (0, 0, screenWidth, screenHeight)
-     *
-     * Its safe to use as filterArea or hitArea for whole stage
-     *
-     * @member {PIXI.Rectangle}
-     */
-    _this.screen = new _math.Rectangle(0, 0, options.width, options.height);
-
-    /**
-     * The canvas element that everything is drawn to
-     *
-     * @member {HTMLCanvasElement}
-     */
-    _this.view = options.view || document.createElement('canvas');
-
-    /**
-     * The resolution / device pixel ratio of the renderer
-     *
-     * @member {number}
-     * @default 1
-     */
-    _this.resolution = options.resolution || _settings2.default.RESOLUTION;
-
-    /**
-     * Whether the render view is transparent
-     *
-     * @member {boolean}
-     */
-    _this.transparent = options.transparent;
-
-    /**
-     * Whether css dimensions of canvas view should be resized to screen dimensions automatically
-     *
-     * @member {boolean}
-     */
-    _this.autoResize = options.autoResize || false;
-
-    /**
-     * Tracks the blend modes useful for this renderer.
-     *
-     * @member {object<string, mixed>}
-     */
-    _this.blendModes = null;
-
-    /**
-     * The value of the preserveDrawingBuffer flag affects whether or not the contents of
-     * the stencil buffer is retained after rendering.
-     *
-     * @member {boolean}
-     */
-    _this.preserveDrawingBuffer = options.preserveDrawingBuffer;
-
-    /**
-     * This sets if the CanvasRenderer will clear the canvas or not before the new render pass.
-     * If the scene is NOT transparent PixiJS will use a canvas sized fillRect operation every
-     * frame to set the canvas background color. If the scene is transparent PixiJS will use clearRect
-     * to clear the canvas every frame. Disable this by setting this to false. For example if
-     * your game has a canvas filling background image you often don't need this set.
-     *
-     * @member {boolean}
-     * @default
-     */
-    _this.clearBeforeRender = options.clearBeforeRender;
-
-    /**
-     * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
-     * Handy for crisp pixel art and speed on legacy devices.
-     *
-     * @member {boolean}
-     */
-    _this.roundPixels = options.roundPixels;
-
-    /**
-     * The background color as a number.
-     *
-     * @member {number}
-     * @private
-     */
-    _this._backgroundColor = 0x000000;
-
-    /**
-     * The background color as an [R, G, B] array.
-     *
-     * @member {number[]}
-     * @private
-     */
-    _this._backgroundColorRgba = [0, 0, 0, 0];
-
-    /**
-     * The background color as a string.
-     *
-     * @member {string}
-     * @private
-     */
-    _this._backgroundColorString = '#000000';
-
-    _this.backgroundColor = options.backgroundColor || _this._backgroundColor; // run bg color setter
-
-    /**
-     * This temporary display object used as the parent of the currently being rendered item
-     *
-     * @member {PIXI.DisplayObject}
-     * @private
-     */
-    _this._tempDisplayObjectParent = new _Container2.default();
-
-    /**
-     * The last root object that the renderer tried to render.
-     *
-     * @member {PIXI.DisplayObject}
-     * @private
-     */
-    _this._lastObjectRendered = _this._tempDisplayObjectParent;
-    return _this;
-  }
-
-  /**
-   * Same as view.width, actual number of pixels in the canvas by horizontal
-   *
-   * @member {number}
-   * @readonly
-   * @default 800
-   */
-
-
-  /**
-   * Resizes the screen and canvas to the specified width and height
-   * Canvas dimensions are multiplied by resolution
-   *
-   * @param {number} screenWidth - the new width of the screen
-   * @param {number} screenHeight - the new height of the screen
-   */
-  SystemRenderer.prototype.resize = function resize(screenWidth, screenHeight) {
-    this.screen.width = screenWidth;
-    this.screen.height = screenHeight;
-
-    this.view.width = screenWidth * this.resolution;
-    this.view.height = screenHeight * this.resolution;
-
-    if (this.autoResize) {
-      this.view.style.width = screenWidth + 'px';
-      this.view.style.height = screenHeight + 'px';
-    }
-  };
-
-  /**
-   * Useful function that returns a texture of the display object that can then be used to create sprites
-   * This can be quite useful if your displayObject is complicated and needs to be reused multiple times.
-   *
-   * @param {PIXI.DisplayObject} displayObject - The displayObject the object will be generated from
-   * @param {number} scaleMode - Should be one of the scaleMode consts
-   * @param {number} resolution - The resolution / device pixel ratio of the texture being generated
-   * @return {PIXI.Texture} a texture of the graphics object
-   */
-
-
-  SystemRenderer.prototype.generateTexture = function generateTexture(displayObject, scaleMode, resolution) {
-    var bounds = displayObject.getLocalBounds();
-
-    var renderTexture = _RenderTexture2.default.create(bounds.width | 0, bounds.height | 0, scaleMode, resolution);
-
-    tempMatrix.tx = -bounds.x;
-    tempMatrix.ty = -bounds.y;
-
-    this.render(displayObject, renderTexture, false, tempMatrix, true);
-
-    return renderTexture;
-  };
-
-  /**
-   * Removes everything from the renderer and optionally removes the Canvas DOM element.
-   *
-   * @param {boolean} [removeView=false] - Removes the Canvas element from the DOM.
-   */
-
-
-  SystemRenderer.prototype.destroy = function destroy(removeView) {
-    if (removeView && this.view.parentNode) {
-      this.view.parentNode.removeChild(this.view);
-    }
-
-    this.type = _const.RENDERER_TYPE.UNKNOWN;
-
-    this.view = null;
-
-    this.screen = null;
-
-    this.resolution = 0;
-
-    this.transparent = false;
-
-    this.autoResize = false;
-
-    this.blendModes = null;
-
-    this.options = null;
-
-    this.preserveDrawingBuffer = false;
-    this.clearBeforeRender = false;
-
-    this.roundPixels = false;
-
-    this._backgroundColor = 0;
-    this._backgroundColorRgba = null;
-    this._backgroundColorString = null;
-
-    this._tempDisplayObjectParent = null;
-    this._lastObjectRendered = null;
-  };
-
-  /**
-   * The background color to fill if not transparent
-   *
-   * @member {number}
-   */
-
-
-  _createClass(SystemRenderer, [{
-    key: 'width',
-    get: function get() {
-      return this.view.width;
-    }
-
-    /**
-     * Same as view.height, actual number of pixels in the canvas by vertical
-     *
-     * @member {number}
-     * @readonly
-     * @default 600
-     */
-
-  }, {
-    key: 'height',
-    get: function get() {
-      return this.view.height;
-    }
-  }, {
-    key: 'backgroundColor',
-    get: function get() {
-      return this._backgroundColor;
-    },
-    set: function set(value) // eslint-disable-line require-jsdoc
-    {
-      this._backgroundColor = value;
-      this._backgroundColorString = (0, _utils.hex2string)(value);
-      (0, _utils.hex2rgb)(value, this._backgroundColorRgba);
-    }
-  }]);
-
-  return SystemRenderer;
-}(_eventemitter2.default);
-
-exports.default = SystemRenderer;
-
-},{"../const":46,"../display/Container":48,"../math":70,"../settings":101,"../textures/RenderTexture":113,"../utils":124,"eventemitter3":3}],77:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _SystemRenderer2 = require('../SystemRenderer');
-
-var _SystemRenderer3 = _interopRequireDefault(_SystemRenderer2);
-
-var _CanvasMaskManager = require('./utils/CanvasMaskManager');
-
-var _CanvasMaskManager2 = _interopRequireDefault(_CanvasMaskManager);
-
-var _CanvasRenderTarget = require('./utils/CanvasRenderTarget');
-
-var _CanvasRenderTarget2 = _interopRequireDefault(_CanvasRenderTarget);
-
-var _mapCanvasBlendModesToPixi = require('./utils/mapCanvasBlendModesToPixi');
-
-var _mapCanvasBlendModesToPixi2 = _interopRequireDefault(_mapCanvasBlendModesToPixi);
-
-var _utils = require('../../utils');
-
-var _const = require('../../const');
-
-var _settings = require('../../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The CanvasRenderer draws the scene and all its content onto a 2d canvas. This renderer should
- * be used for browsers that do not support WebGL. Don't forget to add the CanvasRenderer.view to
- * your DOM or you will not see anything :)
- *
- * @class
- * @memberof PIXI
- * @extends PIXI.SystemRenderer
- */
-var CanvasRenderer = function (_SystemRenderer) {
-    _inherits(CanvasRenderer, _SystemRenderer);
-
-    // eslint-disable-next-line valid-jsdoc
-    /**
-     * @param {object} [options] - The optional renderer parameters
-     * @param {number} [options.width=800] - the width of the screen
-     * @param {number} [options.height=600] - the height of the screen
-     * @param {HTMLCanvasElement} [options.view] - the canvas to use as a view, optional
-     * @param {boolean} [options.transparent=false] - If the render view is transparent, default false
-     * @param {boolean} [options.autoResize=false] - If the render view is automatically resized, default false
-     * @param {boolean} [options.antialias=false] - sets antialias (only applicable in chrome at the moment)
-     * @param {number} [options.resolution=1] - The resolution / device pixel ratio of the renderer. The
-     *  resolution of the renderer retina would be 2.
-     * @param {boolean} [options.preserveDrawingBuffer=false] - enables drawing buffer preservation,
-     *  enable this if you need to call toDataUrl on the webgl context.
-     * @param {boolean} [options.clearBeforeRender=true] - This sets if the renderer will clear the canvas or
-     *      not before the new render pass.
-     * @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area
-     *  (shown if not transparent).
-     * @param {boolean} [options.roundPixels=false] - If true PixiJS will Math.floor() x/y values when rendering,
-     *  stopping pixel interpolation.
-     */
-    function CanvasRenderer(options, arg2, arg3) {
-        _classCallCheck(this, CanvasRenderer);
-
-        var _this = _possibleConstructorReturn(this, _SystemRenderer.call(this, 'Canvas', options, arg2, arg3));
-
-        _this.type = _const.RENDERER_TYPE.CANVAS;
-
-        /**
-         * The root canvas 2d context that everything is drawn with.
-         *
-         * @member {CanvasRenderingContext2D}
-         */
-        _this.rootContext = _this.view.getContext('2d', { alpha: _this.transparent });
-
-        /**
-         * The currently active canvas 2d context (could change with renderTextures)
-         *
-         * @member {CanvasRenderingContext2D}
-         */
-        _this.context = _this.rootContext;
-
-        /**
-         * Boolean flag controlling canvas refresh.
-         *
-         * @member {boolean}
-         */
-        _this.refresh = true;
-
-        /**
-         * Instance of a CanvasMaskManager, handles masking when using the canvas renderer.
-         *
-         * @member {PIXI.CanvasMaskManager}
-         */
-        _this.maskManager = new _CanvasMaskManager2.default(_this);
-
-        /**
-         * The canvas property used to set the canvas smoothing property.
-         *
-         * @member {string}
-         */
-        _this.smoothProperty = 'imageSmoothingEnabled';
-
-        if (!_this.rootContext.imageSmoothingEnabled) {
-            if (_this.rootContext.webkitImageSmoothingEnabled) {
-                _this.smoothProperty = 'webkitImageSmoothingEnabled';
-            } else if (_this.rootContext.mozImageSmoothingEnabled) {
-                _this.smoothProperty = 'mozImageSmoothingEnabled';
-            } else if (_this.rootContext.oImageSmoothingEnabled) {
-                _this.smoothProperty = 'oImageSmoothingEnabled';
-            } else if (_this.rootContext.msImageSmoothingEnabled) {
-                _this.smoothProperty = 'msImageSmoothingEnabled';
-            }
-        }
-
-        _this.initPlugins();
-
-        _this.blendModes = (0, _mapCanvasBlendModesToPixi2.default)();
-        _this._activeBlendMode = null;
-
-        _this.renderingToScreen = false;
-
-        _this.resize(_this.options.width, _this.options.height);
-
-        /**
-         * Fired after rendering finishes.
-         *
-         * @event PIXI.CanvasRenderer#postrender
-         */
-
-        /**
-         * Fired before rendering starts.
-         *
-         * @event PIXI.CanvasRenderer#prerender
-         */
-        return _this;
-    }
-
-    /**
-     * Renders the object to this canvas view
-     *
-     * @param {PIXI.DisplayObject} displayObject - The object to be rendered
-     * @param {PIXI.RenderTexture} [renderTexture] - A render texture to be rendered to.
-     *  If unset, it will render to the root context.
-     * @param {boolean} [clear=false] - Whether to clear the canvas before drawing
-     * @param {PIXI.Transform} [transform] - A transformation to be applied
-     * @param {boolean} [skipUpdateTransform=false] - Whether to skip the update transform
-     */
-
-
-    CanvasRenderer.prototype.render = function render(displayObject, renderTexture, clear, transform, skipUpdateTransform) {
-        if (!this.view) {
-            return;
-        }
-
-        // can be handy to know!
-        this.renderingToScreen = !renderTexture;
-
-        this.emit('prerender');
-
-        var rootResolution = this.resolution;
-
-        if (renderTexture) {
-            renderTexture = renderTexture.baseTexture || renderTexture;
-
-            if (!renderTexture._canvasRenderTarget) {
-                renderTexture._canvasRenderTarget = new _CanvasRenderTarget2.default(renderTexture.width, renderTexture.height, renderTexture.resolution);
-                renderTexture.source = renderTexture._canvasRenderTarget.canvas;
-                renderTexture.valid = true;
-            }
-
-            this.context = renderTexture._canvasRenderTarget.context;
-            this.resolution = renderTexture._canvasRenderTarget.resolution;
-        } else {
-            this.context = this.rootContext;
-        }
-
-        var context = this.context;
-
-        if (!renderTexture) {
-            this._lastObjectRendered = displayObject;
-        }
-
-        if (!skipUpdateTransform) {
-            // update the scene graph
-            var cacheParent = displayObject.parent;
-            var tempWt = this._tempDisplayObjectParent.transform.worldTransform;
-
-            if (transform) {
-                transform.copy(tempWt);
-
-                // lets not forget to flag the parent transform as dirty...
-                this._tempDisplayObjectParent.transform._worldID = -1;
-            } else {
-                tempWt.identity();
-            }
-
-            displayObject.parent = this._tempDisplayObjectParent;
-
-            displayObject.updateTransform();
-            displayObject.parent = cacheParent;
-            // displayObject.hitArea = //TODO add a temp hit area
-        }
-
-        context.setTransform(1, 0, 0, 1, 0, 0);
-        context.globalAlpha = 1;
-        context.globalCompositeOperation = this.blendModes[_const.BLEND_MODES.NORMAL];
-
-        if (navigator.isCocoonJS && this.view.screencanvas) {
-            context.fillStyle = 'black';
-            context.clear();
-        }
-
-        if (clear !== undefined ? clear : this.clearBeforeRender) {
-            if (this.renderingToScreen) {
-                if (this.transparent) {
-                    context.clearRect(0, 0, this.width, this.height);
-                } else {
-                    context.fillStyle = this._backgroundColorString;
-                    context.fillRect(0, 0, this.width, this.height);
-                }
-            } // else {
-            // TODO: implement background for CanvasRenderTarget or RenderTexture?
-            // }
-        }
-
-        // TODO RENDER TARGET STUFF HERE..
-        var tempContext = this.context;
-
-        this.context = context;
-        displayObject.renderCanvas(this);
-        this.context = tempContext;
-
-        this.resolution = rootResolution;
-
-        this.emit('postrender');
-    };
-
-    /**
-     * Clear the canvas of renderer.
-     *
-     * @param {string} [clearColor] - Clear the canvas with this color, except the canvas is transparent.
-     */
-
-
-    CanvasRenderer.prototype.clear = function clear(clearColor) {
-        var context = this.context;
-
-        clearColor = clearColor || this._backgroundColorString;
-
-        if (!this.transparent && clearColor) {
-            context.fillStyle = clearColor;
-            context.fillRect(0, 0, this.width, this.height);
-        } else {
-            context.clearRect(0, 0, this.width, this.height);
-        }
-    };
-
-    /**
-     * Sets the blend mode of the renderer.
-     *
-     * @param {number} blendMode - See {@link PIXI.BLEND_MODES} for valid values.
-     */
-
-
-    CanvasRenderer.prototype.setBlendMode = function setBlendMode(blendMode) {
-        if (this._activeBlendMode === blendMode) {
-            return;
-        }
-
-        this._activeBlendMode = blendMode;
-        this.context.globalCompositeOperation = this.blendModes[blendMode];
-    };
-
-    /**
-     * Removes everything from the renderer and optionally removes the Canvas DOM element.
-     *
-     * @param {boolean} [removeView=false] - Removes the Canvas element from the DOM.
-     */
-
-
-    CanvasRenderer.prototype.destroy = function destroy(removeView) {
-        this.destroyPlugins();
-
-        // call the base destroy
-        _SystemRenderer.prototype.destroy.call(this, removeView);
-
-        this.context = null;
-
-        this.refresh = true;
-
-        this.maskManager.destroy();
-        this.maskManager = null;
-
-        this.smoothProperty = null;
-    };
-
-    /**
-     * Resizes the canvas view to the specified width and height.
-     *
-     * @extends PIXI.SystemRenderer#resize
-     *
-     * @param {number} screenWidth - the new width of the screen
-     * @param {number} screenHeight - the new height of the screen
-     */
-
-
-    CanvasRenderer.prototype.resize = function resize(screenWidth, screenHeight) {
-        _SystemRenderer.prototype.resize.call(this, screenWidth, screenHeight);
-
-        // reset the scale mode.. oddly this seems to be reset when the canvas is resized.
-        // surely a browser bug?? Let PixiJS fix that for you..
-        if (this.smoothProperty) {
-            this.rootContext[this.smoothProperty] = _settings2.default.SCALE_MODE === _const.SCALE_MODES.LINEAR;
-        }
-    };
-
-    return CanvasRenderer;
-}(_SystemRenderer3.default);
-
-/**
- * Collection of installed plugins. These are included by default in PIXI, but can be excluded
- * by creating a custom build. Consult the README for more information about creating custom
- * builds and excluding plugins.
- * @name PIXI.CanvasRenderer#plugins
- * @type {object}
- * @readonly
- * @property {PIXI.accessibility.AccessibilityManager} accessibility Support tabbing interactive elements.
- * @property {PIXI.extract.CanvasExtract} extract Extract image data from renderer.
- * @property {PIXI.interaction.InteractionManager} interaction Handles mouse, touch and pointer events.
- * @property {PIXI.prepare.CanvasPrepare} prepare Pre-render display objects.
- */
-
-/**
- * Adds a plugin to the renderer.
- *
- * @method PIXI.CanvasRenderer#registerPlugin
- * @param {string} pluginName - The name of the plugin.
- * @param {Function} ctor - The constructor function or class for the plugin.
- */
-
-exports.default = CanvasRenderer;
-_utils.pluginTarget.mixin(CanvasRenderer);
-
-},{"../../const":46,"../../settings":101,"../../utils":124,"../SystemRenderer":76,"./utils/CanvasMaskManager":78,"./utils/CanvasRenderTarget":79,"./utils/mapCanvasBlendModesToPixi":81}],78:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _const = require('../../../const');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * A set of functions used to handle masking.
- *
- * @class
- * @memberof PIXI
- */
-var CanvasMaskManager = function () {
-    /**
-     * @param {PIXI.CanvasRenderer} renderer - The canvas renderer.
-     */
-    function CanvasMaskManager(renderer) {
-        _classCallCheck(this, CanvasMaskManager);
-
-        this.renderer = renderer;
-    }
-
-    /**
-     * This method adds it to the current stack of masks.
-     *
-     * @param {object} maskData - the maskData that will be pushed
-     */
-
-
-    CanvasMaskManager.prototype.pushMask = function pushMask(maskData) {
-        var renderer = this.renderer;
-
-        renderer.context.save();
-
-        var cacheAlpha = maskData.alpha;
-        var transform = maskData.transform.worldTransform;
-        var resolution = renderer.resolution;
-
-        renderer.context.setTransform(transform.a * resolution, transform.b * resolution, transform.c * resolution, transform.d * resolution, transform.tx * resolution, transform.ty * resolution);
-
-        // TODO suport sprite alpha masks??
-        // lots of effort required. If demand is great enough..
-        if (!maskData._texture) {
-            this.renderGraphicsShape(maskData);
-            renderer.context.clip();
-        }
-
-        maskData.worldAlpha = cacheAlpha;
-    };
-
-    /**
-     * Renders a PIXI.Graphics shape.
-     *
-     * @param {PIXI.Graphics} graphics - The object to render.
-     */
-
-
-    CanvasMaskManager.prototype.renderGraphicsShape = function renderGraphicsShape(graphics) {
-        var context = this.renderer.context;
-        var len = graphics.graphicsData.length;
-
-        if (len === 0) {
-            return;
-        }
-
-        context.beginPath();
-
-        for (var i = 0; i < len; i++) {
-            var data = graphics.graphicsData[i];
-            var shape = data.shape;
-
-            if (data.type === _const.SHAPES.POLY) {
-                var points = shape.points;
-
-                context.moveTo(points[0], points[1]);
-
-                for (var j = 1; j < points.length / 2; j++) {
-                    context.lineTo(points[j * 2], points[j * 2 + 1]);
-                }
-
-                // if the first and last point are the same close the path - much neater :)
-                if (points[0] === points[points.length - 2] && points[1] === points[points.length - 1]) {
-                    context.closePath();
-                }
-            } else if (data.type === _const.SHAPES.RECT) {
-                context.rect(shape.x, shape.y, shape.width, shape.height);
-                context.closePath();
-            } else if (data.type === _const.SHAPES.CIRC) {
-                // TODO - need to be Undefined!
-                context.arc(shape.x, shape.y, shape.radius, 0, 2 * Math.PI);
-                context.closePath();
-            } else if (data.type === _const.SHAPES.ELIP) {
-                // ellipse code taken from: http://stackoverflow.com/questions/2172798/how-to-draw-an-oval-in-html5-canvas
-
-                var w = shape.width * 2;
-                var h = shape.height * 2;
-
-                var x = shape.x - w / 2;
-                var y = shape.y - h / 2;
-
-                var kappa = 0.5522848;
-                var ox = w / 2 * kappa; // control point offset horizontal
-                var oy = h / 2 * kappa; // control point offset vertical
-                var xe = x + w; // x-end
-                var ye = y + h; // y-end
-                var xm = x + w / 2; // x-middle
-                var ym = y + h / 2; // y-middle
-
-                context.moveTo(x, ym);
-                context.bezierCurveTo(x, ym - oy, xm - ox, y, xm, y);
-                context.bezierCurveTo(xm + ox, y, xe, ym - oy, xe, ym);
-                context.bezierCurveTo(xe, ym + oy, xm + ox, ye, xm, ye);
-                context.bezierCurveTo(xm - ox, ye, x, ym + oy, x, ym);
-                context.closePath();
-            } else if (data.type === _const.SHAPES.RREC) {
-                var rx = shape.x;
-                var ry = shape.y;
-                var width = shape.width;
-                var height = shape.height;
-                var radius = shape.radius;
-
-                var maxRadius = Math.min(width, height) / 2 | 0;
-
-                radius = radius > maxRadius ? maxRadius : radius;
-
-                context.moveTo(rx, ry + radius);
-                context.lineTo(rx, ry + height - radius);
-                context.quadraticCurveTo(rx, ry + height, rx + radius, ry + height);
-                context.lineTo(rx + width - radius, ry + height);
-                context.quadraticCurveTo(rx + width, ry + height, rx + width, ry + height - radius);
-                context.lineTo(rx + width, ry + radius);
-                context.quadraticCurveTo(rx + width, ry, rx + width - radius, ry);
-                context.lineTo(rx + radius, ry);
-                context.quadraticCurveTo(rx, ry, rx, ry + radius);
-                context.closePath();
-            }
-        }
-    };
-
-    /**
-     * Restores the current drawing context to the state it was before the mask was applied.
-     *
-     * @param {PIXI.CanvasRenderer} renderer - The renderer context to use.
-     */
-
-
-    CanvasMaskManager.prototype.popMask = function popMask(renderer) {
-        renderer.context.restore();
-    };
-
-    /**
-     * Destroys this canvas mask manager.
-     *
-     */
-
-
-    CanvasMaskManager.prototype.destroy = function destroy() {
-        /* empty */
-    };
-
-    return CanvasMaskManager;
-}();
-
-exports.default = CanvasMaskManager;
-
-},{"../../../const":46}],79:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _settings = require('../../../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Creates a Canvas element of the given size.
- *
- * @class
- * @memberof PIXI
- */
-var CanvasRenderTarget = function () {
-  /**
-   * @param {number} width - the width for the newly created canvas
-   * @param {number} height - the height for the newly created canvas
-   * @param {number} [resolution=1] - The resolution / device pixel ratio of the canvas
-   */
-  function CanvasRenderTarget(width, height, resolution) {
-    _classCallCheck(this, CanvasRenderTarget);
-
-    /**
-     * The Canvas object that belongs to this CanvasRenderTarget.
-     *
-     * @member {HTMLCanvasElement}
-     */
-    this.canvas = document.createElement('canvas');
-
-    /**
-     * A CanvasRenderingContext2D object representing a two-dimensional rendering context.
-     *
-     * @member {CanvasRenderingContext2D}
-     */
-    this.context = this.canvas.getContext('2d');
-
-    this.resolution = resolution || _settings2.default.RESOLUTION;
-
-    this.resize(width, height);
-  }
-
-  /**
-   * Clears the canvas that was created by the CanvasRenderTarget class.
-   *
-   * @private
-   */
-
-
-  CanvasRenderTarget.prototype.clear = function clear() {
-    this.context.setTransform(1, 0, 0, 1, 0, 0);
-    this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
-  };
-
-  /**
-   * Resizes the canvas to the specified width and height.
-   *
-   * @param {number} width - the new width of the canvas
-   * @param {number} height - the new height of the canvas
-   */
-
-
-  CanvasRenderTarget.prototype.resize = function resize(width, height) {
-    this.canvas.width = width * this.resolution;
-    this.canvas.height = height * this.resolution;
-  };
-
-  /**
-   * Destroys this canvas.
-   *
-   */
-
-
-  CanvasRenderTarget.prototype.destroy = function destroy() {
-    this.context = null;
-    this.canvas = null;
-  };
-
-  /**
-   * The width of the canvas buffer in pixels.
-   *
-   * @member {number}
-   */
-
-
-  _createClass(CanvasRenderTarget, [{
-    key: 'width',
-    get: function get() {
-      return this.canvas.width;
-    },
-    set: function set(val) // eslint-disable-line require-jsdoc
-    {
-      this.canvas.width = val;
-    }
-
-    /**
-     * The height of the canvas buffer in pixels.
-     *
-     * @member {number}
-     */
-
-  }, {
-    key: 'height',
-    get: function get() {
-      return this.canvas.height;
-    },
-    set: function set(val) // eslint-disable-line require-jsdoc
-    {
-      this.canvas.height = val;
-    }
-  }]);
-
-  return CanvasRenderTarget;
-}();
-
-exports.default = CanvasRenderTarget;
-
-},{"../../../settings":101}],80:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = canUseNewCanvasBlendModes;
-/**
- * Creates a little colored canvas
- *
- * @ignore
- * @param {string} color - The color to make the canvas
- * @return {canvas} a small canvas element
- */
-function createColoredCanvas(color) {
-    var canvas = document.createElement('canvas');
-
-    canvas.width = 6;
-    canvas.height = 1;
-
-    var context = canvas.getContext('2d');
-
-    context.fillStyle = color;
-    context.fillRect(0, 0, 6, 1);
-
-    return canvas;
-}
-
-/**
- * Checks whether the Canvas BlendModes are supported by the current browser
- *
- * @return {boolean} whether they are supported
- */
-function canUseNewCanvasBlendModes() {
-    if (typeof document === 'undefined') {
-        return false;
-    }
-
-    var magenta = createColoredCanvas('#ff00ff');
-    var yellow = createColoredCanvas('#ffff00');
-
-    var canvas = document.createElement('canvas');
-
-    canvas.width = 6;
-    canvas.height = 1;
-
-    var context = canvas.getContext('2d');
-
-    context.globalCompositeOperation = 'multiply';
-    context.drawImage(magenta, 0, 0);
-    context.drawImage(yellow, 2, 0);
-
-    var imageData = context.getImageData(2, 0, 1, 1);
-
-    if (!imageData) {
-        return false;
-    }
-
-    var data = imageData.data;
-
-    return data[0] === 255 && data[1] === 0 && data[2] === 0;
-}
-
-},{}],81:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = mapCanvasBlendModesToPixi;
-
-var _const = require('../../../const');
-
-var _canUseNewCanvasBlendModes = require('./canUseNewCanvasBlendModes');
-
-var _canUseNewCanvasBlendModes2 = _interopRequireDefault(_canUseNewCanvasBlendModes);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Maps blend combinations to Canvas.
- *
- * @memberof PIXI
- * @function mapCanvasBlendModesToPixi
- * @private
- * @param {string[]} [array=[]] - The array to output into.
- * @return {string[]} Mapped modes.
- */
-function mapCanvasBlendModesToPixi() {
-    var array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-
-    if ((0, _canUseNewCanvasBlendModes2.default)()) {
-        array[_const.BLEND_MODES.NORMAL] = 'source-over';
-        array[_const.BLEND_MODES.ADD] = 'lighter'; // IS THIS OK???
-        array[_const.BLEND_MODES.MULTIPLY] = 'multiply';
-        array[_const.BLEND_MODES.SCREEN] = 'screen';
-        array[_const.BLEND_MODES.OVERLAY] = 'overlay';
-        array[_const.BLEND_MODES.DARKEN] = 'darken';
-        array[_const.BLEND_MODES.LIGHTEN] = 'lighten';
-        array[_const.BLEND_MODES.COLOR_DODGE] = 'color-dodge';
-        array[_const.BLEND_MODES.COLOR_BURN] = 'color-burn';
-        array[_const.BLEND_MODES.HARD_LIGHT] = 'hard-light';
-        array[_const.BLEND_MODES.SOFT_LIGHT] = 'soft-light';
-        array[_const.BLEND_MODES.DIFFERENCE] = 'difference';
-        array[_const.BLEND_MODES.EXCLUSION] = 'exclusion';
-        array[_const.BLEND_MODES.HUE] = 'hue';
-        array[_const.BLEND_MODES.SATURATION] = 'saturate';
-        array[_const.BLEND_MODES.COLOR] = 'color';
-        array[_const.BLEND_MODES.LUMINOSITY] = 'luminosity';
-    } else {
-        // this means that the browser does not support the cool new blend modes in canvas 'cough' ie 'cough'
-        array[_const.BLEND_MODES.NORMAL] = 'source-over';
-        array[_const.BLEND_MODES.ADD] = 'lighter'; // IS THIS OK???
-        array[_const.BLEND_MODES.MULTIPLY] = 'source-over';
-        array[_const.BLEND_MODES.SCREEN] = 'source-over';
-        array[_const.BLEND_MODES.OVERLAY] = 'source-over';
-        array[_const.BLEND_MODES.DARKEN] = 'source-over';
-        array[_const.BLEND_MODES.LIGHTEN] = 'source-over';
-        array[_const.BLEND_MODES.COLOR_DODGE] = 'source-over';
-        array[_const.BLEND_MODES.COLOR_BURN] = 'source-over';
-        array[_const.BLEND_MODES.HARD_LIGHT] = 'source-over';
-        array[_const.BLEND_MODES.SOFT_LIGHT] = 'source-over';
-        array[_const.BLEND_MODES.DIFFERENCE] = 'source-over';
-        array[_const.BLEND_MODES.EXCLUSION] = 'source-over';
-        array[_const.BLEND_MODES.HUE] = 'source-over';
-        array[_const.BLEND_MODES.SATURATION] = 'source-over';
-        array[_const.BLEND_MODES.COLOR] = 'source-over';
-        array[_const.BLEND_MODES.LUMINOSITY] = 'source-over';
-    }
-    // not-premultiplied, only for webgl
-    array[_const.BLEND_MODES.NORMAL_NPM] = array[_const.BLEND_MODES.NORMAL];
-    array[_const.BLEND_MODES.ADD_NPM] = array[_const.BLEND_MODES.ADD];
-    array[_const.BLEND_MODES.SCREEN_NPM] = array[_const.BLEND_MODES.SCREEN];
-
-    return array;
-}
-
-},{"../../../const":46,"./canUseNewCanvasBlendModes":80}],82:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _const = require('../../const');
-
-var _settings = require('../../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * TextureGarbageCollector. This class manages the GPU and ensures that it does not get clogged
- * up with textures that are no longer being used.
- *
- * @class
- * @memberof PIXI
- */
-var TextureGarbageCollector = function () {
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - The renderer this manager works for.
-     */
-    function TextureGarbageCollector(renderer) {
-        _classCallCheck(this, TextureGarbageCollector);
-
-        this.renderer = renderer;
-
-        this.count = 0;
-        this.checkCount = 0;
-        this.maxIdle = _settings2.default.GC_MAX_IDLE;
-        this.checkCountMax = _settings2.default.GC_MAX_CHECK_COUNT;
-        this.mode = _settings2.default.GC_MODE;
-    }
-
-    /**
-     * Checks to see when the last time a texture was used
-     * if the texture has not been used for a specified amount of time it will be removed from the GPU
-     */
-
-
-    TextureGarbageCollector.prototype.update = function update() {
-        this.count++;
-
-        if (this.mode === _const.GC_MODES.MANUAL) {
-            return;
-        }
-
-        this.checkCount++;
-
-        if (this.checkCount > this.checkCountMax) {
-            this.checkCount = 0;
-
-            this.run();
-        }
-    };
-
-    /**
-     * Checks to see when the last time a texture was used
-     * if the texture has not been used for a specified amount of time it will be removed from the GPU
-     */
-
-
-    TextureGarbageCollector.prototype.run = function run() {
-        var tm = this.renderer.textureManager;
-        var managedTextures = tm._managedTextures;
-        var wasRemoved = false;
-
-        for (var i = 0; i < managedTextures.length; i++) {
-            var texture = managedTextures[i];
-
-            // only supports non generated textures at the moment!
-            if (!texture._glRenderTargets && this.count - texture.touched > this.maxIdle) {
-                tm.destroyTexture(texture, true);
-                managedTextures[i] = null;
-                wasRemoved = true;
-            }
-        }
-
-        if (wasRemoved) {
-            var j = 0;
-
-            for (var _i = 0; _i < managedTextures.length; _i++) {
-                if (managedTextures[_i] !== null) {
-                    managedTextures[j++] = managedTextures[_i];
-                }
-            }
-
-            managedTextures.length = j;
-        }
-    };
-
-    /**
-     * Removes all the textures within the specified displayObject and its children from the GPU
-     *
-     * @param {PIXI.DisplayObject} displayObject - the displayObject to remove the textures from.
-     */
-
-
-    TextureGarbageCollector.prototype.unload = function unload(displayObject) {
-        var tm = this.renderer.textureManager;
-
-        // only destroy non generated textures
-        if (displayObject._texture && displayObject._texture._glRenderTargets) {
-            tm.destroyTexture(displayObject._texture, true);
-        }
-
-        for (var i = displayObject.children.length - 1; i >= 0; i--) {
-            this.unload(displayObject.children[i]);
-        }
-    };
-
-    return TextureGarbageCollector;
-}();
-
-exports.default = TextureGarbageCollector;
-
-},{"../../const":46,"../../settings":101}],83:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _const = require('../../const');
-
-var _RenderTarget = require('./utils/RenderTarget');
-
-var _RenderTarget2 = _interopRequireDefault(_RenderTarget);
-
-var _utils = require('../../utils');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Helper class to create a webGL Texture
- *
- * @class
- * @memberof PIXI
- */
-var TextureManager = function () {
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - A reference to the current renderer
-     */
-    function TextureManager(renderer) {
-        _classCallCheck(this, TextureManager);
-
-        /**
-         * A reference to the current renderer
-         *
-         * @member {PIXI.WebGLRenderer}
-         */
-        this.renderer = renderer;
-
-        /**
-         * The current WebGL rendering context
-         *
-         * @member {WebGLRenderingContext}
-         */
-        this.gl = renderer.gl;
-
-        /**
-         * Track textures in the renderer so we can no longer listen to them on destruction.
-         *
-         * @member {Array<*>}
-         * @private
-         */
-        this._managedTextures = [];
-    }
-
-    /**
-     * Binds a texture.
-     *
-     */
-
-
-    TextureManager.prototype.bindTexture = function bindTexture() {}
-    // empty
-
-
-    /**
-     * Gets a texture.
-     *
-     */
-    ;
-
-    TextureManager.prototype.getTexture = function getTexture() {}
-    // empty
-
-
-    /**
-     * Updates and/or Creates a WebGL texture for the renderer's context.
-     *
-     * @param {PIXI.BaseTexture|PIXI.Texture} texture - the texture to update
-     * @param {number} location - the location the texture will be bound to.
-     * @return {GLTexture} The gl texture.
-     */
-    ;
-
-    TextureManager.prototype.updateTexture = function updateTexture(texture, location) {
-        // assume it good!
-        // texture = texture.baseTexture || texture;
-
-        var gl = this.gl;
-
-        var isRenderTexture = !!texture._glRenderTargets;
-
-        if (!texture.hasLoaded) {
-            return null;
-        }
-
-        var boundTextures = this.renderer.boundTextures;
-
-        // if the location is undefined then this may have been called by n event.
-        // this being the case the texture may already be bound to a slot. As a texture can only be bound once
-        // we need to find its current location if it exists.
-        if (location === undefined) {
-            location = 0;
-
-            // TODO maybe we can use texture bound ids later on...
-            // check if texture is already bound..
-            for (var i = 0; i < boundTextures.length; ++i) {
-                if (boundTextures[i] === texture) {
-                    location = i;
-                    break;
-                }
-            }
-        }
-
-        boundTextures[location] = texture;
-
-        gl.activeTexture(gl.TEXTURE0 + location);
-
-        var glTexture = texture._glTextures[this.renderer.CONTEXT_UID];
-
-        if (!glTexture) {
-            if (isRenderTexture) {
-                var renderTarget = new _RenderTarget2.default(this.gl, texture.width, texture.height, texture.scaleMode, texture.resolution);
-
-                renderTarget.resize(texture.width, texture.height);
-                texture._glRenderTargets[this.renderer.CONTEXT_UID] = renderTarget;
-                glTexture = renderTarget.texture;
-            } else {
-                glTexture = new _pixiGlCore.GLTexture(this.gl, null, null, null, null);
-                glTexture.bind(location);
-                glTexture.premultiplyAlpha = true;
-                glTexture.upload(texture.source);
-            }
-
-            texture._glTextures[this.renderer.CONTEXT_UID] = glTexture;
-
-            texture.on('update', this.updateTexture, this);
-            texture.on('dispose', this.destroyTexture, this);
-
-            this._managedTextures.push(texture);
-
-            if (texture.isPowerOfTwo) {
-                if (texture.mipmap) {
-                    glTexture.enableMipmap();
-                }
-
-                if (texture.wrapMode === _const.WRAP_MODES.CLAMP) {
-                    glTexture.enableWrapClamp();
-                } else if (texture.wrapMode === _const.WRAP_MODES.REPEAT) {
-                    glTexture.enableWrapRepeat();
-                } else {
-                    glTexture.enableWrapMirrorRepeat();
-                }
-            } else {
-                glTexture.enableWrapClamp();
-            }
-
-            if (texture.scaleMode === _const.SCALE_MODES.NEAREST) {
-                glTexture.enableNearestScaling();
-            } else {
-                glTexture.enableLinearScaling();
-            }
-        }
-        // the texture already exists so we only need to update it..
-        else if (isRenderTexture) {
-                texture._glRenderTargets[this.renderer.CONTEXT_UID].resize(texture.width, texture.height);
-            } else {
-                glTexture.upload(texture.source);
-            }
-
-        return glTexture;
-    };
-
-    /**
-     * Deletes the texture from WebGL
-     *
-     * @param {PIXI.BaseTexture|PIXI.Texture} texture - the texture to destroy
-     * @param {boolean} [skipRemove=false] - Whether to skip removing the texture from the TextureManager.
-     */
-
-
-    TextureManager.prototype.destroyTexture = function destroyTexture(texture, skipRemove) {
-        texture = texture.baseTexture || texture;
-
-        if (!texture.hasLoaded) {
-            return;
-        }
-
-        var uid = this.renderer.CONTEXT_UID;
-        var glTextures = texture._glTextures;
-        var glRenderTargets = texture._glRenderTargets;
-
-        if (glTextures[uid]) {
-            this.renderer.unbindTexture(texture);
-
-            glTextures[uid].destroy();
-            texture.off('update', this.updateTexture, this);
-            texture.off('dispose', this.destroyTexture, this);
-
-            delete glTextures[uid];
-
-            if (!skipRemove) {
-                var i = this._managedTextures.indexOf(texture);
-
-                if (i !== -1) {
-                    (0, _utils.removeItems)(this._managedTextures, i, 1);
-                }
-            }
-        }
-
-        if (glRenderTargets && glRenderTargets[uid]) {
-            glRenderTargets[uid].destroy();
-            delete glRenderTargets[uid];
-        }
-    };
-
-    /**
-     * Deletes all the textures from WebGL
-     */
-
-
-    TextureManager.prototype.removeAll = function removeAll() {
-        // empty all the old gl textures as they are useless now
-        for (var i = 0; i < this._managedTextures.length; ++i) {
-            var texture = this._managedTextures[i];
-
-            if (texture._glTextures[this.renderer.CONTEXT_UID]) {
-                delete texture._glTextures[this.renderer.CONTEXT_UID];
-            }
-        }
-    };
-
-    /**
-     * Destroys this manager and removes all its textures
-     */
-
-
-    TextureManager.prototype.destroy = function destroy() {
-        // destroy managed textures
-        for (var i = 0; i < this._managedTextures.length; ++i) {
-            var texture = this._managedTextures[i];
-
-            this.destroyTexture(texture, true);
-
-            texture.off('update', this.updateTexture, this);
-            texture.off('dispose', this.destroyTexture, this);
-        }
-
-        this._managedTextures = null;
-    };
-
-    return TextureManager;
-}();
-
-exports.default = TextureManager;
-
-},{"../../const":46,"../../utils":124,"./utils/RenderTarget":96,"pixi-gl-core":12}],84:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _SystemRenderer2 = require('../SystemRenderer');
-
-var _SystemRenderer3 = _interopRequireDefault(_SystemRenderer2);
-
-var _MaskManager = require('./managers/MaskManager');
-
-var _MaskManager2 = _interopRequireDefault(_MaskManager);
-
-var _StencilManager = require('./managers/StencilManager');
-
-var _StencilManager2 = _interopRequireDefault(_StencilManager);
-
-var _FilterManager = require('./managers/FilterManager');
-
-var _FilterManager2 = _interopRequireDefault(_FilterManager);
-
-var _RenderTarget = require('./utils/RenderTarget');
-
-var _RenderTarget2 = _interopRequireDefault(_RenderTarget);
-
-var _ObjectRenderer = require('./utils/ObjectRenderer');
-
-var _ObjectRenderer2 = _interopRequireDefault(_ObjectRenderer);
-
-var _TextureManager = require('./TextureManager');
-
-var _TextureManager2 = _interopRequireDefault(_TextureManager);
-
-var _BaseTexture = require('../../textures/BaseTexture');
-
-var _BaseTexture2 = _interopRequireDefault(_BaseTexture);
-
-var _TextureGarbageCollector = require('./TextureGarbageCollector');
-
-var _TextureGarbageCollector2 = _interopRequireDefault(_TextureGarbageCollector);
-
-var _WebGLState = require('./WebGLState');
-
-var _WebGLState2 = _interopRequireDefault(_WebGLState);
-
-var _mapWebGLDrawModesToPixi = require('./utils/mapWebGLDrawModesToPixi');
-
-var _mapWebGLDrawModesToPixi2 = _interopRequireDefault(_mapWebGLDrawModesToPixi);
-
-var _validateContext = require('./utils/validateContext');
-
-var _validateContext2 = _interopRequireDefault(_validateContext);
-
-var _utils = require('../../utils');
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-var _const = require('../../const');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var CONTEXT_UID = 0;
-
-/**
- * The WebGLRenderer draws the scene and all its content onto a webGL enabled canvas. This renderer
- * should be used for browsers that support webGL. This Render works by automatically managing webGLBatchs.
- * So no need for Sprite Batches or Sprite Clouds.
- * Don't forget to add the view to your DOM or you will not see anything :)
- *
- * @class
- * @memberof PIXI
- * @extends PIXI.SystemRenderer
- */
-
-var WebGLRenderer = function (_SystemRenderer) {
-    _inherits(WebGLRenderer, _SystemRenderer);
-
-    // eslint-disable-next-line valid-jsdoc
-    /**
-     *
-     * @param {object} [options] - The optional renderer parameters
-     * @param {number} [options.width=800] - the width of the screen
-     * @param {number} [options.height=600] - the height of the screen
-     * @param {HTMLCanvasElement} [options.view] - the canvas to use as a view, optional
-     * @param {boolean} [options.transparent=false] - If the render view is transparent, default false
-     * @param {boolean} [options.autoResize=false] - If the render view is automatically resized, default false
-     * @param {boolean} [options.antialias=false] - sets antialias. If not available natively then FXAA
-     *  antialiasing is used
-     * @param {boolean} [options.forceFXAA=false] - forces FXAA antialiasing to be used over native.
-     *  FXAA is faster, but may not always look as great
-     * @param {number} [options.resolution=1] - The resolution / device pixel ratio of the renderer.
-     *  The resolution of the renderer retina would be 2.
-     * @param {boolean} [options.clearBeforeRender=true] - This sets if the renderer will clear
-     *  the canvas or not before the new render pass. If you wish to set this to false, you *must* set
-     *  preserveDrawingBuffer to `true`.
-     * @param {boolean} [options.preserveDrawingBuffer=false] - enables drawing buffer preservation,
-     *  enable this if you need to call toDataUrl on the webgl context.
-     * @param {boolean} [options.roundPixels=false] - If true PixiJS will Math.floor() x/y values when
-     *  rendering, stopping pixel interpolation.
-     * @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area
-     *  (shown if not transparent).
-     * @param {boolean} [options.legacy=false] - If true PixiJS will aim to ensure compatibility
-     * with older / less advanced devices. If you experiance unexplained flickering try setting this to true.
-     */
-    function WebGLRenderer(options, arg2, arg3) {
-        _classCallCheck(this, WebGLRenderer);
-
-        var _this = _possibleConstructorReturn(this, _SystemRenderer.call(this, 'WebGL', options, arg2, arg3));
-
-        _this.legacy = _this.options.legacy;
-
-        if (_this.legacy) {
-            _pixiGlCore2.default.VertexArrayObject.FORCE_NATIVE = true;
-        }
-
-        /**
-         * The type of this renderer as a standardised const
-         *
-         * @member {number}
-         * @see PIXI.RENDERER_TYPE
-         */
-        _this.type = _const.RENDERER_TYPE.WEBGL;
-
-        _this.handleContextLost = _this.handleContextLost.bind(_this);
-        _this.handleContextRestored = _this.handleContextRestored.bind(_this);
-
-        _this.view.addEventListener('webglcontextlost', _this.handleContextLost, false);
-        _this.view.addEventListener('webglcontextrestored', _this.handleContextRestored, false);
-
-        /**
-         * The options passed in to create a new webgl context.
-         *
-         * @member {object}
-         * @private
-         */
-        _this._contextOptions = {
-            alpha: _this.transparent,
-            antialias: _this.options.antialias,
-            premultipliedAlpha: _this.transparent && _this.transparent !== 'notMultiplied',
-            stencil: true,
-            preserveDrawingBuffer: _this.options.preserveDrawingBuffer
-        };
-
-        _this._backgroundColorRgba[3] = _this.transparent ? 0 : 1;
-
-        /**
-         * Manages the masks using the stencil buffer.
-         *
-         * @member {PIXI.MaskManager}
-         */
-        _this.maskManager = new _MaskManager2.default(_this);
-
-        /**
-         * Manages the stencil buffer.
-         *
-         * @member {PIXI.StencilManager}
-         */
-        _this.stencilManager = new _StencilManager2.default(_this);
-
-        /**
-         * An empty renderer.
-         *
-         * @member {PIXI.ObjectRenderer}
-         */
-        _this.emptyRenderer = new _ObjectRenderer2.default(_this);
-
-        /**
-         * The currently active ObjectRenderer.
-         *
-         * @member {PIXI.ObjectRenderer}
-         */
-        _this.currentRenderer = _this.emptyRenderer;
-
-        _this.initPlugins();
-
-        /**
-         * The current WebGL rendering context, it is created here
-         *
-         * @member {WebGLRenderingContext}
-         */
-        // initialize the context so it is ready for the managers.
-        if (_this.options.context) {
-            // checks to see if a context is valid..
-            (0, _validateContext2.default)(_this.options.context);
-        }
-
-        _this.gl = _this.options.context || _pixiGlCore2.default.createContext(_this.view, _this._contextOptions);
-
-        _this.CONTEXT_UID = CONTEXT_UID++;
-
-        /**
-         * The currently active ObjectRenderer.
-         *
-         * @member {PIXI.WebGLState}
-         */
-        _this.state = new _WebGLState2.default(_this.gl);
-
-        _this.renderingToScreen = true;
-
-        /**
-         * Holds the current state of textures bound to the GPU.
-         * @type {Array}
-         */
-        _this.boundTextures = null;
-
-        /**
-         * Holds the current shader
-         *
-         * @member {PIXI.Shader}
-         */
-        _this._activeShader = null;
-
-        _this._activeVao = null;
-
-        /**
-         * Holds the current render target
-         *
-         * @member {PIXI.RenderTarget}
-         */
-        _this._activeRenderTarget = null;
-
-        _this._initContext();
-
-        /**
-         * Manages the filters.
-         *
-         * @member {PIXI.FilterManager}
-         */
-        _this.filterManager = new _FilterManager2.default(_this);
-        // map some webGL blend and drawmodes..
-        _this.drawModes = (0, _mapWebGLDrawModesToPixi2.default)(_this.gl);
-
-        _this._nextTextureLocation = 0;
-
-        _this.setBlendMode(0);
-
-        /**
-         * Fired after rendering finishes.
-         *
-         * @event PIXI.WebGLRenderer#postrender
-         */
-
-        /**
-         * Fired before rendering starts.
-         *
-         * @event PIXI.WebGLRenderer#prerender
-         */
-
-        /**
-         * Fired when the WebGL context is set.
-         *
-         * @event PIXI.WebGLRenderer#context
-         * @param {WebGLRenderingContext} gl - WebGL context.
-         */
-        return _this;
-    }
-
-    /**
-     * Creates the WebGL context
-     *
-     * @private
-     */
-
-
-    WebGLRenderer.prototype._initContext = function _initContext() {
-        var gl = this.gl;
-
-        // restore a context if it was previously lost
-        if (gl.isContextLost() && gl.getExtension('WEBGL_lose_context')) {
-            gl.getExtension('WEBGL_lose_context').restoreContext();
-        }
-
-        var maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
-
-        this._activeShader = null;
-        this._activeVao = null;
-
-        this.boundTextures = new Array(maxTextures);
-        this.emptyTextures = new Array(maxTextures);
-
-        // create a texture manager...
-        this.textureManager = new _TextureManager2.default(this);
-        this.textureGC = new _TextureGarbageCollector2.default(this);
-
-        this.state.resetToDefault();
-
-        this.rootRenderTarget = new _RenderTarget2.default(gl, this.width, this.height, null, this.resolution, true);
-        this.rootRenderTarget.clearColor = this._backgroundColorRgba;
-
-        this.bindRenderTarget(this.rootRenderTarget);
-
-        // now lets fill up the textures with empty ones!
-        var emptyGLTexture = new _pixiGlCore2.default.GLTexture.fromData(gl, null, 1, 1);
-
-        var tempObj = { _glTextures: {} };
-
-        tempObj._glTextures[this.CONTEXT_UID] = {};
-
-        for (var i = 0; i < maxTextures; i++) {
-            var empty = new _BaseTexture2.default();
-
-            empty._glTextures[this.CONTEXT_UID] = emptyGLTexture;
-
-            this.boundTextures[i] = tempObj;
-            this.emptyTextures[i] = empty;
-            this.bindTexture(null, i);
-        }
-
-        this.emit('context', gl);
-
-        // setup the width/height properties and gl viewport
-        this.resize(this.screen.width, this.screen.height);
-    };
-
-    /**
-     * Renders the object to its webGL view
-     *
-     * @param {PIXI.DisplayObject} displayObject - the object to be rendered
-     * @param {PIXI.RenderTexture} renderTexture - The render texture to render to.
-     * @param {boolean} [clear] - Should the canvas be cleared before the new render
-     * @param {PIXI.Transform} [transform] - A transform to apply to the render texture before rendering.
-     * @param {boolean} [skipUpdateTransform] - Should we skip the update transform pass?
-     */
-
-
-    WebGLRenderer.prototype.render = function render(displayObject, renderTexture, clear, transform, skipUpdateTransform) {
-        // can be handy to know!
-        this.renderingToScreen = !renderTexture;
-
-        this.emit('prerender');
-
-        // no point rendering if our context has been blown up!
-        if (!this.gl || this.gl.isContextLost()) {
-            return;
-        }
-
-        this._nextTextureLocation = 0;
-
-        if (!renderTexture) {
-            this._lastObjectRendered = displayObject;
-        }
-
-        if (!skipUpdateTransform) {
-            // update the scene graph
-            var cacheParent = displayObject.parent;
-
-            displayObject.parent = this._tempDisplayObjectParent;
-            displayObject.updateTransform();
-            displayObject.parent = cacheParent;
-            // displayObject.hitArea = //TODO add a temp hit area
-        }
-
-        this.bindRenderTexture(renderTexture, transform);
-
-        this.currentRenderer.start();
-
-        if (clear !== undefined ? clear : this.clearBeforeRender) {
-            this._activeRenderTarget.clear();
-        }
-
-        displayObject.renderWebGL(this);
-
-        // apply transform..
-        this.currentRenderer.flush();
-
-        // this.setObjectRenderer(this.emptyRenderer);
-
-        this.textureGC.update();
-
-        this.emit('postrender');
-    };
-
-    /**
-     * Changes the current renderer to the one given in parameter
-     *
-     * @param {PIXI.ObjectRenderer} objectRenderer - The object renderer to use.
-     */
-
-
-    WebGLRenderer.prototype.setObjectRenderer = function setObjectRenderer(objectRenderer) {
-        if (this.currentRenderer === objectRenderer) {
-            return;
-        }
-
-        this.currentRenderer.stop();
-        this.currentRenderer = objectRenderer;
-        this.currentRenderer.start();
-    };
-
-    /**
-     * This should be called if you wish to do some custom rendering
-     * It will basically render anything that may be batched up such as sprites
-     *
-     */
-
-
-    WebGLRenderer.prototype.flush = function flush() {
-        this.setObjectRenderer(this.emptyRenderer);
-    };
-
-    /**
-     * Resizes the webGL view to the specified width and height.
-     *
-     * @param {number} screenWidth - the new width of the screen
-     * @param {number} screenHeight - the new height of the screen
-     */
-
-
-    WebGLRenderer.prototype.resize = function resize(screenWidth, screenHeight) {
-        //  if(width * this.resolution === this.width && height * this.resolution === this.height)return;
-
-        _SystemRenderer3.default.prototype.resize.call(this, screenWidth, screenHeight);
-
-        this.rootRenderTarget.resize(screenWidth, screenHeight);
-
-        if (this._activeRenderTarget === this.rootRenderTarget) {
-            this.rootRenderTarget.activate();
-
-            if (this._activeShader) {
-                this._activeShader.uniforms.projectionMatrix = this.rootRenderTarget.projectionMatrix.toArray(true);
-            }
-        }
-    };
-
-    /**
-     * Resizes the webGL view to the specified width and height.
-     *
-     * @param {number} blendMode - the desired blend mode
-     */
-
-
-    WebGLRenderer.prototype.setBlendMode = function setBlendMode(blendMode) {
-        this.state.setBlendMode(blendMode);
-    };
-
-    /**
-     * Erases the active render target and fills the drawing area with a colour
-     *
-     * @param {number} [clearColor] - The colour
-     */
-
-
-    WebGLRenderer.prototype.clear = function clear(clearColor) {
-        this._activeRenderTarget.clear(clearColor);
-    };
-
-    /**
-     * Sets the transform of the active render target to the given matrix
-     *
-     * @param {PIXI.Matrix} matrix - The transformation matrix
-     */
-
-
-    WebGLRenderer.prototype.setTransform = function setTransform(matrix) {
-        this._activeRenderTarget.transform = matrix;
-    };
-
-    /**
-     * Erases the render texture and fills the drawing area with a colour
-     *
-     * @param {PIXI.RenderTexture} renderTexture - The render texture to clear
-     * @param {number} [clearColor] - The colour
-     * @return {PIXI.WebGLRenderer} Returns itself.
-     */
-
-
-    WebGLRenderer.prototype.clearRenderTexture = function clearRenderTexture(renderTexture, clearColor) {
-        var baseTexture = renderTexture.baseTexture;
-        var renderTarget = baseTexture._glRenderTargets[this.CONTEXT_UID];
-
-        if (renderTarget) {
-            renderTarget.clear(clearColor);
-        }
-
-        return this;
-    };
-
-    /**
-     * Binds a render texture for rendering
-     *
-     * @param {PIXI.RenderTexture} renderTexture - The render texture to render
-     * @param {PIXI.Transform} transform - The transform to be applied to the render texture
-     * @return {PIXI.WebGLRenderer} Returns itself.
-     */
-
-
-    WebGLRenderer.prototype.bindRenderTexture = function bindRenderTexture(renderTexture, transform) {
-        var renderTarget = void 0;
-
-        if (renderTexture) {
-            var baseTexture = renderTexture.baseTexture;
-
-            if (!baseTexture._glRenderTargets[this.CONTEXT_UID]) {
-                // bind the current texture
-                this.textureManager.updateTexture(baseTexture, 0);
-            }
-
-            this.unbindTexture(baseTexture);
-
-            renderTarget = baseTexture._glRenderTargets[this.CONTEXT_UID];
-            renderTarget.setFrame(renderTexture.frame);
-        } else {
-            renderTarget = this.rootRenderTarget;
-        }
-
-        renderTarget.transform = transform;
-        this.bindRenderTarget(renderTarget);
-
-        return this;
-    };
-
-    /**
-     * Changes the current render target to the one given in parameter
-     *
-     * @param {PIXI.RenderTarget} renderTarget - the new render target
-     * @return {PIXI.WebGLRenderer} Returns itself.
-     */
-
-
-    WebGLRenderer.prototype.bindRenderTarget = function bindRenderTarget(renderTarget) {
-        if (renderTarget !== this._activeRenderTarget) {
-            this._activeRenderTarget = renderTarget;
-            renderTarget.activate();
-
-            if (this._activeShader) {
-                this._activeShader.uniforms.projectionMatrix = renderTarget.projectionMatrix.toArray(true);
-            }
-
-            this.stencilManager.setMaskStack(renderTarget.stencilMaskStack);
-        }
-
-        return this;
-    };
-
-    /**
-     * Changes the current shader to the one given in parameter
-     *
-     * @param {PIXI.Shader} shader - the new shader
-     * @param {boolean} [autoProject=true] - Whether automatically set the projection matrix
-     * @return {PIXI.WebGLRenderer} Returns itself.
-     */
-
-
-    WebGLRenderer.prototype.bindShader = function bindShader(shader, autoProject) {
-        // TODO cache
-        if (this._activeShader !== shader) {
-            this._activeShader = shader;
-            shader.bind();
-
-            // `autoProject` normally would be a default parameter set to true
-            // but because of how Babel transpiles default parameters
-            // it hinders the performance of this method.
-            if (autoProject !== false) {
-                // automatically set the projection matrix
-                shader.uniforms.projectionMatrix = this._activeRenderTarget.projectionMatrix.toArray(true);
-            }
-        }
-
-        return this;
-    };
-
-    /**
-     * Binds the texture. This will return the location of the bound texture.
-     * It may not be the same as the one you pass in. This is due to optimisation that prevents
-     * needless binding of textures. For example if the texture is already bound it will return the
-     * current location of the texture instead of the one provided. To bypass this use force location
-     *
-     * @param {PIXI.Texture} texture - the new texture
-     * @param {number} location - the suggested texture location
-     * @param {boolean} forceLocation - force the location
-     * @return {number} bound texture location
-     */
-
-
-    WebGLRenderer.prototype.bindTexture = function bindTexture(texture, location, forceLocation) {
-        texture = texture || this.emptyTextures[location];
-        texture = texture.baseTexture || texture;
-        texture.touched = this.textureGC.count;
-
-        if (!forceLocation) {
-            // TODO - maybe look into adding boundIds.. save us the loop?
-            for (var i = 0; i < this.boundTextures.length; i++) {
-                if (this.boundTextures[i] === texture) {
-                    return i;
-                }
-            }
-
-            if (location === undefined) {
-                this._nextTextureLocation++;
-                this._nextTextureLocation %= this.boundTextures.length;
-                location = this.boundTextures.length - this._nextTextureLocation - 1;
-            }
-        } else {
-            location = location || 0;
-        }
-
-        var gl = this.gl;
-        var glTexture = texture._glTextures[this.CONTEXT_UID];
-
-        if (!glTexture) {
-            // this will also bind the texture..
-            this.textureManager.updateTexture(texture, location);
-        } else {
-            // bind the current texture
-            this.boundTextures[location] = texture;
-            gl.activeTexture(gl.TEXTURE0 + location);
-            gl.bindTexture(gl.TEXTURE_2D, glTexture.texture);
-        }
-
-        return location;
-    };
-
-    /**
-    * unbinds the texture ...
-    *
-    * @param {PIXI.Texture} texture - the texture to unbind
-    * @return {PIXI.WebGLRenderer} Returns itself.
-    */
-
-
-    WebGLRenderer.prototype.unbindTexture = function unbindTexture(texture) {
-        var gl = this.gl;
-
-        texture = texture.baseTexture || texture;
-
-        for (var i = 0; i < this.boundTextures.length; i++) {
-            if (this.boundTextures[i] === texture) {
-                this.boundTextures[i] = this.emptyTextures[i];
-
-                gl.activeTexture(gl.TEXTURE0 + i);
-                gl.bindTexture(gl.TEXTURE_2D, this.emptyTextures[i]._glTextures[this.CONTEXT_UID].texture);
-            }
-        }
-
-        return this;
-    };
-
-    /**
-     * Creates a new VAO from this renderer's context and state.
-     *
-     * @return {VertexArrayObject} The new VAO.
-     */
-
-
-    WebGLRenderer.prototype.createVao = function createVao() {
-        return new _pixiGlCore2.default.VertexArrayObject(this.gl, this.state.attribState);
-    };
-
-    /**
-     * Changes the current Vao to the one given in parameter
-     *
-     * @param {PIXI.VertexArrayObject} vao - the new Vao
-     * @return {PIXI.WebGLRenderer} Returns itself.
-     */
-
-
-    WebGLRenderer.prototype.bindVao = function bindVao(vao) {
-        if (this._activeVao === vao) {
-            return this;
-        }
-
-        if (vao) {
-            vao.bind();
-        } else if (this._activeVao) {
-            // TODO this should always be true i think?
-            this._activeVao.unbind();
-        }
-
-        this._activeVao = vao;
-
-        return this;
-    };
-
-    /**
-     * Resets the WebGL state so you can render things however you fancy!
-     *
-     * @return {PIXI.WebGLRenderer} Returns itself.
-     */
-
-
-    WebGLRenderer.prototype.reset = function reset() {
-        this.setObjectRenderer(this.emptyRenderer);
-
-        this._activeShader = null;
-        this._activeRenderTarget = this.rootRenderTarget;
-
-        // bind the main frame buffer (the screen);
-        this.rootRenderTarget.activate();
-
-        this.state.resetToDefault();
-
-        return this;
-    };
-
-    /**
-     * Handles a lost webgl context
-     *
-     * @private
-     * @param {WebGLContextEvent} event - The context lost event.
-     */
-
-
-    WebGLRenderer.prototype.handleContextLost = function handleContextLost(event) {
-        event.preventDefault();
-    };
-
-    /**
-     * Handles a restored webgl context
-     *
-     * @private
-     */
-
-
-    WebGLRenderer.prototype.handleContextRestored = function handleContextRestored() {
-        this.textureManager.removeAll();
-        this._initContext();
-    };
-
-    /**
-     * Removes everything from the renderer (event listeners, spritebatch, etc...)
-     *
-     * @param {boolean} [removeView=false] - Removes the Canvas element from the DOM.
-     *  See: https://github.com/pixijs/pixi.js/issues/2233
-     */
-
-
-    WebGLRenderer.prototype.destroy = function destroy(removeView) {
-        this.destroyPlugins();
-
-        // remove listeners
-        this.view.removeEventListener('webglcontextlost', this.handleContextLost);
-        this.view.removeEventListener('webglcontextrestored', this.handleContextRestored);
-
-        this.textureManager.destroy();
-
-        // call base destroy
-        _SystemRenderer.prototype.destroy.call(this, removeView);
-
-        this.uid = 0;
-
-        // destroy the managers
-        this.maskManager.destroy();
-        this.stencilManager.destroy();
-        this.filterManager.destroy();
-
-        this.maskManager = null;
-        this.filterManager = null;
-        this.textureManager = null;
-        this.currentRenderer = null;
-
-        this.handleContextLost = null;
-        this.handleContextRestored = null;
-
-        this._contextOptions = null;
-        this.gl.useProgram(null);
-
-        if (this.gl.getExtension('WEBGL_lose_context')) {
-            this.gl.getExtension('WEBGL_lose_context').loseContext();
-        }
-
-        this.gl = null;
-
-        // this = null;
-    };
-
-    return WebGLRenderer;
-}(_SystemRenderer3.default);
-
-/**
- * Collection of installed plugins. These are included by default in PIXI, but can be excluded
- * by creating a custom build. Consult the README for more information about creating custom
- * builds and excluding plugins.
- * @name PIXI.WebGLRenderer#plugins
- * @type {object}
- * @readonly
- * @property {PIXI.accessibility.AccessibilityManager} accessibility Support tabbing interactive elements.
- * @property {PIXI.extract.WebGLExtract} extract Extract image data from renderer.
- * @property {PIXI.interaction.InteractionManager} interaction Handles mouse, touch and pointer events.
- * @property {PIXI.prepare.WebGLPrepare} prepare Pre-render display objects.
- */
-
-/**
- * Adds a plugin to the renderer.
- *
- * @method PIXI.WebGLRenderer#registerPlugin
- * @param {string} pluginName - The name of the plugin.
- * @param {Function} ctor - The constructor function or class for the plugin.
- */
-
-exports.default = WebGLRenderer;
-_utils.pluginTarget.mixin(WebGLRenderer);
-
-},{"../../const":46,"../../textures/BaseTexture":112,"../../utils":124,"../SystemRenderer":76,"./TextureGarbageCollector":82,"./TextureManager":83,"./WebGLState":85,"./managers/FilterManager":90,"./managers/MaskManager":91,"./managers/StencilManager":92,"./utils/ObjectRenderer":94,"./utils/RenderTarget":96,"./utils/mapWebGLDrawModesToPixi":99,"./utils/validateContext":100,"pixi-gl-core":12}],85:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _mapWebGLBlendModesToPixi = require('./utils/mapWebGLBlendModesToPixi');
-
-var _mapWebGLBlendModesToPixi2 = _interopRequireDefault(_mapWebGLBlendModesToPixi);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var BLEND = 0;
-var DEPTH_TEST = 1;
-var FRONT_FACE = 2;
-var CULL_FACE = 3;
-var BLEND_FUNC = 4;
-
-/**
- * A WebGL state machines
- *
- * @memberof PIXI
- * @class
- */
-
-var WebGLState = function () {
-    /**
-     * @param {WebGLRenderingContext} gl - The current WebGL rendering context
-     */
-    function WebGLState(gl) {
-        _classCallCheck(this, WebGLState);
-
-        /**
-         * The current active state
-         *
-         * @member {Uint8Array}
-         */
-        this.activeState = new Uint8Array(16);
-
-        /**
-         * The default state
-         *
-         * @member {Uint8Array}
-         */
-        this.defaultState = new Uint8Array(16);
-
-        // default blend mode..
-        this.defaultState[0] = 1;
-
-        /**
-         * The current state index in the stack
-         *
-         * @member {number}
-         * @private
-         */
-        this.stackIndex = 0;
-
-        /**
-         * The stack holding all the different states
-         *
-         * @member {Array<*>}
-         * @private
-         */
-        this.stack = [];
-
-        /**
-         * The current WebGL rendering context
-         *
-         * @member {WebGLRenderingContext}
-         */
-        this.gl = gl;
-
-        this.maxAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
-
-        this.attribState = {
-            tempAttribState: new Array(this.maxAttribs),
-            attribState: new Array(this.maxAttribs)
-        };
-
-        this.blendModes = (0, _mapWebGLBlendModesToPixi2.default)(gl);
-
-        // check we have vao..
-        this.nativeVaoExtension = gl.getExtension('OES_vertex_array_object') || gl.getExtension('MOZ_OES_vertex_array_object') || gl.getExtension('WEBKIT_OES_vertex_array_object');
-    }
-
-    /**
-     * Pushes a new active state
-     */
-
-
-    WebGLState.prototype.push = function push() {
-        // next state..
-        var state = this.stack[this.stackIndex];
-
-        if (!state) {
-            state = this.stack[this.stackIndex] = new Uint8Array(16);
-        }
-
-        ++this.stackIndex;
-
-        // copy state..
-        // set active state so we can force overrides of gl state
-        for (var i = 0; i < this.activeState.length; i++) {
-            state[i] = this.activeState[i];
-        }
-    };
-
-    /**
-     * Pops a state out
-     */
-
-
-    WebGLState.prototype.pop = function pop() {
-        var state = this.stack[--this.stackIndex];
-
-        this.setState(state);
-    };
-
-    /**
-     * Sets the current state
-     *
-     * @param {*} state - The state to set.
-     */
-
-
-    WebGLState.prototype.setState = function setState(state) {
-        this.setBlend(state[BLEND]);
-        this.setDepthTest(state[DEPTH_TEST]);
-        this.setFrontFace(state[FRONT_FACE]);
-        this.setCullFace(state[CULL_FACE]);
-        this.setBlendMode(state[BLEND_FUNC]);
-    };
-
-    /**
-     * Enables or disabled blending.
-     *
-     * @param {boolean} value - Turn on or off webgl blending.
-     */
-
-
-    WebGLState.prototype.setBlend = function setBlend(value) {
-        value = value ? 1 : 0;
-
-        if (this.activeState[BLEND] === value) {
-            return;
-        }
-
-        this.activeState[BLEND] = value;
-        this.gl[value ? 'enable' : 'disable'](this.gl.BLEND);
-    };
-
-    /**
-     * Sets the blend mode.
-     *
-     * @param {number} value - The blend mode to set to.
-     */
-
-
-    WebGLState.prototype.setBlendMode = function setBlendMode(value) {
-        if (value === this.activeState[BLEND_FUNC]) {
-            return;
-        }
-
-        this.activeState[BLEND_FUNC] = value;
-
-        var mode = this.blendModes[value];
-
-        if (mode.length === 2) {
-            this.gl.blendFunc(mode[0], mode[1]);
-        } else {
-            this.gl.blendFuncSeparate(mode[0], mode[1], mode[2], mode[3]);
-        }
-    };
-
-    /**
-     * Sets whether to enable or disable depth test.
-     *
-     * @param {boolean} value - Turn on or off webgl depth testing.
-     */
-
-
-    WebGLState.prototype.setDepthTest = function setDepthTest(value) {
-        value = value ? 1 : 0;
-
-        if (this.activeState[DEPTH_TEST] === value) {
-            return;
-        }
-
-        this.activeState[DEPTH_TEST] = value;
-        this.gl[value ? 'enable' : 'disable'](this.gl.DEPTH_TEST);
-    };
-
-    /**
-     * Sets whether to enable or disable cull face.
-     *
-     * @param {boolean} value - Turn on or off webgl cull face.
-     */
-
-
-    WebGLState.prototype.setCullFace = function setCullFace(value) {
-        value = value ? 1 : 0;
-
-        if (this.activeState[CULL_FACE] === value) {
-            return;
-        }
-
-        this.activeState[CULL_FACE] = value;
-        this.gl[value ? 'enable' : 'disable'](this.gl.CULL_FACE);
-    };
-
-    /**
-     * Sets the gl front face.
-     *
-     * @param {boolean} value - true is clockwise and false is counter-clockwise
-     */
-
-
-    WebGLState.prototype.setFrontFace = function setFrontFace(value) {
-        value = value ? 1 : 0;
-
-        if (this.activeState[FRONT_FACE] === value) {
-            return;
-        }
-
-        this.activeState[FRONT_FACE] = value;
-        this.gl.frontFace(this.gl[value ? 'CW' : 'CCW']);
-    };
-
-    /**
-     * Disables all the vaos in use
-     *
-     */
-
-
-    WebGLState.prototype.resetAttributes = function resetAttributes() {
-        for (var i = 0; i < this.attribState.tempAttribState.length; i++) {
-            this.attribState.tempAttribState[i] = 0;
-        }
-
-        for (var _i = 0; _i < this.attribState.attribState.length; _i++) {
-            this.attribState.attribState[_i] = 0;
-        }
-
-        // im going to assume one is always active for performance reasons.
-        for (var _i2 = 1; _i2 < this.maxAttribs; _i2++) {
-            this.gl.disableVertexAttribArray(_i2);
-        }
-    };
-
-    // used
-    /**
-     * Resets all the logic and disables the vaos
-     */
-
-
-    WebGLState.prototype.resetToDefault = function resetToDefault() {
-        // unbind any VAO if they exist..
-        if (this.nativeVaoExtension) {
-            this.nativeVaoExtension.bindVertexArrayOES(null);
-        }
-
-        // reset all attributes..
-        this.resetAttributes();
-
-        // set active state so we can force overrides of gl state
-        for (var i = 0; i < this.activeState.length; ++i) {
-            this.activeState[i] = 32;
-        }
-
-        this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, false);
-
-        this.setState(this.defaultState);
-    };
-
-    return WebGLState;
-}();
-
-exports.default = WebGLState;
-
-},{"./utils/mapWebGLBlendModesToPixi":98}],86:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _extractUniformsFromSrc = require('./extractUniformsFromSrc');
-
-var _extractUniformsFromSrc2 = _interopRequireDefault(_extractUniformsFromSrc);
-
-var _utils = require('../../../utils');
-
-var _const = require('../../../const');
-
-var _settings = require('../../../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var SOURCE_KEY_MAP = {};
-
-// let math = require('../../../math');
-/**
- * @class
- * @memberof PIXI
- * @extends PIXI.Shader
- */
-
-var Filter = function () {
-  /**
-   * @param {string} [vertexSrc] - The source of the vertex shader.
-   * @param {string} [fragmentSrc] - The source of the fragment shader.
-   * @param {object} [uniforms] - Custom uniforms to use to augment the built-in ones.
-   */
-  function Filter(vertexSrc, fragmentSrc, uniforms) {
-    _classCallCheck(this, Filter);
-
-    /**
-     * The vertex shader.
-     *
-     * @member {string}
-     */
-    this.vertexSrc = vertexSrc || Filter.defaultVertexSrc;
-
-    /**
-     * The fragment shader.
-     *
-     * @member {string}
-     */
-    this.fragmentSrc = fragmentSrc || Filter.defaultFragmentSrc;
-
-    this._blendMode = _const.BLEND_MODES.NORMAL;
-
-    this.uniformData = uniforms || (0, _extractUniformsFromSrc2.default)(this.vertexSrc, this.fragmentSrc, 'projectionMatrix|uSampler');
-
-    /**
-     * An object containing the current values of custom uniforms.
-     * @example <caption>Updating the value of a custom uniform</caption>
-     * filter.uniforms.time = performance.now();
-     *
-     * @member {object}
-     */
-    this.uniforms = {};
-
-    for (var i in this.uniformData) {
-      this.uniforms[i] = this.uniformData[i].value;
-    }
-
-    // this is where we store shader references..
-    // TODO we could cache this!
-    this.glShaders = {};
-
-    // used for cacheing.. sure there is a better way!
-    if (!SOURCE_KEY_MAP[this.vertexSrc + this.fragmentSrc]) {
-      SOURCE_KEY_MAP[this.vertexSrc + this.fragmentSrc] = (0, _utils.uid)();
-    }
-
-    this.glShaderKey = SOURCE_KEY_MAP[this.vertexSrc + this.fragmentSrc];
-
-    /**
-     * The padding of the filter. Some filters require extra space to breath such as a blur.
-     * Increasing this will add extra width and height to the bounds of the object that the
-     * filter is applied to.
-     *
-     * @member {number}
-     */
-    this.padding = 4;
-
-    /**
-     * The resolution of the filter. Setting this to be lower will lower the quality but
-     * increase the performance of the filter.
-     *
-     * @member {number}
-     */
-    this.resolution = _settings2.default.RESOLUTION;
-
-    /**
-     * If enabled is true the filter is applied, if false it will not.
-     *
-     * @member {boolean}
-     */
-    this.enabled = true;
-
-    /**
-     * If enabled, PixiJS will fit the filter area into boundaries for better performance.
-     * Switch it off if it does not work for specific shader.
-     *
-     * @member {boolean}
-     */
-    this.autoFit = true;
-  }
-
-  /**
-   * Applies the filter
-   *
-   * @param {PIXI.FilterManager} filterManager - The renderer to retrieve the filter from
-   * @param {PIXI.RenderTarget} input - The input render target.
-   * @param {PIXI.RenderTarget} output - The target to output to.
-   * @param {boolean} clear - Should the output be cleared before rendering to it
-   * @param {object} [currentState] - It's current state of filter.
-   *        There are some useful properties in the currentState :
-   *        target, filters, sourceFrame, destinationFrame, renderTarget, resolution
-   */
-
-
-  Filter.prototype.apply = function apply(filterManager, input, output, clear, currentState) // eslint-disable-line no-unused-vars
-  {
-    // --- //
-    //  this.uniforms.filterMatrix = filterManager.calculateSpriteMatrix(tempMatrix, window.panda );
-
-    // do as you please!
-
-    filterManager.applyFilter(this, input, output, clear);
-
-    // or just do a regular render..
-  };
-
-  /**
-   * Sets the blendmode of the filter
-   *
-   * @member {number}
-   * @default PIXI.BLEND_MODES.NORMAL
-   */
-
-
-  _createClass(Filter, [{
-    key: 'blendMode',
-    get: function get() {
-      return this._blendMode;
-    },
-    set: function set(value) // eslint-disable-line require-jsdoc
-    {
-      this._blendMode = value;
-    }
-
-    /**
-     * The default vertex shader source
-     *
-     * @static
-     * @constant
-     */
-
-  }], [{
-    key: 'defaultVertexSrc',
-    get: function get() {
-      return ['attribute vec2 aVertexPosition;', 'attribute vec2 aTextureCoord;', 'uniform mat3 projectionMatrix;', 'uniform mat3 filterMatrix;', 'varying vec2 vTextureCoord;', 'varying vec2 vFilterCoord;', 'void main(void){', '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);', '   vFilterCoord = ( filterMatrix * vec3( aTextureCoord, 1.0)  ).xy;', '   vTextureCoord = aTextureCoord ;', '}'].join('\n');
-    }
-
-    /**
-     * The default fragment shader source
-     *
-     * @static
-     * @constant
-     */
-
-  }, {
-    key: 'defaultFragmentSrc',
-    get: function get() {
-      return ['varying vec2 vTextureCoord;', 'varying vec2 vFilterCoord;', 'uniform sampler2D uSampler;', 'uniform sampler2D filterSampler;', 'void main(void){', '   vec4 masky = texture2D(filterSampler, vFilterCoord);', '   vec4 sample = texture2D(uSampler, vTextureCoord);', '   vec4 color;', '   if(mod(vFilterCoord.x, 1.0) > 0.5)', '   {', '     color = vec4(1.0, 0.0, 0.0, 1.0);', '   }', '   else', '   {', '     color = vec4(0.0, 1.0, 0.0, 1.0);', '   }',
-      // '   gl_FragColor = vec4(mod(vFilterCoord.x, 1.5), vFilterCoord.y,0.0,1.0);',
-      '   gl_FragColor = mix(sample, masky, 0.5);', '   gl_FragColor *= sample.a;', '}'].join('\n');
-    }
-  }]);
-
-  return Filter;
-}();
-
-exports.default = Filter;
-
-},{"../../../const":46,"../../../settings":101,"../../../utils":124,"./extractUniformsFromSrc":87}],87:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = extractUniformsFromSrc;
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var defaultValue = _pixiGlCore2.default.shader.defaultValue;
-
-function extractUniformsFromSrc(vertexSrc, fragmentSrc, mask) {
-    var vertUniforms = extractUniformsFromString(vertexSrc, mask);
-    var fragUniforms = extractUniformsFromString(fragmentSrc, mask);
-
-    return Object.assign(vertUniforms, fragUniforms);
-}
-
-function extractUniformsFromString(string) {
-    var maskRegex = new RegExp('^(projectionMatrix|uSampler|filterArea|filterClamp)$');
-
-    var uniforms = {};
-    var nameSplit = void 0;
-
-    // clean the lines a little - remove extra spaces / tabs etc
-    // then split along ';'
-    var lines = string.replace(/\s+/g, ' ').split(/\s*;\s*/);
-
-    // loop through..
-    for (var i = 0; i < lines.length; i++) {
-        var line = lines[i].trim();
-
-        if (line.indexOf('uniform') > -1) {
-            var splitLine = line.split(' ');
-            var type = splitLine[1];
-
-            var name = splitLine[2];
-            var size = 1;
-
-            if (name.indexOf('[') > -1) {
-                // array!
-                nameSplit = name.split(/\[|]/);
-                name = nameSplit[0];
-                size *= Number(nameSplit[1]);
-            }
-
-            if (!name.match(maskRegex)) {
-                uniforms[name] = {
-                    value: defaultValue(type, size),
-                    name: name,
-                    type: type
-                };
-            }
-        }
-    }
-
-    return uniforms;
-}
-
-},{"pixi-gl-core":12}],88:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.calculateScreenSpaceMatrix = calculateScreenSpaceMatrix;
-exports.calculateNormalizedScreenSpaceMatrix = calculateNormalizedScreenSpaceMatrix;
-exports.calculateSpriteMatrix = calculateSpriteMatrix;
-
-var _math = require('../../../math');
-
-/**
- * Calculates the mapped matrix
- * @param filterArea {Rectangle} The filter area
- * @param sprite {Sprite} the target sprite
- * @param outputMatrix {Matrix} @alvin
- */
-// TODO playing around here.. this is temporary - (will end up in the shader)
-// this returns a matrix that will normalise map filter cords in the filter to screen space
-function calculateScreenSpaceMatrix(outputMatrix, filterArea, textureSize) {
-    // let worldTransform = sprite.worldTransform.copy(Matrix.TEMP_MATRIX),
-    // let texture = {width:1136, height:700};//sprite._texture.baseTexture;
-
-    // TODO unwrap?
-    var mappedMatrix = outputMatrix.identity();
-
-    mappedMatrix.translate(filterArea.x / textureSize.width, filterArea.y / textureSize.height);
-
-    mappedMatrix.scale(textureSize.width, textureSize.height);
-
-    return mappedMatrix;
-}
-
-function calculateNormalizedScreenSpaceMatrix(outputMatrix, filterArea, textureSize) {
-    var mappedMatrix = outputMatrix.identity();
-
-    mappedMatrix.translate(filterArea.x / textureSize.width, filterArea.y / textureSize.height);
-
-    var translateScaleX = textureSize.width / filterArea.width;
-    var translateScaleY = textureSize.height / filterArea.height;
-
-    mappedMatrix.scale(translateScaleX, translateScaleY);
-
-    return mappedMatrix;
-}
-
-// this will map the filter coord so that a texture can be used based on the transform of a sprite
-function calculateSpriteMatrix(outputMatrix, filterArea, textureSize, sprite) {
-    var worldTransform = sprite.worldTransform.copy(_math.Matrix.TEMP_MATRIX);
-    var texture = sprite._texture.baseTexture;
-
-    // TODO unwrap?
-    var mappedMatrix = outputMatrix.identity();
-
-    // scale..
-    var ratio = textureSize.height / textureSize.width;
-
-    mappedMatrix.translate(filterArea.x / textureSize.width, filterArea.y / textureSize.height);
-
-    mappedMatrix.scale(1, ratio);
-
-    var translateScaleX = textureSize.width / texture.width;
-    var translateScaleY = textureSize.height / texture.height;
-
-    worldTransform.tx /= texture.width * translateScaleX;
-
-    // this...?  free beer for anyone who can explain why this makes sense!
-    worldTransform.ty /= texture.width * translateScaleX;
-    // worldTransform.ty /= texture.height * translateScaleY;
-
-    worldTransform.invert();
-    mappedMatrix.prepend(worldTransform);
-
-    // apply inverse scale..
-    mappedMatrix.scale(1, 1 / ratio);
-
-    mappedMatrix.scale(translateScaleX, translateScaleY);
-
-    mappedMatrix.translate(sprite.anchor.x, sprite.anchor.y);
-
-    return mappedMatrix;
-}
-
-},{"../../../math":70}],89:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Filter2 = require('../Filter');
-
-var _Filter3 = _interopRequireDefault(_Filter2);
-
-var _math = require('../../../../math');
-
-var _path = require('path');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The SpriteMaskFilter class
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI
- */
-var SpriteMaskFilter = function (_Filter) {
-    _inherits(SpriteMaskFilter, _Filter);
-
-    /**
-     * @param {PIXI.Sprite} sprite - the target sprite
-     */
-    function SpriteMaskFilter(sprite) {
-        _classCallCheck(this, SpriteMaskFilter);
-
-        var maskMatrix = new _math.Matrix();
-
-        var _this = _possibleConstructorReturn(this, _Filter.call(this, 'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 otherMatrix;\n\nvarying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;\n}\n', 'varying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform float alpha;\nuniform sampler2D mask;\n\nvoid main(void)\n{\n    // check clip! this will stop the mask bleeding out from the edges\n    vec2 text = abs( vMaskCoord - 0.5 );\n    text = step(0.5, text);\n\n    float clip = 1.0 - max(text.y, text.x);\n    vec4 original = texture2D(uSampler, vTextureCoord);\n    vec4 masky = texture2D(mask, vMaskCoord);\n\n    original *= (masky.r * masky.a * alpha * clip);\n\n    gl_FragColor = original;\n}\n'));
-
-        sprite.renderable = false;
-
-        _this.maskSprite = sprite;
-        _this.maskMatrix = maskMatrix;
-        return _this;
-    }
-
-    /**
-     * Applies the filter
-     *
-     * @param {PIXI.FilterManager} filterManager - The renderer to retrieve the filter from
-     * @param {PIXI.RenderTarget} input - The input render target.
-     * @param {PIXI.RenderTarget} output - The target to output to.
-     */
-
-
-    SpriteMaskFilter.prototype.apply = function apply(filterManager, input, output) {
-        var maskSprite = this.maskSprite;
-
-        this.uniforms.mask = maskSprite._texture;
-        this.uniforms.otherMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, maskSprite);
-        this.uniforms.alpha = maskSprite.worldAlpha;
-
-        filterManager.applyFilter(this, input, output);
-    };
-
-    return SpriteMaskFilter;
-}(_Filter3.default);
-
-exports.default = SpriteMaskFilter;
-
-},{"../../../../math":70,"../Filter":86,"path":23}],90:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _WebGLManager2 = require('./WebGLManager');
-
-var _WebGLManager3 = _interopRequireDefault(_WebGLManager2);
-
-var _RenderTarget = require('../utils/RenderTarget');
-
-var _RenderTarget2 = _interopRequireDefault(_RenderTarget);
-
-var _Quad = require('../utils/Quad');
-
-var _Quad2 = _interopRequireDefault(_Quad);
-
-var _math = require('../../../math');
-
-var _Shader = require('../../../Shader');
-
-var _Shader2 = _interopRequireDefault(_Shader);
-
-var _filterTransforms = require('../filters/filterTransforms');
-
-var filterTransforms = _interopRequireWildcard(_filterTransforms);
-
-var _bitTwiddle = require('bit-twiddle');
-
-var _bitTwiddle2 = _interopRequireDefault(_bitTwiddle);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @ignore
- * @class
- */
-var FilterState =
-/**
- *
- */
-function FilterState() {
-    _classCallCheck(this, FilterState);
-
-    this.renderTarget = null;
-    this.sourceFrame = new _math.Rectangle();
-    this.destinationFrame = new _math.Rectangle();
-    this.filters = [];
-    this.target = null;
-    this.resolution = 1;
-};
-
-/**
- * @class
- * @memberof PIXI
- * @extends PIXI.WebGLManager
- */
-
-
-var FilterManager = function (_WebGLManager) {
-    _inherits(FilterManager, _WebGLManager);
-
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - The renderer this manager works for.
-     */
-    function FilterManager(renderer) {
-        _classCallCheck(this, FilterManager);
-
-        var _this = _possibleConstructorReturn(this, _WebGLManager.call(this, renderer));
-
-        _this.gl = _this.renderer.gl;
-        // know about sprites!
-        _this.quad = new _Quad2.default(_this.gl, renderer.state.attribState);
-
-        _this.shaderCache = {};
-        // todo add default!
-        _this.pool = {};
-
-        _this.filterData = null;
-        return _this;
-    }
-
-    /**
-     * Adds a new filter to the manager.
-     *
-     * @param {PIXI.DisplayObject} target - The target of the filter to render.
-     * @param {PIXI.Filter[]} filters - The filters to apply.
-     */
-
-
-    FilterManager.prototype.pushFilter = function pushFilter(target, filters) {
-        var renderer = this.renderer;
-
-        var filterData = this.filterData;
-
-        if (!filterData) {
-            filterData = this.renderer._activeRenderTarget.filterStack;
-
-            // add new stack
-            var filterState = new FilterState();
-
-            filterState.sourceFrame = filterState.destinationFrame = this.renderer._activeRenderTarget.size;
-            filterState.renderTarget = renderer._activeRenderTarget;
-
-            this.renderer._activeRenderTarget.filterData = filterData = {
-                index: 0,
-                stack: [filterState]
-            };
-
-            this.filterData = filterData;
-        }
-
-        // get the current filter state..
-        var currentState = filterData.stack[++filterData.index];
-
-        if (!currentState) {
-            currentState = filterData.stack[filterData.index] = new FilterState();
-        }
-
-        // for now we go off the filter of the first resolution..
-        var resolution = filters[0].resolution;
-        var padding = filters[0].padding | 0;
-        var targetBounds = target.filterArea || target.getBounds(true);
-        var sourceFrame = currentState.sourceFrame;
-        var destinationFrame = currentState.destinationFrame;
-
-        sourceFrame.x = (targetBounds.x * resolution | 0) / resolution;
-        sourceFrame.y = (targetBounds.y * resolution | 0) / resolution;
-        sourceFrame.width = (targetBounds.width * resolution | 0) / resolution;
-        sourceFrame.height = (targetBounds.height * resolution | 0) / resolution;
-
-        if (filterData.stack[0].renderTarget.transform) {//
-
-            // TODO we should fit the rect around the transform..
-        } else if (filters[0].autoFit) {
-            sourceFrame.fit(filterData.stack[0].destinationFrame);
-        }
-
-        // lets apply the padding After we fit the element to the screen.
-        // this should stop the strange side effects that can occur when cropping to the edges
-        sourceFrame.pad(padding);
-
-        destinationFrame.width = sourceFrame.width;
-        destinationFrame.height = sourceFrame.height;
-
-        // lets play the padding after we fit the element to the screen.
-        // this should stop the strange side effects that can occur when cropping to the edges
-
-        var renderTarget = this.getPotRenderTarget(renderer.gl, sourceFrame.width, sourceFrame.height, resolution);
-
-        currentState.target = target;
-        currentState.filters = filters;
-        currentState.resolution = resolution;
-        currentState.renderTarget = renderTarget;
-
-        // bind the render target to draw the shape in the top corner..
-
-        renderTarget.setFrame(destinationFrame, sourceFrame);
-
-        // bind the render target
-        renderer.bindRenderTarget(renderTarget);
-        renderTarget.clear();
-    };
-
-    /**
-     * Pops off the filter and applies it.
-     *
-     */
-
-
-    FilterManager.prototype.popFilter = function popFilter() {
-        var filterData = this.filterData;
-
-        var lastState = filterData.stack[filterData.index - 1];
-        var currentState = filterData.stack[filterData.index];
-
-        this.quad.map(currentState.renderTarget.size, currentState.sourceFrame).upload();
-
-        var filters = currentState.filters;
-
-        if (filters.length === 1) {
-            filters[0].apply(this, currentState.renderTarget, lastState.renderTarget, false, currentState);
-            this.freePotRenderTarget(currentState.renderTarget);
-        } else {
-            var flip = currentState.renderTarget;
-            var flop = this.getPotRenderTarget(this.renderer.gl, currentState.sourceFrame.width, currentState.sourceFrame.height, currentState.resolution);
-
-            flop.setFrame(currentState.destinationFrame, currentState.sourceFrame);
-
-            // finally lets clear the render target before drawing to it..
-            flop.clear();
-
-            var i = 0;
-
-            for (i = 0; i < filters.length - 1; ++i) {
-                filters[i].apply(this, flip, flop, true, currentState);
-
-                var t = flip;
-
-                flip = flop;
-                flop = t;
-            }
-
-            filters[i].apply(this, flip, lastState.renderTarget, false, currentState);
-
-            this.freePotRenderTarget(flip);
-            this.freePotRenderTarget(flop);
-        }
-
-        filterData.index--;
-
-        if (filterData.index === 0) {
-            this.filterData = null;
-        }
-    };
-
-    /**
-     * Draws a filter.
-     *
-     * @param {PIXI.Filter} filter - The filter to draw.
-     * @param {PIXI.RenderTarget} input - The input render target.
-     * @param {PIXI.RenderTarget} output - The target to output to.
-     * @param {boolean} clear - Should the output be cleared before rendering to it
-     */
-
-
-    FilterManager.prototype.applyFilter = function applyFilter(filter, input, output, clear) {
-        var renderer = this.renderer;
-        var gl = renderer.gl;
-
-        var shader = filter.glShaders[renderer.CONTEXT_UID];
-
-        // cacheing..
-        if (!shader) {
-            if (filter.glShaderKey) {
-                shader = this.shaderCache[filter.glShaderKey];
-
-                if (!shader) {
-                    shader = new _Shader2.default(this.gl, filter.vertexSrc, filter.fragmentSrc);
-
-                    filter.glShaders[renderer.CONTEXT_UID] = this.shaderCache[filter.glShaderKey] = shader;
-                }
-            } else {
-                shader = filter.glShaders[renderer.CONTEXT_UID] = new _Shader2.default(this.gl, filter.vertexSrc, filter.fragmentSrc);
-            }
-
-            // TODO - this only needs to be done once?
-            renderer.bindVao(null);
-
-            this.quad.initVao(shader);
-        }
-
-        renderer.bindVao(this.quad.vao);
-
-        renderer.bindRenderTarget(output);
-
-        if (clear) {
-            gl.disable(gl.SCISSOR_TEST);
-            renderer.clear(); // [1, 1, 1, 1]);
-            gl.enable(gl.SCISSOR_TEST);
-        }
-
-        // in case the render target is being masked using a scissor rect
-        if (output === renderer.maskManager.scissorRenderTarget) {
-            renderer.maskManager.pushScissorMask(null, renderer.maskManager.scissorData);
-        }
-
-        renderer.bindShader(shader);
-
-        // free unit 0 for us, doesn't matter what was there
-        // don't try to restore it, because syncUniforms can upload it to another slot
-        // and it'll be a problem
-        var tex = this.renderer.emptyTextures[0];
-
-        this.renderer.boundTextures[0] = tex;
-        // this syncs the PixiJS filters  uniforms with glsl uniforms
-        this.syncUniforms(shader, filter);
-
-        renderer.state.setBlendMode(filter.blendMode);
-
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, input.texture.texture);
-
-        this.quad.vao.draw(this.renderer.gl.TRIANGLES, 6, 0);
-
-        gl.bindTexture(gl.TEXTURE_2D, tex._glTextures[this.renderer.CONTEXT_UID].texture);
-    };
-
-    /**
-     * Uploads the uniforms of the filter.
-     *
-     * @param {GLShader} shader - The underlying gl shader.
-     * @param {PIXI.Filter} filter - The filter we are synchronizing.
-     */
-
-
-    FilterManager.prototype.syncUniforms = function syncUniforms(shader, filter) {
-        var uniformData = filter.uniformData;
-        var uniforms = filter.uniforms;
-
-        // 0 is reserved for the PixiJS texture so we start at 1!
-        var textureCount = 1;
-        var currentState = void 0;
-
-        // filterArea and filterClamp that are handled by FilterManager directly
-        // they must not appear in uniformData
-
-        if (shader.uniforms.filterArea) {
-            currentState = this.filterData.stack[this.filterData.index];
-
-            var filterArea = shader.uniforms.filterArea;
-
-            filterArea[0] = currentState.renderTarget.size.width;
-            filterArea[1] = currentState.renderTarget.size.height;
-            filterArea[2] = currentState.sourceFrame.x;
-            filterArea[3] = currentState.sourceFrame.y;
-
-            shader.uniforms.filterArea = filterArea;
-        }
-
-        // use this to clamp displaced texture coords so they belong to filterArea
-        // see displacementFilter fragment shader for an example
-        if (shader.uniforms.filterClamp) {
-            currentState = currentState || this.filterData.stack[this.filterData.index];
-
-            var filterClamp = shader.uniforms.filterClamp;
-
-            filterClamp[0] = 0;
-            filterClamp[1] = 0;
-            filterClamp[2] = (currentState.sourceFrame.width - 1) / currentState.renderTarget.size.width;
-            filterClamp[3] = (currentState.sourceFrame.height - 1) / currentState.renderTarget.size.height;
-
-            shader.uniforms.filterClamp = filterClamp;
-        }
-
-        // TODO Cacheing layer..
-        for (var i in uniformData) {
-            if (uniformData[i].type === 'sampler2D' && uniforms[i] !== 0) {
-                if (uniforms[i].baseTexture) {
-                    shader.uniforms[i] = this.renderer.bindTexture(uniforms[i].baseTexture, textureCount);
-                } else {
-                    shader.uniforms[i] = textureCount;
-
-                    // TODO
-                    // this is helpful as renderTargets can also be set.
-                    // Although thinking about it, we could probably
-                    // make the filter texture cache return a RenderTexture
-                    // rather than a renderTarget
-                    var gl = this.renderer.gl;
-
-                    this.renderer.boundTextures[textureCount] = this.renderer.emptyTextures[textureCount];
-                    gl.activeTexture(gl.TEXTURE0 + textureCount);
-
-                    uniforms[i].texture.bind();
-                }
-
-                textureCount++;
-            } else if (uniformData[i].type === 'mat3') {
-                // check if its PixiJS matrix..
-                if (uniforms[i].a !== undefined) {
-                    shader.uniforms[i] = uniforms[i].toArray(true);
-                } else {
-                    shader.uniforms[i] = uniforms[i];
-                }
-            } else if (uniformData[i].type === 'vec2') {
-                // check if its a point..
-                if (uniforms[i].x !== undefined) {
-                    var val = shader.uniforms[i] || new Float32Array(2);
-
-                    val[0] = uniforms[i].x;
-                    val[1] = uniforms[i].y;
-                    shader.uniforms[i] = val;
-                } else {
-                    shader.uniforms[i] = uniforms[i];
-                }
-            } else if (uniformData[i].type === 'float') {
-                if (shader.uniforms.data[i].value !== uniformData[i]) {
-                    shader.uniforms[i] = uniforms[i];
-                }
-            } else {
-                shader.uniforms[i] = uniforms[i];
-            }
-        }
-    };
-
-    /**
-     * Gets a render target from the pool, or creates a new one.
-     *
-     * @param {boolean} clear - Should we clear the render texture when we get it?
-     * @param {number} resolution - The resolution of the target.
-     * @return {PIXI.RenderTarget} The new render target
-     */
-
-
-    FilterManager.prototype.getRenderTarget = function getRenderTarget(clear, resolution) {
-        var currentState = this.filterData.stack[this.filterData.index];
-        var renderTarget = this.getPotRenderTarget(this.renderer.gl, currentState.sourceFrame.width, currentState.sourceFrame.height, resolution || currentState.resolution);
-
-        renderTarget.setFrame(currentState.destinationFrame, currentState.sourceFrame);
-
-        return renderTarget;
-    };
-
-    /**
-     * Returns a render target to the pool.
-     *
-     * @param {PIXI.RenderTarget} renderTarget - The render target to return.
-     */
-
-
-    FilterManager.prototype.returnRenderTarget = function returnRenderTarget(renderTarget) {
-        this.freePotRenderTarget(renderTarget);
-    };
-
-    /**
-     * Calculates the mapped matrix.
-     *
-     * TODO playing around here.. this is temporary - (will end up in the shader)
-     * this returns a matrix that will normalise map filter cords in the filter to screen space
-     *
-     * @param {PIXI.Matrix} outputMatrix - the matrix to output to.
-     * @return {PIXI.Matrix} The mapped matrix.
-     */
-
-
-    FilterManager.prototype.calculateScreenSpaceMatrix = function calculateScreenSpaceMatrix(outputMatrix) {
-        var currentState = this.filterData.stack[this.filterData.index];
-
-        return filterTransforms.calculateScreenSpaceMatrix(outputMatrix, currentState.sourceFrame, currentState.renderTarget.size);
-    };
-
-    /**
-     * Multiply vTextureCoord to this matrix to achieve (0,0,1,1) for filterArea
-     *
-     * @param {PIXI.Matrix} outputMatrix - The matrix to output to.
-     * @return {PIXI.Matrix} The mapped matrix.
-     */
-
-
-    FilterManager.prototype.calculateNormalizedScreenSpaceMatrix = function calculateNormalizedScreenSpaceMatrix(outputMatrix) {
-        var currentState = this.filterData.stack[this.filterData.index];
-
-        return filterTransforms.calculateNormalizedScreenSpaceMatrix(outputMatrix, currentState.sourceFrame, currentState.renderTarget.size, currentState.destinationFrame);
-    };
-
-    /**
-     * This will map the filter coord so that a texture can be used based on the transform of a sprite
-     *
-     * @param {PIXI.Matrix} outputMatrix - The matrix to output to.
-     * @param {PIXI.Sprite} sprite - The sprite to map to.
-     * @return {PIXI.Matrix} The mapped matrix.
-     */
-
-
-    FilterManager.prototype.calculateSpriteMatrix = function calculateSpriteMatrix(outputMatrix, sprite) {
-        var currentState = this.filterData.stack[this.filterData.index];
-
-        return filterTransforms.calculateSpriteMatrix(outputMatrix, currentState.sourceFrame, currentState.renderTarget.size, sprite);
-    };
-
-    /**
-     * Destroys this Filter Manager.
-     *
-     */
-
-
-    FilterManager.prototype.destroy = function destroy() {
-        this.shaderCache = {};
-        this.emptyPool();
-    };
-
-    /**
-     * Gets a Power-of-Two render texture.
-     *
-     * TODO move to a seperate class could be on renderer?
-     * also - could cause issue with multiple contexts?
-     *
-     * @private
-     * @param {WebGLRenderingContext} gl - The webgl rendering context
-     * @param {number} minWidth - The minimum width of the render target.
-     * @param {number} minHeight - The minimum height of the render target.
-     * @param {number} resolution - The resolution of the render target.
-     * @return {PIXI.RenderTarget} The new render target.
-     */
-
-
-    FilterManager.prototype.getPotRenderTarget = function getPotRenderTarget(gl, minWidth, minHeight, resolution) {
-        // TODO you could return a bigger texture if there is not one in the pool?
-        minWidth = _bitTwiddle2.default.nextPow2(minWidth * resolution);
-        minHeight = _bitTwiddle2.default.nextPow2(minHeight * resolution);
-
-        var key = (minWidth & 0xFFFF) << 16 | minHeight & 0xFFFF;
-
-        if (!this.pool[key]) {
-            this.pool[key] = [];
-        }
-
-        var renderTarget = this.pool[key].pop();
-
-        // creating render target will cause texture to be bound!
-        if (!renderTarget) {
-            // temporary bypass cache..
-            var tex = this.renderer.boundTextures[0];
-
-            gl.activeTexture(gl.TEXTURE0);
-
-            // internally - this will cause a texture to be bound..
-            renderTarget = new _RenderTarget2.default(gl, minWidth, minHeight, null, 1);
-
-            // set the current one back
-            gl.bindTexture(gl.TEXTURE_2D, tex._glTextures[this.renderer.CONTEXT_UID].texture);
-        }
-
-        // manually tweak the resolution...
-        // this will not modify the size of the frame buffer, just its resolution.
-        renderTarget.resolution = resolution;
-        renderTarget.defaultFrame.width = renderTarget.size.width = minWidth / resolution;
-        renderTarget.defaultFrame.height = renderTarget.size.height = minHeight / resolution;
-
-        return renderTarget;
-    };
-
-    /**
-     * Empties the texture pool.
-     *
-     */
-
-
-    FilterManager.prototype.emptyPool = function emptyPool() {
-        for (var i in this.pool) {
-            var textures = this.pool[i];
-
-            if (textures) {
-                for (var j = 0; j < textures.length; j++) {
-                    textures[j].destroy(true);
-                }
-            }
-        }
-
-        this.pool = {};
-    };
-
-    /**
-     * Frees a render target back into the pool.
-     *
-     * @param {PIXI.RenderTarget} renderTarget - The renderTarget to free
-     */
-
-
-    FilterManager.prototype.freePotRenderTarget = function freePotRenderTarget(renderTarget) {
-        var minWidth = renderTarget.size.width * renderTarget.resolution;
-        var minHeight = renderTarget.size.height * renderTarget.resolution;
-        var key = (minWidth & 0xFFFF) << 16 | minHeight & 0xFFFF;
-
-        this.pool[key].push(renderTarget);
-    };
-
-    return FilterManager;
-}(_WebGLManager3.default);
-
-exports.default = FilterManager;
-
-},{"../../../Shader":44,"../../../math":70,"../filters/filterTransforms":88,"../utils/Quad":95,"../utils/RenderTarget":96,"./WebGLManager":93,"bit-twiddle":1}],91:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _WebGLManager2 = require('./WebGLManager');
-
-var _WebGLManager3 = _interopRequireDefault(_WebGLManager2);
-
-var _SpriteMaskFilter = require('../filters/spriteMask/SpriteMaskFilter');
-
-var _SpriteMaskFilter2 = _interopRequireDefault(_SpriteMaskFilter);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * @class
- * @extends PIXI.WebGLManager
- * @memberof PIXI
- */
-var MaskManager = function (_WebGLManager) {
-    _inherits(MaskManager, _WebGLManager);
-
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - The renderer this manager works for.
-     */
-    function MaskManager(renderer) {
-        _classCallCheck(this, MaskManager);
-
-        // TODO - we don't need both!
-        var _this = _possibleConstructorReturn(this, _WebGLManager.call(this, renderer));
-
-        _this.scissor = false;
-        _this.scissorData = null;
-        _this.scissorRenderTarget = null;
-
-        _this.enableScissor = true;
-
-        _this.alphaMaskPool = [];
-        _this.alphaMaskIndex = 0;
-        return _this;
-    }
-
-    /**
-     * Applies the Mask and adds it to the current filter stack.
-     *
-     * @param {PIXI.DisplayObject} target - Display Object to push the mask to
-     * @param {PIXI.Sprite|PIXI.Graphics} maskData - The masking data.
-     */
-
-
-    MaskManager.prototype.pushMask = function pushMask(target, maskData) {
-        // TODO the root check means scissor rect will not
-        // be used on render textures more info here:
-        // https://github.com/pixijs/pixi.js/pull/3545
-
-        if (maskData.texture) {
-            this.pushSpriteMask(target, maskData);
-        } else if (this.enableScissor && !this.scissor && this.renderer._activeRenderTarget.root && !this.renderer.stencilManager.stencilMaskStack.length && maskData.isFastRect()) {
-            var matrix = maskData.worldTransform;
-
-            var rot = Math.atan2(matrix.b, matrix.a);
-
-            // use the nearest degree!
-            rot = Math.round(rot * (180 / Math.PI));
-
-            if (rot % 90) {
-                this.pushStencilMask(maskData);
-            } else {
-                this.pushScissorMask(target, maskData);
-            }
-        } else {
-            this.pushStencilMask(maskData);
-        }
-    };
-
-    /**
-     * Removes the last mask from the mask stack and doesn't return it.
-     *
-     * @param {PIXI.DisplayObject} target - Display Object to pop the mask from
-     * @param {PIXI.Sprite|PIXI.Graphics} maskData - The masking data.
-     */
-
-
-    MaskManager.prototype.popMask = function popMask(target, maskData) {
-        if (maskData.texture) {
-            this.popSpriteMask(target, maskData);
-        } else if (this.enableScissor && !this.renderer.stencilManager.stencilMaskStack.length) {
-            this.popScissorMask(target, maskData);
-        } else {
-            this.popStencilMask(target, maskData);
-        }
-    };
-
-    /**
-     * Applies the Mask and adds it to the current filter stack.
-     *
-     * @param {PIXI.RenderTarget} target - Display Object to push the sprite mask to
-     * @param {PIXI.Sprite} maskData - Sprite to be used as the mask
-     */
-
-
-    MaskManager.prototype.pushSpriteMask = function pushSpriteMask(target, maskData) {
-        var alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex];
-
-        if (!alphaMaskFilter) {
-            alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex] = [new _SpriteMaskFilter2.default(maskData)];
-        }
-
-        alphaMaskFilter[0].resolution = this.renderer.resolution;
-        alphaMaskFilter[0].maskSprite = maskData;
-
-        // TODO - may cause issues!
-        target.filterArea = maskData.getBounds(true);
-
-        this.renderer.filterManager.pushFilter(target, alphaMaskFilter);
-
-        this.alphaMaskIndex++;
-    };
-
-    /**
-     * Removes the last filter from the filter stack and doesn't return it.
-     *
-     */
-
-
-    MaskManager.prototype.popSpriteMask = function popSpriteMask() {
-        this.renderer.filterManager.popFilter();
-        this.alphaMaskIndex--;
-    };
-
-    /**
-     * Applies the Mask and adds it to the current filter stack.
-     *
-     * @param {PIXI.Sprite|PIXI.Graphics} maskData - The masking data.
-     */
-
-
-    MaskManager.prototype.pushStencilMask = function pushStencilMask(maskData) {
-        this.renderer.currentRenderer.stop();
-        this.renderer.stencilManager.pushStencil(maskData);
-    };
-
-    /**
-     * Removes the last filter from the filter stack and doesn't return it.
-     *
-     */
-
-
-    MaskManager.prototype.popStencilMask = function popStencilMask() {
-        this.renderer.currentRenderer.stop();
-        this.renderer.stencilManager.popStencil();
-    };
-
-    /**
-     *
-     * @param {PIXI.DisplayObject} target - Display Object to push the mask to
-     * @param {PIXI.Graphics} maskData - The masking data.
-     */
-
-
-    MaskManager.prototype.pushScissorMask = function pushScissorMask(target, maskData) {
-        maskData.renderable = true;
-
-        var renderTarget = this.renderer._activeRenderTarget;
-
-        var bounds = maskData.getBounds();
-
-        bounds.fit(renderTarget.size);
-        maskData.renderable = false;
-
-        this.renderer.gl.enable(this.renderer.gl.SCISSOR_TEST);
-
-        var resolution = this.renderer.resolution;
-
-        this.renderer.gl.scissor(bounds.x * resolution, (renderTarget.root ? renderTarget.size.height - bounds.y - bounds.height : bounds.y) * resolution, bounds.width * resolution, bounds.height * resolution);
-
-        this.scissorRenderTarget = renderTarget;
-        this.scissorData = maskData;
-        this.scissor = true;
-    };
-
-    /**
-     *
-     *
-     */
-
-
-    MaskManager.prototype.popScissorMask = function popScissorMask() {
-        this.scissorRenderTarget = null;
-        this.scissorData = null;
-        this.scissor = false;
-
-        // must be scissor!
-        var gl = this.renderer.gl;
-
-        gl.disable(gl.SCISSOR_TEST);
-    };
-
-    return MaskManager;
-}(_WebGLManager3.default);
-
-exports.default = MaskManager;
-
-},{"../filters/spriteMask/SpriteMaskFilter":89,"./WebGLManager":93}],92:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _WebGLManager2 = require('./WebGLManager');
-
-var _WebGLManager3 = _interopRequireDefault(_WebGLManager2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * @class
- * @extends PIXI.WebGLManager
- * @memberof PIXI
- */
-var StencilManager = function (_WebGLManager) {
-    _inherits(StencilManager, _WebGLManager);
-
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - The renderer this manager works for.
-     */
-    function StencilManager(renderer) {
-        _classCallCheck(this, StencilManager);
-
-        var _this = _possibleConstructorReturn(this, _WebGLManager.call(this, renderer));
-
-        _this.stencilMaskStack = null;
-        return _this;
-    }
-
-    /**
-     * Changes the mask stack that is used by this manager.
-     *
-     * @param {PIXI.Graphics[]} stencilMaskStack - The mask stack
-     */
-
-
-    StencilManager.prototype.setMaskStack = function setMaskStack(stencilMaskStack) {
-        this.stencilMaskStack = stencilMaskStack;
-
-        var gl = this.renderer.gl;
-
-        if (stencilMaskStack.length === 0) {
-            gl.disable(gl.STENCIL_TEST);
-        } else {
-            gl.enable(gl.STENCIL_TEST);
-        }
-    };
-
-    /**
-     * Applies the Mask and adds it to the current filter stack. @alvin
-     *
-     * @param {PIXI.Graphics} graphics - The mask
-     */
-
-
-    StencilManager.prototype.pushStencil = function pushStencil(graphics) {
-        this.renderer.setObjectRenderer(this.renderer.plugins.graphics);
-
-        this.renderer._activeRenderTarget.attachStencilBuffer();
-
-        var gl = this.renderer.gl;
-        var sms = this.stencilMaskStack;
-
-        if (sms.length === 0) {
-            gl.enable(gl.STENCIL_TEST);
-            gl.clear(gl.STENCIL_BUFFER_BIT);
-            gl.stencilFunc(gl.ALWAYS, 1, 1);
-        }
-
-        sms.push(graphics);
-
-        gl.colorMask(false, false, false, false);
-        gl.stencilFunc(gl.EQUAL, 0, sms.length);
-        gl.stencilOp(gl.KEEP, gl.KEEP, gl.INCR);
-
-        this.renderer.plugins.graphics.render(graphics);
-
-        gl.colorMask(true, true, true, true);
-        gl.stencilFunc(gl.NOTEQUAL, 0, sms.length);
-        gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
-    };
-
-    /**
-     * TODO @alvin
-     */
-
-
-    StencilManager.prototype.popStencil = function popStencil() {
-        this.renderer.setObjectRenderer(this.renderer.plugins.graphics);
-
-        var gl = this.renderer.gl;
-        var sms = this.stencilMaskStack;
-
-        var graphics = sms.pop();
-
-        if (sms.length === 0) {
-            // the stack is empty!
-            gl.disable(gl.STENCIL_TEST);
-        } else {
-            gl.colorMask(false, false, false, false);
-            gl.stencilFunc(gl.EQUAL, 0, sms.length);
-            gl.stencilOp(gl.KEEP, gl.KEEP, gl.DECR);
-
-            this.renderer.plugins.graphics.render(graphics);
-
-            gl.colorMask(true, true, true, true);
-            gl.stencilFunc(gl.NOTEQUAL, 0, sms.length);
-            gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
-        }
-    };
-
-    /**
-     * Destroys the mask stack.
-     *
-     */
-
-
-    StencilManager.prototype.destroy = function destroy() {
-        _WebGLManager3.default.prototype.destroy.call(this);
-
-        this.stencilMaskStack.stencilStack = null;
-    };
-
-    return StencilManager;
-}(_WebGLManager3.default);
-
-exports.default = StencilManager;
-
-},{"./WebGLManager":93}],93:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @class
- * @memberof PIXI
- */
-var WebGLManager = function () {
-  /**
-   * @param {PIXI.WebGLRenderer} renderer - The renderer this manager works for.
-   */
-  function WebGLManager(renderer) {
-    _classCallCheck(this, WebGLManager);
-
-    /**
-     * The renderer this manager works for.
-     *
-     * @member {PIXI.WebGLRenderer}
-     */
-    this.renderer = renderer;
-
-    this.renderer.on('context', this.onContextChange, this);
-  }
-
-  /**
-   * Generic method called when there is a WebGL context change.
-   *
-   */
-
-
-  WebGLManager.prototype.onContextChange = function onContextChange() {}
-  // do some codes init!
-
-
-  /**
-   * Generic destroy methods to be overridden by the subclass
-   *
-   */
-  ;
-
-  WebGLManager.prototype.destroy = function destroy() {
-    this.renderer.off('context', this.onContextChange, this);
-
-    this.renderer = null;
-  };
-
-  return WebGLManager;
-}();
-
-exports.default = WebGLManager;
-
-},{}],94:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _WebGLManager2 = require('../managers/WebGLManager');
-
-var _WebGLManager3 = _interopRequireDefault(_WebGLManager2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * Base for a common object renderer that can be used as a system renderer plugin.
- *
- * @class
- * @extends PIXI.WebGLManager
- * @memberof PIXI
- */
-var ObjectRenderer = function (_WebGLManager) {
-  _inherits(ObjectRenderer, _WebGLManager);
-
-  function ObjectRenderer() {
-    _classCallCheck(this, ObjectRenderer);
-
-    return _possibleConstructorReturn(this, _WebGLManager.apply(this, arguments));
-  }
-
-  /**
-   * Starts the renderer and sets the shader
-   *
-   */
-  ObjectRenderer.prototype.start = function start() {}
-  // set the shader..
-
-
-  /**
-   * Stops the renderer
-   *
-   */
-  ;
-
-  ObjectRenderer.prototype.stop = function stop() {
-    this.flush();
-  };
-
-  /**
-   * Stub method for rendering content and emptying the current batch.
-   *
-   */
-
-
-  ObjectRenderer.prototype.flush = function flush() {}
-  // flush!
-
-
-  /**
-   * Renders an object
-   *
-   * @param {PIXI.DisplayObject} object - The object to render.
-   */
-  ;
-
-  ObjectRenderer.prototype.render = function render(object) // eslint-disable-line no-unused-vars
-  {
-    // render the object
-  };
-
-  return ObjectRenderer;
-}(_WebGLManager3.default);
-
-exports.default = ObjectRenderer;
-
-},{"../managers/WebGLManager":93}],95:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-var _createIndicesForQuads = require('../../../utils/createIndicesForQuads');
-
-var _createIndicesForQuads2 = _interopRequireDefault(_createIndicesForQuads);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Helper class to create a quad
- *
- * @class
- * @memberof PIXI
- */
-var Quad = function () {
-  /**
-   * @param {WebGLRenderingContext} gl - The gl context for this quad to use.
-   * @param {object} state - TODO: Description
-   */
-  function Quad(gl, state) {
-    _classCallCheck(this, Quad);
-
-    /**
-     * the current WebGL drawing context
-     *
-     * @member {WebGLRenderingContext}
-     */
-    this.gl = gl;
-
-    /**
-     * An array of vertices
-     *
-     * @member {Float32Array}
-     */
-    this.vertices = new Float32Array([-1, -1, 1, -1, 1, 1, -1, 1]);
-
-    /**
-     * The Uvs of the quad
-     *
-     * @member {Float32Array}
-     */
-    this.uvs = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
-
-    this.interleaved = new Float32Array(8 * 2);
-
-    for (var i = 0; i < 4; i++) {
-      this.interleaved[i * 4] = this.vertices[i * 2];
-      this.interleaved[i * 4 + 1] = this.vertices[i * 2 + 1];
-      this.interleaved[i * 4 + 2] = this.uvs[i * 2];
-      this.interleaved[i * 4 + 3] = this.uvs[i * 2 + 1];
-    }
-
-    /**
-     * An array containing the indices of the vertices
-     *
-     * @member {Uint16Array}
-     */
-    this.indices = (0, _createIndicesForQuads2.default)(1);
-
-    /**
-     * The vertex buffer
-     *
-     * @member {glCore.GLBuffer}
-     */
-    this.vertexBuffer = _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl, this.interleaved, gl.STATIC_DRAW);
-
-    /**
-     * The index buffer
-     *
-     * @member {glCore.GLBuffer}
-     */
-    this.indexBuffer = _pixiGlCore2.default.GLBuffer.createIndexBuffer(gl, this.indices, gl.STATIC_DRAW);
-
-    /**
-     * The vertex array object
-     *
-     * @member {glCore.VertexArrayObject}
-     */
-    this.vao = new _pixiGlCore2.default.VertexArrayObject(gl, state);
-  }
-
-  /**
-   * Initialises the vaos and uses the shader.
-   *
-   * @param {PIXI.Shader} shader - the shader to use
-   */
-
-
-  Quad.prototype.initVao = function initVao(shader) {
-    this.vao.clear().addIndex(this.indexBuffer).addAttribute(this.vertexBuffer, shader.attributes.aVertexPosition, this.gl.FLOAT, false, 4 * 4, 0).addAttribute(this.vertexBuffer, shader.attributes.aTextureCoord, this.gl.FLOAT, false, 4 * 4, 2 * 4);
-  };
-
-  /**
-   * Maps two Rectangle to the quad.
-   *
-   * @param {PIXI.Rectangle} targetTextureFrame - the first rectangle
-   * @param {PIXI.Rectangle} destinationFrame - the second rectangle
-   * @return {PIXI.Quad} Returns itself.
-   */
-
-
-  Quad.prototype.map = function map(targetTextureFrame, destinationFrame) {
-    var x = 0; // destinationFrame.x / targetTextureFrame.width;
-    var y = 0; // destinationFrame.y / targetTextureFrame.height;
-
-    this.uvs[0] = x;
-    this.uvs[1] = y;
-
-    this.uvs[2] = x + destinationFrame.width / targetTextureFrame.width;
-    this.uvs[3] = y;
-
-    this.uvs[4] = x + destinationFrame.width / targetTextureFrame.width;
-    this.uvs[5] = y + destinationFrame.height / targetTextureFrame.height;
-
-    this.uvs[6] = x;
-    this.uvs[7] = y + destinationFrame.height / targetTextureFrame.height;
-
-    x = destinationFrame.x;
-    y = destinationFrame.y;
-
-    this.vertices[0] = x;
-    this.vertices[1] = y;
-
-    this.vertices[2] = x + destinationFrame.width;
-    this.vertices[3] = y;
-
-    this.vertices[4] = x + destinationFrame.width;
-    this.vertices[5] = y + destinationFrame.height;
-
-    this.vertices[6] = x;
-    this.vertices[7] = y + destinationFrame.height;
-
-    return this;
-  };
-
-  /**
-   * Binds the buffer and uploads the data
-   *
-   * @return {PIXI.Quad} Returns itself.
-   */
-
-
-  Quad.prototype.upload = function upload() {
-    for (var i = 0; i < 4; i++) {
-      this.interleaved[i * 4] = this.vertices[i * 2];
-      this.interleaved[i * 4 + 1] = this.vertices[i * 2 + 1];
-      this.interleaved[i * 4 + 2] = this.uvs[i * 2];
-      this.interleaved[i * 4 + 3] = this.uvs[i * 2 + 1];
-    }
-
-    this.vertexBuffer.upload(this.interleaved);
-
-    return this;
-  };
-
-  /**
-   * Removes this quad from WebGL
-   */
-
-
-  Quad.prototype.destroy = function destroy() {
-    var gl = this.gl;
-
-    gl.deleteBuffer(this.vertexBuffer);
-    gl.deleteBuffer(this.indexBuffer);
-  };
-
-  return Quad;
-}();
-
-exports.default = Quad;
-
-},{"../../../utils/createIndicesForQuads":122,"pixi-gl-core":12}],96:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _math = require('../../../math');
-
-var _const = require('../../../const');
-
-var _settings = require('../../../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _pixiGlCore = require('pixi-gl-core');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @class
- * @memberof PIXI
- */
-var RenderTarget = function () {
-  /**
-   * @param {WebGLRenderingContext} gl - The current WebGL drawing context
-   * @param {number} [width=0] - the horizontal range of the filter
-   * @param {number} [height=0] - the vertical range of the filter
-   * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-   * @param {number} [resolution=1] - The current resolution / device pixel ratio
-   * @param {boolean} [root=false] - Whether this object is the root element or not
-   */
-  function RenderTarget(gl, width, height, scaleMode, resolution, root) {
-    _classCallCheck(this, RenderTarget);
-
-    // TODO Resolution could go here ( eg low res blurs )
-
-    /**
-     * The current WebGL drawing context.
-     *
-     * @member {WebGLRenderingContext}
-     */
-    this.gl = gl;
-
-    // next time to create a frame buffer and texture
-
-    /**
-     * A frame buffer
-     *
-     * @member {PIXI.glCore.GLFramebuffer}
-     */
-    this.frameBuffer = null;
-
-    /**
-     * The texture
-     *
-     * @member {PIXI.glCore.GLTexture}
-     */
-    this.texture = null;
-
-    /**
-     * The background colour of this render target, as an array of [r,g,b,a] values
-     *
-     * @member {number[]}
-     */
-    this.clearColor = [0, 0, 0, 0];
-
-    /**
-     * The size of the object as a rectangle
-     *
-     * @member {PIXI.Rectangle}
-     */
-    this.size = new _math.Rectangle(0, 0, 1, 1);
-
-    /**
-     * The current resolution / device pixel ratio
-     *
-     * @member {number}
-     * @default 1
-     */
-    this.resolution = resolution || _settings2.default.RESOLUTION;
-
-    /**
-     * The projection matrix
-     *
-     * @member {PIXI.Matrix}
-     */
-    this.projectionMatrix = new _math.Matrix();
-
-    /**
-     * The object's transform
-     *
-     * @member {PIXI.Matrix}
-     */
-    this.transform = null;
-
-    /**
-     * The frame.
-     *
-     * @member {PIXI.Rectangle}
-     */
-    this.frame = null;
-
-    /**
-     * The stencil buffer stores masking data for the render target
-     *
-     * @member {glCore.GLBuffer}
-     */
-    this.defaultFrame = new _math.Rectangle();
-    this.destinationFrame = null;
-    this.sourceFrame = null;
-
-    /**
-     * The stencil buffer stores masking data for the render target
-     *
-     * @member {glCore.GLBuffer}
-     */
-    this.stencilBuffer = null;
-
-    /**
-     * The data structure for the stencil masks
-     *
-     * @member {PIXI.Graphics[]}
-     */
-    this.stencilMaskStack = [];
-
-    /**
-     * Stores filter data for the render target
-     *
-     * @member {object[]}
-     */
-    this.filterData = null;
-
-    /**
-     * The scale mode.
-     *
-     * @member {number}
-     * @default PIXI.settings.SCALE_MODE
-     * @see PIXI.SCALE_MODES
-     */
-    this.scaleMode = scaleMode !== undefined ? scaleMode : _settings2.default.SCALE_MODE;
-
-    /**
-     * Whether this object is the root element or not
-     *
-     * @member {boolean}
-     */
-    this.root = root;
-
-    if (!this.root) {
-      this.frameBuffer = _pixiGlCore.GLFramebuffer.createRGBA(gl, 100, 100);
-
-      if (this.scaleMode === _const.SCALE_MODES.NEAREST) {
-        this.frameBuffer.texture.enableNearestScaling();
-      } else {
-        this.frameBuffer.texture.enableLinearScaling();
-      }
-      /*
-          A frame buffer needs a target to render to..
-          create a texture and bind it attach it to the framebuffer..
-       */
-
-      // this is used by the base texture
-      this.texture = this.frameBuffer.texture;
-    } else {
-      // make it a null framebuffer..
-      this.frameBuffer = new _pixiGlCore.GLFramebuffer(gl, 100, 100);
-      this.frameBuffer.framebuffer = null;
-    }
-
-    this.setFrame();
-
-    this.resize(width, height);
-  }
-
-  /**
-   * Clears the filter texture.
-   *
-   * @param {number[]} [clearColor=this.clearColor] - Array of [r,g,b,a] to clear the framebuffer
-   */
-
-
-  RenderTarget.prototype.clear = function clear(clearColor) {
-    var cc = clearColor || this.clearColor;
-
-    this.frameBuffer.clear(cc[0], cc[1], cc[2], cc[3]); // r,g,b,a);
-  };
-
-  /**
-   * Binds the stencil buffer.
-   *
-   */
-
-
-  RenderTarget.prototype.attachStencilBuffer = function attachStencilBuffer() {
-    // TODO check if stencil is done?
-    /**
-     * The stencil buffer is used for masking in pixi
-     * lets create one and then add attach it to the framebuffer..
-     */
-    if (!this.root) {
-      this.frameBuffer.enableStencil();
-    }
-  };
-
-  /**
-   * Sets the frame of the render target.
-   *
-   * @param {Rectangle} destinationFrame - The destination frame.
-   * @param {Rectangle} sourceFrame - The source frame.
-   */
-
-
-  RenderTarget.prototype.setFrame = function setFrame(destinationFrame, sourceFrame) {
-    this.destinationFrame = destinationFrame || this.destinationFrame || this.defaultFrame;
-    this.sourceFrame = sourceFrame || this.sourceFrame || this.destinationFrame;
-  };
-
-  /**
-   * Binds the buffers and initialises the viewport.
-   *
-   */
-
-
-  RenderTarget.prototype.activate = function activate() {
-    // TOOD refactor usage of frame..
-    var gl = this.gl;
-
-    // make sure the texture is unbound!
-    this.frameBuffer.bind();
-
-    this.calculateProjection(this.destinationFrame, this.sourceFrame);
-
-    if (this.transform) {
-      this.projectionMatrix.append(this.transform);
-    }
-
-    // TODO add a check as them may be the same!
-    if (this.destinationFrame !== this.sourceFrame) {
-      gl.enable(gl.SCISSOR_TEST);
-      gl.scissor(this.destinationFrame.x | 0, this.destinationFrame.y | 0, this.destinationFrame.width * this.resolution | 0, this.destinationFrame.height * this.resolution | 0);
-    } else {
-      gl.disable(gl.SCISSOR_TEST);
-    }
-
-    // TODO - does not need to be updated all the time??
-    gl.viewport(this.destinationFrame.x | 0, this.destinationFrame.y | 0, this.destinationFrame.width * this.resolution | 0, this.destinationFrame.height * this.resolution | 0);
-  };
-
-  /**
-   * Updates the projection matrix based on a projection frame (which is a rectangle)
-   *
-   * @param {Rectangle} destinationFrame - The destination frame.
-   * @param {Rectangle} sourceFrame - The source frame.
-   */
-
-
-  RenderTarget.prototype.calculateProjection = function calculateProjection(destinationFrame, sourceFrame) {
-    var pm = this.projectionMatrix;
-
-    sourceFrame = sourceFrame || destinationFrame;
-
-    pm.identity();
-
-    // TODO: make dest scale source
-    if (!this.root) {
-      pm.a = 1 / destinationFrame.width * 2;
-      pm.d = 1 / destinationFrame.height * 2;
-
-      pm.tx = -1 - sourceFrame.x * pm.a;
-      pm.ty = -1 - sourceFrame.y * pm.d;
-    } else {
-      pm.a = 1 / destinationFrame.width * 2;
-      pm.d = -1 / destinationFrame.height * 2;
-
-      pm.tx = -1 - sourceFrame.x * pm.a;
-      pm.ty = 1 - sourceFrame.y * pm.d;
-    }
-  };
-
-  /**
-   * Resizes the texture to the specified width and height
-   *
-   * @param {number} width - the new width of the texture
-   * @param {number} height - the new height of the texture
-   */
-
-
-  RenderTarget.prototype.resize = function resize(width, height) {
-    width = width | 0;
-    height = height | 0;
-
-    if (this.size.width === width && this.size.height === height) {
-      return;
-    }
-
-    this.size.width = width;
-    this.size.height = height;
-
-    this.defaultFrame.width = width;
-    this.defaultFrame.height = height;
-
-    this.frameBuffer.resize(width * this.resolution, height * this.resolution);
-
-    var projectionFrame = this.frame || this.size;
-
-    this.calculateProjection(projectionFrame);
-  };
-
-  /**
-   * Destroys the render target.
-   *
-   */
-
-
-  RenderTarget.prototype.destroy = function destroy() {
-    this.frameBuffer.destroy();
-
-    this.frameBuffer = null;
-    this.texture = null;
-  };
-
-  return RenderTarget;
-}();
-
-exports.default = RenderTarget;
-
-},{"../../../const":46,"../../../math":70,"../../../settings":101,"pixi-gl-core":12}],97:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = checkMaxIfStatmentsInShader;
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var fragTemplate = ['precision mediump float;', 'void main(void){', 'float test = 0.1;', '%forloop%', 'gl_FragColor = vec4(0.0);', '}'].join('\n');
-
-function checkMaxIfStatmentsInShader(maxIfs, gl) {
-    var createTempContext = !gl;
-
-    if (maxIfs === 0) {
-        throw new Error('Invalid value of `0` passed to `checkMaxIfStatementsInShader`');
-    }
-
-    if (createTempContext) {
-        var tinyCanvas = document.createElement('canvas');
-
-        tinyCanvas.width = 1;
-        tinyCanvas.height = 1;
-
-        gl = _pixiGlCore2.default.createContext(tinyCanvas);
-    }
-
-    var shader = gl.createShader(gl.FRAGMENT_SHADER);
-
-    while (true) // eslint-disable-line no-constant-condition
-    {
-        var fragmentSrc = fragTemplate.replace(/%forloop%/gi, generateIfTestSrc(maxIfs));
-
-        gl.shaderSource(shader, fragmentSrc);
-        gl.compileShader(shader);
-
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            maxIfs = maxIfs / 2 | 0;
-        } else {
-            // valid!
-            break;
-        }
-    }
-
-    if (createTempContext) {
-        // get rid of context
-        if (gl.getExtension('WEBGL_lose_context')) {
-            gl.getExtension('WEBGL_lose_context').loseContext();
-        }
-    }
-
-    return maxIfs;
-}
-
-function generateIfTestSrc(maxIfs) {
-    var src = '';
-
-    for (var i = 0; i < maxIfs; ++i) {
-        if (i > 0) {
-            src += '\nelse ';
-        }
-
-        if (i < maxIfs - 1) {
-            src += 'if(test == ' + i + '.0){}';
-        }
-    }
-
-    return src;
-}
-
-},{"pixi-gl-core":12}],98:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = mapWebGLBlendModesToPixi;
-
-var _const = require('../../../const');
-
-/**
- * Maps gl blend combinations to WebGL.
- *
- * @memberof PIXI
- * @function mapWebGLBlendModesToPixi
- * @private
- * @param {WebGLRenderingContext} gl - The rendering context.
- * @param {string[]} [array=[]] - The array to output into.
- * @return {string[]} Mapped modes.
- */
-function mapWebGLBlendModesToPixi(gl) {
-    var array = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-
-    // TODO - premultiply alpha would be different.
-    // add a boolean for that!
-    array[_const.BLEND_MODES.NORMAL] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.ADD] = [gl.ONE, gl.DST_ALPHA];
-    array[_const.BLEND_MODES.MULTIPLY] = [gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.SCREEN] = [gl.ONE, gl.ONE_MINUS_SRC_COLOR];
-    array[_const.BLEND_MODES.OVERLAY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.DARKEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.LIGHTEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.COLOR_DODGE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.COLOR_BURN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.HARD_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.SOFT_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.DIFFERENCE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.EXCLUSION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.HUE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.SATURATION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.COLOR] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.LUMINOSITY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-
-    // not-premultiplied blend modes
-    array[_const.BLEND_MODES.NORMAL_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-    array[_const.BLEND_MODES.ADD_NPM] = [gl.SRC_ALPHA, gl.DST_ALPHA, gl.ONE, gl.DST_ALPHA];
-    array[_const.BLEND_MODES.SCREEN_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_COLOR, gl.ONE, gl.ONE_MINUS_SRC_COLOR];
-
-    return array;
-}
-
-},{"../../../const":46}],99:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = mapWebGLDrawModesToPixi;
-
-var _const = require('../../../const');
-
-/**
- * Generic Mask Stack data structure.
- *
- * @memberof PIXI
- * @function mapWebGLDrawModesToPixi
- * @private
- * @param {WebGLRenderingContext} gl - The current WebGL drawing context
- * @param {object} [object={}] - The object to map into
- * @return {object} The mapped draw modes.
- */
-function mapWebGLDrawModesToPixi(gl) {
-  var object = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-  object[_const.DRAW_MODES.POINTS] = gl.POINTS;
-  object[_const.DRAW_MODES.LINES] = gl.LINES;
-  object[_const.DRAW_MODES.LINE_LOOP] = gl.LINE_LOOP;
-  object[_const.DRAW_MODES.LINE_STRIP] = gl.LINE_STRIP;
-  object[_const.DRAW_MODES.TRIANGLES] = gl.TRIANGLES;
-  object[_const.DRAW_MODES.TRIANGLE_STRIP] = gl.TRIANGLE_STRIP;
-  object[_const.DRAW_MODES.TRIANGLE_FAN] = gl.TRIANGLE_FAN;
-
-  return object;
-}
-
-},{"../../../const":46}],100:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = validateContext;
-function validateContext(gl) {
-    var attributes = gl.getContextAttributes();
-
-    // this is going to be fairly simple for now.. but at least we have room to grow!
-    if (!attributes.stencil) {
-        /* eslint-disable no-console */
-        console.warn('Provided WebGL context does not have a stencil buffer, masks may not render correctly');
-        /* eslint-enable no-console */
-    }
-}
-
-},{}],101:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _maxRecommendedTextures = require('./utils/maxRecommendedTextures');
-
-var _maxRecommendedTextures2 = _interopRequireDefault(_maxRecommendedTextures);
-
-var _canUploadSameBuffer = require('./utils/canUploadSameBuffer');
-
-var _canUploadSameBuffer2 = _interopRequireDefault(_canUploadSameBuffer);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * User's customizable globals for overriding the default PIXI settings, such
- * as a renderer's default resolution, framerate, float percision, etc.
- * @example
- * // Use the native window resolution as the default resolution
- * // will support high-density displays when rendering
- * PIXI.settings.RESOLUTION = window.devicePixelRatio.
- *
- * // Disable interpolation when scaling, will make texture be pixelated
- * PIXI.settings.SCALE_MODE = PIXI.SCALE_MODES.NEAREST;
- * @namespace PIXI.settings
- */
-exports.default = {
-
-  /**
-   * Target frames per millisecond.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 0.06
-   */
-  TARGET_FPMS: 0.06,
-
-  /**
-   * If set to true WebGL will attempt make textures mimpaped by default.
-   * Mipmapping will only succeed if the base texture uploaded has power of two dimensions.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {boolean}
-   * @default true
-   */
-  MIPMAP_TEXTURES: true,
-
-  /**
-   * Default resolution / device pixel ratio of the renderer.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 1
-   */
-  RESOLUTION: 1,
-
-  /**
-   * Default filter resolution.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 1
-   */
-  FILTER_RESOLUTION: 1,
-
-  /**
-   * The maximum textures that this device supports.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 32
-   */
-  SPRITE_MAX_TEXTURES: (0, _maxRecommendedTextures2.default)(32),
-
-  // TODO: maybe change to SPRITE.BATCH_SIZE: 2000
-  // TODO: maybe add PARTICLE.BATCH_SIZE: 15000
-
-  /**
-   * The default sprite batch size.
-   *
-   * The default aims to balance desktop and mobile devices.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 4096
-   */
-  SPRITE_BATCH_SIZE: 4096,
-
-  /**
-   * The prefix that denotes a URL is for a retina asset.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {RegExp}
-   * @example `@2x`
-   * @default /@([0-9\.]+)x/
-   */
-  RETINA_PREFIX: /@([0-9\.]+)x/,
-
-  /**
-   * The default render options if none are supplied to {@link PIXI.WebGLRenderer}
-   * or {@link PIXI.CanvasRenderer}.
-   *
-   * @static
-   * @constant
-   * @memberof PIXI.settings
-   * @type {object}
-   * @property {HTMLCanvasElement} view=null
-   * @property {number} resolution=1
-   * @property {boolean} antialias=false
-   * @property {boolean} forceFXAA=false
-   * @property {boolean} autoResize=false
-   * @property {boolean} transparent=false
-   * @property {number} backgroundColor=0x000000
-   * @property {boolean} clearBeforeRender=true
-   * @property {boolean} preserveDrawingBuffer=false
-   * @property {boolean} roundPixels=false
-   * @property {number} width=800
-   * @property {number} height=600
-   * @property {boolean} legacy=false
-   */
-  RENDER_OPTIONS: {
-    view: null,
-    antialias: false,
-    forceFXAA: false,
-    autoResize: false,
-    transparent: false,
-    backgroundColor: 0x000000,
-    clearBeforeRender: true,
-    preserveDrawingBuffer: false,
-    roundPixels: false,
-    width: 800,
-    height: 600,
-    legacy: false
-  },
-
-  /**
-   * Default transform type.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {PIXI.TRANSFORM_MODE}
-   * @default PIXI.TRANSFORM_MODE.STATIC
-   */
-  TRANSFORM_MODE: 0,
-
-  /**
-   * Default Garbage Collection mode.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {PIXI.GC_MODES}
-   * @default PIXI.GC_MODES.AUTO
-   */
-  GC_MODE: 0,
-
-  /**
-   * Default Garbage Collection max idle.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 3600
-   */
-  GC_MAX_IDLE: 60 * 60,
-
-  /**
-   * Default Garbage Collection maximum check count.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 600
-   */
-  GC_MAX_CHECK_COUNT: 60 * 10,
-
-  /**
-   * Default wrap modes that are supported by pixi.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {PIXI.WRAP_MODES}
-   * @default PIXI.WRAP_MODES.CLAMP
-   */
-  WRAP_MODE: 0,
-
-  /**
-   * The scale modes that are supported by pixi.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {PIXI.SCALE_MODES}
-   * @default PIXI.SCALE_MODES.LINEAR
-   */
-  SCALE_MODE: 0,
-
-  /**
-   * Default specify float precision in vertex shader.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {PIXI.PRECISION}
-   * @default PIXI.PRECISION.HIGH
-   */
-  PRECISION_VERTEX: 'highp',
-
-  /**
-   * Default specify float precision in fragment shader.
-   *
-   * @static
-   * @memberof PIXI.settings
-   * @type {PIXI.PRECISION}
-   * @default PIXI.PRECISION.MEDIUM
-   */
-  PRECISION_FRAGMENT: 'mediump',
-
-  /**
-   * Can we upload the same buffer in a single frame?
-   *
-   * @static
-   * @constant
-   * @memberof PIXI
-   * @type {boolean}
-   */
-  CAN_UPLOAD_SAME_BUFFER: (0, _canUploadSameBuffer2.default)()
-
-};
-
-},{"./utils/canUploadSameBuffer":121,"./utils/maxRecommendedTextures":126}],102:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _math = require('../math');
-
-var _utils = require('../utils');
-
-var _const = require('../const');
-
-var _Texture = require('../textures/Texture');
-
-var _Texture2 = _interopRequireDefault(_Texture);
-
-var _Container2 = require('../display/Container');
-
-var _Container3 = _interopRequireDefault(_Container2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var tempPoint = new _math.Point();
-
-/**
- * The Sprite object is the base for all textured objects that are rendered to the screen
- *
- * A sprite can be created directly from an image like this:
- *
- * ```js
- * let sprite = new PIXI.Sprite.fromImage('assets/image.png');
- * ```
- *
- * @class
- * @extends PIXI.Container
- * @memberof PIXI
- */
-
-var Sprite = function (_Container) {
-    _inherits(Sprite, _Container);
-
-    /**
-     * @param {PIXI.Texture} texture - The texture for this sprite
-     */
-    function Sprite(texture) {
-        _classCallCheck(this, Sprite);
-
-        /**
-         * The anchor sets the origin point of the texture.
-         * The default is 0,0 this means the texture's origin is the top left
-         * Setting the anchor to 0.5,0.5 means the texture's origin is centered
-         * Setting the anchor to 1,1 would mean the texture's origin point will be the bottom right corner
-         *
-         * @member {PIXI.ObservablePoint}
-         * @private
-         */
-        var _this = _possibleConstructorReturn(this, _Container.call(this));
-
-        _this._anchor = new _math.ObservablePoint(_this._onAnchorUpdate, _this);
-
-        /**
-         * The texture that the sprite is using
-         *
-         * @private
-         * @member {PIXI.Texture}
-         */
-        _this._texture = null;
-
-        /**
-         * The width of the sprite (this is initially set by the texture)
-         *
-         * @private
-         * @member {number}
-         */
-        _this._width = 0;
-
-        /**
-         * The height of the sprite (this is initially set by the texture)
-         *
-         * @private
-         * @member {number}
-         */
-        _this._height = 0;
-
-        /**
-         * The tint applied to the sprite. This is a hex value. A value of 0xFFFFFF will remove any tint effect.
-         *
-         * @private
-         * @member {number}
-         * @default 0xFFFFFF
-         */
-        _this._tint = null;
-        _this._tintRGB = null;
-        _this.tint = 0xFFFFFF;
-
-        /**
-         * The blend mode to be applied to the sprite. Apply a value of `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.
-         *
-         * @member {number}
-         * @default PIXI.BLEND_MODES.NORMAL
-         * @see PIXI.BLEND_MODES
-         */
-        _this.blendMode = _const.BLEND_MODES.NORMAL;
-
-        /**
-         * The shader that will be used to render the sprite. Set to null to remove a current shader.
-         *
-         * @member {PIXI.Filter|PIXI.Shader}
-         */
-        _this.shader = null;
-
-        /**
-         * An internal cached value of the tint.
-         *
-         * @private
-         * @member {number}
-         * @default 0xFFFFFF
-         */
-        _this.cachedTint = 0xFFFFFF;
-
-        // call texture setter
-        _this.texture = texture || _Texture2.default.EMPTY;
-
-        /**
-         * this is used to store the vertex data of the sprite (basically a quad)
-         *
-         * @private
-         * @member {Float32Array}
-         */
-        _this.vertexData = new Float32Array(8);
-
-        /**
-         * This is used to calculate the bounds of the object IF it is a trimmed sprite
-         *
-         * @private
-         * @member {Float32Array}
-         */
-        _this.vertexTrimmedData = null;
-
-        _this._transformID = -1;
-        _this._textureID = -1;
-
-        _this._transformTrimmedID = -1;
-        _this._textureTrimmedID = -1;
-
-        /**
-         * Plugin that is responsible for rendering this element.
-         * Allows to customize the rendering process without overriding '_renderWebGL' & '_renderCanvas' methods.
-         *
-         * @member {string}
-         * @default 'sprite'
-         */
-        _this.pluginName = 'sprite';
-        return _this;
-    }
-
-    /**
-     * When the texture is updated, this event will fire to update the scale and frame
-     *
-     * @private
-     */
-
-
-    Sprite.prototype._onTextureUpdate = function _onTextureUpdate() {
-        this._textureID = -1;
-        this._textureTrimmedID = -1;
-
-        // so if _width is 0 then width was not set..
-        if (this._width) {
-            this.scale.x = (0, _utils.sign)(this.scale.x) * this._width / this._texture.orig.width;
-        }
-
-        if (this._height) {
-            this.scale.y = (0, _utils.sign)(this.scale.y) * this._height / this._texture.orig.height;
-        }
-    };
-
-    /**
-     * Called when the anchor position updates.
-     *
-     * @private
-     */
-
-
-    Sprite.prototype._onAnchorUpdate = function _onAnchorUpdate() {
-        this._transformID = -1;
-        this._transformTrimmedID = -1;
-    };
-
-    /**
-     * calculates worldTransform * vertices, store it in vertexData
-     */
-
-
-    Sprite.prototype.calculateVertices = function calculateVertices() {
-        if (this._transformID === this.transform._worldID && this._textureID === this._texture._updateID) {
-            return;
-        }
-
-        this._transformID = this.transform._worldID;
-        this._textureID = this._texture._updateID;
-
-        // set the vertex data
-
-        var texture = this._texture;
-        var wt = this.transform.worldTransform;
-        var a = wt.a;
-        var b = wt.b;
-        var c = wt.c;
-        var d = wt.d;
-        var tx = wt.tx;
-        var ty = wt.ty;
-        var vertexData = this.vertexData;
-        var trim = texture.trim;
-        var orig = texture.orig;
-        var anchor = this._anchor;
-
-        var w0 = 0;
-        var w1 = 0;
-        var h0 = 0;
-        var h1 = 0;
-
-        if (trim) {
-            // if the sprite is trimmed and is not a tilingsprite then we need to add the extra
-            // space before transforming the sprite coords.
-            w1 = trim.x - anchor._x * orig.width;
-            w0 = w1 + trim.width;
-
-            h1 = trim.y - anchor._y * orig.height;
-            h0 = h1 + trim.height;
-        } else {
-            w1 = -anchor._x * orig.width;
-            w0 = w1 + orig.width;
-
-            h1 = -anchor._y * orig.height;
-            h0 = h1 + orig.height;
-        }
-
-        // xy
-        vertexData[0] = a * w1 + c * h1 + tx;
-        vertexData[1] = d * h1 + b * w1 + ty;
-
-        // xy
-        vertexData[2] = a * w0 + c * h1 + tx;
-        vertexData[3] = d * h1 + b * w0 + ty;
-
-        // xy
-        vertexData[4] = a * w0 + c * h0 + tx;
-        vertexData[5] = d * h0 + b * w0 + ty;
-
-        // xy
-        vertexData[6] = a * w1 + c * h0 + tx;
-        vertexData[7] = d * h0 + b * w1 + ty;
-    };
-
-    /**
-     * calculates worldTransform * vertices for a non texture with a trim. store it in vertexTrimmedData
-     * This is used to ensure that the true width and height of a trimmed texture is respected
-     */
-
-
-    Sprite.prototype.calculateTrimmedVertices = function calculateTrimmedVertices() {
-        if (!this.vertexTrimmedData) {
-            this.vertexTrimmedData = new Float32Array(8);
-        } else if (this._transformTrimmedID === this.transform._worldID && this._textureTrimmedID === this._texture._updateID) {
-            return;
-        }
-
-        this._transformTrimmedID = this.transform._worldID;
-        this._textureTrimmedID = this._texture._updateID;
-
-        // lets do some special trim code!
-        var texture = this._texture;
-        var vertexData = this.vertexTrimmedData;
-        var orig = texture.orig;
-        var anchor = this._anchor;
-
-        // lets calculate the new untrimmed bounds..
-        var wt = this.transform.worldTransform;
-        var a = wt.a;
-        var b = wt.b;
-        var c = wt.c;
-        var d = wt.d;
-        var tx = wt.tx;
-        var ty = wt.ty;
-
-        var w1 = -anchor._x * orig.width;
-        var w0 = w1 + orig.width;
-
-        var h1 = -anchor._y * orig.height;
-        var h0 = h1 + orig.height;
-
-        // xy
-        vertexData[0] = a * w1 + c * h1 + tx;
-        vertexData[1] = d * h1 + b * w1 + ty;
-
-        // xy
-        vertexData[2] = a * w0 + c * h1 + tx;
-        vertexData[3] = d * h1 + b * w0 + ty;
-
-        // xy
-        vertexData[4] = a * w0 + c * h0 + tx;
-        vertexData[5] = d * h0 + b * w0 + ty;
-
-        // xy
-        vertexData[6] = a * w1 + c * h0 + tx;
-        vertexData[7] = d * h0 + b * w1 + ty;
-    };
-
-    /**
-    *
-    * Renders the object using the WebGL renderer
-    *
-    * @private
-    * @param {PIXI.WebGLRenderer} renderer - The webgl renderer to use.
-    */
-
-
-    Sprite.prototype._renderWebGL = function _renderWebGL(renderer) {
-        this.calculateVertices();
-
-        renderer.setObjectRenderer(renderer.plugins[this.pluginName]);
-        renderer.plugins[this.pluginName].render(this);
-    };
-
-    /**
-    * Renders the object using the Canvas renderer
-    *
-    * @private
-    * @param {PIXI.CanvasRenderer} renderer - The renderer
-    */
-
-
-    Sprite.prototype._renderCanvas = function _renderCanvas(renderer) {
-        renderer.plugins[this.pluginName].render(this);
-    };
-
-    /**
-     * Updates the bounds of the sprite.
-     *
-     * @private
-     */
-
-
-    Sprite.prototype._calculateBounds = function _calculateBounds() {
-        var trim = this._texture.trim;
-        var orig = this._texture.orig;
-
-        // First lets check to see if the current texture has a trim..
-        if (!trim || trim.width === orig.width && trim.height === orig.height) {
-            // no trim! lets use the usual calculations..
-            this.calculateVertices();
-            this._bounds.addQuad(this.vertexData);
-        } else {
-            // lets calculate a special trimmed bounds...
-            this.calculateTrimmedVertices();
-            this._bounds.addQuad(this.vertexTrimmedData);
-        }
-    };
-
-    /**
-     * Gets the local bounds of the sprite object.
-     *
-     * @param {PIXI.Rectangle} rect - The output rectangle.
-     * @return {PIXI.Rectangle} The bounds.
-     */
-
-
-    Sprite.prototype.getLocalBounds = function getLocalBounds(rect) {
-        // we can do a fast local bounds if the sprite has no children!
-        if (this.children.length === 0) {
-            this._bounds.minX = this._texture.orig.width * -this._anchor._x;
-            this._bounds.minY = this._texture.orig.height * -this._anchor._y;
-            this._bounds.maxX = this._texture.orig.width * (1 - this._anchor._x);
-            this._bounds.maxY = this._texture.orig.height * (1 - this._anchor._x);
-
-            if (!rect) {
-                if (!this._localBoundsRect) {
-                    this._localBoundsRect = new _math.Rectangle();
-                }
-
-                rect = this._localBoundsRect;
-            }
-
-            return this._bounds.getRectangle(rect);
-        }
-
-        return _Container.prototype.getLocalBounds.call(this, rect);
-    };
-
-    /**
-     * Tests if a point is inside this sprite
-     *
-     * @param {PIXI.Point} point - the point to test
-     * @return {boolean} the result of the test
-     */
-
-
-    Sprite.prototype.containsPoint = function containsPoint(point) {
-        this.worldTransform.applyInverse(point, tempPoint);
-
-        var width = this._texture.orig.width;
-        var height = this._texture.orig.height;
-        var x1 = -width * this.anchor.x;
-        var y1 = 0;
-
-        if (tempPoint.x >= x1 && tempPoint.x < x1 + width) {
-            y1 = -height * this.anchor.y;
-
-            if (tempPoint.y >= y1 && tempPoint.y < y1 + height) {
-                return true;
-            }
-        }
-
-        return false;
-    };
-
-    /**
-     * Destroys this sprite and optionally its texture and children
-     *
-     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-     *  have been set to that value
-     * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
-     *      method called as well. 'options' will be passed on to those calls.
-     * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well
-     * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well
-     */
-
-
-    Sprite.prototype.destroy = function destroy(options) {
-        _Container.prototype.destroy.call(this, options);
-
-        this._anchor = null;
-
-        var destroyTexture = typeof options === 'boolean' ? options : options && options.texture;
-
-        if (destroyTexture) {
-            var destroyBaseTexture = typeof options === 'boolean' ? options : options && options.baseTexture;
-
-            this._texture.destroy(!!destroyBaseTexture);
-        }
-
-        this._texture = null;
-        this.shader = null;
-    };
-
-    // some helper functions..
-
-    /**
-     * Helper function that creates a new sprite based on the source you provide.
-     * The source can be - frame id, image url, video url, canvas element, video element, base texture
-     *
-     * @static
-     * @param {number|string|PIXI.BaseTexture|HTMLCanvasElement|HTMLVideoElement} source Source to create texture from
-     * @return {PIXI.Sprite} The newly created sprite
-     */
-
-
-    Sprite.from = function from(source) {
-        return new Sprite(_Texture2.default.from(source));
-    };
-
-    /**
-     * Helper function that creates a sprite that will contain a texture from the TextureCache based on the frameId
-     * The frame ids are created when a Texture packer file has been loaded
-     *
-     * @static
-     * @param {string} frameId - The frame Id of the texture in the cache
-     * @return {PIXI.Sprite} A new Sprite using a texture from the texture cache matching the frameId
-     */
-
-
-    Sprite.fromFrame = function fromFrame(frameId) {
-        var texture = _utils.TextureCache[frameId];
-
-        if (!texture) {
-            throw new Error('The frameId "' + frameId + '" does not exist in the texture cache');
-        }
-
-        return new Sprite(texture);
-    };
-
-    /**
-     * Helper function that creates a sprite that will contain a texture based on an image url
-     * If the image is not in the texture cache it will be loaded
-     *
-     * @static
-     * @param {string} imageId - The image url of the texture
-     * @param {boolean} [crossorigin=(auto)] - if you want to specify the cross-origin parameter
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - if you want to specify the scale mode,
-     *  see {@link PIXI.SCALE_MODES} for possible values
-     * @return {PIXI.Sprite} A new Sprite using a texture from the texture cache matching the image id
-     */
-
-
-    Sprite.fromImage = function fromImage(imageId, crossorigin, scaleMode) {
-        return new Sprite(_Texture2.default.fromImage(imageId, crossorigin, scaleMode));
-    };
-
-    /**
-     * The width of the sprite, setting this will actually modify the scale to achieve the value set
-     *
-     * @member {number}
-     */
-
-
-    _createClass(Sprite, [{
-        key: 'width',
-        get: function get() {
-            return Math.abs(this.scale.x) * this._texture.orig.width;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            var s = (0, _utils.sign)(this.scale.x) || 1;
-
-            this.scale.x = s * value / this._texture.orig.width;
-            this._width = value;
-        }
-
-        /**
-         * The height of the sprite, setting this will actually modify the scale to achieve the value set
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'height',
-        get: function get() {
-            return Math.abs(this.scale.y) * this._texture.orig.height;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            var s = (0, _utils.sign)(this.scale.y) || 1;
-
-            this.scale.y = s * value / this._texture.orig.height;
-            this._height = value;
-        }
-
-        /**
-         * The anchor sets the origin point of the texture.
-         * The default is 0,0 this means the texture's origin is the top left
-         * Setting the anchor to 0.5,0.5 means the texture's origin is centered
-         * Setting the anchor to 1,1 would mean the texture's origin point will be the bottom right corner
-         *
-         * @member {PIXI.ObservablePoint}
-         */
-
-    }, {
-        key: 'anchor',
-        get: function get() {
-            return this._anchor;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._anchor.copy(value);
-        }
-
-        /**
-         * The tint applied to the sprite. This is a hex value.
-         * A value of 0xFFFFFF will remove any tint effect.
-         *
-         * @member {number}
-         * @default 0xFFFFFF
-         */
-
-    }, {
-        key: 'tint',
-        get: function get() {
-            return this._tint;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._tint = value;
-            this._tintRGB = (value >> 16) + (value & 0xff00) + ((value & 0xff) << 16);
-        }
-
-        /**
-         * The texture that the sprite is using
-         *
-         * @member {PIXI.Texture}
-         */
-
-    }, {
-        key: 'texture',
-        get: function get() {
-            return this._texture;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (this._texture === value) {
-                return;
-            }
-
-            this._texture = value;
-            this.cachedTint = 0xFFFFFF;
-
-            this._textureID = -1;
-            this._textureTrimmedID = -1;
-
-            if (value) {
-                // wait for the texture to load
-                if (value.baseTexture.hasLoaded) {
-                    this._onTextureUpdate();
-                } else {
-                    value.once('update', this._onTextureUpdate, this);
-                }
-            }
-        }
-    }]);
-
-    return Sprite;
-}(_Container3.default);
-
-exports.default = Sprite;
-
-},{"../const":46,"../display/Container":48,"../math":70,"../textures/Texture":115,"../utils":124}],103:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _CanvasRenderer = require('../../renderers/canvas/CanvasRenderer');
-
-var _CanvasRenderer2 = _interopRequireDefault(_CanvasRenderer);
-
-var _const = require('../../const');
-
-var _math = require('../../math');
-
-var _CanvasTinter = require('./CanvasTinter');
-
-var _CanvasTinter2 = _interopRequireDefault(_CanvasTinter);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var canvasRenderWorldTransform = new _math.Matrix();
-
-/**
- * @author Mat Groves
- *
- * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
- * for creating the original PixiJS version!
- * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they now
- * share 4 bytes on the vertex buffer
- *
- * Heavily inspired by LibGDX's CanvasSpriteRenderer:
- * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/CanvasSpriteRenderer.java
- */
-
-/**
- * Renderer dedicated to drawing and batching sprites.
- *
- * @class
- * @private
- * @memberof PIXI
- */
-
-var CanvasSpriteRenderer = function () {
-    /**
-     * @param {PIXI.WebGLRenderer} renderer -The renderer sprite this batch works for.
-     */
-    function CanvasSpriteRenderer(renderer) {
-        _classCallCheck(this, CanvasSpriteRenderer);
-
-        this.renderer = renderer;
-    }
-
-    /**
-     * Renders the sprite object.
-     *
-     * @param {PIXI.Sprite} sprite - the sprite to render when using this spritebatch
-     */
-
-
-    CanvasSpriteRenderer.prototype.render = function render(sprite) {
-        var texture = sprite._texture;
-        var renderer = this.renderer;
-
-        var width = texture._frame.width;
-        var height = texture._frame.height;
-
-        var wt = sprite.transform.worldTransform;
-        var dx = 0;
-        var dy = 0;
-
-        if (texture.orig.width <= 0 || texture.orig.height <= 0 || !texture.baseTexture.source) {
-            return;
-        }
-
-        renderer.setBlendMode(sprite.blendMode);
-
-        //  Ignore null sources
-        if (texture.valid) {
-            renderer.context.globalAlpha = sprite.worldAlpha;
-
-            // If smoothingEnabled is supported and we need to change the smoothing property for sprite texture
-            var smoothingEnabled = texture.baseTexture.scaleMode === _const.SCALE_MODES.LINEAR;
-
-            if (renderer.smoothProperty && renderer.context[renderer.smoothProperty] !== smoothingEnabled) {
-                renderer.context[renderer.smoothProperty] = smoothingEnabled;
-            }
-
-            if (texture.trim) {
-                dx = texture.trim.width / 2 + texture.trim.x - sprite.anchor.x * texture.orig.width;
-                dy = texture.trim.height / 2 + texture.trim.y - sprite.anchor.y * texture.orig.height;
-            } else {
-                dx = (0.5 - sprite.anchor.x) * texture.orig.width;
-                dy = (0.5 - sprite.anchor.y) * texture.orig.height;
-            }
-
-            if (texture.rotate) {
-                wt.copy(canvasRenderWorldTransform);
-                wt = canvasRenderWorldTransform;
-                _math.GroupD8.matrixAppendRotationInv(wt, texture.rotate, dx, dy);
-                // the anchor has already been applied above, so lets set it to zero
-                dx = 0;
-                dy = 0;
-            }
-
-            dx -= width / 2;
-            dy -= height / 2;
-
-            // Allow for pixel rounding
-            if (renderer.roundPixels) {
-                renderer.context.setTransform(wt.a, wt.b, wt.c, wt.d, wt.tx * renderer.resolution | 0, wt.ty * renderer.resolution | 0);
-
-                dx = dx | 0;
-                dy = dy | 0;
-            } else {
-                renderer.context.setTransform(wt.a, wt.b, wt.c, wt.d, wt.tx * renderer.resolution, wt.ty * renderer.resolution);
-            }
-
-            var resolution = texture.baseTexture.resolution;
-
-            if (sprite.tint !== 0xFFFFFF) {
-                if (sprite.cachedTint !== sprite.tint || sprite.tintedTexture.tintId !== sprite._texture._updateID) {
-                    sprite.cachedTint = sprite.tint;
-
-                    // TODO clean up caching - how to clean up the caches?
-                    sprite.tintedTexture = _CanvasTinter2.default.getTintedTexture(sprite, sprite.tint);
-                }
-
-                renderer.context.drawImage(sprite.tintedTexture, 0, 0, width * resolution, height * resolution, dx * renderer.resolution, dy * renderer.resolution, width * renderer.resolution, height * renderer.resolution);
-            } else {
-                renderer.context.drawImage(texture.baseTexture.source, texture._frame.x * resolution, texture._frame.y * resolution, width * resolution, height * resolution, dx * renderer.resolution, dy * renderer.resolution, width * renderer.resolution, height * renderer.resolution);
-            }
-        }
-    };
-
-    /**
-     * destroy the sprite object.
-     *
-     */
-
-
-    CanvasSpriteRenderer.prototype.destroy = function destroy() {
-        this.renderer = null;
-    };
-
-    return CanvasSpriteRenderer;
-}();
-
-exports.default = CanvasSpriteRenderer;
-
-
-_CanvasRenderer2.default.registerPlugin('sprite', CanvasSpriteRenderer);
-
-},{"../../const":46,"../../math":70,"../../renderers/canvas/CanvasRenderer":77,"./CanvasTinter":104}],104:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _utils = require('../../utils');
-
-var _canUseNewCanvasBlendModes = require('../../renderers/canvas/utils/canUseNewCanvasBlendModes');
-
-var _canUseNewCanvasBlendModes2 = _interopRequireDefault(_canUseNewCanvasBlendModes);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Utility methods for Sprite/Texture tinting.
- *
- * @class
- * @memberof PIXI
- */
-var CanvasTinter = {
-    /**
-     * Basically this method just needs a sprite and a color and tints the sprite with the given color.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @param {PIXI.Sprite} sprite - the sprite to tint
-     * @param {number} color - the color to use to tint the sprite with
-     * @return {HTMLCanvasElement} The tinted canvas
-     */
-    getTintedTexture: function getTintedTexture(sprite, color) {
-        var texture = sprite._texture;
-
-        color = CanvasTinter.roundColor(color);
-
-        var stringColor = '#' + ('00000' + (color | 0).toString(16)).substr(-6);
-
-        texture.tintCache = texture.tintCache || {};
-
-        var cachedTexture = texture.tintCache[stringColor];
-
-        var canvas = void 0;
-
-        if (cachedTexture) {
-            if (cachedTexture.tintId === texture._updateID) {
-                return texture.tintCache[stringColor];
-            }
-
-            canvas = texture.tintCache[stringColor];
-        } else {
-            canvas = CanvasTinter.canvas || document.createElement('canvas');
-        }
-
-        CanvasTinter.tintMethod(texture, color, canvas);
-
-        canvas.tintId = texture._updateID;
-
-        if (CanvasTinter.convertTintToImage) {
-            // is this better?
-            var tintImage = new Image();
-
-            tintImage.src = canvas.toDataURL();
-
-            texture.tintCache[stringColor] = tintImage;
-        } else {
-            texture.tintCache[stringColor] = canvas;
-            // if we are not converting the texture to an image then we need to lose the reference to the canvas
-            CanvasTinter.canvas = null;
-        }
-
-        return canvas;
-    },
-
-    /**
-     * Tint a texture using the 'multiply' operation.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @param {PIXI.Texture} texture - the texture to tint
-     * @param {number} color - the color to use to tint the sprite with
-     * @param {HTMLCanvasElement} canvas - the current canvas
-     */
-    tintWithMultiply: function tintWithMultiply(texture, color, canvas) {
-        var context = canvas.getContext('2d');
-        var crop = texture._frame.clone();
-        var resolution = texture.baseTexture.resolution;
-
-        crop.x *= resolution;
-        crop.y *= resolution;
-        crop.width *= resolution;
-        crop.height *= resolution;
-
-        canvas.width = Math.ceil(crop.width);
-        canvas.height = Math.ceil(crop.height);
-
-        context.fillStyle = '#' + ('00000' + (color | 0).toString(16)).substr(-6);
-
-        context.fillRect(0, 0, crop.width, crop.height);
-
-        context.globalCompositeOperation = 'multiply';
-
-        context.drawImage(texture.baseTexture.source, crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
-
-        context.globalCompositeOperation = 'destination-atop';
-
-        context.drawImage(texture.baseTexture.source, crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
-    },
-
-    /**
-     * Tint a texture using the 'overlay' operation.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @param {PIXI.Texture} texture - the texture to tint
-     * @param {number} color - the color to use to tint the sprite with
-     * @param {HTMLCanvasElement} canvas - the current canvas
-     */
-    tintWithOverlay: function tintWithOverlay(texture, color, canvas) {
-        var context = canvas.getContext('2d');
-        var crop = texture._frame.clone();
-        var resolution = texture.baseTexture.resolution;
-
-        crop.x *= resolution;
-        crop.y *= resolution;
-        crop.width *= resolution;
-        crop.height *= resolution;
-
-        canvas.width = Math.ceil(crop.width);
-        canvas.height = Math.ceil(crop.height);
-
-        context.globalCompositeOperation = 'copy';
-        context.fillStyle = '#' + ('00000' + (color | 0).toString(16)).substr(-6);
-        context.fillRect(0, 0, crop.width, crop.height);
-
-        context.globalCompositeOperation = 'destination-atop';
-        context.drawImage(texture.baseTexture.source, crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
-
-        // context.globalCompositeOperation = 'copy';
-    },
-
-
-    /**
-     * Tint a texture pixel per pixel.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @param {PIXI.Texture} texture - the texture to tint
-     * @param {number} color - the color to use to tint the sprite with
-     * @param {HTMLCanvasElement} canvas - the current canvas
-     */
-    tintWithPerPixel: function tintWithPerPixel(texture, color, canvas) {
-        var context = canvas.getContext('2d');
-        var crop = texture._frame.clone();
-        var resolution = texture.baseTexture.resolution;
-
-        crop.x *= resolution;
-        crop.y *= resolution;
-        crop.width *= resolution;
-        crop.height *= resolution;
-
-        canvas.width = Math.ceil(crop.width);
-        canvas.height = Math.ceil(crop.height);
-
-        context.globalCompositeOperation = 'copy';
-        context.drawImage(texture.baseTexture.source, crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
-
-        var rgbValues = (0, _utils.hex2rgb)(color);
-        var r = rgbValues[0];
-        var g = rgbValues[1];
-        var b = rgbValues[2];
-
-        var pixelData = context.getImageData(0, 0, crop.width, crop.height);
-
-        var pixels = pixelData.data;
-
-        for (var i = 0; i < pixels.length; i += 4) {
-            pixels[i + 0] *= r;
-            pixels[i + 1] *= g;
-            pixels[i + 2] *= b;
-        }
-
-        context.putImageData(pixelData, 0, 0);
-    },
-
-    /**
-     * Rounds the specified color according to the CanvasTinter.cacheStepsPerColorChannel.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @param {number} color - the color to round, should be a hex color
-     * @return {number} The rounded color.
-     */
-    roundColor: function roundColor(color) {
-        var step = CanvasTinter.cacheStepsPerColorChannel;
-
-        var rgbValues = (0, _utils.hex2rgb)(color);
-
-        rgbValues[0] = Math.min(255, rgbValues[0] / step * step);
-        rgbValues[1] = Math.min(255, rgbValues[1] / step * step);
-        rgbValues[2] = Math.min(255, rgbValues[2] / step * step);
-
-        return (0, _utils.rgb2hex)(rgbValues);
-    },
-
-    /**
-     * Number of steps which will be used as a cap when rounding colors.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @type {number}
-     */
-    cacheStepsPerColorChannel: 8,
-
-    /**
-     * Tint cache boolean flag.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @type {boolean}
-     */
-    convertTintToImage: false,
-
-    /**
-     * Whether or not the Canvas BlendModes are supported, consequently the ability to tint using the multiply method.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @type {boolean}
-     */
-    canUseMultiply: (0, _canUseNewCanvasBlendModes2.default)(),
-
-    /**
-     * The tinting method that will be used.
-     *
-     * @memberof PIXI.CanvasTinter
-     * @type {tintMethodFunctionType}
-     */
-    tintMethod: 0
-};
-
-CanvasTinter.tintMethod = CanvasTinter.canUseMultiply ? CanvasTinter.tintWithMultiply : CanvasTinter.tintWithPerPixel;
-
-/**
- * The tintMethod type.
- *
- * @memberof PIXI.CanvasTinter
- * @callback tintMethodFunctionType
- * @param texture {PIXI.Texture} the texture to tint
- * @param color {number} the color to use to tint the sprite with
- * @param canvas {HTMLCanvasElement} the current canvas
- */
-
-exports.default = CanvasTinter;
-
-},{"../../renderers/canvas/utils/canUseNewCanvasBlendModes":80,"../../utils":124}],105:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @class
- * @memberof PIXI
- */
-var Buffer = function () {
-  /**
-   * @param {number} size - The size of the buffer in bytes.
-   */
-  function Buffer(size) {
-    _classCallCheck(this, Buffer);
-
-    this.vertices = new ArrayBuffer(size);
-
-    /**
-     * View on the vertices as a Float32Array for positions
-     *
-     * @member {Float32Array}
-     */
-    this.float32View = new Float32Array(this.vertices);
-
-    /**
-     * View on the vertices as a Uint32Array for uvs
-     *
-     * @member {Float32Array}
-     */
-    this.uint32View = new Uint32Array(this.vertices);
-  }
-
-  /**
-   * Destroys the buffer.
-   *
-   */
-
-
-  Buffer.prototype.destroy = function destroy() {
-    this.vertices = null;
-    this.positions = null;
-    this.uvs = null;
-    this.colors = null;
-  };
-
-  return Buffer;
-}();
-
-exports.default = Buffer;
-
-},{}],106:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _ObjectRenderer2 = require('../../renderers/webgl/utils/ObjectRenderer');
-
-var _ObjectRenderer3 = _interopRequireDefault(_ObjectRenderer2);
-
-var _WebGLRenderer = require('../../renderers/webgl/WebGLRenderer');
-
-var _WebGLRenderer2 = _interopRequireDefault(_WebGLRenderer);
-
-var _createIndicesForQuads = require('../../utils/createIndicesForQuads');
-
-var _createIndicesForQuads2 = _interopRequireDefault(_createIndicesForQuads);
-
-var _generateMultiTextureShader = require('./generateMultiTextureShader');
-
-var _generateMultiTextureShader2 = _interopRequireDefault(_generateMultiTextureShader);
-
-var _checkMaxIfStatmentsInShader = require('../../renderers/webgl/utils/checkMaxIfStatmentsInShader');
-
-var _checkMaxIfStatmentsInShader2 = _interopRequireDefault(_checkMaxIfStatmentsInShader);
-
-var _BatchBuffer = require('./BatchBuffer');
-
-var _BatchBuffer2 = _interopRequireDefault(_BatchBuffer);
-
-var _settings = require('../../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _utils = require('../../utils');
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-var _bitTwiddle = require('bit-twiddle');
-
-var _bitTwiddle2 = _interopRequireDefault(_bitTwiddle);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var TICK = 0;
-var TEXTURE_TICK = 0;
-
-/**
- * Renderer dedicated to drawing and batching sprites.
- *
- * @class
- * @private
- * @memberof PIXI
- * @extends PIXI.ObjectRenderer
- */
-
-var SpriteRenderer = function (_ObjectRenderer) {
-    _inherits(SpriteRenderer, _ObjectRenderer);
-
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - The renderer this sprite batch works for.
-     */
-    function SpriteRenderer(renderer) {
-        _classCallCheck(this, SpriteRenderer);
-
-        /**
-         * Number of values sent in the vertex buffer.
-         * aVertexPosition(2), aTextureCoord(1), aColor(1), aTextureId(1) = 5
-         *
-         * @member {number}
-         */
-        var _this = _possibleConstructorReturn(this, _ObjectRenderer.call(this, renderer));
-
-        _this.vertSize = 5;
-
-        /**
-         * The size of the vertex information in bytes.
-         *
-         * @member {number}
-         */
-        _this.vertByteSize = _this.vertSize * 4;
-
-        /**
-         * The number of images in the SpriteRenderer before it flushes.
-         *
-         * @member {number}
-         */
-        _this.size = _settings2.default.SPRITE_BATCH_SIZE; // 2000 is a nice balance between mobile / desktop
-
-        // the total number of bytes in our batch
-        // let numVerts = this.size * 4 * this.vertByteSize;
-
-        _this.buffers = [];
-        for (var i = 1; i <= _bitTwiddle2.default.nextPow2(_this.size); i *= 2) {
-            _this.buffers.push(new _BatchBuffer2.default(i * 4 * _this.vertByteSize));
-        }
-
-        /**
-         * Holds the indices of the geometry (quads) to draw
-         *
-         * @member {Uint16Array}
-         */
-        _this.indices = (0, _createIndicesForQuads2.default)(_this.size);
-
-        /**
-         * The default shaders that is used if a sprite doesn't have a more specific one.
-         * there is a shader for each number of textures that can be rendererd.
-         * These shaders will also be generated on the fly as required.
-         * @member {PIXI.Shader[]}
-         */
-        _this.shader = null;
-
-        _this.currentIndex = 0;
-        _this.groups = [];
-
-        for (var k = 0; k < _this.size; k++) {
-            _this.groups[k] = { textures: [], textureCount: 0, ids: [], size: 0, start: 0, blend: 0 };
-        }
-
-        _this.sprites = [];
-
-        _this.vertexBuffers = [];
-        _this.vaos = [];
-
-        _this.vaoMax = 2;
-        _this.vertexCount = 0;
-
-        _this.renderer.on('prerender', _this.onPrerender, _this);
-        return _this;
-    }
-
-    /**
-     * Sets up the renderer context and necessary buffers.
-     *
-     * @private
-     */
-
-
-    SpriteRenderer.prototype.onContextChange = function onContextChange() {
-        var gl = this.renderer.gl;
-
-        if (this.renderer.legacy) {
-            this.MAX_TEXTURES = 1;
-        } else {
-            // step 1: first check max textures the GPU can handle.
-            this.MAX_TEXTURES = Math.min(gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS), _settings2.default.SPRITE_MAX_TEXTURES);
-
-            // step 2: check the maximum number of if statements the shader can have too..
-            this.MAX_TEXTURES = (0, _checkMaxIfStatmentsInShader2.default)(this.MAX_TEXTURES, gl);
-        }
-
-        this.shader = (0, _generateMultiTextureShader2.default)(gl, this.MAX_TEXTURES);
-
-        // create a couple of buffers
-        this.indexBuffer = _pixiGlCore2.default.GLBuffer.createIndexBuffer(gl, this.indices, gl.STATIC_DRAW);
-
-        // we use the second shader as the first one depending on your browser may omit aTextureId
-        // as it is not used by the shader so is optimized out.
-
-        this.renderer.bindVao(null);
-
-        var attrs = this.shader.attributes;
-
-        for (var i = 0; i < this.vaoMax; i++) {
-            /* eslint-disable max-len */
-            var vertexBuffer = this.vertexBuffers[i] = _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl, null, gl.STREAM_DRAW);
-            /* eslint-enable max-len */
-
-            // build the vao object that will render..
-            var vao = this.renderer.createVao().addIndex(this.indexBuffer).addAttribute(vertexBuffer, attrs.aVertexPosition, gl.FLOAT, false, this.vertByteSize, 0).addAttribute(vertexBuffer, attrs.aTextureCoord, gl.UNSIGNED_SHORT, true, this.vertByteSize, 2 * 4).addAttribute(vertexBuffer, attrs.aColor, gl.UNSIGNED_BYTE, true, this.vertByteSize, 3 * 4);
-
-            if (attrs.aTextureId) {
-                vao.addAttribute(vertexBuffer, attrs.aTextureId, gl.FLOAT, false, this.vertByteSize, 4 * 4);
-            }
-
-            this.vaos[i] = vao;
-        }
-
-        this.vao = this.vaos[0];
-        this.currentBlendMode = 99999;
-
-        this.boundTextures = new Array(this.MAX_TEXTURES);
-    };
-
-    /**
-     * Called before the renderer starts rendering.
-     *
-     */
-
-
-    SpriteRenderer.prototype.onPrerender = function onPrerender() {
-        this.vertexCount = 0;
-    };
-
-    /**
-     * Renders the sprite object.
-     *
-     * @param {PIXI.Sprite} sprite - the sprite to render when using this spritebatch
-     */
-
-
-    SpriteRenderer.prototype.render = function render(sprite) {
-        // TODO set blend modes..
-        // check texture..
-        if (this.currentIndex >= this.size) {
-            this.flush();
-        }
-
-        // get the uvs for the texture
-
-        // if the uvs have not updated then no point rendering just yet!
-        if (!sprite._texture._uvs) {
-            return;
-        }
-
-        // push a texture.
-        // increment the batchsize
-        this.sprites[this.currentIndex++] = sprite;
-    };
-
-    /**
-     * Renders the content and empties the current batch.
-     *
-     */
-
-
-    SpriteRenderer.prototype.flush = function flush() {
-        if (this.currentIndex === 0) {
-            return;
-        }
-
-        var gl = this.renderer.gl;
-        var MAX_TEXTURES = this.MAX_TEXTURES;
-
-        var np2 = _bitTwiddle2.default.nextPow2(this.currentIndex);
-        var log2 = _bitTwiddle2.default.log2(np2);
-        var buffer = this.buffers[log2];
-
-        var sprites = this.sprites;
-        var groups = this.groups;
-
-        var float32View = buffer.float32View;
-        var uint32View = buffer.uint32View;
-
-        var boundTextures = this.boundTextures;
-        var rendererBoundTextures = this.renderer.boundTextures;
-        var touch = this.renderer.textureGC.count;
-
-        var index = 0;
-        var nextTexture = void 0;
-        var currentTexture = void 0;
-        var groupCount = 1;
-        var textureCount = 0;
-        var currentGroup = groups[0];
-        var vertexData = void 0;
-        var uvs = void 0;
-        var blendMode = _utils.premultiplyBlendMode[sprites[0]._texture.baseTexture.premultipliedAlpha ? 1 : 0][sprites[0].blendMode];
-
-        currentGroup.textureCount = 0;
-        currentGroup.start = 0;
-        currentGroup.blend = blendMode;
-
-        TICK++;
-
-        var i = void 0;
-
-        // copy textures..
-        for (i = 0; i < MAX_TEXTURES; ++i) {
-            boundTextures[i] = rendererBoundTextures[i];
-            boundTextures[i]._virtalBoundId = i;
-        }
-
-        for (i = 0; i < this.currentIndex; ++i) {
-            // upload the sprite elemetns...
-            // they have all ready been calculated so we just need to push them into the buffer.
-            var sprite = sprites[i];
-
-            nextTexture = sprite._texture.baseTexture;
-
-            var spriteBlendMode = _utils.premultiplyBlendMode[Number(nextTexture.premultipliedAlpha)][sprite.blendMode];
-
-            if (blendMode !== spriteBlendMode) {
-                // finish a group..
-                blendMode = spriteBlendMode;
-
-                // force the batch to break!
-                currentTexture = null;
-                textureCount = MAX_TEXTURES;
-                TICK++;
-            }
-
-            if (currentTexture !== nextTexture) {
-                currentTexture = nextTexture;
-
-                if (nextTexture._enabled !== TICK) {
-                    if (textureCount === MAX_TEXTURES) {
-                        TICK++;
-
-                        currentGroup.size = i - currentGroup.start;
-
-                        textureCount = 0;
-
-                        currentGroup = groups[groupCount++];
-                        currentGroup.blend = blendMode;
-                        currentGroup.textureCount = 0;
-                        currentGroup.start = i;
-                    }
-
-                    nextTexture.touched = touch;
-
-                    if (nextTexture._virtalBoundId === -1) {
-                        for (var j = 0; j < MAX_TEXTURES; ++j) {
-                            var tIndex = (j + TEXTURE_TICK) % MAX_TEXTURES;
-
-                            var t = boundTextures[tIndex];
-
-                            if (t._enabled !== TICK) {
-                                TEXTURE_TICK++;
-
-                                t._virtalBoundId = -1;
-
-                                nextTexture._virtalBoundId = tIndex;
-
-                                boundTextures[tIndex] = nextTexture;
-                                break;
-                            }
-                        }
-                    }
-
-                    nextTexture._enabled = TICK;
-
-                    currentGroup.textureCount++;
-                    currentGroup.ids[textureCount] = nextTexture._virtalBoundId;
-                    currentGroup.textures[textureCount++] = nextTexture;
-                }
-            }
-
-            vertexData = sprite.vertexData;
-
-            // TODO this sum does not need to be set each frame..
-            uvs = sprite._texture._uvs.uvsUint32;
-
-            if (this.renderer.roundPixels) {
-                var resolution = this.renderer.resolution;
-
-                // xy
-                float32View[index] = (vertexData[0] * resolution | 0) / resolution;
-                float32View[index + 1] = (vertexData[1] * resolution | 0) / resolution;
-
-                // xy
-                float32View[index + 5] = (vertexData[2] * resolution | 0) / resolution;
-                float32View[index + 6] = (vertexData[3] * resolution | 0) / resolution;
-
-                // xy
-                float32View[index + 10] = (vertexData[4] * resolution | 0) / resolution;
-                float32View[index + 11] = (vertexData[5] * resolution | 0) / resolution;
-
-                // xy
-                float32View[index + 15] = (vertexData[6] * resolution | 0) / resolution;
-                float32View[index + 16] = (vertexData[7] * resolution | 0) / resolution;
-            } else {
-                // xy
-                float32View[index] = vertexData[0];
-                float32View[index + 1] = vertexData[1];
-
-                // xy
-                float32View[index + 5] = vertexData[2];
-                float32View[index + 6] = vertexData[3];
-
-                // xy
-                float32View[index + 10] = vertexData[4];
-                float32View[index + 11] = vertexData[5];
-
-                // xy
-                float32View[index + 15] = vertexData[6];
-                float32View[index + 16] = vertexData[7];
-            }
-
-            uint32View[index + 2] = uvs[0];
-            uint32View[index + 7] = uvs[1];
-            uint32View[index + 12] = uvs[2];
-            uint32View[index + 17] = uvs[3];
-            /* eslint-disable max-len */
-            var alpha = Math.min(sprite.worldAlpha, 1.0);
-            // we dont call extra function if alpha is 1.0, that's faster
-            var argb = alpha < 1.0 && nextTexture.premultipliedAlpha ? (0, _utils.premultiplyTint)(sprite._tintRGB, alpha) : sprite._tintRGB + (alpha * 255 << 24);
-
-            uint32View[index + 3] = uint32View[index + 8] = uint32View[index + 13] = uint32View[index + 18] = argb;
-            float32View[index + 4] = float32View[index + 9] = float32View[index + 14] = float32View[index + 19] = nextTexture._virtalBoundId;
-            /* eslint-enable max-len */
-
-            index += 20;
-        }
-
-        currentGroup.size = i - currentGroup.start;
-
-        if (!_settings2.default.CAN_UPLOAD_SAME_BUFFER) {
-            // this is still needed for IOS performance..
-            // it really does not like uploading to the same buffer in a single frame!
-            if (this.vaoMax <= this.vertexCount) {
-                this.vaoMax++;
-
-                var attrs = this.shader.attributes;
-
-                /* eslint-disable max-len */
-                var vertexBuffer = this.vertexBuffers[this.vertexCount] = _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl, null, gl.STREAM_DRAW);
-                /* eslint-enable max-len */
-
-                // build the vao object that will render..
-                var vao = this.renderer.createVao().addIndex(this.indexBuffer).addAttribute(vertexBuffer, attrs.aVertexPosition, gl.FLOAT, false, this.vertByteSize, 0).addAttribute(vertexBuffer, attrs.aTextureCoord, gl.UNSIGNED_SHORT, true, this.vertByteSize, 2 * 4).addAttribute(vertexBuffer, attrs.aColor, gl.UNSIGNED_BYTE, true, this.vertByteSize, 3 * 4);
-
-                if (attrs.aTextureId) {
-                    vao.addAttribute(vertexBuffer, attrs.aTextureId, gl.FLOAT, false, this.vertByteSize, 4 * 4);
-                }
-
-                this.vaos[this.vertexCount] = vao;
-            }
-
-            this.renderer.bindVao(this.vaos[this.vertexCount]);
-
-            this.vertexBuffers[this.vertexCount].upload(buffer.vertices, 0, false);
-
-            this.vertexCount++;
-        } else {
-            // lets use the faster option, always use buffer number 0
-            this.vertexBuffers[this.vertexCount].upload(buffer.vertices, 0, true);
-        }
-
-        for (i = 0; i < MAX_TEXTURES; ++i) {
-            rendererBoundTextures[i]._virtalBoundId = -1;
-        }
-
-        // render the groups..
-        for (i = 0; i < groupCount; ++i) {
-            var group = groups[i];
-            var groupTextureCount = group.textureCount;
-
-            for (var _j = 0; _j < groupTextureCount; _j++) {
-                currentTexture = group.textures[_j];
-
-                // reset virtual ids..
-                // lets do a quick check..
-                if (rendererBoundTextures[group.ids[_j]] !== currentTexture) {
-                    this.renderer.bindTexture(currentTexture, group.ids[_j], true);
-                }
-
-                // reset the virtualId..
-                currentTexture._virtalBoundId = -1;
-            }
-
-            // set the blend mode..
-            this.renderer.state.setBlendMode(group.blend);
-
-            gl.drawElements(gl.TRIANGLES, group.size * 6, gl.UNSIGNED_SHORT, group.start * 6 * 2);
-        }
-
-        // reset elements for the next flush
-        this.currentIndex = 0;
-    };
-
-    /**
-     * Starts a new sprite batch.
-     */
-
-
-    SpriteRenderer.prototype.start = function start() {
-        this.renderer.bindShader(this.shader);
-
-        if (_settings2.default.CAN_UPLOAD_SAME_BUFFER) {
-            // bind buffer #0, we don't need others
-            this.renderer.bindVao(this.vaos[this.vertexCount]);
-
-            this.vertexBuffers[this.vertexCount].bind();
-        }
-    };
-
-    /**
-     * Stops and flushes the current batch.
-     *
-     */
-
-
-    SpriteRenderer.prototype.stop = function stop() {
-        this.flush();
-    };
-
-    /**
-     * Destroys the SpriteRenderer.
-     *
-     */
-
-
-    SpriteRenderer.prototype.destroy = function destroy() {
-        for (var i = 0; i < this.vaoMax; i++) {
-            if (this.vertexBuffers[i]) {
-                this.vertexBuffers[i].destroy();
-            }
-            if (this.vaos[i]) {
-                this.vaos[i].destroy();
-            }
-        }
-
-        if (this.indexBuffer) {
-            this.indexBuffer.destroy();
-        }
-
-        this.renderer.off('prerender', this.onPrerender, this);
-
-        _ObjectRenderer.prototype.destroy.call(this);
-
-        if (this.shader) {
-            this.shader.destroy();
-            this.shader = null;
-        }
-
-        this.vertexBuffers = null;
-        this.vaos = null;
-        this.indexBuffer = null;
-        this.indices = null;
-
-        this.sprites = null;
-
-        for (var _i = 0; _i < this.buffers.length; ++_i) {
-            this.buffers[_i].destroy();
-        }
-    };
-
-    return SpriteRenderer;
-}(_ObjectRenderer3.default);
-
-exports.default = SpriteRenderer;
-
-
-_WebGLRenderer2.default.registerPlugin('sprite', SpriteRenderer);
-
-},{"../../renderers/webgl/WebGLRenderer":84,"../../renderers/webgl/utils/ObjectRenderer":94,"../../renderers/webgl/utils/checkMaxIfStatmentsInShader":97,"../../settings":101,"../../utils":124,"../../utils/createIndicesForQuads":122,"./BatchBuffer":105,"./generateMultiTextureShader":107,"bit-twiddle":1,"pixi-gl-core":12}],107:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = generateMultiTextureShader;
-
-var _Shader = require('../../Shader');
-
-var _Shader2 = _interopRequireDefault(_Shader);
-
-var _path = require('path');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var fragTemplate = ['varying vec2 vTextureCoord;', 'varying vec4 vColor;', 'varying float vTextureId;', 'uniform sampler2D uSamplers[%count%];', 'void main(void){', 'vec4 color;', 'float textureId = floor(vTextureId+0.5);', '%forloop%', 'gl_FragColor = color * vColor;', '}'].join('\n');
-
-function generateMultiTextureShader(gl, maxTextures) {
-    var vertexSrc = 'precision highp float;\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\nattribute float aTextureId;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\n\nvoid main(void){\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vTextureId = aTextureId;\n    vColor = aColor;\n}\n';
-    var fragmentSrc = fragTemplate;
-
-    fragmentSrc = fragmentSrc.replace(/%count%/gi, maxTextures);
-    fragmentSrc = fragmentSrc.replace(/%forloop%/gi, generateSampleSrc(maxTextures));
-
-    var shader = new _Shader2.default(gl, vertexSrc, fragmentSrc);
-
-    var sampleValues = [];
-
-    for (var i = 0; i < maxTextures; i++) {
-        sampleValues[i] = i;
-    }
-
-    shader.bind();
-    shader.uniforms.uSamplers = sampleValues;
-
-    return shader;
-}
-
-function generateSampleSrc(maxTextures) {
-    var src = '';
-
-    src += '\n';
-    src += '\n';
-
-    for (var i = 0; i < maxTextures; i++) {
-        if (i > 0) {
-            src += '\nelse ';
-        }
-
-        if (i < maxTextures - 1) {
-            src += 'if(textureId == ' + i + '.0)';
-        }
-
-        src += '\n{';
-        src += '\n\tcolor = texture2D(uSamplers[' + i + '], vTextureCoord);';
-        src += '\n}';
-    }
-
-    src += '\n';
-    src += '\n';
-
-    return src;
-}
-
-},{"../../Shader":44,"path":23}],108:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _Sprite2 = require('../sprites/Sprite');
-
-var _Sprite3 = _interopRequireDefault(_Sprite2);
-
-var _Texture = require('../textures/Texture');
-
-var _Texture2 = _interopRequireDefault(_Texture);
-
-var _math = require('../math');
-
-var _utils = require('../utils');
-
-var _const = require('../const');
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _TextStyle = require('./TextStyle');
-
-var _TextStyle2 = _interopRequireDefault(_TextStyle);
-
-var _TextMetrics = require('./TextMetrics');
-
-var _TextMetrics2 = _interopRequireDefault(_TextMetrics);
-
-var _trimCanvas = require('../utils/trimCanvas');
-
-var _trimCanvas2 = _interopRequireDefault(_trimCanvas);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint max-depth: [2, 8] */
-
-
-var defaultDestroyOptions = {
-    texture: true,
-    children: false,
-    baseTexture: true
-};
-
-/**
- * A Text Object will create a line or multiple lines of text. To split a line you can use '\n' in your text string,
- * or add a wordWrap property set to true and and wordWrapWidth property with a value in the style object.
- *
- * A Text can be created directly from a string and a style object
- *
- * ```js
- * let text = new PIXI.Text('This is a PixiJS text',{fontFamily : 'Arial', fontSize: 24, fill : 0xff1010, align : 'center'});
- * ```
- *
- * @class
- * @extends PIXI.Sprite
- * @memberof PIXI
- */
-
-var Text = function (_Sprite) {
-    _inherits(Text, _Sprite);
-
-    /**
-     * @param {string} text - The string that you would like the text to display
-     * @param {object|PIXI.TextStyle} [style] - The style parameters
-     * @param {HTMLCanvasElement} [canvas] - The canvas element for drawing text
-     */
-    function Text(text, style, canvas) {
-        _classCallCheck(this, Text);
-
-        canvas = canvas || document.createElement('canvas');
-
-        canvas.width = 3;
-        canvas.height = 3;
-
-        var texture = _Texture2.default.fromCanvas(canvas, _settings2.default.SCALE_MODE, 'text');
-
-        texture.orig = new _math.Rectangle();
-        texture.trim = new _math.Rectangle();
-
-        // base texture is already automatically added to the cache, now adding the actual texture
-        var _this = _possibleConstructorReturn(this, _Sprite.call(this, texture));
-
-        _Texture2.default.addToCache(_this._texture, _this._texture.baseTexture.textureCacheIds[0]);
-
-        /**
-         * The canvas element that everything is drawn to
-         *
-         * @member {HTMLCanvasElement}
-         */
-        _this.canvas = canvas;
-
-        /**
-         * The canvas 2d context that everything is drawn with
-         * @member {CanvasRenderingContext2D}
-         */
-        _this.context = _this.canvas.getContext('2d');
-
-        /**
-         * The resolution / device pixel ratio of the canvas. This is set automatically by the renderer.
-         * @member {number}
-         * @default 1
-         */
-        _this.resolution = _settings2.default.RESOLUTION;
-
-        /**
-         * Private tracker for the current text.
-         *
-         * @member {string}
-         * @private
-         */
-        _this._text = null;
-
-        /**
-         * Private tracker for the current style.
-         *
-         * @member {object}
-         * @private
-         */
-        _this._style = null;
-        /**
-         * Private listener to track style changes.
-         *
-         * @member {Function}
-         * @private
-         */
-        _this._styleListener = null;
-
-        /**
-         * Private tracker for the current font.
-         *
-         * @member {string}
-         * @private
-         */
-        _this._font = '';
-
-        _this.text = text;
-        _this.style = style;
-
-        _this.localStyleID = -1;
-        return _this;
-    }
-
-    /**
-     * Renders text and updates it when needed.
-     *
-     * @private
-     * @param {boolean} respectDirty - Whether to abort updating the text if the Text isn't dirty and the function is called.
-     */
-
-
-    Text.prototype.updateText = function updateText(respectDirty) {
-        var style = this._style;
-
-        // check if style has changed..
-        if (this.localStyleID !== style.styleID) {
-            this.dirty = true;
-            this.localStyleID = style.styleID;
-        }
-
-        if (!this.dirty && respectDirty) {
-            return;
-        }
-
-        this._font = this._style.toFontString();
-
-        var context = this.context;
-        var measured = _TextMetrics2.default.measureText(this._text, this._style, this._style.wordWrap, this.canvas);
-        var width = measured.width;
-        var height = measured.height;
-        var lines = measured.lines;
-        var lineHeight = measured.lineHeight;
-        var lineWidths = measured.lineWidths;
-        var maxLineWidth = measured.maxLineWidth;
-        var fontProperties = measured.fontProperties;
-
-        this.canvas.width = Math.ceil((width + style.padding * 2) * this.resolution);
-        this.canvas.height = Math.ceil((height + style.padding * 2) * this.resolution);
-
-        context.scale(this.resolution, this.resolution);
-
-        context.clearRect(0, 0, this.canvas.width, this.canvas.height);
-
-        context.font = this._font;
-        context.strokeStyle = style.stroke;
-        context.lineWidth = style.strokeThickness;
-        context.textBaseline = style.textBaseline;
-        context.lineJoin = style.lineJoin;
-        context.miterLimit = style.miterLimit;
-
-        var linePositionX = void 0;
-        var linePositionY = void 0;
-
-        if (style.dropShadow) {
-            context.fillStyle = style.dropShadowColor;
-            context.globalAlpha = style.dropShadowAlpha;
-            context.shadowBlur = style.dropShadowBlur;
-
-            if (style.dropShadowBlur > 0) {
-                context.shadowColor = style.dropShadowColor;
-            }
-
-            var xShadowOffset = Math.cos(style.dropShadowAngle) * style.dropShadowDistance;
-            var yShadowOffset = Math.sin(style.dropShadowAngle) * style.dropShadowDistance;
-
-            for (var i = 0; i < lines.length; i++) {
-                linePositionX = style.strokeThickness / 2;
-                linePositionY = style.strokeThickness / 2 + i * lineHeight + fontProperties.ascent;
-
-                if (style.align === 'right') {
-                    linePositionX += maxLineWidth - lineWidths[i];
-                } else if (style.align === 'center') {
-                    linePositionX += (maxLineWidth - lineWidths[i]) / 2;
-                }
-
-                if (style.fill) {
-                    this.drawLetterSpacing(lines[i], linePositionX + xShadowOffset + style.padding, linePositionY + yShadowOffset + style.padding);
-
-                    if (style.stroke && style.strokeThickness) {
-                        context.strokeStyle = style.dropShadowColor;
-                        this.drawLetterSpacing(lines[i], linePositionX + xShadowOffset + style.padding, linePositionY + yShadowOffset + style.padding, true);
-                        context.strokeStyle = style.stroke;
-                    }
-                }
-            }
-        }
-
-        // reset the shadow blur and alpha that was set by the drop shadow, for the regular text
-        context.shadowBlur = 0;
-        context.globalAlpha = 1;
-
-        // set canvas text styles
-        context.fillStyle = this._generateFillStyle(style, lines);
-
-        // draw lines line by line
-        for (var _i = 0; _i < lines.length; _i++) {
-            linePositionX = style.strokeThickness / 2;
-            linePositionY = style.strokeThickness / 2 + _i * lineHeight + fontProperties.ascent;
-
-            if (style.align === 'right') {
-                linePositionX += maxLineWidth - lineWidths[_i];
-            } else if (style.align === 'center') {
-                linePositionX += (maxLineWidth - lineWidths[_i]) / 2;
-            }
-
-            if (style.stroke && style.strokeThickness) {
-                this.drawLetterSpacing(lines[_i], linePositionX + style.padding, linePositionY + style.padding, true);
-            }
-
-            if (style.fill) {
-                this.drawLetterSpacing(lines[_i], linePositionX + style.padding, linePositionY + style.padding);
-            }
-        }
-
-        this.updateTexture();
-    };
-
-    /**
-     * Render the text with letter-spacing.
-     * @param {string} text - The text to draw
-     * @param {number} x - Horizontal position to draw the text
-     * @param {number} y - Vertical position to draw the text
-     * @param {boolean} [isStroke=false] - Is this drawing for the outside stroke of the
-     *  text? If not, it's for the inside fill
-     * @private
-     */
-
-
-    Text.prototype.drawLetterSpacing = function drawLetterSpacing(text, x, y) {
-        var isStroke = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
-        var style = this._style;
-
-        // letterSpacing of 0 means normal
-        var letterSpacing = style.letterSpacing;
-
-        if (letterSpacing === 0) {
-            if (isStroke) {
-                this.context.strokeText(text, x, y);
-            } else {
-                this.context.fillText(text, x, y);
-            }
-
-            return;
-        }
-
-        var characters = String.prototype.split.call(text, '');
-        var currentPosition = x;
-        var index = 0;
-        var current = '';
-
-        while (index < text.length) {
-            current = characters[index++];
-            if (isStroke) {
-                this.context.strokeText(current, currentPosition, y);
-            } else {
-                this.context.fillText(current, currentPosition, y);
-            }
-            currentPosition += this.context.measureText(current).width + letterSpacing;
-        }
-    };
-
-    /**
-     * Updates texture size based on canvas size
-     *
-     * @private
-     */
-
-
-    Text.prototype.updateTexture = function updateTexture() {
-        var canvas = this.canvas;
-
-        if (this._style.trim) {
-            var trimmed = (0, _trimCanvas2.default)(canvas);
-
-            canvas.width = trimmed.width;
-            canvas.height = trimmed.height;
-            this.context.putImageData(trimmed.data, 0, 0);
-        }
-
-        var texture = this._texture;
-        var style = this._style;
-        var padding = style.trim ? 0 : style.padding;
-        var baseTexture = texture.baseTexture;
-
-        baseTexture.hasLoaded = true;
-        baseTexture.resolution = this.resolution;
-
-        baseTexture.realWidth = canvas.width;
-        baseTexture.realHeight = canvas.height;
-        baseTexture.width = canvas.width / this.resolution;
-        baseTexture.height = canvas.height / this.resolution;
-
-        texture.trim.width = texture._frame.width = canvas.width / this.resolution;
-        texture.trim.height = texture._frame.height = canvas.height / this.resolution;
-        texture.trim.x = -padding;
-        texture.trim.y = -padding;
-
-        texture.orig.width = texture._frame.width - padding * 2;
-        texture.orig.height = texture._frame.height - padding * 2;
-
-        // call sprite onTextureUpdate to update scale if _width or _height were set
-        this._onTextureUpdate();
-
-        baseTexture.emit('update', baseTexture);
-
-        this.dirty = false;
-    };
-
-    /**
-     * Renders the object using the WebGL renderer
-     *
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-
-
-    Text.prototype.renderWebGL = function renderWebGL(renderer) {
-        if (this.resolution !== renderer.resolution) {
-            this.resolution = renderer.resolution;
-            this.dirty = true;
-        }
-
-        this.updateText(true);
-
-        _Sprite.prototype.renderWebGL.call(this, renderer);
-    };
-
-    /**
-     * Renders the object using the Canvas renderer
-     *
-     * @private
-     * @param {PIXI.CanvasRenderer} renderer - The renderer
-     */
-
-
-    Text.prototype._renderCanvas = function _renderCanvas(renderer) {
-        if (this.resolution !== renderer.resolution) {
-            this.resolution = renderer.resolution;
-            this.dirty = true;
-        }
-
-        this.updateText(true);
-
-        _Sprite.prototype._renderCanvas.call(this, renderer);
-    };
-
-    /**
-     * Gets the local bounds of the text object.
-     *
-     * @param {Rectangle} rect - The output rectangle.
-     * @return {Rectangle} The bounds.
-     */
-
-
-    Text.prototype.getLocalBounds = function getLocalBounds(rect) {
-        this.updateText(true);
-
-        return _Sprite.prototype.getLocalBounds.call(this, rect);
-    };
-
-    /**
-     * calculates the bounds of the Text as a rectangle. The bounds calculation takes the worldTransform into account.
-     */
-
-
-    Text.prototype._calculateBounds = function _calculateBounds() {
-        this.updateText(true);
-        this.calculateVertices();
-        // if we have already done this on THIS frame.
-        this._bounds.addQuad(this.vertexData);
-    };
-
-    /**
-     * Method to be called upon a TextStyle change.
-     * @private
-     */
-
-
-    Text.prototype._onStyleChange = function _onStyleChange() {
-        this.dirty = true;
-    };
-
-    /**
-     * Generates the fill style. Can automatically generate a gradient based on the fill style being an array
-     *
-     * @private
-     * @param {object} style - The style.
-     * @param {string[]} lines - The lines of text.
-     * @return {string|number|CanvasGradient} The fill style
-     */
-
-
-    Text.prototype._generateFillStyle = function _generateFillStyle(style, lines) {
-        if (!Array.isArray(style.fill)) {
-            return style.fill;
-        }
-
-        // cocoon on canvas+ cannot generate textures, so use the first colour instead
-        if (navigator.isCocoonJS) {
-            return style.fill[0];
-        }
-
-        // the gradient will be evenly spaced out according to how large the array is.
-        // ['#FF0000', '#00FF00', '#0000FF'] would created stops at 0.25, 0.5 and 0.75
-        var gradient = void 0;
-        var totalIterations = void 0;
-        var currentIteration = void 0;
-        var stop = void 0;
-
-        var width = this.canvas.width / this.resolution;
-        var height = this.canvas.height / this.resolution;
-
-        // make a copy of the style settings, so we can manipulate them later
-        var fill = style.fill.slice();
-        var fillGradientStops = style.fillGradientStops.slice();
-
-        // wanting to evenly distribute the fills. So an array of 4 colours should give fills of 0.25, 0.5 and 0.75
-        if (!fillGradientStops.length) {
-            var lengthPlus1 = fill.length + 1;
-
-            for (var i = 1; i < lengthPlus1; ++i) {
-                fillGradientStops.push(i / lengthPlus1);
-            }
-        }
-
-        // stop the bleeding of the last gradient on the line above to the top gradient of the this line
-        // by hard defining the first gradient colour at point 0, and last gradient colour at point 1
-        fill.unshift(style.fill[0]);
-        fillGradientStops.unshift(0);
-
-        fill.push(style.fill[style.fill.length - 1]);
-        fillGradientStops.push(1);
-
-        if (style.fillGradientType === _const.TEXT_GRADIENT.LINEAR_VERTICAL) {
-            // start the gradient at the top center of the canvas, and end at the bottom middle of the canvas
-            gradient = this.context.createLinearGradient(width / 2, 0, width / 2, height);
-
-            // we need to repeat the gradient so that each individual line of text has the same vertical gradient effect
-            // ['#FF0000', '#00FF00', '#0000FF'] over 2 lines would create stops at 0.125, 0.25, 0.375, 0.625, 0.75, 0.875
-            totalIterations = (fill.length + 1) * lines.length;
-            currentIteration = 0;
-            for (var _i2 = 0; _i2 < lines.length; _i2++) {
-                currentIteration += 1;
-                for (var j = 0; j < fill.length; j++) {
-                    if (typeof fillGradientStops[j] === 'number') {
-                        stop = fillGradientStops[j] / lines.length + _i2 / lines.length;
-                    } else {
-                        stop = currentIteration / totalIterations;
-                    }
-                    gradient.addColorStop(stop, fill[j]);
-                    currentIteration++;
-                }
-            }
-        } else {
-            // start the gradient at the center left of the canvas, and end at the center right of the canvas
-            gradient = this.context.createLinearGradient(0, height / 2, width, height / 2);
-
-            // can just evenly space out the gradients in this case, as multiple lines makes no difference
-            // to an even left to right gradient
-            totalIterations = fill.length + 1;
-            currentIteration = 1;
-
-            for (var _i3 = 0; _i3 < fill.length; _i3++) {
-                if (typeof fillGradientStops[_i3] === 'number') {
-                    stop = fillGradientStops[_i3];
-                } else {
-                    stop = currentIteration / totalIterations;
-                }
-                gradient.addColorStop(stop, fill[_i3]);
-                currentIteration++;
-            }
-        }
-
-        return gradient;
-    };
-
-    /**
-     * Destroys this text object.
-     * Note* Unlike a Sprite, a Text object will automatically destroy its baseTexture and texture as
-     * the majority of the time the texture will not be shared with any other Sprites.
-     *
-     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-     *  have been set to that value
-     * @param {boolean} [options.children=false] - if set to true, all the children will have their
-     *  destroy method called as well. 'options' will be passed on to those calls.
-     * @param {boolean} [options.texture=true] - Should it destroy the current texture of the sprite as well
-     * @param {boolean} [options.baseTexture=true] - Should it destroy the base texture of the sprite as well
-     */
-
-
-    Text.prototype.destroy = function destroy(options) {
-        if (typeof options === 'boolean') {
-            options = { children: options };
-        }
-
-        options = Object.assign({}, defaultDestroyOptions, options);
-
-        _Sprite.prototype.destroy.call(this, options);
-
-        // make sure to reset the the context and canvas.. dont want this hanging around in memory!
-        this.context = null;
-        this.canvas = null;
-
-        this._style = null;
-    };
-
-    /**
-     * The width of the Text, setting this will actually modify the scale to achieve the value set
-     *
-     * @member {number}
-     */
-
-
-    _createClass(Text, [{
-        key: 'width',
-        get: function get() {
-            this.updateText(true);
-
-            return Math.abs(this.scale.x) * this._texture.orig.width;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.updateText(true);
-
-            var s = (0, _utils.sign)(this.scale.x) || 1;
-
-            this.scale.x = s * value / this._texture.orig.width;
-            this._width = value;
-        }
-
-        /**
-         * The height of the Text, setting this will actually modify the scale to achieve the value set
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'height',
-        get: function get() {
-            this.updateText(true);
-
-            return Math.abs(this.scale.y) * this._texture.orig.height;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.updateText(true);
-
-            var s = (0, _utils.sign)(this.scale.y) || 1;
-
-            this.scale.y = s * value / this._texture.orig.height;
-            this._height = value;
-        }
-
-        /**
-         * Set the style of the text. Set up an event listener to listen for changes on the style
-         * object and mark the text as dirty.
-         *
-         * @member {object|PIXI.TextStyle}
-         */
-
-    }, {
-        key: 'style',
-        get: function get() {
-            return this._style;
-        },
-        set: function set(style) // eslint-disable-line require-jsdoc
-        {
-            style = style || {};
-
-            if (style instanceof _TextStyle2.default) {
-                this._style = style;
-            } else {
-                this._style = new _TextStyle2.default(style);
-            }
-
-            this.localStyleID = -1;
-            this.dirty = true;
-        }
-
-        /**
-         * Set the copy for the text object. To split a line you can use '\n'.
-         *
-         * @member {string}
-         */
-
-    }, {
-        key: 'text',
-        get: function get() {
-            return this._text;
-        },
-        set: function set(text) // eslint-disable-line require-jsdoc
-        {
-            text = String(text === '' || text === null || text === undefined ? ' ' : text);
-
-            if (this._text === text) {
-                return;
-            }
-            this._text = text;
-            this.dirty = true;
-        }
-    }]);
-
-    return Text;
-}(_Sprite3.default);
-
-exports.default = Text;
-
-},{"../const":46,"../math":70,"../settings":101,"../sprites/Sprite":102,"../textures/Texture":115,"../utils":124,"../utils/trimCanvas":129,"./TextMetrics":109,"./TextStyle":110}],109:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * The TextMetrics object represents the measurement of a block of text with a specified style.
- *
- * @class
- * @memberOf PIXI
- */
-var TextMetrics = function () {
-    /**
-     * @param {string} text - the text that was measured
-     * @param {PIXI.TextStyle} style - the style that was measured
-     * @param {number} width - the measured width of the text
-     * @param {number} height - the measured height of the text
-     * @param {array} lines - an array of the lines of text broken by new lines and wrapping if specified in style
-     * @param {array} lineWidths - an array of the line widths for each line matched to `lines`
-     * @param {number} lineHeight - the measured line height for this style
-     * @param {number} maxLineWidth - the maximum line width for all measured lines
-     * @param {Object} fontProperties - the font properties object from TextMetrics.measureFont
-     */
-    function TextMetrics(text, style, width, height, lines, lineWidths, lineHeight, maxLineWidth, fontProperties) {
-        _classCallCheck(this, TextMetrics);
-
-        this.text = text;
-        this.style = style;
-        this.width = width;
-        this.height = height;
-        this.lines = lines;
-        this.lineWidths = lineWidths;
-        this.lineHeight = lineHeight;
-        this.maxLineWidth = maxLineWidth;
-        this.fontProperties = fontProperties;
-    }
-
-    /**
-     * Measures the supplied string of text and returns a Rectangle.
-     *
-     * @param {string} text - the text to measure.
-     * @param {PIXI.TextStyle} style - the text style to use for measuring
-     * @param {boolean} [wordWrap] - optional override for if word-wrap should be applied to the text.
-     * @param {HTMLCanvasElement} [canvas] - optional specification of the canvas to use for measuring.
-     * @return {PIXI.TextMetrics} measured width and height of the text.
-     */
-
-
-    TextMetrics.measureText = function measureText(text, style, wordWrap) {
-        var canvas = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : TextMetrics._canvas;
-
-        wordWrap = wordWrap || style.wordWrap;
-        var font = style.toFontString();
-        var fontProperties = TextMetrics.measureFont(font);
-        var context = canvas.getContext('2d');
-
-        context.font = font;
-
-        var outputText = wordWrap ? TextMetrics.wordWrap(text, style, canvas) : text;
-        var lines = outputText.split(/(?:\r\n|\r|\n)/);
-        var lineWidths = new Array(lines.length);
-        var maxLineWidth = 0;
-
-        for (var i = 0; i < lines.length; i++) {
-            var lineWidth = context.measureText(lines[i]).width + (lines[i].length - 1) * style.letterSpacing;
-
-            lineWidths[i] = lineWidth;
-            maxLineWidth = Math.max(maxLineWidth, lineWidth);
-        }
-        var width = maxLineWidth + style.strokeThickness;
-
-        if (style.dropShadow) {
-            width += style.dropShadowDistance;
-        }
-
-        var lineHeight = style.lineHeight || fontProperties.fontSize + style.strokeThickness;
-        var height = Math.max(lineHeight, fontProperties.fontSize + style.strokeThickness) + (lines.length - 1) * lineHeight;
-
-        if (style.dropShadow) {
-            height += style.dropShadowDistance;
-        }
-
-        return new TextMetrics(text, style, width, height, lines, lineWidths, lineHeight, maxLineWidth, fontProperties);
-    };
-
-    /**
-     * Applies newlines to a string to have it optimally fit into the horizontal
-     * bounds set by the Text object's wordWrapWidth property.
-     *
-     * @private
-     * @param {string} text - String to apply word wrapping to
-     * @param {PIXI.TextStyle} style - the style to use when wrapping
-     * @param {HTMLCanvasElement} [canvas] - optional specification of the canvas to use for measuring.
-     * @return {string} New string with new lines applied where required
-     */
-
-
-    TextMetrics.wordWrap = function wordWrap(text, style) {
-        var canvas = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : TextMetrics._canvas;
-
-        var context = canvas.getContext('2d');
-
-        // Greedy wrapping algorithm that will wrap words as the line grows longer
-        // than its horizontal bounds.
-        var result = '';
-        var lines = text.split('\n');
-        var wordWrapWidth = style.wordWrapWidth;
-        var characterCache = {};
-
-        for (var i = 0; i < lines.length; i++) {
-            var spaceLeft = wordWrapWidth;
-            var words = lines[i].split(' ');
-
-            for (var j = 0; j < words.length; j++) {
-                var wordWidth = context.measureText(words[j]).width;
-
-                if (style.breakWords && wordWidth > wordWrapWidth) {
-                    // Word should be split in the middle
-                    var characters = words[j].split('');
-
-                    for (var c = 0; c < characters.length; c++) {
-                        var character = characters[c];
-                        var characterWidth = characterCache[character];
-
-                        if (characterWidth === undefined) {
-                            characterWidth = context.measureText(character).width;
-                            characterCache[character] = characterWidth;
-                        }
-
-                        if (characterWidth > spaceLeft) {
-                            result += '\n' + character;
-                            spaceLeft = wordWrapWidth - characterWidth;
-                        } else {
-                            if (c === 0) {
-                                result += ' ';
-                            }
-
-                            result += character;
-                            spaceLeft -= characterWidth;
-                        }
-                    }
-                } else {
-                    var wordWidthWithSpace = wordWidth + context.measureText(' ').width;
-
-                    if (j === 0 || wordWidthWithSpace > spaceLeft) {
-                        // Skip printing the newline if it's the first word of the line that is
-                        // greater than the word wrap width.
-                        if (j > 0) {
-                            result += '\n';
-                        }
-                        result += words[j];
-                        spaceLeft = wordWrapWidth - wordWidth;
-                    } else {
-                        spaceLeft -= wordWidthWithSpace;
-                        result += ' ' + words[j];
-                    }
-                }
-            }
-
-            if (i < lines.length - 1) {
-                result += '\n';
-            }
-        }
-
-        return result;
-    };
-
-    /**
-     * Calculates the ascent, descent and fontSize of a given font-style
-     *
-     * @static
-     * @param {string} font - String representing the style of the font
-     * @return {PIXI.TextMetrics~FontMetrics} Font properties object
-     */
-
-
-    TextMetrics.measureFont = function measureFont(font) {
-        // as this method is used for preparing assets, don't recalculate things if we don't need to
-        if (TextMetrics._fonts[font]) {
-            return TextMetrics._fonts[font];
-        }
-
-        var properties = {};
-
-        var canvas = TextMetrics._canvas;
-        var context = TextMetrics._context;
-
-        context.font = font;
-
-        var width = Math.ceil(context.measureText('|MÉq').width);
-        var baseline = Math.ceil(context.measureText('M').width);
-        var height = 2 * baseline;
-
-        baseline = baseline * 1.4 | 0;
-
-        canvas.width = width;
-        canvas.height = height;
-
-        context.fillStyle = '#f00';
-        context.fillRect(0, 0, width, height);
-
-        context.font = font;
-
-        context.textBaseline = 'alphabetic';
-        context.fillStyle = '#000';
-        context.fillText('|MÉq', 0, baseline);
-
-        var imagedata = context.getImageData(0, 0, width, height).data;
-        var pixels = imagedata.length;
-        var line = width * 4;
-
-        var i = 0;
-        var idx = 0;
-        var stop = false;
-
-        // ascent. scan from top to bottom until we find a non red pixel
-        for (i = 0; i < baseline; ++i) {
-            for (var j = 0; j < line; j += 4) {
-                if (imagedata[idx + j] !== 255) {
-                    stop = true;
-                    break;
-                }
-            }
-            if (!stop) {
-                idx += line;
-            } else {
-                break;
-            }
-        }
-
-        properties.ascent = baseline - i;
-
-        idx = pixels - line;
-        stop = false;
-
-        // descent. scan from bottom to top until we find a non red pixel
-        for (i = height; i > baseline; --i) {
-            for (var _j = 0; _j < line; _j += 4) {
-                if (imagedata[idx + _j] !== 255) {
-                    stop = true;
-                    break;
-                }
-            }
-
-            if (!stop) {
-                idx -= line;
-            } else {
-                break;
-            }
-        }
-
-        properties.descent = i - baseline;
-        properties.fontSize = properties.ascent + properties.descent;
-
-        TextMetrics._fonts[font] = properties;
-
-        return properties;
-    };
-
-    return TextMetrics;
-}();
-
-/**
- * Internal return object for {@link PIXI.TextMetrics.measureFont `TextMetrics.measureFont`}.
- * @class FontMetrics
- * @memberof PIXI.TextMetrics~
- * @property {number} ascent - The ascent distance
- * @property {number} descent - The descent distance
- * @property {number} fontSize - Font size from ascent to descent
- */
-
-exports.default = TextMetrics;
-var canvas = document.createElement('canvas');
-
-canvas.width = canvas.height = 10;
-
-/**
- * Cached canvas element for measuring text
- * @memberof PIXI.TextMetrics
- * @type {HTMLCanvasElement}
- * @private
- */
-TextMetrics._canvas = canvas;
-
-/**
- * Cache for context to use.
- * @memberof PIXI.TextMetrics
- * @type {CanvasRenderingContext2D}
- * @private
- */
-TextMetrics._context = canvas.getContext('2d');
-
-/**
- * Cache of PIXI.TextMetrics~FontMetrics objects.
- * @memberof PIXI.TextMetrics
- * @type {Object}
- * @private
- */
-TextMetrics._fonts = {};
-
-},{}],110:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // disabling eslint for now, going to rewrite this in v5
-/* eslint-disable */
-
-var _const = require('../const');
-
-var _utils = require('../utils');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var defaultStyle = {
-    align: 'left',
-    breakWords: false,
-    dropShadow: false,
-    dropShadowAlpha: 1,
-    dropShadowAngle: Math.PI / 6,
-    dropShadowBlur: 0,
-    dropShadowColor: 'black',
-    dropShadowDistance: 5,
-    fill: 'black',
-    fillGradientType: _const.TEXT_GRADIENT.LINEAR_VERTICAL,
-    fillGradientStops: [],
-    fontFamily: 'Arial',
-    fontSize: 26,
-    fontStyle: 'normal',
-    fontVariant: 'normal',
-    fontWeight: 'normal',
-    letterSpacing: 0,
-    lineHeight: 0,
-    lineJoin: 'miter',
-    miterLimit: 10,
-    padding: 0,
-    stroke: 'black',
-    strokeThickness: 0,
-    textBaseline: 'alphabetic',
-    trim: false,
-    wordWrap: false,
-    wordWrapWidth: 100
-};
-
-/**
- * A TextStyle Object decorates a Text Object. It can be shared between
- * multiple Text objects. Changing the style will update all text objects using it.
- *
- * @class
- * @memberof PIXI
- */
-
-var TextStyle = function () {
-    /**
-     * @param {object} [style] - The style parameters
-     * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center' or 'right'),
-     *  does not affect single line text
-     * @param {boolean} [style.breakWords=false] - Indicates if lines can be wrapped within words, it
-     *  needs wordWrap to be set to true
-     * @param {boolean} [style.dropShadow=false] - Set a drop shadow for the text
-     * @param {number} [style.dropShadowAlpha=1] - Set alpha for the drop shadow
-     * @param {number} [style.dropShadowAngle=Math.PI/6] - Set a angle of the drop shadow
-     * @param {number} [style.dropShadowBlur=0] - Set a shadow blur radius
-     * @param {string} [style.dropShadowColor='black'] - A fill style to be used on the dropshadow e.g 'red', '#00FF00'
-     * @param {number} [style.dropShadowDistance=5] - Set a distance of the drop shadow
-     * @param {string|string[]|number|number[]|CanvasGradient|CanvasPattern} [style.fill='black'] - A canvas
-     *  fillstyle that will be used on the text e.g 'red', '#00FF00'. Can be an array to create a gradient
-     *  eg ['#000000','#FFFFFF']
-     * {@link https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillStyle|MDN}
-     * @param {number} [style.fillGradientType=PIXI.TEXT_GRADIENT.LINEAR_VERTICAL] - If fill is an array of colours
-     *  to create a gradient, this can change the type/direction of the gradient. See {@link PIXI.TEXT_GRADIENT}
-     * @param {number[]} [style.fillGradientStops] - If fill is an array of colours to create a gradient, this array can set
-     * the stop points (numbers between 0 and 1) for the color, overriding the default behaviour of evenly spacing them.
-     * @param {string|string[]} [style.fontFamily='Arial'] - The font family
-     * @param {number|string} [style.fontSize=26] - The font size (as a number it converts to px, but as a string,
-     *  equivalents are '26px','20pt','160%' or '1.6em')
-     * @param {string} [style.fontStyle='normal'] - The font style ('normal', 'italic' or 'oblique')
-     * @param {string} [style.fontVariant='normal'] - The font variant ('normal' or 'small-caps')
-     * @param {string} [style.fontWeight='normal'] - The font weight ('normal', 'bold', 'bolder', 'lighter' and '100',
-     *  '200', '300', '400', '500', '600', '700', 800' or '900')
-     * @param {number} [style.letterSpacing=0] - The amount of spacing between letters, default is 0
-     * @param {number} [style.lineHeight] - The line height, a number that represents the vertical space that a letter uses
-     * @param {string} [style.lineJoin='miter'] - The lineJoin property sets the type of corner created, it can resolve
-     *      spiked text issues. Default is 'miter' (creates a sharp corner).
-     * @param {number} [style.miterLimit=10] - The miter limit to use when using the 'miter' lineJoin mode. This can reduce
-     *      or increase the spikiness of rendered text.
-     * @param {number} [style.padding=0] - Occasionally some fonts are cropped. Adding some padding will prevent this from
-     *     happening by adding padding to all sides of the text.
-     * @param {string|number} [style.stroke='black'] - A canvas fillstyle that will be used on the text stroke
-     *  e.g 'blue', '#FCFF00'
-     * @param {number} [style.strokeThickness=0] - A number that represents the thickness of the stroke.
-     *  Default is 0 (no stroke)
-     * @param {boolean} [style.trim=false] - Trim transparent borders
-     * @param {string} [style.textBaseline='alphabetic'] - The baseline of the text that is rendered.
-     * @param {boolean} [style.wordWrap=false] - Indicates if word wrap should be used
-     * @param {number} [style.wordWrapWidth=100] - The width at which text will wrap, it needs wordWrap to be set to true
-     */
-    function TextStyle(style) {
-        _classCallCheck(this, TextStyle);
-
-        this.styleID = 0;
-
-        Object.assign(this, defaultStyle, style);
-    }
-
-    /**
-     * Creates a new TextStyle object with the same values as this one.
-     * Note that the only the properties of the object are cloned.
-     *
-     * @return {PIXI.TextStyle} New cloned TextStyle object
-     */
-
-
-    TextStyle.prototype.clone = function clone() {
-        var clonedProperties = {};
-
-        for (var key in defaultStyle) {
-            clonedProperties[key] = this[key];
-        }
-
-        return new TextStyle(clonedProperties);
-    };
-
-    /**
-     * Resets all properties to the defaults specified in TextStyle.prototype._default
-     */
-
-
-    TextStyle.prototype.reset = function reset() {
-        Object.assign(this, defaultStyle);
-    };
-
-    /**
-     * Generates a font style string to use for `TextMetrics.measureFont()`.
-     *
-     * @return {string} Font style string, for passing to `TextMetrics.measureFont()`
-     */
-    TextStyle.prototype.toFontString = function toFontString() {
-        // build canvas api font setting from individual components. Convert a numeric this.fontSize to px
-        var fontSizeString = typeof this.fontSize === 'number' ? this.fontSize + 'px' : this.fontSize;
-
-        // Clean-up fontFamily property by quoting each font name
-        // this will support font names with spaces
-        var fontFamilies = this.fontFamily;
-
-        if (!Array.isArray(this.fontFamily)) {
-            fontFamilies = this.fontFamily.split(',');
-        }
-
-        for (var i = fontFamilies.length - 1; i >= 0; i--) {
-            // Trim any extra white-space
-            var fontFamily = fontFamilies[i].trim();
-
-            // Check if font already contains strings
-            if (!/([\"\'])[^\'\"]+\1/.test(fontFamily)) {
-                fontFamily = '"' + fontFamily + '"';
-            }
-            fontFamilies[i] = fontFamily;
-        }
-
-        return this.fontStyle + ' ' + this.fontVariant + ' ' + this.fontWeight + ' ' + fontSizeString + ' ' + fontFamilies.join(',');
-    };
-
-    _createClass(TextStyle, [{
-        key: 'align',
-        get: function get() {
-            return this._align;
-        },
-        set: function set(align) {
-            if (this._align !== align) {
-                this._align = align;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'breakWords',
-        get: function get() {
-            return this._breakWords;
-        },
-        set: function set(breakWords) {
-            if (this._breakWords !== breakWords) {
-                this._breakWords = breakWords;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'dropShadow',
-        get: function get() {
-            return this._dropShadow;
-        },
-        set: function set(dropShadow) {
-            if (this._dropShadow !== dropShadow) {
-                this._dropShadow = dropShadow;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'dropShadowAlpha',
-        get: function get() {
-            return this._dropShadowAlpha;
-        },
-        set: function set(dropShadowAlpha) {
-            if (this._dropShadowAlpha !== dropShadowAlpha) {
-                this._dropShadowAlpha = dropShadowAlpha;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'dropShadowAngle',
-        get: function get() {
-            return this._dropShadowAngle;
-        },
-        set: function set(dropShadowAngle) {
-            if (this._dropShadowAngle !== dropShadowAngle) {
-                this._dropShadowAngle = dropShadowAngle;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'dropShadowBlur',
-        get: function get() {
-            return this._dropShadowBlur;
-        },
-        set: function set(dropShadowBlur) {
-            if (this._dropShadowBlur !== dropShadowBlur) {
-                this._dropShadowBlur = dropShadowBlur;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'dropShadowColor',
-        get: function get() {
-            return this._dropShadowColor;
-        },
-        set: function set(dropShadowColor) {
-            var outputColor = getColor(dropShadowColor);
-            if (this._dropShadowColor !== outputColor) {
-                this._dropShadowColor = outputColor;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'dropShadowDistance',
-        get: function get() {
-            return this._dropShadowDistance;
-        },
-        set: function set(dropShadowDistance) {
-            if (this._dropShadowDistance !== dropShadowDistance) {
-                this._dropShadowDistance = dropShadowDistance;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fill',
-        get: function get() {
-            return this._fill;
-        },
-        set: function set(fill) {
-            var outputColor = getColor(fill);
-            if (this._fill !== outputColor) {
-                this._fill = outputColor;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fillGradientType',
-        get: function get() {
-            return this._fillGradientType;
-        },
-        set: function set(fillGradientType) {
-            if (this._fillGradientType !== fillGradientType) {
-                this._fillGradientType = fillGradientType;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fillGradientStops',
-        get: function get() {
-            return this._fillGradientStops;
-        },
-        set: function set(fillGradientStops) {
-            if (!areArraysEqual(this._fillGradientStops, fillGradientStops)) {
-                this._fillGradientStops = fillGradientStops;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fontFamily',
-        get: function get() {
-            return this._fontFamily;
-        },
-        set: function set(fontFamily) {
-            if (this.fontFamily !== fontFamily) {
-                this._fontFamily = fontFamily;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fontSize',
-        get: function get() {
-            return this._fontSize;
-        },
-        set: function set(fontSize) {
-            if (this._fontSize !== fontSize) {
-                this._fontSize = fontSize;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fontStyle',
-        get: function get() {
-            return this._fontStyle;
-        },
-        set: function set(fontStyle) {
-            if (this._fontStyle !== fontStyle) {
-                this._fontStyle = fontStyle;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fontVariant',
-        get: function get() {
-            return this._fontVariant;
-        },
-        set: function set(fontVariant) {
-            if (this._fontVariant !== fontVariant) {
-                this._fontVariant = fontVariant;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'fontWeight',
-        get: function get() {
-            return this._fontWeight;
-        },
-        set: function set(fontWeight) {
-            if (this._fontWeight !== fontWeight) {
-                this._fontWeight = fontWeight;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'letterSpacing',
-        get: function get() {
-            return this._letterSpacing;
-        },
-        set: function set(letterSpacing) {
-            if (this._letterSpacing !== letterSpacing) {
-                this._letterSpacing = letterSpacing;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'lineHeight',
-        get: function get() {
-            return this._lineHeight;
-        },
-        set: function set(lineHeight) {
-            if (this._lineHeight !== lineHeight) {
-                this._lineHeight = lineHeight;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'lineJoin',
-        get: function get() {
-            return this._lineJoin;
-        },
-        set: function set(lineJoin) {
-            if (this._lineJoin !== lineJoin) {
-                this._lineJoin = lineJoin;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'miterLimit',
-        get: function get() {
-            return this._miterLimit;
-        },
-        set: function set(miterLimit) {
-            if (this._miterLimit !== miterLimit) {
-                this._miterLimit = miterLimit;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'padding',
-        get: function get() {
-            return this._padding;
-        },
-        set: function set(padding) {
-            if (this._padding !== padding) {
-                this._padding = padding;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'stroke',
-        get: function get() {
-            return this._stroke;
-        },
-        set: function set(stroke) {
-            var outputColor = getColor(stroke);
-            if (this._stroke !== outputColor) {
-                this._stroke = outputColor;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'strokeThickness',
-        get: function get() {
-            return this._strokeThickness;
-        },
-        set: function set(strokeThickness) {
-            if (this._strokeThickness !== strokeThickness) {
-                this._strokeThickness = strokeThickness;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'textBaseline',
-        get: function get() {
-            return this._textBaseline;
-        },
-        set: function set(textBaseline) {
-            if (this._textBaseline !== textBaseline) {
-                this._textBaseline = textBaseline;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'trim',
-        get: function get() {
-            return this._trim;
-        },
-        set: function set(trim) {
-            if (this._trim !== trim) {
-                this._trim = trim;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'wordWrap',
-        get: function get() {
-            return this._wordWrap;
-        },
-        set: function set(wordWrap) {
-            if (this._wordWrap !== wordWrap) {
-                this._wordWrap = wordWrap;
-                this.styleID++;
-            }
-        }
-    }, {
-        key: 'wordWrapWidth',
-        get: function get() {
-            return this._wordWrapWidth;
-        },
-        set: function set(wordWrapWidth) {
-            if (this._wordWrapWidth !== wordWrapWidth) {
-                this._wordWrapWidth = wordWrapWidth;
-                this.styleID++;
-            }
-        }
-    }]);
-
-    return TextStyle;
-}();
-
-/**
- * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.
- *
- * @param {number|number[]} color
- * @return {string} The color as a string.
- */
-
-
-exports.default = TextStyle;
-function getSingleColor(color) {
-    if (typeof color === 'number') {
-        return (0, _utils.hex2string)(color);
-    } else if (typeof color === 'string') {
-        if (color.indexOf('0x') === 0) {
-            color = color.replace('0x', '#');
-        }
-    }
-
-    return color;
-}
-
-/**
- * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.
- * This version can also convert array of colors
- *
- * @param {number|number[]} color
- * @return {string} The color as a string.
- */
-function getColor(color) {
-    if (!Array.isArray(color)) {
-        return getSingleColor(color);
-    } else {
-        for (var i = 0; i < color.length; ++i) {
-            color[i] = getSingleColor(color[i]);
-        }
-
-        return color;
-    }
-}
-
-/**
- * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.
- * This version can also convert array of colors
- *
- * @param {Array} array1 First array to compare
- * @param {Array} array2 Second array to compare
- * @return {boolean} Do the arrays contain the same values in the same order
- */
-function areArraysEqual(array1, array2) {
-    if (!Array.isArray(array1) || !Array.isArray(array2)) {
-        return false;
-    }
-
-    if (array1.length !== array2.length) {
-        return false;
-    }
-
-    for (var i = 0; i < array1.length; ++i) {
-        if (array1[i] !== array2[i]) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-},{"../const":46,"../utils":124}],111:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _BaseTexture2 = require('./BaseTexture');
-
-var _BaseTexture3 = _interopRequireDefault(_BaseTexture2);
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * A BaseRenderTexture is a special texture that allows any PixiJS display object to be rendered to it.
- *
- * __Hint__: All DisplayObjects (i.e. Sprites) that render to a BaseRenderTexture should be preloaded
- * otherwise black rectangles will be drawn instead.
- *
- * A BaseRenderTexture takes a snapshot of any Display Object given to its render method. The position
- * and rotation of the given Display Objects is ignored. For example:
- *
- * ```js
- * let renderer = PIXI.autoDetectRenderer(1024, 1024, { view: canvas, ratio: 1 });
- * let baseRenderTexture = new PIXI.BaseRenderTexture(renderer, 800, 600);
- * let sprite = PIXI.Sprite.fromImage("spinObj_01.png");
- *
- * sprite.position.x = 800/2;
- * sprite.position.y = 600/2;
- * sprite.anchor.x = 0.5;
- * sprite.anchor.y = 0.5;
- *
- * baseRenderTexture.render(sprite);
- * ```
- *
- * The Sprite in this case will be rendered using its local transform. To render this sprite at 0,0
- * you can clear the transform
- *
- * ```js
- *
- * sprite.setTransform()
- *
- * let baseRenderTexture = new PIXI.BaseRenderTexture(100, 100);
- * let renderTexture = new PIXI.RenderTexture(baseRenderTexture);
- *
- * renderer.render(sprite, renderTexture);  // Renders to center of RenderTexture
- * ```
- *
- * @class
- * @extends PIXI.BaseTexture
- * @memberof PIXI
- */
-var BaseRenderTexture = function (_BaseTexture) {
-  _inherits(BaseRenderTexture, _BaseTexture);
-
-  /**
-   * @param {number} [width=100] - The width of the base render texture
-   * @param {number} [height=100] - The height of the base render texture
-   * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-   * @param {number} [resolution=1] - The resolution / device pixel ratio of the texture being generated
-   */
-  function BaseRenderTexture() {
-    var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
-    var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
-    var scaleMode = arguments[2];
-    var resolution = arguments[3];
-
-    _classCallCheck(this, BaseRenderTexture);
-
-    var _this = _possibleConstructorReturn(this, _BaseTexture.call(this, null, scaleMode));
-
-    _this.resolution = resolution || _settings2.default.RESOLUTION;
-
-    _this.width = width;
-    _this.height = height;
-
-    _this.realWidth = _this.width * _this.resolution;
-    _this.realHeight = _this.height * _this.resolution;
-
-    _this.scaleMode = scaleMode !== undefined ? scaleMode : _settings2.default.SCALE_MODE;
-    _this.hasLoaded = true;
-
-    /**
-     * A map of renderer IDs to webgl renderTargets
-     *
-     * @private
-     * @member {object<number, WebGLTexture>}
-     */
-    _this._glRenderTargets = {};
-
-    /**
-     * A reference to the canvas render target (we only need one as this can be shared across renderers)
-     *
-     * @private
-     * @member {object<number, WebGLTexture>}
-     */
-    _this._canvasRenderTarget = null;
-
-    /**
-     * This will let the renderer know if the texture is valid. If it's not then it cannot be rendered.
-     *
-     * @member {boolean}
-     */
-    _this.valid = false;
-    return _this;
-  }
-
-  /**
-   * Resizes the BaseRenderTexture.
-   *
-   * @param {number} width - The width to resize to.
-   * @param {number} height - The height to resize to.
-   */
-
-
-  BaseRenderTexture.prototype.resize = function resize(width, height) {
-    if (width === this.width && height === this.height) {
-      return;
-    }
-
-    this.valid = width > 0 && height > 0;
-
-    this.width = width;
-    this.height = height;
-
-    this.realWidth = this.width * this.resolution;
-    this.realHeight = this.height * this.resolution;
-
-    if (!this.valid) {
-      return;
-    }
-
-    this.emit('update', this);
-  };
-
-  /**
-   * Destroys this texture
-   *
-   */
-
-
-  BaseRenderTexture.prototype.destroy = function destroy() {
-    _BaseTexture.prototype.destroy.call(this, true);
-    this.renderer = null;
-  };
-
-  return BaseRenderTexture;
-}(_BaseTexture3.default);
-
-exports.default = BaseRenderTexture;
-
-},{"../settings":101,"./BaseTexture":112}],112:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _utils = require('../utils');
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _eventemitter = require('eventemitter3');
-
-var _eventemitter2 = _interopRequireDefault(_eventemitter);
-
-var _determineCrossOrigin = require('../utils/determineCrossOrigin');
-
-var _determineCrossOrigin2 = _interopRequireDefault(_determineCrossOrigin);
-
-var _bitTwiddle = require('bit-twiddle');
-
-var _bitTwiddle2 = _interopRequireDefault(_bitTwiddle);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * A texture stores the information that represents an image. All textures have a base texture.
- *
- * @class
- * @extends EventEmitter
- * @memberof PIXI
- */
-var BaseTexture = function (_EventEmitter) {
-    _inherits(BaseTexture, _EventEmitter);
-
-    /**
-     * @param {HTMLImageElement|HTMLCanvasElement} [source] - the source object of the texture.
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @param {number} [resolution=1] - The resolution / device pixel ratio of the texture
-     */
-    function BaseTexture(source, scaleMode, resolution) {
-        _classCallCheck(this, BaseTexture);
-
-        var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
-
-        _this.uid = (0, _utils.uid)();
-
-        _this.touched = 0;
-
-        /**
-         * The resolution / device pixel ratio of the texture
-         *
-         * @member {number}
-         * @default 1
-         */
-        _this.resolution = resolution || _settings2.default.RESOLUTION;
-
-        /**
-         * The width of the base texture set when the image has loaded
-         *
-         * @readonly
-         * @member {number}
-         */
-        _this.width = 100;
-
-        /**
-         * The height of the base texture set when the image has loaded
-         *
-         * @readonly
-         * @member {number}
-         */
-        _this.height = 100;
-
-        // TODO docs
-        // used to store the actual dimensions of the source
-        /**
-         * Used to store the actual width of the source of this texture
-         *
-         * @readonly
-         * @member {number}
-         */
-        _this.realWidth = 100;
-        /**
-         * Used to store the actual height of the source of this texture
-         *
-         * @readonly
-         * @member {number}
-         */
-        _this.realHeight = 100;
-
-        /**
-         * The scale mode to apply when scaling this texture
-         *
-         * @member {number}
-         * @default PIXI.settings.SCALE_MODE
-         * @see PIXI.SCALE_MODES
-         */
-        _this.scaleMode = scaleMode !== undefined ? scaleMode : _settings2.default.SCALE_MODE;
-
-        /**
-         * Set to true once the base texture has successfully loaded.
-         *
-         * This is never true if the underlying source fails to load or has no texture data.
-         *
-         * @readonly
-         * @member {boolean}
-         */
-        _this.hasLoaded = false;
-
-        /**
-         * Set to true if the source is currently loading.
-         *
-         * If an Image source is loading the 'loaded' or 'error' event will be
-         * dispatched when the operation ends. An underyling source that is
-         * immediately-available bypasses loading entirely.
-         *
-         * @readonly
-         * @member {boolean}
-         */
-        _this.isLoading = false;
-
-        /**
-         * The image source that is used to create the texture.
-         *
-         * TODO: Make this a setter that calls loadSource();
-         *
-         * @readonly
-         * @member {HTMLImageElement|HTMLCanvasElement}
-         */
-        _this.source = null; // set in loadSource, if at all
-
-        /**
-         * The image source that is used to create the texture. This is used to
-         * store the original Svg source when it is replaced with a canvas element.
-         *
-         * TODO: Currently not in use but could be used when re-scaling svg.
-         *
-         * @readonly
-         * @member {Image}
-         */
-        _this.origSource = null; // set in loadSvg, if at all
-
-        /**
-         * Type of image defined in source, eg. `png` or `svg`
-         *
-         * @readonly
-         * @member {string}
-         */
-        _this.imageType = null; // set in updateImageType
-
-        /**
-         * Scale for source image. Used with Svg images to scale them before rasterization.
-         *
-         * @readonly
-         * @member {number}
-         */
-        _this.sourceScale = 1.0;
-
-        /**
-         * Controls if RGB channels should be pre-multiplied by Alpha  (WebGL only)
-         * All blend modes, and shaders written for default value. Change it on your own risk.
-         *
-         * @member {boolean}
-         * @default true
-         */
-        _this.premultipliedAlpha = true;
-
-        /**
-         * The image url of the texture
-         *
-         * @member {string}
-         */
-        _this.imageUrl = null;
-
-        /**
-         * Whether or not the texture is a power of two, try to use power of two textures as much
-         * as you can
-         *
-         * @private
-         * @member {boolean}
-         */
-        _this.isPowerOfTwo = false;
-
-        // used for webGL
-
-        /**
-         *
-         * Set this to true if a mipmap of this texture needs to be generated. This value needs
-         * to be set before the texture is used
-         * Also the texture must be a power of two size to work
-         *
-         * @member {boolean}
-         * @see PIXI.MIPMAP_TEXTURES
-         */
-        _this.mipmap = _settings2.default.MIPMAP_TEXTURES;
-
-        /**
-         *
-         * WebGL Texture wrap mode
-         *
-         * @member {number}
-         * @see PIXI.WRAP_MODES
-         */
-        _this.wrapMode = _settings2.default.WRAP_MODE;
-
-        /**
-         * A map of renderer IDs to webgl textures
-         *
-         * @private
-         * @member {object<number, WebGLTexture>}
-         */
-        _this._glTextures = {};
-
-        _this._enabled = 0;
-        _this._virtalBoundId = -1;
-
-        /**
-         * If the object has been destroyed via destroy(). If true, it should not be used.
-         *
-         * @member {boolean}
-         * @private
-         * @readonly
-         */
-        _this._destroyed = false;
-
-        /**
-         * The ids under which this BaseTexture has been added to the base texture cache. This is
-         * automatically set as long as BaseTexture.addToCache is used, but may not be set if a
-         * BaseTexture is added directly to the BaseTextureCache array.
-         *
-         * @member {string[]}
-         */
-        _this.textureCacheIds = [];
-
-        // if no source passed don't try to load
-        if (source) {
-            _this.loadSource(source);
-        }
-
-        /**
-         * Fired when a not-immediately-available source finishes loading.
-         *
-         * @protected
-         * @event PIXI.BaseTexture#loaded
-         * @param {PIXI.BaseTexture} baseTexture - Resource loaded.
-         */
-
-        /**
-         * Fired when a not-immediately-available source fails to load.
-         *
-         * @protected
-         * @event PIXI.BaseTexture#error
-         * @param {PIXI.BaseTexture} baseTexture - Resource errored.
-         */
-
-        /**
-         * Fired when BaseTexture is updated.
-         *
-         * @protected
-         * @event PIXI.BaseTexture#update
-         * @param {PIXI.BaseTexture} baseTexture - Instance of texture being updated.
-         */
-
-        /**
-         * Fired when BaseTexture is destroyed.
-         *
-         * @protected
-         * @event PIXI.BaseTexture#dispose
-         * @param {PIXI.BaseTexture} baseTexture - Instance of texture being destroyed.
-         */
-        return _this;
-    }
-
-    /**
-     * Updates the texture on all the webgl renderers, this also assumes the src has changed.
-     *
-     * @fires PIXI.BaseTexture#update
-     */
-
-
-    BaseTexture.prototype.update = function update() {
-        // Svg size is handled during load
-        if (this.imageType !== 'svg') {
-            this.realWidth = this.source.naturalWidth || this.source.videoWidth || this.source.width;
-            this.realHeight = this.source.naturalHeight || this.source.videoHeight || this.source.height;
-
-            this._updateDimensions();
-        }
-
-        this.emit('update', this);
-    };
-
-    /**
-     * Update dimensions from real values
-     */
-
-
-    BaseTexture.prototype._updateDimensions = function _updateDimensions() {
-        this.width = this.realWidth / this.resolution;
-        this.height = this.realHeight / this.resolution;
-
-        this.isPowerOfTwo = _bitTwiddle2.default.isPow2(this.realWidth) && _bitTwiddle2.default.isPow2(this.realHeight);
-    };
-
-    /**
-     * Load a source.
-     *
-     * If the source is not-immediately-available, such as an image that needs to be
-     * downloaded, then the 'loaded' or 'error' event will be dispatched in the future
-     * and `hasLoaded` will remain false after this call.
-     *
-     * The logic state after calling `loadSource` directly or indirectly (eg. `fromImage`, `new BaseTexture`) is:
-     *
-     *     if (texture.hasLoaded) {
-     *        // texture ready for use
-     *     } else if (texture.isLoading) {
-     *        // listen to 'loaded' and/or 'error' events on texture
-     *     } else {
-     *        // not loading, not going to load UNLESS the source is reloaded
-     *        // (it may still make sense to listen to the events)
-     *     }
-     *
-     * @protected
-     * @param {HTMLImageElement|HTMLCanvasElement} source - the source object of the texture.
-     */
-
-
-    BaseTexture.prototype.loadSource = function loadSource(source) {
-        var wasLoading = this.isLoading;
-
-        this.hasLoaded = false;
-        this.isLoading = false;
-
-        if (wasLoading && this.source) {
-            this.source.onload = null;
-            this.source.onerror = null;
-        }
-
-        var firstSourceLoaded = !this.source;
-
-        this.source = source;
-
-        // Apply source if loaded. Otherwise setup appropriate loading monitors.
-        if ((source.src && source.complete || source.getContext) && source.width && source.height) {
-            this._updateImageType();
-
-            if (this.imageType === 'svg') {
-                this._loadSvgSource();
-            } else {
-                this._sourceLoaded();
-            }
-
-            if (firstSourceLoaded) {
-                // send loaded event if previous source was null and we have been passed a pre-loaded IMG element
-                this.emit('loaded', this);
-            }
-        } else if (!source.getContext) {
-            // Image fail / not ready
-            this.isLoading = true;
-
-            var scope = this;
-
-            source.onload = function () {
-                scope._updateImageType();
-                source.onload = null;
-                source.onerror = null;
-
-                if (!scope.isLoading) {
-                    return;
-                }
-
-                scope.isLoading = false;
-                scope._sourceLoaded();
-
-                if (scope.imageType === 'svg') {
-                    scope._loadSvgSource();
-
-                    return;
-                }
-
-                scope.emit('loaded', scope);
-            };
-
-            source.onerror = function () {
-                source.onload = null;
-                source.onerror = null;
-
-                if (!scope.isLoading) {
-                    return;
-                }
-
-                scope.isLoading = false;
-                scope.emit('error', scope);
-            };
-
-            // Per http://www.w3.org/TR/html5/embedded-content-0.html#the-img-element
-            //   "The value of `complete` can thus change while a script is executing."
-            // So complete needs to be re-checked after the callbacks have been added..
-            // NOTE: complete will be true if the image has no src so best to check if the src is set.
-            if (source.complete && source.src) {
-                // ..and if we're complete now, no need for callbacks
-                source.onload = null;
-                source.onerror = null;
-
-                if (scope.imageType === 'svg') {
-                    scope._loadSvgSource();
-
-                    return;
-                }
-
-                this.isLoading = false;
-
-                if (source.width && source.height) {
-                    this._sourceLoaded();
-
-                    // If any previous subscribers possible
-                    if (wasLoading) {
-                        this.emit('loaded', this);
-                    }
-                }
-                // If any previous subscribers possible
-                else if (wasLoading) {
-                        this.emit('error', this);
-                    }
-            }
-        }
-    };
-
-    /**
-     * Updates type of the source image.
-     */
-
-
-    BaseTexture.prototype._updateImageType = function _updateImageType() {
-        if (!this.imageUrl) {
-            return;
-        }
-
-        var dataUri = (0, _utils.decomposeDataUri)(this.imageUrl);
-        var imageType = void 0;
-
-        if (dataUri && dataUri.mediaType === 'image') {
-            // Check for subType validity
-            var firstSubType = dataUri.subType.split('+')[0];
-
-            imageType = (0, _utils.getUrlFileExtension)('.' + firstSubType);
-
-            if (!imageType) {
-                throw new Error('Invalid image type in data URI.');
-            }
-        } else {
-            imageType = (0, _utils.getUrlFileExtension)(this.imageUrl);
-
-            if (!imageType) {
-                imageType = 'png';
-            }
-        }
-
-        this.imageType = imageType;
-    };
-
-    /**
-     * Checks if `source` is an SVG image and whether it's loaded via a URL or a data URI. Then calls
-     * `_loadSvgSourceUsingDataUri` or `_loadSvgSourceUsingXhr`.
-     */
-
-
-    BaseTexture.prototype._loadSvgSource = function _loadSvgSource() {
-        if (this.imageType !== 'svg') {
-            // Do nothing if source is not svg
-            return;
-        }
-
-        var dataUri = (0, _utils.decomposeDataUri)(this.imageUrl);
-
-        if (dataUri) {
-            this._loadSvgSourceUsingDataUri(dataUri);
-        } else {
-            // We got an URL, so we need to do an XHR to check the svg size
-            this._loadSvgSourceUsingXhr();
-        }
-    };
-
-    /**
-     * Reads an SVG string from data URI and then calls `_loadSvgSourceUsingString`.
-     *
-     * @param {string} dataUri - The data uri to load from.
-     */
-
-
-    BaseTexture.prototype._loadSvgSourceUsingDataUri = function _loadSvgSourceUsingDataUri(dataUri) {
-        var svgString = void 0;
-
-        if (dataUri.encoding === 'base64') {
-            if (!atob) {
-                throw new Error('Your browser doesn\'t support base64 conversions.');
-            }
-            svgString = atob(dataUri.data);
-        } else {
-            svgString = dataUri.data;
-        }
-
-        this._loadSvgSourceUsingString(svgString);
-    };
-
-    /**
-     * Loads an SVG string from `imageUrl` using XHR and then calls `_loadSvgSourceUsingString`.
-     */
-
-
-    BaseTexture.prototype._loadSvgSourceUsingXhr = function _loadSvgSourceUsingXhr() {
-        var _this2 = this;
-
-        var svgXhr = new XMLHttpRequest();
-
-        // This throws error on IE, so SVG Document can't be used
-        // svgXhr.responseType = 'document';
-
-        // This is not needed since we load the svg as string (breaks IE too)
-        // but overrideMimeType() can be used to force the response to be parsed as XML
-        // svgXhr.overrideMimeType('image/svg+xml');
-
-        svgXhr.onload = function () {
-            if (svgXhr.readyState !== svgXhr.DONE || svgXhr.status !== 200) {
-                throw new Error('Failed to load SVG using XHR.');
-            }
-
-            _this2._loadSvgSourceUsingString(svgXhr.response);
-        };
-
-        svgXhr.onerror = function () {
-            return _this2.emit('error', _this2);
-        };
-
-        svgXhr.open('GET', this.imageUrl, true);
-        svgXhr.send();
-    };
-
-    /**
-     * Loads texture using an SVG string. The original SVG Image is stored as `origSource` and the
-     * created canvas is the new `source`. The SVG is scaled using `sourceScale`. Called by
-     * `_loadSvgSourceUsingXhr` or `_loadSvgSourceUsingDataUri`.
-     *
-     * @param  {string} svgString SVG source as string
-     *
-     * @fires PIXI.BaseTexture#loaded
-     */
-
-
-    BaseTexture.prototype._loadSvgSourceUsingString = function _loadSvgSourceUsingString(svgString) {
-        var svgSize = (0, _utils.getSvgSize)(svgString);
-
-        var svgWidth = svgSize.width;
-        var svgHeight = svgSize.height;
-
-        if (!svgWidth || !svgHeight) {
-            throw new Error('The SVG image must have width and height defined (in pixels), canvas API needs them.');
-        }
-
-        // Scale realWidth and realHeight
-        this.realWidth = Math.round(svgWidth * this.sourceScale);
-        this.realHeight = Math.round(svgHeight * this.sourceScale);
-
-        this._updateDimensions();
-
-        // Create a canvas element
-        var canvas = document.createElement('canvas');
-
-        canvas.width = this.realWidth;
-        canvas.height = this.realHeight;
-        canvas._pixiId = 'canvas_' + (0, _utils.uid)();
-
-        // Draw the Svg to the canvas
-        canvas.getContext('2d').drawImage(this.source, 0, 0, svgWidth, svgHeight, 0, 0, this.realWidth, this.realHeight);
-
-        // Replace the original source image with the canvas
-        this.origSource = this.source;
-        this.source = canvas;
-
-        // Add also the canvas in cache (destroy clears by `imageUrl` and `source._pixiId`)
-        BaseTexture.addToCache(this, canvas._pixiId);
-
-        this.isLoading = false;
-        this._sourceLoaded();
-        this.emit('loaded', this);
-    };
-
-    /**
-     * Used internally to update the width, height, and some other tracking vars once
-     * a source has successfully loaded.
-     *
-     * @private
-     */
-
-
-    BaseTexture.prototype._sourceLoaded = function _sourceLoaded() {
-        this.hasLoaded = true;
-        this.update();
-    };
-
-    /**
-     * Destroys this base texture
-     *
-     */
-
-
-    BaseTexture.prototype.destroy = function destroy() {
-        if (this.imageUrl) {
-            delete _utils.TextureCache[this.imageUrl];
-
-            this.imageUrl = null;
-
-            if (!navigator.isCocoonJS) {
-                this.source.src = '';
-            }
-        }
-
-        this.source = null;
-
-        this.dispose();
-
-        BaseTexture.removeFromCache(this);
-        this.textureCacheIds = null;
-
-        this._destroyed = true;
-    };
-
-    /**
-     * Frees the texture from WebGL memory without destroying this texture object.
-     * This means you can still use the texture later which will upload it to GPU
-     * memory again.
-     *
-     * @fires PIXI.BaseTexture#dispose
-     */
-
-
-    BaseTexture.prototype.dispose = function dispose() {
-        this.emit('dispose', this);
-    };
-
-    /**
-     * Changes the source image of the texture.
-     * The original source must be an Image element.
-     *
-     * @param {string} newSrc - the path of the image
-     */
-
-
-    BaseTexture.prototype.updateSourceImage = function updateSourceImage(newSrc) {
-        this.source.src = newSrc;
-
-        this.loadSource(this.source);
-    };
-
-    /**
-     * Helper function that creates a base texture from the given image url.
-     * If the image is not in the base texture cache it will be created and loaded.
-     *
-     * @static
-     * @param {string} imageUrl - The image url of the texture
-     * @param {boolean} [crossorigin=(auto)] - Should use anonymous CORS? Defaults to true if the URL is not a data-URI.
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @param {number} [sourceScale=(auto)] - Scale for the original image, used with Svg images.
-     * @return {PIXI.BaseTexture} The new base texture.
-     */
-
-
-    BaseTexture.fromImage = function fromImage(imageUrl, crossorigin, scaleMode, sourceScale) {
-        var baseTexture = _utils.BaseTextureCache[imageUrl];
-
-        if (!baseTexture) {
-            // new Image() breaks tex loading in some versions of Chrome.
-            // See https://code.google.com/p/chromium/issues/detail?id=238071
-            var image = new Image(); // document.createElement('img');
-
-            if (crossorigin === undefined && imageUrl.indexOf('data:') !== 0) {
-                image.crossOrigin = (0, _determineCrossOrigin2.default)(imageUrl);
-            } else if (crossorigin) {
-                image.crossOrigin = typeof crossorigin === 'string' ? crossorigin : 'anonymous';
-            }
-
-            baseTexture = new BaseTexture(image, scaleMode);
-            baseTexture.imageUrl = imageUrl;
-
-            if (sourceScale) {
-                baseTexture.sourceScale = sourceScale;
-            }
-
-            // if there is an @2x at the end of the url we are going to assume its a highres image
-            baseTexture.resolution = (0, _utils.getResolutionOfUrl)(imageUrl);
-
-            image.src = imageUrl; // Setting this triggers load
-
-            BaseTexture.addToCache(baseTexture, imageUrl);
-        }
-
-        return baseTexture;
-    };
-
-    /**
-     * Helper function that creates a base texture from the given canvas element.
-     *
-     * @static
-     * @param {HTMLCanvasElement} canvas - The canvas element source of the texture
-     * @param {number} scaleMode - See {@link PIXI.SCALE_MODES} for possible values
-     * @param {string} [origin='canvas'] - A string origin of who created the base texture
-     * @return {PIXI.BaseTexture} The new base texture.
-     */
-
-
-    BaseTexture.fromCanvas = function fromCanvas(canvas, scaleMode) {
-        var origin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'canvas';
-
-        if (!canvas._pixiId) {
-            canvas._pixiId = origin + '_' + (0, _utils.uid)();
-        }
-
-        var baseTexture = _utils.BaseTextureCache[canvas._pixiId];
-
-        if (!baseTexture) {
-            baseTexture = new BaseTexture(canvas, scaleMode);
-            BaseTexture.addToCache(baseTexture, canvas._pixiId);
-        }
-
-        return baseTexture;
-    };
-
-    /**
-     * Helper function that creates a base texture based on the source you provide.
-     * The source can be - image url, image element, canvas element.
-     *
-     * @static
-     * @param {string|HTMLImageElement|HTMLCanvasElement} source - The source to create base texture from.
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @param {number} [sourceScale=(auto)] - Scale for the original image, used with Svg images.
-     * @return {PIXI.BaseTexture} The new base texture.
-     */
-
-
-    BaseTexture.from = function from(source, scaleMode, sourceScale) {
-        if (typeof source === 'string') {
-            return BaseTexture.fromImage(source, undefined, scaleMode, sourceScale);
-        } else if (source instanceof HTMLImageElement) {
-            var imageUrl = source.src;
-            var baseTexture = _utils.BaseTextureCache[imageUrl];
-
-            if (!baseTexture) {
-                baseTexture = new BaseTexture(source, scaleMode);
-                baseTexture.imageUrl = imageUrl;
-
-                if (sourceScale) {
-                    baseTexture.sourceScale = sourceScale;
-                }
-
-                // if there is an @2x at the end of the url we are going to assume its a highres image
-                baseTexture.resolution = (0, _utils.getResolutionOfUrl)(imageUrl);
-
-                BaseTexture.addToCache(baseTexture, imageUrl);
-            }
-
-            return baseTexture;
-        } else if (source instanceof HTMLCanvasElement) {
-            return BaseTexture.fromCanvas(source, scaleMode);
-        }
-
-        // lets assume its a base texture!
-        return source;
-    };
-
-    /**
-     * Adds a BaseTexture to the global BaseTextureCache. This cache is shared across the whole PIXI object.
-     *
-     * @static
-     * @param {PIXI.BaseTexture} baseTexture - The BaseTexture to add to the cache.
-     * @param {string} id - The id that the BaseTexture will be stored against.
-     */
-
-
-    BaseTexture.addToCache = function addToCache(baseTexture, id) {
-        if (id) {
-            if (baseTexture.textureCacheIds.indexOf(id) === -1) {
-                baseTexture.textureCacheIds.push(id);
-            }
-
-            /* eslint-disable no-console */
-            if (_utils.BaseTextureCache[id]) {
-                console.warn('BaseTexture added to the cache with an id [' + id + '] that already had an entry');
-            }
-            /* eslint-enable no-console */
-
-            _utils.BaseTextureCache[id] = baseTexture;
-        }
-    };
-
-    /**
-     * Remove a BaseTexture from the global BaseTextureCache.
-     *
-     * @static
-     * @param {string|PIXI.BaseTexture} baseTexture - id of a BaseTexture to be removed, or a BaseTexture instance itself.
-     * @return {PIXI.BaseTexture|null} The BaseTexture that was removed.
-     */
-
-
-    BaseTexture.removeFromCache = function removeFromCache(baseTexture) {
-        if (typeof baseTexture === 'string') {
-            var baseTextureFromCache = _utils.BaseTextureCache[baseTexture];
-
-            if (baseTextureFromCache) {
-                var index = baseTextureFromCache.textureCacheIds.indexOf(baseTexture);
-
-                if (index > -1) {
-                    baseTextureFromCache.textureCacheIds.splice(index, 1);
-                }
-
-                delete _utils.BaseTextureCache[baseTexture];
-
-                return baseTextureFromCache;
-            }
-        } else if (baseTexture && baseTexture.textureCacheIds) {
-            for (var i = 0; i < baseTexture.textureCacheIds.length; ++i) {
-                delete _utils.BaseTextureCache[baseTexture.textureCacheIds[i]];
-            }
-
-            baseTexture.textureCacheIds.length = 0;
-
-            return baseTexture;
-        }
-
-        return null;
-    };
-
-    return BaseTexture;
-}(_eventemitter2.default);
-
-exports.default = BaseTexture;
-
-},{"../settings":101,"../utils":124,"../utils/determineCrossOrigin":123,"bit-twiddle":1,"eventemitter3":3}],113:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _BaseRenderTexture = require('./BaseRenderTexture');
-
-var _BaseRenderTexture2 = _interopRequireDefault(_BaseRenderTexture);
-
-var _Texture2 = require('./Texture');
-
-var _Texture3 = _interopRequireDefault(_Texture2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * A RenderTexture is a special texture that allows any PixiJS display object to be rendered to it.
- *
- * __Hint__: All DisplayObjects (i.e. Sprites) that render to a RenderTexture should be preloaded
- * otherwise black rectangles will be drawn instead.
- *
- * A RenderTexture takes a snapshot of any Display Object given to its render method. For example:
- *
- * ```js
- * let renderer = PIXI.autoDetectRenderer(1024, 1024, { view: canvas, ratio: 1 });
- * let renderTexture = PIXI.RenderTexture.create(800, 600);
- * let sprite = PIXI.Sprite.fromImage("spinObj_01.png");
- *
- * sprite.position.x = 800/2;
- * sprite.position.y = 600/2;
- * sprite.anchor.x = 0.5;
- * sprite.anchor.y = 0.5;
- *
- * renderer.render(sprite, renderTexture);
- * ```
- *
- * The Sprite in this case will be rendered using its local transform. To render this sprite at 0,0
- * you can clear the transform
- *
- * ```js
- *
- * sprite.setTransform()
- *
- * let renderTexture = new PIXI.RenderTexture.create(100, 100);
- *
- * renderer.render(sprite, renderTexture);  // Renders to center of RenderTexture
- * ```
- *
- * @class
- * @extends PIXI.Texture
- * @memberof PIXI
- */
-var RenderTexture = function (_Texture) {
-    _inherits(RenderTexture, _Texture);
-
-    /**
-     * @param {PIXI.BaseRenderTexture} baseRenderTexture - The renderer used for this RenderTexture
-     * @param {PIXI.Rectangle} [frame] - The rectangle frame of the texture to show
-     */
-    function RenderTexture(baseRenderTexture, frame) {
-        _classCallCheck(this, RenderTexture);
-
-        // support for legacy..
-        var _legacyRenderer = null;
-
-        if (!(baseRenderTexture instanceof _BaseRenderTexture2.default)) {
-            /* eslint-disable prefer-rest-params, no-console */
-            var width = arguments[1];
-            var height = arguments[2];
-            var scaleMode = arguments[3];
-            var resolution = arguments[4];
-
-            // we have an old render texture..
-            console.warn('Please use RenderTexture.create(' + width + ', ' + height + ') instead of the ctor directly.');
-            _legacyRenderer = arguments[0];
-            /* eslint-enable prefer-rest-params, no-console */
-
-            frame = null;
-            baseRenderTexture = new _BaseRenderTexture2.default(width, height, scaleMode, resolution);
-        }
-
-        /**
-         * The base texture object that this texture uses
-         *
-         * @member {BaseTexture}
-         */
-
-        var _this = _possibleConstructorReturn(this, _Texture.call(this, baseRenderTexture, frame));
-
-        _this.legacyRenderer = _legacyRenderer;
-
-        /**
-         * This will let the renderer know if the texture is valid. If it's not then it cannot be rendered.
-         *
-         * @member {boolean}
-         */
-        _this.valid = true;
-
-        _this._updateUvs();
-        return _this;
-    }
-
-    /**
-     * Resizes the RenderTexture.
-     *
-     * @param {number} width - The width to resize to.
-     * @param {number} height - The height to resize to.
-     * @param {boolean} doNotResizeBaseTexture - Should the baseTexture.width and height values be resized as well?
-     */
-
-
-    RenderTexture.prototype.resize = function resize(width, height, doNotResizeBaseTexture) {
-        // TODO - could be not required..
-        this.valid = width > 0 && height > 0;
-
-        this._frame.width = this.orig.width = width;
-        this._frame.height = this.orig.height = height;
-
-        if (!doNotResizeBaseTexture) {
-            this.baseTexture.resize(width, height);
-        }
-
-        this._updateUvs();
-    };
-
-    /**
-     * A short hand way of creating a render texture.
-     *
-     * @param {number} [width=100] - The width of the render texture
-     * @param {number} [height=100] - The height of the render texture
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @param {number} [resolution=1] - The resolution / device pixel ratio of the texture being generated
-     * @return {PIXI.RenderTexture} The new render texture
-     */
-
-
-    RenderTexture.create = function create(width, height, scaleMode, resolution) {
-        return new RenderTexture(new _BaseRenderTexture2.default(width, height, scaleMode, resolution));
-    };
-
-    return RenderTexture;
-}(_Texture3.default);
-
-exports.default = RenderTexture;
-
-},{"./BaseRenderTexture":111,"./Texture":115}],114:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _ = require('../');
-
-var _utils = require('../utils');
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Utility class for maintaining reference to a collection
- * of Textures on a single Spritesheet.
- *
- * @class
- * @memberof PIXI
- */
-var Spritesheet = function () {
-    _createClass(Spritesheet, null, [{
-        key: 'BATCH_SIZE',
-
-        /**
-         * The maximum number of Textures to build per process.
-         *
-         * @type {number}
-         * @default 1000
-         */
-        get: function get() {
-            return 1000;
-        }
-
-        /**
-         * @param {PIXI.BaseTexture} baseTexture Reference to the source BaseTexture object.
-         * @param {Object} data - Spritesheet image data.
-         * @param {string} [resolutionFilename] - The filename to consider when determining
-         *        the resolution of the spritesheet. If not provided, the imageUrl will
-         *        be used on the BaseTexture.
-         */
-
-    }]);
-
-    function Spritesheet(baseTexture, data) {
-        var resolutionFilename = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-
-        _classCallCheck(this, Spritesheet);
-
-        /**
-         * Reference to ths source texture
-         * @type {PIXI.BaseTexture}
-         */
-        this.baseTexture = baseTexture;
-
-        /**
-         * Map of spritesheet textures.
-         * @type {Object}
-         */
-        this.textures = {};
-
-        /**
-         * Reference to the original JSON data.
-         * @type {Object}
-         */
-        this.data = data;
-
-        /**
-         * The resolution of the spritesheet.
-         * @type {number}
-         */
-        this.resolution = this._updateResolution(resolutionFilename || this.baseTexture.imageUrl);
-
-        /**
-         * Map of spritesheet frames.
-         * @type {Object}
-         * @private
-         */
-        this._frames = this.data.frames;
-
-        /**
-         * Collection of frame names.
-         * @type {string[]}
-         * @private
-         */
-        this._frameKeys = Object.keys(this._frames);
-
-        /**
-         * Current batch index being processed.
-         * @type {number}
-         * @private
-         */
-        this._batchIndex = 0;
-
-        /**
-         * Callback when parse is completed.
-         * @type {Function}
-         * @private
-         */
-        this._callback = null;
-    }
-
-    /**
-     * Generate the resolution from the filename or fallback
-     * to the meta.scale field of the JSON data.
-     *
-     * @private
-     * @param {string} resolutionFilename - The filename to use for resolving
-     *        the default resolution.
-     * @return {number} Resolution to use for spritesheet.
-     */
-
-
-    Spritesheet.prototype._updateResolution = function _updateResolution(resolutionFilename) {
-        var scale = this.data.meta.scale;
-
-        // Use a defaultValue of `null` to check if a url-based resolution is set
-        var resolution = (0, _utils.getResolutionOfUrl)(resolutionFilename, null);
-
-        // No resolution found via URL
-        if (resolution === null) {
-            // Use the scale value or default to 1
-            resolution = scale !== undefined ? parseFloat(scale) : 1;
-        }
-
-        // For non-1 resolutions, update baseTexture
-        if (resolution !== 1) {
-            this.baseTexture.resolution = resolution;
-            this.baseTexture.update();
-        }
-
-        return resolution;
-    };
-
-    /**
-     * Parser spritesheet from loaded data. This is done asynchronously
-     * to prevent creating too many Texture within a single process.
-     *
-     * @param {Function} callback - Callback when complete returns
-     *        a map of the Textures for this spritesheet.
-     */
-
-
-    Spritesheet.prototype.parse = function parse(callback) {
-        this._batchIndex = 0;
-        this._callback = callback;
-
-        if (this._frameKeys.length <= Spritesheet.BATCH_SIZE) {
-            this._processFrames(0);
-            this._parseComplete();
-        } else {
-            this._nextBatch();
-        }
-    };
-
-    /**
-     * Process a batch of frames
-     *
-     * @private
-     * @param {number} initialFrameIndex - The index of frame to start.
-     */
-
-
-    Spritesheet.prototype._processFrames = function _processFrames(initialFrameIndex) {
-        var frameIndex = initialFrameIndex;
-        var maxFrames = Spritesheet.BATCH_SIZE;
-
-        while (frameIndex - initialFrameIndex < maxFrames && frameIndex < this._frameKeys.length) {
-            var i = this._frameKeys[frameIndex];
-            var rect = this._frames[i].frame;
-
-            if (rect) {
-                var frame = null;
-                var trim = null;
-                var orig = new _.Rectangle(0, 0, this._frames[i].sourceSize.w / this.resolution, this._frames[i].sourceSize.h / this.resolution);
-
-                if (this._frames[i].rotated) {
-                    frame = new _.Rectangle(rect.x / this.resolution, rect.y / this.resolution, rect.h / this.resolution, rect.w / this.resolution);
-                } else {
-                    frame = new _.Rectangle(rect.x / this.resolution, rect.y / this.resolution, rect.w / this.resolution, rect.h / this.resolution);
-                }
-
-                //  Check to see if the sprite is trimmed
-                if (this._frames[i].trimmed) {
-                    trim = new _.Rectangle(this._frames[i].spriteSourceSize.x / this.resolution, this._frames[i].spriteSourceSize.y / this.resolution, rect.w / this.resolution, rect.h / this.resolution);
-                }
-
-                this.textures[i] = new _.Texture(this.baseTexture, frame, orig, trim, this._frames[i].rotated ? 2 : 0);
-
-                // lets also add the frame to pixi's global cache for fromFrame and fromImage functions
-                _.Texture.addToCache(this.textures[i], i);
-            }
-
-            frameIndex++;
-        }
-    };
-
-    /**
-     * The parse has completed.
-     *
-     * @private
-     */
-
-
-    Spritesheet.prototype._parseComplete = function _parseComplete() {
-        var callback = this._callback;
-
-        this._callback = null;
-        this._batchIndex = 0;
-        callback.call(this, this.textures);
-    };
-
-    /**
-     * Begin the next batch of textures.
-     *
-     * @private
-     */
-
-
-    Spritesheet.prototype._nextBatch = function _nextBatch() {
-        var _this = this;
-
-        this._processFrames(this._batchIndex * Spritesheet.BATCH_SIZE);
-        this._batchIndex++;
-        setTimeout(function () {
-            if (_this._batchIndex * Spritesheet.BATCH_SIZE < _this._frameKeys.length) {
-                _this._nextBatch();
-            } else {
-                _this._parseComplete();
-            }
-        }, 0);
-    };
-
-    /**
-     * Destroy Spritesheet and don't use after this.
-     *
-     * @param {boolean} [destroyBase=false] Whether to destroy the base texture as well
-     */
-
-
-    Spritesheet.prototype.destroy = function destroy() {
-        var destroyBase = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-        for (var i in this.textures) {
-            this.textures[i].destroy();
-        }
-        this._frames = null;
-        this._frameKeys = null;
-        this.data = null;
-        this.textures = null;
-        if (destroyBase) {
-            this.baseTexture.destroy();
-        }
-        this.baseTexture = null;
-    };
-
-    return Spritesheet;
-}();
-
-exports.default = Spritesheet;
-
-},{"../":65,"../utils":124}],115:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _BaseTexture = require('./BaseTexture');
-
-var _BaseTexture2 = _interopRequireDefault(_BaseTexture);
-
-var _VideoBaseTexture = require('./VideoBaseTexture');
-
-var _VideoBaseTexture2 = _interopRequireDefault(_VideoBaseTexture);
-
-var _TextureUvs = require('./TextureUvs');
-
-var _TextureUvs2 = _interopRequireDefault(_TextureUvs);
-
-var _eventemitter = require('eventemitter3');
-
-var _eventemitter2 = _interopRequireDefault(_eventemitter);
-
-var _math = require('../math');
-
-var _utils = require('../utils');
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * A texture stores the information that represents an image or part of an image. It cannot be added
- * to the display list directly. Instead use it as the texture for a Sprite. If no frame is provided
- * then the whole image is used.
- *
- * You can directly create a texture from an image and then reuse it multiple times like this :
- *
- * ```js
- * let texture = PIXI.Texture.fromImage('assets/image.png');
- * let sprite1 = new PIXI.Sprite(texture);
- * let sprite2 = new PIXI.Sprite(texture);
- * ```
- *
- * Textures made from SVGs, loaded or not, cannot be used before the file finishes processing.
- * You can check for this by checking the sprite's _textureID property.
- * ```js
- * var texture = PIXI.Texture.fromImage('assets/image.svg');
- * var sprite1 = new PIXI.Sprite(texture);
- * //sprite1._textureID should not be undefined if the texture has finished processing the SVG file
- * ```
- * You can use a ticker or rAF to ensure your sprites load the finished textures after processing. See issue #3068.
- *
- * @class
- * @extends EventEmitter
- * @memberof PIXI
- */
-var Texture = function (_EventEmitter) {
-    _inherits(Texture, _EventEmitter);
-
-    /**
-     * @param {PIXI.BaseTexture} baseTexture - The base texture source to create the texture from
-     * @param {PIXI.Rectangle} [frame] - The rectangle frame of the texture to show
-     * @param {PIXI.Rectangle} [orig] - The area of original texture
-     * @param {PIXI.Rectangle} [trim] - Trimmed rectangle of original texture
-     * @param {number} [rotate] - indicates how the texture was rotated by texture packer. See {@link PIXI.GroupD8}
-     */
-    function Texture(baseTexture, frame, orig, trim, rotate) {
-        _classCallCheck(this, Texture);
-
-        /**
-         * Does this Texture have any frame data assigned to it?
-         *
-         * @member {boolean}
-         */
-        var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
-
-        _this.noFrame = false;
-
-        if (!frame) {
-            _this.noFrame = true;
-            frame = new _math.Rectangle(0, 0, 1, 1);
-        }
-
-        if (baseTexture instanceof Texture) {
-            baseTexture = baseTexture.baseTexture;
-        }
-
-        /**
-         * The base texture that this texture uses.
-         *
-         * @member {PIXI.BaseTexture}
-         */
-        _this.baseTexture = baseTexture;
-
-        /**
-         * This is the area of the BaseTexture image to actually copy to the Canvas / WebGL when rendering,
-         * irrespective of the actual frame size or placement (which can be influenced by trimmed texture atlases)
-         *
-         * @member {PIXI.Rectangle}
-         */
-        _this._frame = frame;
-
-        /**
-         * This is the trimmed area of original texture, before it was put in atlas
-         *
-         * @member {PIXI.Rectangle}
-         */
-        _this.trim = trim;
-
-        /**
-         * This will let the renderer know if the texture is valid. If it's not then it cannot be rendered.
-         *
-         * @member {boolean}
-         */
-        _this.valid = false;
-
-        /**
-         * This will let a renderer know that a texture has been updated (used mainly for webGL uv updates)
-         *
-         * @member {boolean}
-         */
-        _this.requiresUpdate = false;
-
-        /**
-         * The WebGL UV data cache.
-         *
-         * @member {PIXI.TextureUvs}
-         * @private
-         */
-        _this._uvs = null;
-
-        /**
-         * This is the area of original texture, before it was put in atlas
-         *
-         * @member {PIXI.Rectangle}
-         */
-        _this.orig = orig || frame; // new Rectangle(0, 0, 1, 1);
-
-        _this._rotate = Number(rotate || 0);
-
-        if (rotate === true) {
-            // this is old texturepacker legacy, some games/libraries are passing "true" for rotated textures
-            _this._rotate = 2;
-        } else if (_this._rotate % 2 !== 0) {
-            throw new Error('attempt to use diamond-shaped UVs. If you are sure, set rotation manually');
-        }
-
-        if (baseTexture.hasLoaded) {
-            if (_this.noFrame) {
-                frame = new _math.Rectangle(0, 0, baseTexture.width, baseTexture.height);
-
-                // if there is no frame we should monitor for any base texture changes..
-                baseTexture.on('update', _this.onBaseTextureUpdated, _this);
-            }
-            _this.frame = frame;
-        } else {
-            baseTexture.once('loaded', _this.onBaseTextureLoaded, _this);
-        }
-
-        /**
-         * Fired when the texture is updated. This happens if the frame or the baseTexture is updated.
-         *
-         * @event PIXI.Texture#update
-         * @protected
-         * @param {PIXI.Texture} texture - Instance of texture being updated.
-         */
-
-        _this._updateID = 0;
-
-        /**
-         * Extra field for extra plugins. May contain clamp settings and some matrices
-         * @type {Object}
-         */
-        _this.transform = null;
-
-        /**
-         * The ids under which this Texture has been added to the texture cache. This is
-         * automatically set as long as Texture.addToCache is used, but may not be set if a
-         * Texture is added directly to the TextureCache array.
-         *
-         * @member {string[]}
-         */
-        _this.textureCacheIds = [];
-        return _this;
-    }
-
-    /**
-     * Updates this texture on the gpu.
-     *
-     */
-
-
-    Texture.prototype.update = function update() {
-        this.baseTexture.update();
-    };
-
-    /**
-     * Called when the base texture is loaded
-     *
-     * @private
-     * @param {PIXI.BaseTexture} baseTexture - The base texture.
-     */
-
-
-    Texture.prototype.onBaseTextureLoaded = function onBaseTextureLoaded(baseTexture) {
-        this._updateID++;
-
-        // TODO this code looks confusing.. boo to abusing getters and setters!
-        if (this.noFrame) {
-            this.frame = new _math.Rectangle(0, 0, baseTexture.width, baseTexture.height);
-        } else {
-            this.frame = this._frame;
-        }
-
-        this.baseTexture.on('update', this.onBaseTextureUpdated, this);
-        this.emit('update', this);
-    };
-
-    /**
-     * Called when the base texture is updated
-     *
-     * @private
-     * @param {PIXI.BaseTexture} baseTexture - The base texture.
-     */
-
-
-    Texture.prototype.onBaseTextureUpdated = function onBaseTextureUpdated(baseTexture) {
-        this._updateID++;
-
-        this._frame.width = baseTexture.width;
-        this._frame.height = baseTexture.height;
-
-        this.emit('update', this);
-    };
-
-    /**
-     * Destroys this texture
-     *
-     * @param {boolean} [destroyBase=false] Whether to destroy the base texture as well
-     */
-
-
-    Texture.prototype.destroy = function destroy(destroyBase) {
-        if (this.baseTexture) {
-            if (destroyBase) {
-                // delete the texture if it exists in the texture cache..
-                // this only needs to be removed if the base texture is actually destroyed too..
-                if (_utils.TextureCache[this.baseTexture.imageUrl]) {
-                    Texture.removeFromCache(this.baseTexture.imageUrl);
-                }
-
-                this.baseTexture.destroy();
-            }
-
-            this.baseTexture.off('update', this.onBaseTextureUpdated, this);
-            this.baseTexture.off('loaded', this.onBaseTextureLoaded, this);
-
-            this.baseTexture = null;
-        }
-
-        this._frame = null;
-        this._uvs = null;
-        this.trim = null;
-        this.orig = null;
-
-        this.valid = false;
-
-        Texture.removeFromCache(this);
-        this.textureCacheIds = null;
-    };
-
-    /**
-     * Creates a new texture object that acts the same as this one.
-     *
-     * @return {PIXI.Texture} The new texture
-     */
-
-
-    Texture.prototype.clone = function clone() {
-        return new Texture(this.baseTexture, this.frame, this.orig, this.trim, this.rotate);
-    };
-
-    /**
-     * Updates the internal WebGL UV cache.
-     *
-     * @protected
-     */
-
-
-    Texture.prototype._updateUvs = function _updateUvs() {
-        if (!this._uvs) {
-            this._uvs = new _TextureUvs2.default();
-        }
-
-        this._uvs.set(this._frame, this.baseTexture, this.rotate);
-
-        this._updateID++;
-    };
-
-    /**
-     * Helper function that creates a Texture object from the given image url.
-     * If the image is not in the texture cache it will be  created and loaded.
-     *
-     * @static
-     * @param {string} imageUrl - The image url of the texture
-     * @param {boolean} [crossorigin] - Whether requests should be treated as crossorigin
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @param {number} [sourceScale=(auto)] - Scale for the original image, used with SVG images.
-     * @return {PIXI.Texture} The newly created texture
-     */
-
-
-    Texture.fromImage = function fromImage(imageUrl, crossorigin, scaleMode, sourceScale) {
-        var texture = _utils.TextureCache[imageUrl];
-
-        if (!texture) {
-            texture = new Texture(_BaseTexture2.default.fromImage(imageUrl, crossorigin, scaleMode, sourceScale));
-            Texture.addToCache(texture, imageUrl);
-        }
-
-        return texture;
-    };
-
-    /**
-     * Helper function that creates a sprite that will contain a texture from the TextureCache based on the frameId
-     * The frame ids are created when a Texture packer file has been loaded
-     *
-     * @static
-     * @param {string} frameId - The frame Id of the texture in the cache
-     * @return {PIXI.Texture} The newly created texture
-     */
-
-
-    Texture.fromFrame = function fromFrame(frameId) {
-        var texture = _utils.TextureCache[frameId];
-
-        if (!texture) {
-            throw new Error('The frameId "' + frameId + '" does not exist in the texture cache');
-        }
-
-        return texture;
-    };
-
-    /**
-     * Helper function that creates a new Texture based on the given canvas element.
-     *
-     * @static
-     * @param {HTMLCanvasElement} canvas - The canvas element source of the texture
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @param {string} [origin='canvas'] - A string origin of who created the base texture
-     * @return {PIXI.Texture} The newly created texture
-     */
-
-
-    Texture.fromCanvas = function fromCanvas(canvas, scaleMode) {
-        var origin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'canvas';
-
-        return new Texture(_BaseTexture2.default.fromCanvas(canvas, scaleMode, origin));
-    };
-
-    /**
-     * Helper function that creates a new Texture based on the given video element.
-     *
-     * @static
-     * @param {HTMLVideoElement|string} video - The URL or actual element of the video
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @return {PIXI.Texture} The newly created texture
-     */
-
-
-    Texture.fromVideo = function fromVideo(video, scaleMode) {
-        if (typeof video === 'string') {
-            return Texture.fromVideoUrl(video, scaleMode);
-        }
-
-        return new Texture(_VideoBaseTexture2.default.fromVideo(video, scaleMode));
-    };
-
-    /**
-     * Helper function that creates a new Texture based on the video url.
-     *
-     * @static
-     * @param {string} videoUrl - URL of the video
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @return {PIXI.Texture} The newly created texture
-     */
-
-
-    Texture.fromVideoUrl = function fromVideoUrl(videoUrl, scaleMode) {
-        return new Texture(_VideoBaseTexture2.default.fromUrl(videoUrl, scaleMode));
-    };
-
-    /**
-     * Helper function that creates a new Texture based on the source you provide.
-     * The source can be - frame id, image url, video url, canvas element, video element, base texture
-     *
-     * @static
-     * @param {number|string|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|PIXI.BaseTexture}
-     *        source - Source to create texture from
-     * @return {PIXI.Texture} The newly created texture
-     */
-
-
-    Texture.from = function from(source) {
-        // TODO auto detect cross origin..
-        // TODO pass in scale mode?
-        if (typeof source === 'string') {
-            var texture = _utils.TextureCache[source];
-
-            if (!texture) {
-                // check if its a video..
-                var isVideo = source.match(/\.(mp4|webm|ogg|h264|avi|mov)$/) !== null;
-
-                if (isVideo) {
-                    return Texture.fromVideoUrl(source);
-                }
-
-                return Texture.fromImage(source);
-            }
-
-            return texture;
-        } else if (source instanceof HTMLImageElement) {
-            return new Texture(_BaseTexture2.default.from(source));
-        } else if (source instanceof HTMLCanvasElement) {
-            return Texture.fromCanvas(source, _settings2.default.SCALE_MODE, 'HTMLCanvasElement');
-        } else if (source instanceof HTMLVideoElement) {
-            return Texture.fromVideo(source);
-        } else if (source instanceof _BaseTexture2.default) {
-            return new Texture(source);
-        }
-
-        // lets assume its a texture!
-        return source;
-    };
-
-    /**
-     * Create a texture from a source and add to the cache.
-     *
-     * @static
-     * @param {HTMLImageElement|HTMLCanvasElement} source - The input source.
-     * @param {String} imageUrl - File name of texture, for cache and resolving resolution.
-     * @param {String} [name] - Human readible name for the texture cache. If no name is
-     *        specified, only `imageUrl` will be used as the cache ID.
-     * @return {PIXI.Texture} Output texture
-     */
-
-
-    Texture.fromLoader = function fromLoader(source, imageUrl, name) {
-        var baseTexture = new _BaseTexture2.default(source, undefined, (0, _utils.getResolutionOfUrl)(imageUrl));
-        var texture = new Texture(baseTexture);
-
-        baseTexture.imageUrl = imageUrl;
-
-        // No name, use imageUrl instead
-        if (!name) {
-            name = imageUrl;
-        }
-
-        // lets also add the frame to pixi's global cache for fromFrame and fromImage fucntions
-        _BaseTexture2.default.addToCache(texture.baseTexture, name);
-        Texture.addToCache(texture, name);
-
-        // also add references by url if they are different.
-        if (name !== imageUrl) {
-            _BaseTexture2.default.addToCache(texture.baseTexture, imageUrl);
-            Texture.addToCache(texture, imageUrl);
-        }
-
-        return texture;
-    };
-
-    /**
-     * Adds a Texture to the global TextureCache. This cache is shared across the whole PIXI object.
-     *
-     * @static
-     * @param {PIXI.Texture} texture - The Texture to add to the cache.
-     * @param {string} id - The id that the Texture will be stored against.
-     */
-
-
-    Texture.addToCache = function addToCache(texture, id) {
-        if (id) {
-            if (texture.textureCacheIds.indexOf(id) === -1) {
-                texture.textureCacheIds.push(id);
-            }
-
-            /* eslint-disable no-console */
-            if (_utils.TextureCache[id]) {
-                console.warn('Texture added to the cache with an id [' + id + '] that already had an entry');
-            }
-            /* eslint-enable no-console */
-
-            _utils.TextureCache[id] = texture;
-        }
-    };
-
-    /**
-     * Remove a Texture from the global TextureCache.
-     *
-     * @static
-     * @param {string|PIXI.Texture} texture - id of a Texture to be removed, or a Texture instance itself
-     * @return {PIXI.Texture|null} The Texture that was removed
-     */
-
-
-    Texture.removeFromCache = function removeFromCache(texture) {
-        if (typeof texture === 'string') {
-            var textureFromCache = _utils.TextureCache[texture];
-
-            if (textureFromCache) {
-                var index = textureFromCache.textureCacheIds.indexOf(texture);
-
-                if (index > -1) {
-                    textureFromCache.textureCacheIds.splice(index, 1);
-                }
-
-                delete _utils.TextureCache[texture];
-
-                return textureFromCache;
-            }
-        } else if (texture && texture.textureCacheIds) {
-            for (var i = 0; i < texture.textureCacheIds.length; ++i) {
-                delete _utils.TextureCache[texture.textureCacheIds[i]];
-            }
-
-            texture.textureCacheIds.length = 0;
-
-            return texture;
-        }
-
-        return null;
-    };
-
-    /**
-     * The frame specifies the region of the base texture that this texture uses.
-     *
-     * @member {PIXI.Rectangle}
-     */
-
-
-    _createClass(Texture, [{
-        key: 'frame',
-        get: function get() {
-            return this._frame;
-        },
-        set: function set(frame) // eslint-disable-line require-jsdoc
-        {
-            this._frame = frame;
-
-            this.noFrame = false;
-
-            if (frame.x + frame.width > this.baseTexture.width || frame.y + frame.height > this.baseTexture.height) {
-                throw new Error('Texture Error: frame does not fit inside the base Texture dimensions: ' + ('X: ' + frame.x + ' + ' + frame.width + ' = ' + (frame.x + frame.width) + ' > ' + this.baseTexture.width + ' ') + ('Y: ' + frame.y + ' + ' + frame.height + ' = ' + (frame.y + frame.height) + ' > ' + this.baseTexture.height));
-            }
-
-            // this.valid = frame && frame.width && frame.height && this.baseTexture.source && this.baseTexture.hasLoaded;
-            this.valid = frame && frame.width && frame.height && this.baseTexture.hasLoaded;
-
-            if (!this.trim && !this.rotate) {
-                this.orig = frame;
-            }
-
-            if (this.valid) {
-                this._updateUvs();
-            }
-        }
-
-        /**
-         * Indicates whether the texture is rotated inside the atlas
-         * set to 2 to compensate for texture packer rotation
-         * set to 6 to compensate for spine packer rotation
-         * can be used to rotate or mirror sprites
-         * See {@link PIXI.GroupD8} for explanation
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'rotate',
-        get: function get() {
-            return this._rotate;
-        },
-        set: function set(rotate) // eslint-disable-line require-jsdoc
-        {
-            this._rotate = rotate;
-            if (this.valid) {
-                this._updateUvs();
-            }
-        }
-
-        /**
-         * The width of the Texture in pixels.
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'width',
-        get: function get() {
-            return this.orig.width;
-        }
-
-        /**
-         * The height of the Texture in pixels.
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'height',
-        get: function get() {
-            return this.orig.height;
-        }
-    }]);
-
-    return Texture;
-}(_eventemitter2.default);
-
-exports.default = Texture;
-
-
-function createWhiteTexture() {
-    var canvas = document.createElement('canvas');
-
-    canvas.width = 10;
-    canvas.height = 10;
-
-    var context = canvas.getContext('2d');
-
-    context.fillStyle = 'white';
-    context.fillRect(0, 0, 10, 10);
-
-    return new Texture(new _BaseTexture2.default(canvas));
-}
-
-function removeAllHandlers(tex) {
-    tex.destroy = function _emptyDestroy() {/* empty */};
-    tex.on = function _emptyOn() {/* empty */};
-    tex.once = function _emptyOnce() {/* empty */};
-    tex.emit = function _emptyEmit() {/* empty */};
-}
-
-/**
- * An empty texture, used often to not have to create multiple empty textures.
- * Can not be destroyed.
- *
- * @static
- * @constant
- */
-Texture.EMPTY = new Texture(new _BaseTexture2.default());
-removeAllHandlers(Texture.EMPTY);
-removeAllHandlers(Texture.EMPTY.baseTexture);
-
-/**
- * A white texture of 10x10 size, used for graphics and other things
- * Can not be destroyed.
- *
- * @static
- * @constant
- */
-Texture.WHITE = createWhiteTexture();
-removeAllHandlers(Texture.WHITE);
-removeAllHandlers(Texture.WHITE.baseTexture);
-
-},{"../math":70,"../settings":101,"../utils":124,"./BaseTexture":112,"./TextureUvs":116,"./VideoBaseTexture":117,"eventemitter3":3}],116:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _GroupD = require('../math/GroupD8');
-
-var _GroupD2 = _interopRequireDefault(_GroupD);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * A standard object to store the Uvs of a texture
- *
- * @class
- * @private
- * @memberof PIXI
- */
-var TextureUvs = function () {
-    /**
-     *
-     */
-    function TextureUvs() {
-        _classCallCheck(this, TextureUvs);
-
-        this.x0 = 0;
-        this.y0 = 0;
-
-        this.x1 = 1;
-        this.y1 = 0;
-
-        this.x2 = 1;
-        this.y2 = 1;
-
-        this.x3 = 0;
-        this.y3 = 1;
-
-        this.uvsUint32 = new Uint32Array(4);
-    }
-
-    /**
-     * Sets the texture Uvs based on the given frame information.
-     *
-     * @private
-     * @param {PIXI.Rectangle} frame - The frame of the texture
-     * @param {PIXI.Rectangle} baseFrame - The base frame of the texture
-     * @param {number} rotate - Rotation of frame, see {@link PIXI.GroupD8}
-     */
-
-
-    TextureUvs.prototype.set = function set(frame, baseFrame, rotate) {
-        var tw = baseFrame.width;
-        var th = baseFrame.height;
-
-        if (rotate) {
-            // width and height div 2 div baseFrame size
-            var w2 = frame.width / 2 / tw;
-            var h2 = frame.height / 2 / th;
-
-            // coordinates of center
-            var cX = frame.x / tw + w2;
-            var cY = frame.y / th + h2;
-
-            rotate = _GroupD2.default.add(rotate, _GroupD2.default.NW); // NW is top-left corner
-            this.x0 = cX + w2 * _GroupD2.default.uX(rotate);
-            this.y0 = cY + h2 * _GroupD2.default.uY(rotate);
-
-            rotate = _GroupD2.default.add(rotate, 2); // rotate 90 degrees clockwise
-            this.x1 = cX + w2 * _GroupD2.default.uX(rotate);
-            this.y1 = cY + h2 * _GroupD2.default.uY(rotate);
-
-            rotate = _GroupD2.default.add(rotate, 2);
-            this.x2 = cX + w2 * _GroupD2.default.uX(rotate);
-            this.y2 = cY + h2 * _GroupD2.default.uY(rotate);
-
-            rotate = _GroupD2.default.add(rotate, 2);
-            this.x3 = cX + w2 * _GroupD2.default.uX(rotate);
-            this.y3 = cY + h2 * _GroupD2.default.uY(rotate);
-        } else {
-            this.x0 = frame.x / tw;
-            this.y0 = frame.y / th;
-
-            this.x1 = (frame.x + frame.width) / tw;
-            this.y1 = frame.y / th;
-
-            this.x2 = (frame.x + frame.width) / tw;
-            this.y2 = (frame.y + frame.height) / th;
-
-            this.x3 = frame.x / tw;
-            this.y3 = (frame.y + frame.height) / th;
-        }
-
-        this.uvsUint32[0] = (this.y0 * 65535 & 0xFFFF) << 16 | this.x0 * 65535 & 0xFFFF;
-        this.uvsUint32[1] = (this.y1 * 65535 & 0xFFFF) << 16 | this.x1 * 65535 & 0xFFFF;
-        this.uvsUint32[2] = (this.y2 * 65535 & 0xFFFF) << 16 | this.x2 * 65535 & 0xFFFF;
-        this.uvsUint32[3] = (this.y3 * 65535 & 0xFFFF) << 16 | this.x3 * 65535 & 0xFFFF;
-    };
-
-    return TextureUvs;
-}();
-
-exports.default = TextureUvs;
-
-},{"../math/GroupD8":66}],117:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _BaseTexture2 = require('./BaseTexture');
-
-var _BaseTexture3 = _interopRequireDefault(_BaseTexture2);
-
-var _utils = require('../utils');
-
-var _ticker = require('../ticker');
-
-var _const = require('../const');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * A texture of a [playing] Video.
- *
- * Video base textures mimic PixiJS BaseTexture.from.... method in their creation process.
- *
- * This can be used in several ways, such as:
- *
- * ```js
- * let texture = PIXI.VideoBaseTexture.fromUrl('http://mydomain.com/video.mp4');
- *
- * let texture = PIXI.VideoBaseTexture.fromUrl({ src: 'http://mydomain.com/video.mp4', mime: 'video/mp4' });
- *
- * let texture = PIXI.VideoBaseTexture.fromUrls(['/video.webm', '/video.mp4']);
- *
- * let texture = PIXI.VideoBaseTexture.fromUrls([
- *     { src: '/video.webm', mime: 'video/webm' },
- *     { src: '/video.mp4', mime: 'video/mp4' }
- * ]);
- * ```
- *
- * See the ["deus" demo](http://www.goodboydigital.com/pixijs/examples/deus/).
- *
- * @class
- * @extends PIXI.BaseTexture
- * @memberof PIXI
- */
-var VideoBaseTexture = function (_BaseTexture) {
-    _inherits(VideoBaseTexture, _BaseTexture);
-
-    /**
-     * @param {HTMLVideoElement} source - Video source
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     */
-    function VideoBaseTexture(source, scaleMode) {
-        _classCallCheck(this, VideoBaseTexture);
-
-        if (!source) {
-            throw new Error('No video source element specified.');
-        }
-
-        // hook in here to check if video is already available.
-        // BaseTexture looks for a source.complete boolean, plus width & height.
-
-        if ((source.readyState === source.HAVE_ENOUGH_DATA || source.readyState === source.HAVE_FUTURE_DATA) && source.width && source.height) {
-            source.complete = true;
-        }
-
-        var _this = _possibleConstructorReturn(this, _BaseTexture.call(this, source, scaleMode));
-
-        _this.width = source.videoWidth;
-        _this.height = source.videoHeight;
-
-        _this._autoUpdate = true;
-        _this._isAutoUpdating = false;
-
-        /**
-         * When set to true will automatically play videos used by this texture once
-         * they are loaded. If false, it will not modify the playing state.
-         *
-         * @member {boolean}
-         * @default true
-         */
-        _this.autoPlay = true;
-
-        _this.update = _this.update.bind(_this);
-        _this._onCanPlay = _this._onCanPlay.bind(_this);
-
-        source.addEventListener('play', _this._onPlayStart.bind(_this));
-        source.addEventListener('pause', _this._onPlayStop.bind(_this));
-        _this.hasLoaded = false;
-        _this.__loaded = false;
-
-        if (!_this._isSourceReady()) {
-            source.addEventListener('canplay', _this._onCanPlay);
-            source.addEventListener('canplaythrough', _this._onCanPlay);
-        } else {
-            _this._onCanPlay();
-        }
-        return _this;
-    }
-
-    /**
-     * Returns true if the underlying source is playing.
-     *
-     * @private
-     * @return {boolean} True if playing.
-     */
-
-
-    VideoBaseTexture.prototype._isSourcePlaying = function _isSourcePlaying() {
-        var source = this.source;
-
-        return source.currentTime > 0 && source.paused === false && source.ended === false && source.readyState > 2;
-    };
-
-    /**
-     * Returns true if the underlying source is ready for playing.
-     *
-     * @private
-     * @return {boolean} True if ready.
-     */
-
-
-    VideoBaseTexture.prototype._isSourceReady = function _isSourceReady() {
-        return this.source.readyState === 3 || this.source.readyState === 4;
-    };
-
-    /**
-     * Runs the update loop when the video is ready to play
-     *
-     * @private
-     */
-
-
-    VideoBaseTexture.prototype._onPlayStart = function _onPlayStart() {
-        // Just in case the video has not received its can play even yet..
-        if (!this.hasLoaded) {
-            this._onCanPlay();
-        }
-
-        if (!this._isAutoUpdating && this.autoUpdate) {
-            _ticker.shared.add(this.update, this, _const.UPDATE_PRIORITY.HIGH);
-            this._isAutoUpdating = true;
-        }
-    };
-
-    /**
-     * Fired when a pause event is triggered, stops the update loop
-     *
-     * @private
-     */
-
-
-    VideoBaseTexture.prototype._onPlayStop = function _onPlayStop() {
-        if (this._isAutoUpdating) {
-            _ticker.shared.remove(this.update, this);
-            this._isAutoUpdating = false;
-        }
-    };
-
-    /**
-     * Fired when the video is loaded and ready to play
-     *
-     * @private
-     */
-
-
-    VideoBaseTexture.prototype._onCanPlay = function _onCanPlay() {
-        this.hasLoaded = true;
-
-        if (this.source) {
-            this.source.removeEventListener('canplay', this._onCanPlay);
-            this.source.removeEventListener('canplaythrough', this._onCanPlay);
-
-            this.width = this.source.videoWidth;
-            this.height = this.source.videoHeight;
-
-            // prevent multiple loaded dispatches..
-            if (!this.__loaded) {
-                this.__loaded = true;
-                this.emit('loaded', this);
-            }
-
-            if (this._isSourcePlaying()) {
-                this._onPlayStart();
-            } else if (this.autoPlay) {
-                this.source.play();
-            }
-        }
-    };
-
-    /**
-     * Destroys this texture
-     *
-     */
-
-
-    VideoBaseTexture.prototype.destroy = function destroy() {
-        if (this._isAutoUpdating) {
-            _ticker.shared.remove(this.update, this);
-        }
-
-        if (this.source && this.source._pixiId) {
-            _BaseTexture3.default.removeFromCache(this.source._pixiId);
-            delete this.source._pixiId;
-        }
-
-        _BaseTexture.prototype.destroy.call(this);
-    };
-
-    /**
-     * Mimic PixiJS BaseTexture.from.... method.
-     *
-     * @static
-     * @param {HTMLVideoElement} video - Video to create texture from
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES} for possible values
-     * @return {PIXI.VideoBaseTexture} Newly created VideoBaseTexture
-     */
-
-
-    VideoBaseTexture.fromVideo = function fromVideo(video, scaleMode) {
-        if (!video._pixiId) {
-            video._pixiId = 'video_' + (0, _utils.uid)();
-        }
-
-        var baseTexture = _utils.BaseTextureCache[video._pixiId];
-
-        if (!baseTexture) {
-            baseTexture = new VideoBaseTexture(video, scaleMode);
-            _BaseTexture3.default.addToCache(baseTexture, video._pixiId);
-        }
-
-        return baseTexture;
-    };
-
-    /**
-     * Helper function that creates a new BaseTexture based on the given video element.
-     * This BaseTexture can then be used to create a texture
-     *
-     * @static
-     * @param {string|object|string[]|object[]} videoSrc - The URL(s) for the video.
-     * @param {string} [videoSrc.src] - One of the source urls for the video
-     * @param {string} [videoSrc.mime] - The mimetype of the video (e.g. 'video/mp4'). If not specified
-     *  the url's extension will be used as the second part of the mime type.
-     * @param {number} scaleMode - See {@link PIXI.SCALE_MODES} for possible values
-     * @return {PIXI.VideoBaseTexture} Newly created VideoBaseTexture
-     */
-
-
-    VideoBaseTexture.fromUrl = function fromUrl(videoSrc, scaleMode) {
-        var video = document.createElement('video');
-
-        video.setAttribute('webkit-playsinline', '');
-        video.setAttribute('playsinline', '');
-
-        // array of objects or strings
-        if (Array.isArray(videoSrc)) {
-            for (var i = 0; i < videoSrc.length; ++i) {
-                video.appendChild(createSource(videoSrc[i].src || videoSrc[i], videoSrc[i].mime));
-            }
-        }
-        // single object or string
-        else {
-                video.appendChild(createSource(videoSrc.src || videoSrc, videoSrc.mime));
-            }
-
-        video.load();
-
-        return VideoBaseTexture.fromVideo(video, scaleMode);
-    };
-
-    /**
-     * Should the base texture automatically update itself, set to true by default
-     *
-     * @member {boolean}
-     */
-
-
-    _createClass(VideoBaseTexture, [{
-        key: 'autoUpdate',
-        get: function get() {
-            return this._autoUpdate;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (value !== this._autoUpdate) {
-                this._autoUpdate = value;
-
-                if (!this._autoUpdate && this._isAutoUpdating) {
-                    _ticker.shared.remove(this.update, this);
-                    this._isAutoUpdating = false;
-                } else if (this._autoUpdate && !this._isAutoUpdating) {
-                    _ticker.shared.add(this.update, this, _const.UPDATE_PRIORITY.HIGH);
-                    this._isAutoUpdating = true;
-                }
-            }
-        }
-    }]);
-
-    return VideoBaseTexture;
-}(_BaseTexture3.default);
-
-exports.default = VideoBaseTexture;
-
-
-VideoBaseTexture.fromUrls = VideoBaseTexture.fromUrl;
-
-function createSource(path, type) {
-    if (!type) {
-        type = 'video/' + path.substr(path.lastIndexOf('.') + 1);
-    }
-
-    var source = document.createElement('source');
-
-    source.src = path;
-    source.type = type;
-
-    return source;
-}
-
-},{"../const":46,"../ticker":120,"../utils":124,"./BaseTexture":112}],118:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _const = require('../const');
-
-var _TickerListener = require('./TickerListener');
-
-var _TickerListener2 = _interopRequireDefault(_TickerListener);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * A Ticker class that runs an update loop that other objects listen to.
- * This class is composed around listeners
- * meant for execution on the next requested animation frame.
- * Animation frames are requested only when necessary,
- * e.g. When the ticker is started and the emitter has listeners.
- *
- * @class
- * @memberof PIXI.ticker
- */
-var Ticker = function () {
-    /**
-     *
-     */
-    function Ticker() {
-        var _this = this;
-
-        _classCallCheck(this, Ticker);
-
-        /**
-         * The first listener. All new listeners added are chained on this.
-         * @private
-         * @type {TickerListener}
-         */
-        this._head = new _TickerListener2.default(null, null, Infinity);
-
-        /**
-         * Internal current frame request ID
-         * @private
-         */
-        this._requestId = null;
-
-        /**
-         * Internal value managed by minFPS property setter and getter.
-         * This is the maximum allowed milliseconds between updates.
-         * @private
-         */
-        this._maxElapsedMS = 100;
-
-        /**
-         * Whether or not this ticker should invoke the method
-         * {@link PIXI.ticker.Ticker#start} automatically
-         * when a listener is added.
-         *
-         * @member {boolean}
-         * @default false
-         */
-        this.autoStart = false;
-
-        /**
-         * Scalar time value from last frame to this frame.
-         * This value is capped by setting {@link PIXI.ticker.Ticker#minFPS}
-         * and is scaled with {@link PIXI.ticker.Ticker#speed}.
-         * **Note:** The cap may be exceeded by scaling.
-         *
-         * @member {number}
-         * @default 1
-         */
-        this.deltaTime = 1;
-
-        /**
-         * Time elapsed in milliseconds from last frame to this frame.
-         * Opposed to what the scalar {@link PIXI.ticker.Ticker#deltaTime}
-         * is based, this value is neither capped nor scaled.
-         * If the platform supports DOMHighResTimeStamp,
-         * this value will have a precision of 1 µs.
-         * Defaults to target frame time
-         *
-         * @member {number}
-         * @default 16.66
-         */
-        this.elapsedMS = 1 / _settings2.default.TARGET_FPMS;
-
-        /**
-         * The last time {@link PIXI.ticker.Ticker#update} was invoked.
-         * This value is also reset internally outside of invoking
-         * update, but only when a new animation frame is requested.
-         * If the platform supports DOMHighResTimeStamp,
-         * this value will have a precision of 1 µs.
-         *
-         * @member {number}
-         * @default 0
-         */
-        this.lastTime = 0;
-
-        /**
-         * Factor of current {@link PIXI.ticker.Ticker#deltaTime}.
-         * @example
-         * // Scales ticker.deltaTime to what would be
-         * // the equivalent of approximately 120 FPS
-         * ticker.speed = 2;
-         *
-         * @member {number}
-         * @default 1
-         */
-        this.speed = 1;
-
-        /**
-         * Whether or not this ticker has been started.
-         * `true` if {@link PIXI.ticker.Ticker#start} has been called.
-         * `false` if {@link PIXI.ticker.Ticker#stop} has been called.
-         * While `false`, this value may change to `true` in the
-         * event of {@link PIXI.ticker.Ticker#autoStart} being `true`
-         * and a listener is added.
-         *
-         * @member {boolean}
-         * @default false
-         */
-        this.started = false;
-
-        /**
-         * Internal tick method bound to ticker instance.
-         * This is because in early 2015, Function.bind
-         * is still 60% slower in high performance scenarios.
-         * Also separating frame requests from update method
-         * so listeners may be called at any time and with
-         * any animation API, just invoke ticker.update(time).
-         *
-         * @private
-         * @param {number} time - Time since last tick.
-         */
-        this._tick = function (time) {
-            _this._requestId = null;
-
-            if (_this.started) {
-                // Invoke listeners now
-                _this.update(time);
-                // Listener side effects may have modified ticker state.
-                if (_this.started && _this._requestId === null && _this._head.next) {
-                    _this._requestId = requestAnimationFrame(_this._tick);
-                }
-            }
-        };
-    }
-
-    /**
-     * Conditionally requests a new animation frame.
-     * If a frame has not already been requested, and if the internal
-     * emitter has listeners, a new frame is requested.
-     *
-     * @private
-     */
-
-
-    Ticker.prototype._requestIfNeeded = function _requestIfNeeded() {
-        if (this._requestId === null && this._head.next) {
-            // ensure callbacks get correct delta
-            this.lastTime = performance.now();
-            this._requestId = requestAnimationFrame(this._tick);
-        }
-    };
-
-    /**
-     * Conditionally cancels a pending animation frame.
-     *
-     * @private
-     */
-
-
-    Ticker.prototype._cancelIfNeeded = function _cancelIfNeeded() {
-        if (this._requestId !== null) {
-            cancelAnimationFrame(this._requestId);
-            this._requestId = null;
-        }
-    };
-
-    /**
-     * Conditionally requests a new animation frame.
-     * If the ticker has been started it checks if a frame has not already
-     * been requested, and if the internal emitter has listeners. If these
-     * conditions are met, a new frame is requested. If the ticker has not
-     * been started, but autoStart is `true`, then the ticker starts now,
-     * and continues with the previous conditions to request a new frame.
-     *
-     * @private
-     */
-
-
-    Ticker.prototype._startIfPossible = function _startIfPossible() {
-        if (this.started) {
-            this._requestIfNeeded();
-        } else if (this.autoStart) {
-            this.start();
-        }
-    };
-
-    /**
-     * Register a handler for tick events. Calls continuously unless
-     * it is removed or the ticker is stopped.
-     *
-     * @param {Function} fn - The listener function to be added for updates
-     * @param {Function} [context] - The listener context
-     * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
-     * @returns {PIXI.ticker.Ticker} This instance of a ticker
-     */
-
-
-    Ticker.prototype.add = function add(fn, context) {
-        var priority = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _const.UPDATE_PRIORITY.NORMAL;
-
-        return this._addListener(new _TickerListener2.default(fn, context, priority));
-    };
-
-    /**
-     * Add a handler for the tick event which is only execute once.
-     *
-     * @param {Function} fn - The listener function to be added for one update
-     * @param {Function} [context] - The listener context
-     * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
-     * @returns {PIXI.ticker.Ticker} This instance of a ticker
-     */
-
-
-    Ticker.prototype.addOnce = function addOnce(fn, context) {
-        var priority = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _const.UPDATE_PRIORITY.NORMAL;
-
-        return this._addListener(new _TickerListener2.default(fn, context, priority, true));
-    };
-
-    /**
-     * Internally adds the event handler so that it can be sorted by priority.
-     * Priority allows certain handler (user, AnimatedSprite, Interaction) to be run
-     * before the rendering.
-     *
-     * @private
-     * @param {TickerListener} listener - Current listener being added.
-     * @returns {PIXI.ticker.Ticker} This instance of a ticker
-     */
-
-
-    Ticker.prototype._addListener = function _addListener(listener) {
-        // For attaching to head
-        var current = this._head.next;
-        var previous = this._head;
-
-        // Add the first item
-        if (!current) {
-            listener.connect(previous);
-        } else {
-            // Go from highest to lowest priority
-            while (current) {
-                if (listener.priority > current.priority) {
-                    listener.connect(previous);
-                    break;
-                }
-                previous = current;
-                current = current.next;
-            }
-
-            // Not yet connected
-            if (!listener.previous) {
-                listener.connect(previous);
-            }
-        }
-
-        this._startIfPossible();
-
-        return this;
-    };
-
-    /**
-     * Removes any handlers matching the function and context parameters.
-     * If no handlers are left after removing, then it cancels the animation frame.
-     *
-     * @param {Function} fn - The listener function to be removed
-     * @param {Function} [context] - The listener context to be removed
-     * @returns {PIXI.ticker.Ticker} This instance of a ticker
-     */
-
-
-    Ticker.prototype.remove = function remove(fn, context) {
-        var listener = this._head.next;
-
-        while (listener) {
-            // We found a match, lets remove it
-            // no break to delete all possible matches
-            // incase a listener was added 2+ times
-            if (listener.match(fn, context)) {
-                listener = listener.destroy();
-            } else {
-                listener = listener.next;
-            }
-        }
-
-        if (!this._head.next) {
-            this._cancelIfNeeded();
-        }
-
-        return this;
-    };
-
-    /**
-     * Starts the ticker. If the ticker has listeners
-     * a new animation frame is requested at this point.
-     */
-
-
-    Ticker.prototype.start = function start() {
-        if (!this.started) {
-            this.started = true;
-            this._requestIfNeeded();
-        }
-    };
-
-    /**
-     * Stops the ticker. If the ticker has requested
-     * an animation frame it is canceled at this point.
-     */
-
-
-    Ticker.prototype.stop = function stop() {
-        if (this.started) {
-            this.started = false;
-            this._cancelIfNeeded();
-        }
-    };
-
-    /**
-     * Destroy the ticker and don't use after this. Calling
-     * this method removes all references to internal events.
-     */
-
-
-    Ticker.prototype.destroy = function destroy() {
-        this.stop();
-
-        var listener = this._head.next;
-
-        while (listener) {
-            listener = listener.destroy(true);
-        }
-
-        this._head.destroy();
-        this._head = null;
-    };
-
-    /**
-     * Triggers an update. An update entails setting the
-     * current {@link PIXI.ticker.Ticker#elapsedMS},
-     * the current {@link PIXI.ticker.Ticker#deltaTime},
-     * invoking all listeners with current deltaTime,
-     * and then finally setting {@link PIXI.ticker.Ticker#lastTime}
-     * with the value of currentTime that was provided.
-     * This method will be called automatically by animation
-     * frame callbacks if the ticker instance has been started
-     * and listeners are added.
-     *
-     * @param {number} [currentTime=performance.now()] - the current time of execution
-     */
-
-
-    Ticker.prototype.update = function update() {
-        var currentTime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : performance.now();
-
-        var elapsedMS = void 0;
-
-        // If the difference in time is zero or negative, we ignore most of the work done here.
-        // If there is no valid difference, then should be no reason to let anyone know about it.
-        // A zero delta, is exactly that, nothing should update.
-        //
-        // The difference in time can be negative, and no this does not mean time traveling.
-        // This can be the result of a race condition between when an animation frame is requested
-        // on the current JavaScript engine event loop, and when the ticker's start method is invoked
-        // (which invokes the internal _requestIfNeeded method). If a frame is requested before
-        // _requestIfNeeded is invoked, then the callback for the animation frame the ticker requests,
-        // can receive a time argument that can be less than the lastTime value that was set within
-        // _requestIfNeeded. This difference is in microseconds, but this is enough to cause problems.
-        //
-        // This check covers this browser engine timing issue, as well as if consumers pass an invalid
-        // currentTime value. This may happen if consumers opt-out of the autoStart, and update themselves.
-
-        if (currentTime > this.lastTime) {
-            // Save uncapped elapsedMS for measurement
-            elapsedMS = this.elapsedMS = currentTime - this.lastTime;
-
-            // cap the milliseconds elapsed used for deltaTime
-            if (elapsedMS > this._maxElapsedMS) {
-                elapsedMS = this._maxElapsedMS;
-            }
-
-            this.deltaTime = elapsedMS * _settings2.default.TARGET_FPMS * this.speed;
-
-            // Cache a local reference, in-case ticker is destroyed
-            // during the emit, we can still check for head.next
-            var head = this._head;
-
-            // Invoke listeners added to internal emitter
-            var listener = head.next;
-
-            while (listener) {
-                listener = listener.emit(this.deltaTime);
-            }
-
-            if (!head.next) {
-                this._cancelIfNeeded();
-            }
-        } else {
-            this.deltaTime = this.elapsedMS = 0;
-        }
-
-        this.lastTime = currentTime;
-    };
-
-    /**
-     * The frames per second at which this ticker is running.
-     * The default is approximately 60 in most modern browsers.
-     * **Note:** This does not factor in the value of
-     * {@link PIXI.ticker.Ticker#speed}, which is specific
-     * to scaling {@link PIXI.ticker.Ticker#deltaTime}.
-     *
-     * @member {number}
-     * @readonly
-     */
-
-
-    _createClass(Ticker, [{
-        key: 'FPS',
-        get: function get() {
-            return 1000 / this.elapsedMS;
-        }
-
-        /**
-         * Manages the maximum amount of milliseconds allowed to
-         * elapse between invoking {@link PIXI.ticker.Ticker#update}.
-         * This value is used to cap {@link PIXI.ticker.Ticker#deltaTime},
-         * but does not effect the measured value of {@link PIXI.ticker.Ticker#FPS}.
-         * When setting this property it is clamped to a value between
-         * `0` and `PIXI.settings.TARGET_FPMS * 1000`.
-         *
-         * @member {number}
-         * @default 10
-         */
-
-    }, {
-        key: 'minFPS',
-        get: function get() {
-            return 1000 / this._maxElapsedMS;
-        },
-        set: function set(fps) // eslint-disable-line require-jsdoc
-        {
-            // Clamp: 0 to TARGET_FPMS
-            var minFPMS = Math.min(Math.max(0, fps) / 1000, _settings2.default.TARGET_FPMS);
-
-            this._maxElapsedMS = 1 / minFPMS;
-        }
-    }]);
-
-    return Ticker;
-}();
-
-exports.default = Ticker;
-
-},{"../const":46,"../settings":101,"./TickerListener":119}],119:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Internal class for handling the priority sorting of ticker handlers.
- *
- * @private
- * @class
- * @memberof PIXI.ticker
- */
-var TickerListener = function () {
-    /**
-     * Constructor
-     *
-     * @param {Function} fn - The listener function to be added for one update
-     * @param {Function} [context=null] - The listener context
-     * @param {number} [priority=0] - The priority for emitting
-     * @param {boolean} [once=false] - If the handler should fire once
-     */
-    function TickerListener(fn) {
-        var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-        var priority = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-        var once = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
-        _classCallCheck(this, TickerListener);
-
-        /**
-         * The handler function to execute.
-         * @member {Function}
-         */
-        this.fn = fn;
-
-        /**
-         * The calling to execute.
-         * @member {Function}
-         */
-        this.context = context;
-
-        /**
-         * The current priority.
-         * @member {number}
-         */
-        this.priority = priority;
-
-        /**
-         * If this should only execute once.
-         * @member {boolean}
-         */
-        this.once = once;
-
-        /**
-         * The next item in chain.
-         * @member {TickerListener}
-         */
-        this.next = null;
-
-        /**
-         * The previous item in chain.
-         * @member {TickerListener}
-         */
-        this.previous = null;
-
-        /**
-         * `true` if this listener has been destroyed already.
-         * @member {boolean}
-         * @private
-         */
-        this._destroyed = false;
-    }
-
-    /**
-     * Simple compare function to figure out if a function and context match.
-     *
-     * @param {Function} fn - The listener function to be added for one update
-     * @param {Function} context - The listener context
-     * @return {boolean} `true` if the listener match the arguments
-     */
-
-
-    TickerListener.prototype.match = function match(fn, context) {
-        context = context || null;
-
-        return this.fn === fn && this.context === context;
-    };
-
-    /**
-     * Emit by calling the current function.
-     * @param {number} deltaTime - time since the last emit.
-     * @return {TickerListener} Next ticker
-     */
-
-
-    TickerListener.prototype.emit = function emit(deltaTime) {
-        if (this.fn) {
-            if (this.context) {
-                this.fn.call(this.context, deltaTime);
-            } else {
-                this.fn(deltaTime);
-            }
-        }
-
-        var redirect = this.next;
-
-        if (this.once) {
-            this.destroy(true);
-        }
-
-        // Soft-destroying should remove
-        // the next reference
-        if (this._destroyed) {
-            this.next = null;
-        }
-
-        return redirect;
-    };
-
-    /**
-     * Connect to the list.
-     * @param {TickerListener} previous - Input node, previous listener
-     */
-
-
-    TickerListener.prototype.connect = function connect(previous) {
-        this.previous = previous;
-        if (previous.next) {
-            previous.next.previous = this;
-        }
-        this.next = previous.next;
-        previous.next = this;
-    };
-
-    /**
-     * Destroy and don't use after this.
-     * @param {boolean} [hard = false] `true` to remove the `next` reference, this
-     *        is considered a hard destroy. Soft destroy maintains the next reference.
-     * @return {TickerListener} The listener to redirect while emitting or removing.
-     */
-
-
-    TickerListener.prototype.destroy = function destroy() {
-        var hard = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-        this._destroyed = true;
-        this.fn = null;
-        this.context = null;
-
-        // Disconnect, hook up next and previous
-        if (this.previous) {
-            this.previous.next = this.next;
-        }
-
-        if (this.next) {
-            this.next.previous = this.previous;
-        }
-
-        // Redirect to the next item
-        var redirect = this.previous;
-
-        // Remove references
-        this.next = hard ? null : redirect;
-        this.previous = null;
-
-        return redirect;
-    };
-
-    return TickerListener;
-}();
-
-exports.default = TickerListener;
-
-},{}],120:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.Ticker = exports.shared = undefined;
-
-var _Ticker = require('./Ticker');
-
-var _Ticker2 = _interopRequireDefault(_Ticker);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The shared ticker instance used by {@link PIXI.extras.AnimatedSprite}.
- * and by {@link PIXI.interaction.InteractionManager}.
- * The property {@link PIXI.ticker.Ticker#autoStart} is set to `true`
- * for this instance. Please follow the examples for usage, including
- * how to opt-out of auto-starting the shared ticker.
- *
- * @example
- * let ticker = PIXI.ticker.shared;
- * // Set this to prevent starting this ticker when listeners are added.
- * // By default this is true only for the PIXI.ticker.shared instance.
- * ticker.autoStart = false;
- * // FYI, call this to ensure the ticker is stopped. It should be stopped
- * // if you have not attempted to render anything yet.
- * ticker.stop();
- * // Call this when you are ready for a running shared ticker.
- * ticker.start();
- *
- * @example
- * // You may use the shared ticker to render...
- * let renderer = PIXI.autoDetectRenderer(800, 600);
- * let stage = new PIXI.Container();
- * let interactionManager = PIXI.interaction.InteractionManager(renderer);
- * document.body.appendChild(renderer.view);
- * ticker.add(function (time) {
- *     renderer.render(stage);
- * });
- *
- * @example
- * // Or you can just update it manually.
- * ticker.autoStart = false;
- * ticker.stop();
- * function animate(time) {
- *     ticker.update(time);
- *     renderer.render(stage);
- *     requestAnimationFrame(animate);
- * }
- * animate(performance.now());
- *
- * @type {PIXI.ticker.Ticker}
- * @memberof PIXI.ticker
- */
-var shared = new _Ticker2.default();
-
-shared.autoStart = true;
-shared.destroy = function () {
-  // protect destroying shared ticker
-  // this is used by other internal systems
-  // like AnimatedSprite and InteractionManager
-};
-
-/**
- * This namespace contains an API for interacting with PIXI's internal global update loop.
- *
- * This ticker is used for rendering, {@link PIXI.extras.AnimatedSprite AnimatedSprite},
- * {@link PIXI.interaction.InteractionManager InteractionManager} and many other time-based PIXI systems.
- * @example
- * const ticker = new PIXI.ticker.Ticker();
- * ticker.stop();
- * ticker.add((deltaTime) => {
- *   // do something every frame
- * });
- * ticker.start();
- * @namespace PIXI.ticker
- */
-exports.shared = shared;
-exports.Ticker = _Ticker2.default;
-
-},{"./Ticker":118}],121:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-exports.default = canUploadSameBuffer;
-function canUploadSameBuffer() {
-	// Uploading the same buffer multiple times in a single frame can cause perf issues.
-	// Apparent on IOS so only check for that at the moment
-	// this check may become more complex if this issue pops up elsewhere.
-	var ios = !!navigator.platform && /iPad|iPhone|iPod/.test(navigator.platform);
-
-	return !ios;
-}
-
-},{}],122:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-exports.default = createIndicesForQuads;
-/**
- * Generic Mask Stack data structure
- *
- * @memberof PIXI
- * @function createIndicesForQuads
- * @private
- * @param {number} size - Number of quads
- * @return {Uint16Array} indices
- */
-function createIndicesForQuads(size) {
-    // the total number of indices in our array, there are 6 points per quad.
-
-    var totalIndices = size * 6;
-
-    var indices = new Uint16Array(totalIndices);
-
-    // fill the indices with the quads to draw
-    for (var i = 0, j = 0; i < totalIndices; i += 6, j += 4) {
-        indices[i + 0] = j + 0;
-        indices[i + 1] = j + 1;
-        indices[i + 2] = j + 2;
-        indices[i + 3] = j + 0;
-        indices[i + 4] = j + 2;
-        indices[i + 5] = j + 3;
-    }
-
-    return indices;
-}
-
-},{}],123:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = determineCrossOrigin;
-
-var _url2 = require('url');
-
-var _url3 = _interopRequireDefault(_url2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var tempAnchor = void 0;
-
-/**
- * Sets the `crossOrigin` property for this resource based on if the url
- * for this resource is cross-origin. If crossOrigin was manually set, this
- * function does nothing.
- * Nipped from the resource loader!
- *
- * @ignore
- * @param {string} url - The url to test.
- * @param {object} [loc=window.location] - The location object to test against.
- * @return {string} The crossOrigin value to use (or empty string for none).
- */
-function determineCrossOrigin(url) {
-    var loc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window.location;
-
-    // data: and javascript: urls are considered same-origin
-    if (url.indexOf('data:') === 0) {
-        return '';
-    }
-
-    // default is window.location
-    loc = loc || window.location;
-
-    if (!tempAnchor) {
-        tempAnchor = document.createElement('a');
-    }
-
-    // let the browser determine the full href for the url of this resource and then
-    // parse with the node url lib, we can't use the properties of the anchor element
-    // because they don't work in IE9 :(
-    tempAnchor.href = url;
-    url = _url3.default.parse(tempAnchor.href);
-
-    var samePort = !url.port && loc.port === '' || url.port === loc.port;
-
-    // if cross origin
-    if (url.hostname !== loc.hostname || !samePort || url.protocol !== loc.protocol) {
-        return 'anonymous';
-    }
-
-    return '';
-}
-
-},{"url":29}],124:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.premultiplyBlendMode = exports.BaseTextureCache = exports.TextureCache = exports.mixins = exports.pluginTarget = exports.EventEmitter = exports.removeItems = exports.isMobile = undefined;
-exports.uid = uid;
-exports.hex2rgb = hex2rgb;
-exports.hex2string = hex2string;
-exports.rgb2hex = rgb2hex;
-exports.getResolutionOfUrl = getResolutionOfUrl;
-exports.decomposeDataUri = decomposeDataUri;
-exports.getUrlFileExtension = getUrlFileExtension;
-exports.getSvgSize = getSvgSize;
-exports.skipHello = skipHello;
-exports.sayHello = sayHello;
-exports.isWebGLSupported = isWebGLSupported;
-exports.sign = sign;
-exports.destroyTextureCache = destroyTextureCache;
-exports.clearTextureCache = clearTextureCache;
-exports.correctBlendMode = correctBlendMode;
-exports.premultiplyTint = premultiplyTint;
-exports.premultiplyRgba = premultiplyRgba;
-exports.premultiplyTintToRgba = premultiplyTintToRgba;
-
-var _const = require('../const');
-
-var _settings = require('../settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-var _eventemitter = require('eventemitter3');
-
-var _eventemitter2 = _interopRequireDefault(_eventemitter);
-
-var _pluginTarget = require('./pluginTarget');
-
-var _pluginTarget2 = _interopRequireDefault(_pluginTarget);
-
-var _mixin = require('./mixin');
-
-var mixins = _interopRequireWildcard(_mixin);
-
-var _ismobilejs = require('ismobilejs');
-
-var isMobile = _interopRequireWildcard(_ismobilejs);
-
-var _removeArrayItems = require('remove-array-items');
-
-var _removeArrayItems2 = _interopRequireDefault(_removeArrayItems);
-
-var _mapPremultipliedBlendModes = require('./mapPremultipliedBlendModes');
-
-var _mapPremultipliedBlendModes2 = _interopRequireDefault(_mapPremultipliedBlendModes);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var nextUid = 0;
-var saidHello = false;
-
-/**
- * Generalized convenience utilities for PIXI.
- * @example
- * // Extend PIXI's internal Event Emitter.
- * class MyEmitter extends PIXI.utils.EventEmitter {
- *   constructor() {
- *      super();
- *      console.log("Emitter created!");
- *   }
- * }
- *
- * // Get info on current device
- * console.log(PIXI.utils.isMobile);
- *
- * // Convert hex color to string
- * console.log(PIXI.utils.hex2string(0xff00ff)); // returns: "#ff00ff"
- * @namespace PIXI.utils
- */
-exports.isMobile = isMobile;
-exports.removeItems = _removeArrayItems2.default;
-exports.EventEmitter = _eventemitter2.default;
-exports.pluginTarget = _pluginTarget2.default;
-exports.mixins = mixins;
-
-/**
- * Gets the next unique identifier
- *
- * @memberof PIXI.utils
- * @function uid
- * @return {number} The next unique identifier to use.
- */
-
-function uid() {
-    return ++nextUid;
-}
-
-/**
- * Converts a hex color number to an [R, G, B] array
- *
- * @memberof PIXI.utils
- * @function hex2rgb
- * @param {number} hex - The number to convert
- * @param  {number[]} [out=[]] If supplied, this array will be used rather than returning a new one
- * @return {number[]} An array representing the [R, G, B] of the color.
- */
-function hex2rgb(hex, out) {
-    out = out || [];
-
-    out[0] = (hex >> 16 & 0xFF) / 255;
-    out[1] = (hex >> 8 & 0xFF) / 255;
-    out[2] = (hex & 0xFF) / 255;
-
-    return out;
-}
-
-/**
- * Converts a hex color number to a string.
- *
- * @memberof PIXI.utils
- * @function hex2string
- * @param {number} hex - Number in hex
- * @return {string} The string color.
- */
-function hex2string(hex) {
-    hex = hex.toString(16);
-    hex = '000000'.substr(0, 6 - hex.length) + hex;
-
-    return '#' + hex;
-}
-
-/**
- * Converts a color as an [R, G, B] array to a hex number
- *
- * @memberof PIXI.utils
- * @function rgb2hex
- * @param {number[]} rgb - rgb array
- * @return {number} The color number
- */
-function rgb2hex(rgb) {
-    return (rgb[0] * 255 << 16) + (rgb[1] * 255 << 8) + (rgb[2] * 255 | 0);
-}
-
-/**
- * get the resolution / device pixel ratio of an asset by looking for the prefix
- * used by spritesheets and image urls
- *
- * @memberof PIXI.utils
- * @function getResolutionOfUrl
- * @param {string} url - the image path
- * @param {number} [defaultValue=1] - the defaultValue if no filename prefix is set.
- * @return {number} resolution / device pixel ratio of an asset
- */
-function getResolutionOfUrl(url, defaultValue) {
-    var resolution = _settings2.default.RETINA_PREFIX.exec(url);
-
-    if (resolution) {
-        return parseFloat(resolution[1]);
-    }
-
-    return defaultValue !== undefined ? defaultValue : 1;
-}
-
-/**
- * Typedef for decomposeDataUri return object.
- *
- * @typedef {object} DecomposedDataUri
- * @property {mediaType} Media type, eg. `image`
- * @property {subType} Sub type, eg. `png`
- * @property {encoding} Data encoding, eg. `base64`
- * @property {data} The actual data
- */
-
-/**
- * Split a data URI into components. Returns undefined if
- * parameter `dataUri` is not a valid data URI.
- *
- * @memberof PIXI.utils
- * @function decomposeDataUri
- * @param {string} dataUri - the data URI to check
- * @return {DecomposedDataUri|undefined} The decomposed data uri or undefined
- */
-function decomposeDataUri(dataUri) {
-    var dataUriMatch = _const.DATA_URI.exec(dataUri);
-
-    if (dataUriMatch) {
-        return {
-            mediaType: dataUriMatch[1] ? dataUriMatch[1].toLowerCase() : undefined,
-            subType: dataUriMatch[2] ? dataUriMatch[2].toLowerCase() : undefined,
-            encoding: dataUriMatch[3] ? dataUriMatch[3].toLowerCase() : undefined,
-            data: dataUriMatch[4]
-        };
-    }
-
-    return undefined;
-}
-
-/**
- * Get type of the image by regexp for extension. Returns undefined for unknown extensions.
- *
- * @memberof PIXI.utils
- * @function getUrlFileExtension
- * @param {string} url - the image path
- * @return {string|undefined} image extension
- */
-function getUrlFileExtension(url) {
-    var extension = _const.URL_FILE_EXTENSION.exec(url);
-
-    if (extension) {
-        return extension[1].toLowerCase();
-    }
-
-    return undefined;
-}
-
-/**
- * Typedef for Size object.
- *
- * @typedef {object} Size
- * @property {width} Width component
- * @property {height} Height component
- */
-
-/**
- * Get size from an svg string using regexp.
- *
- * @memberof PIXI.utils
- * @function getSvgSize
- * @param {string} svgString - a serialized svg element
- * @return {Size|undefined} image extension
- */
-function getSvgSize(svgString) {
-    var sizeMatch = _const.SVG_SIZE.exec(svgString);
-    var size = {};
-
-    if (sizeMatch) {
-        size[sizeMatch[1]] = Math.round(parseFloat(sizeMatch[3]));
-        size[sizeMatch[5]] = Math.round(parseFloat(sizeMatch[7]));
-    }
-
-    return size;
-}
-
-/**
- * Skips the hello message of renderers that are created after this is run.
- *
- * @function skipHello
- * @memberof PIXI.utils
- */
-function skipHello() {
-    saidHello = true;
-}
-
-/**
- * Logs out the version and renderer information for this running instance of PIXI.
- * If you don't want to see this message you can run `PIXI.utils.skipHello()` before
- * creating your renderer. Keep in mind that doing that will forever makes you a jerk face.
- *
- * @static
- * @function sayHello
- * @memberof PIXI.utils
- * @param {string} type - The string renderer type to log.
- */
-function sayHello(type) {
-    if (saidHello) {
-        return;
-    }
-
-    if (navigator.userAgent.toLowerCase().indexOf('chrome') > -1) {
-        var args = ['\n %c %c %c PixiJS ' + _const.VERSION + ' - \u2730 ' + type + ' \u2730  %c  %c  http://www.pixijs.com/  %c %c \u2665%c\u2665%c\u2665 \n\n', 'background: #ff66a5; padding:5px 0;', 'background: #ff66a5; padding:5px 0;', 'color: #ff66a5; background: #030307; padding:5px 0;', 'background: #ff66a5; padding:5px 0;', 'background: #ffc3dc; padding:5px 0;', 'background: #ff66a5; padding:5px 0;', 'color: #ff2424; background: #fff; padding:5px 0;', 'color: #ff2424; background: #fff; padding:5px 0;', 'color: #ff2424; background: #fff; padding:5px 0;'];
-
-        window.console.log.apply(console, args);
-    } else if (window.console) {
-        window.console.log('PixiJS ' + _const.VERSION + ' - ' + type + ' - http://www.pixijs.com/');
-    }
-
-    saidHello = true;
-}
-
-/**
- * Helper for checking for webgl support
- *
- * @memberof PIXI.utils
- * @function isWebGLSupported
- * @return {boolean} is webgl supported
- */
-function isWebGLSupported() {
-    var contextOptions = { stencil: true, failIfMajorPerformanceCaveat: true };
-
-    try {
-        if (!window.WebGLRenderingContext) {
-            return false;
-        }
-
-        var canvas = document.createElement('canvas');
-        var gl = canvas.getContext('webgl', contextOptions) || canvas.getContext('experimental-webgl', contextOptions);
-
-        var success = !!(gl && gl.getContextAttributes().stencil);
-
-        if (gl) {
-            var loseContext = gl.getExtension('WEBGL_lose_context');
-
-            if (loseContext) {
-                loseContext.loseContext();
-            }
-        }
-
-        gl = null;
-
-        return success;
-    } catch (e) {
-        return false;
-    }
-}
-
-/**
- * Returns sign of number
- *
- * @memberof PIXI.utils
- * @function sign
- * @param {number} n - the number to check the sign of
- * @returns {number} 0 if `n` is 0, -1 if `n` is negative, 1 if `n` is positive
- */
-function sign(n) {
-    if (n === 0) return 0;
-
-    return n < 0 ? -1 : 1;
-}
-
-/**
- * @todo Describe property usage
- *
- * @memberof PIXI.utils
- * @private
- */
-var TextureCache = exports.TextureCache = Object.create(null);
-
-/**
- * @todo Describe property usage
- *
- * @memberof PIXI.utils
- * @private
- */
-var BaseTextureCache = exports.BaseTextureCache = Object.create(null);
-
-/**
- * Destroys all texture in the cache
- *
- * @memberof PIXI.utils
- * @function destroyTextureCache
- */
-function destroyTextureCache() {
-    var key = void 0;
-
-    for (key in TextureCache) {
-        TextureCache[key].destroy();
-    }
-    for (key in BaseTextureCache) {
-        BaseTextureCache[key].destroy();
-    }
-}
-
-/**
- * Removes all textures from cache, but does not destroy them
- *
- * @memberof PIXI.utils
- * @function clearTextureCache
- */
-function clearTextureCache() {
-    var key = void 0;
-
-    for (key in TextureCache) {
-        delete TextureCache[key];
-    }
-    for (key in BaseTextureCache) {
-        delete BaseTextureCache[key];
-    }
-}
-
-/**
- * maps premultiply flag and blendMode to adjusted blendMode
- * @memberof PIXI.utils
- * @const premultiplyBlendMode
- * @type {Array<number[]>}
- */
-var premultiplyBlendMode = exports.premultiplyBlendMode = (0, _mapPremultipliedBlendModes2.default)();
-
-/**
- * changes blendMode according to texture format
- *
- * @memberof PIXI.utils
- * @function correctBlendMode
- * @param {number} blendMode supposed blend mode
- * @param {boolean} premultiplied  whether source is premultiplied
- * @returns {number} true blend mode for this texture
- */
-function correctBlendMode(blendMode, premultiplied) {
-    return premultiplyBlendMode[premultiplied ? 1 : 0][blendMode];
-}
-
-/**
- * premultiplies tint
- *
- * @param {number} tint integet RGB
- * @param {number} alpha floating point alpha (0.0-1.0)
- * @returns {number} tint multiplied by alpha
- */
-function premultiplyTint(tint, alpha) {
-    if (alpha === 1.0) {
-        return (alpha * 255 << 24) + tint;
-    }
-    if (alpha === 0.0) {
-        return 0;
-    }
-    var R = tint >> 16 & 0xFF;
-    var G = tint >> 8 & 0xFF;
-    var B = tint & 0xFF;
-
-    R = R * alpha + 0.5 | 0;
-    G = G * alpha + 0.5 | 0;
-    B = B * alpha + 0.5 | 0;
-
-    return (alpha * 255 << 24) + (R << 16) + (G << 8) + B;
-}
-
-/**
- * combines rgb and alpha to out array
- *
- * @param {Float32Array|number[]} rgb input rgb
- * @param {number} alpha alpha param
- * @param {Float32Array} [out] output
- * @param {boolean} [premultiply=true] do premultiply it
- * @returns {Float32Array} vec4 rgba
- */
-function premultiplyRgba(rgb, alpha, out, premultiply) {
-    out = out || new Float32Array(4);
-    if (premultiply || premultiply === undefined) {
-        out[0] = rgb[0] * alpha;
-        out[1] = rgb[1] * alpha;
-        out[2] = rgb[2] * alpha;
-    } else {
-        out[0] = rgb[0];
-        out[1] = rgb[1];
-        out[2] = rgb[2];
-    }
-    out[3] = alpha;
-
-    return out;
-}
-
-/**
- * converts integer tint and float alpha to vec4 form, premultiplies by default
- *
- * @param {number} tint input tint
- * @param {number} alpha alpha param
- * @param {Float32Array} [out] output
- * @param {boolean} [premultiply=true] do premultiply it
- * @returns {Float32Array} vec4 rgba
- */
-function premultiplyTintToRgba(tint, alpha, out, premultiply) {
-    out = out || new Float32Array(4);
-    out[0] = (tint >> 16 & 0xFF) / 255.0;
-    out[1] = (tint >> 8 & 0xFF) / 255.0;
-    out[2] = (tint & 0xFF) / 255.0;
-    if (premultiply || premultiply === undefined) {
-        out[0] *= alpha;
-        out[1] *= alpha;
-        out[2] *= alpha;
-    }
-    out[3] = alpha;
-
-    return out;
-}
-
-},{"../const":46,"../settings":101,"./mapPremultipliedBlendModes":125,"./mixin":127,"./pluginTarget":128,"eventemitter3":3,"ismobilejs":4,"remove-array-items":31}],125:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = mapPremultipliedBlendModes;
-
-var _const = require('../const');
-
-/**
- * Corrects PixiJS blend, takes premultiplied alpha into account
- *
- * @memberof PIXI
- * @function mapPremultipliedBlendModes
- * @private
- * @param {Array<number[]>} [array] - The array to output into.
- * @return {Array<number[]>} Mapped modes.
- */
-
-function mapPremultipliedBlendModes() {
-    var pm = [];
-    var npm = [];
-
-    for (var i = 0; i < 32; i++) {
-        pm[i] = i;
-        npm[i] = i;
-    }
-
-    pm[_const.BLEND_MODES.NORMAL_NPM] = _const.BLEND_MODES.NORMAL;
-    pm[_const.BLEND_MODES.ADD_NPM] = _const.BLEND_MODES.ADD;
-    pm[_const.BLEND_MODES.SCREEN_NPM] = _const.BLEND_MODES.SCREEN;
-
-    npm[_const.BLEND_MODES.NORMAL] = _const.BLEND_MODES.NORMAL_NPM;
-    npm[_const.BLEND_MODES.ADD] = _const.BLEND_MODES.ADD_NPM;
-    npm[_const.BLEND_MODES.SCREEN] = _const.BLEND_MODES.SCREEN_NPM;
-
-    var array = [];
-
-    array.push(npm);
-    array.push(pm);
-
-    return array;
-}
-
-},{"../const":46}],126:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = maxRecommendedTextures;
-
-var _ismobilejs = require('ismobilejs');
-
-var _ismobilejs2 = _interopRequireDefault(_ismobilejs);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function maxRecommendedTextures(max) {
-    if (_ismobilejs2.default.tablet || _ismobilejs2.default.phone) {
-        // check if the res is iphone 6 or higher..
-        return 4;
-    }
-
-    // desktop should be ok
-    return max;
-}
-
-},{"ismobilejs":4}],127:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-exports.mixin = mixin;
-exports.delayMixin = delayMixin;
-exports.performMixins = performMixins;
-/**
- * Mixes all enumerable properties and methods from a source object to a target object.
- *
- * @memberof PIXI.utils.mixins
- * @function mixin
- * @param {object} target The prototype or instance that properties and methods should be added to.
- * @param {object} source The source of properties and methods to mix in.
- */
-function mixin(target, source) {
-    if (!target || !source) return;
-    // in ES8/ES2017, this would be really easy:
-    // Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-
-    // get all the enumerable property keys
-    var keys = Object.keys(source);
-
-    // loop through properties
-    for (var i = 0; i < keys.length; ++i) {
-        var propertyName = keys[i];
-
-        // Set the property using the property descriptor - this works for accessors and normal value properties
-        Object.defineProperty(target, propertyName, Object.getOwnPropertyDescriptor(source, propertyName));
-    }
-}
-
-var mixins = [];
-
-/**
- * Queues a mixin to be handled towards the end of the initialization of PIXI, so that deprecation
- * can take effect.
- *
- * @memberof PIXI.utils.mixins
- * @function delayMixin
- * @private
- * @param {object} target The prototype or instance that properties and methods should be added to.
- * @param {object} source The source of properties and methods to mix in.
- */
-function delayMixin(target, source) {
-    mixins.push(target, source);
-}
-
-/**
- * Handles all mixins queued via delayMixin().
- *
- * @memberof PIXI.utils.mixins
- * @function performMixins
- * @private
- */
-function performMixins() {
-    for (var i = 0; i < mixins.length; i += 2) {
-        mixin(mixins[i], mixins[i + 1]);
-    }
-    mixins.length = 0;
-}
-
-},{}],128:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-/**
- * Mixins functionality to make an object have "plugins".
- *
- * @example
- *      function MyObject() {}
- *
- *      pluginTarget.mixin(MyObject);
- *
- * @mixin
- * @memberof PIXI.utils
- * @param {object} obj - The object to mix into.
- */
-function pluginTarget(obj) {
-    obj.__plugins = {};
-
-    /**
-     * Adds a plugin to an object
-     *
-     * @param {string} pluginName - The events that should be listed.
-     * @param {Function} ctor - The constructor function for the plugin.
-     */
-    obj.registerPlugin = function registerPlugin(pluginName, ctor) {
-        obj.__plugins[pluginName] = ctor;
-    };
-
-    /**
-     * Instantiates all the plugins of this object
-     *
-     */
-    obj.prototype.initPlugins = function initPlugins() {
-        this.plugins = this.plugins || {};
-
-        for (var o in obj.__plugins) {
-            this.plugins[o] = new obj.__plugins[o](this);
-        }
-    };
-
-    /**
-     * Removes all the plugins of this object
-     *
-     */
-    obj.prototype.destroyPlugins = function destroyPlugins() {
-        for (var o in this.plugins) {
-            this.plugins[o].destroy();
-            this.plugins[o] = null;
-        }
-
-        this.plugins = null;
-    };
-}
-
-exports.default = {
-    /**
-     * Mixes in the properties of the pluginTarget into another object
-     *
-     * @param {object} obj - The obj to mix into
-     */
-    mixin: function mixin(obj) {
-        pluginTarget(obj);
-    }
-};
-
-},{}],129:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = trimCanvas;
-/**
- * Trim transparent borders from a canvas
- *
- * @memberof PIXI
- * @function trimCanvas
- * @private
- * @param {HTMLCanvasElement} canvas - the canvas to trim
- * @returns {object} Trim data
- */
-function trimCanvas(canvas) {
-    // https://gist.github.com/remy/784508
-
-    var width = canvas.width;
-    var height = canvas.height;
-
-    var context = canvas.getContext('2d');
-    var imageData = context.getImageData(0, 0, width, height);
-    var pixels = imageData.data;
-    var len = pixels.length;
-
-    var bound = {
-        top: null,
-        left: null,
-        right: null,
-        bottom: null
-    };
-    var i = void 0;
-    var x = void 0;
-    var y = void 0;
-
-    for (i = 0; i < len; i += 4) {
-        if (pixels[i + 3] !== 0) {
-            x = i / 4 % width;
-            y = ~~(i / 4 / width);
-
-            if (bound.top === null) {
-                bound.top = y;
-            }
-
-            if (bound.left === null) {
-                bound.left = x;
-            } else if (x < bound.left) {
-                bound.left = x;
-            }
-
-            if (bound.right === null) {
-                bound.right = x + 1;
-            } else if (bound.right < x) {
-                bound.right = x + 1;
-            }
-
-            if (bound.bottom === null) {
-                bound.bottom = y;
-            } else if (bound.bottom < y) {
-                bound.bottom = y;
-            }
-        }
-    }
-
-    width = bound.right - bound.left;
-    height = bound.bottom - bound.top + 1;
-
-    var data = context.getImageData(bound.left, bound.top, width, height);
-
-    return {
-        height: height,
-        width: width,
-        data: data
-    };
-}
-
-},{}],130:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = deprecation;
-// provide method to give a stack track for warnings
-// useful for tracking-down where deprecated methods/properties/classes
-// are being used within the code
-function warn(msg) {
-    /* eslint-disable no-console */
-    var stack = new Error().stack;
-
-    // Handle IE < 10 and Safari < 6
-    if (typeof stack === 'undefined') {
-        console.warn('Deprecation Warning: ', msg);
-    } else {
-        // chop off the stack trace which includes pixi.js internal calls
-        stack = stack.split('\n').splice(3).join('\n');
-
-        if (console.groupCollapsed) {
-            console.groupCollapsed('%cDeprecation Warning: %c%s', 'color:#614108;background:#fffbe6', 'font-weight:normal;color:#614108;background:#fffbe6', msg);
-            console.warn(stack);
-            console.groupEnd();
-        } else {
-            console.warn('Deprecation Warning: ', msg);
-            console.warn(stack);
-        }
-    }
-    /* eslint-enable no-console */
-}
-
-function deprecation(core) {
-    var mesh = core.mesh,
-        particles = core.particles,
-        extras = core.extras,
-        filters = core.filters,
-        prepare = core.prepare,
-        loaders = core.loaders,
-        interaction = core.interaction;
-
-
-    Object.defineProperties(core, {
-
-        /**
-         * @class
-         * @private
-         * @name SpriteBatch
-         * @memberof PIXI
-         * @see PIXI.ParticleContainer
-         * @throws {ReferenceError} SpriteBatch does not exist any more, please use the new ParticleContainer instead.
-         * @deprecated since version 3.0.0
-         */
-        SpriteBatch: {
-            get: function get() {
-                throw new ReferenceError('SpriteBatch does not exist any more, ' + 'please use the new ParticleContainer instead.');
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name AssetLoader
-         * @memberof PIXI
-         * @see PIXI.loaders.Loader
-         * @throws {ReferenceError} The loader system was overhauled in PixiJS v3,
-         * please see the new PIXI.loaders.Loader class.
-         * @deprecated since version 3.0.0
-         */
-        AssetLoader: {
-            get: function get() {
-                throw new ReferenceError('The loader system was overhauled in PixiJS v3, ' + 'please see the new PIXI.loaders.Loader class.');
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name Stage
-         * @memberof PIXI
-         * @see PIXI.Container
-         * @deprecated since version 3.0.0
-         */
-        Stage: {
-            get: function get() {
-                warn('You do not need to use a PIXI Stage any more, you can simply render any container.');
-
-                return core.Container;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name DisplayObjectContainer
-         * @memberof PIXI
-         * @see PIXI.Container
-         * @deprecated since version 3.0.0
-         */
-        DisplayObjectContainer: {
-            get: function get() {
-                warn('DisplayObjectContainer has been shortened to Container, please use Container from now on.');
-
-                return core.Container;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name Strip
-         * @memberof PIXI
-         * @see PIXI.mesh.Mesh
-         * @deprecated since version 3.0.0
-         */
-        Strip: {
-            get: function get() {
-                warn('The Strip class has been renamed to Mesh and moved to mesh.Mesh, please use mesh.Mesh from now on.');
-
-                return mesh.Mesh;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name Rope
-         * @memberof PIXI
-         * @see PIXI.mesh.Rope
-         * @deprecated since version 3.0.0
-         */
-        Rope: {
-            get: function get() {
-                warn('The Rope class has been moved to mesh.Rope, please use mesh.Rope from now on.');
-
-                return mesh.Rope;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name ParticleContainer
-         * @memberof PIXI
-         * @see PIXI.particles.ParticleContainer
-         * @deprecated since version 4.0.0
-         */
-        ParticleContainer: {
-            get: function get() {
-                warn('The ParticleContainer class has been moved to particles.ParticleContainer, ' + 'please use particles.ParticleContainer from now on.');
-
-                return particles.ParticleContainer;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name MovieClip
-         * @memberof PIXI
-         * @see PIXI.extras.MovieClip
-         * @deprecated since version 3.0.0
-         */
-        MovieClip: {
-            get: function get() {
-                warn('The MovieClip class has been moved to extras.AnimatedSprite, please use extras.AnimatedSprite.');
-
-                return extras.AnimatedSprite;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name TilingSprite
-         * @memberof PIXI
-         * @see PIXI.extras.TilingSprite
-         * @deprecated since version 3.0.0
-         */
-        TilingSprite: {
-            get: function get() {
-                warn('The TilingSprite class has been moved to extras.TilingSprite, ' + 'please use extras.TilingSprite from now on.');
-
-                return extras.TilingSprite;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name BitmapText
-         * @memberof PIXI
-         * @see PIXI.extras.BitmapText
-         * @deprecated since version 3.0.0
-         */
-        BitmapText: {
-            get: function get() {
-                warn('The BitmapText class has been moved to extras.BitmapText, ' + 'please use extras.BitmapText from now on.');
-
-                return extras.BitmapText;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name blendModes
-         * @memberof PIXI
-         * @see PIXI.BLEND_MODES
-         * @deprecated since version 3.0.0
-         */
-        blendModes: {
-            get: function get() {
-                warn('The blendModes has been moved to BLEND_MODES, please use BLEND_MODES from now on.');
-
-                return core.BLEND_MODES;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name scaleModes
-         * @memberof PIXI
-         * @see PIXI.SCALE_MODES
-         * @deprecated since version 3.0.0
-         */
-        scaleModes: {
-            get: function get() {
-                warn('The scaleModes has been moved to SCALE_MODES, please use SCALE_MODES from now on.');
-
-                return core.SCALE_MODES;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name BaseTextureCache
-         * @memberof PIXI
-         * @see PIXI.utils.BaseTextureCache
-         * @deprecated since version 3.0.0
-         */
-        BaseTextureCache: {
-            get: function get() {
-                warn('The BaseTextureCache class has been moved to utils.BaseTextureCache, ' + 'please use utils.BaseTextureCache from now on.');
-
-                return core.utils.BaseTextureCache;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name TextureCache
-         * @memberof PIXI
-         * @see PIXI.utils.TextureCache
-         * @deprecated since version 3.0.0
-         */
-        TextureCache: {
-            get: function get() {
-                warn('The TextureCache class has been moved to utils.TextureCache, ' + 'please use utils.TextureCache from now on.');
-
-                return core.utils.TextureCache;
-            }
-        },
-
-        /**
-         * @namespace
-         * @private
-         * @name math
-         * @memberof PIXI
-         * @see PIXI
-         * @deprecated since version 3.0.6
-         */
-        math: {
-            get: function get() {
-                warn('The math namespace is deprecated, please access members already accessible on PIXI.');
-
-                return core;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name PIXI.AbstractFilter
-         * @see PIXI.Filter
-         * @deprecated since version 3.0.6
-         */
-        AbstractFilter: {
-            get: function get() {
-                warn('AstractFilter has been renamed to Filter, please use PIXI.Filter');
-
-                return core.Filter;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name PIXI.TransformManual
-         * @see PIXI.TransformBase
-         * @deprecated since version 4.0.0
-         */
-        TransformManual: {
-            get: function get() {
-                warn('TransformManual has been renamed to TransformBase, please update your pixi-spine');
-
-                return core.TransformBase;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.TARGET_FPMS
-         * @see PIXI.settings.TARGET_FPMS
-         * @deprecated since version 4.2.0
-         */
-        TARGET_FPMS: {
-            get: function get() {
-                warn('PIXI.TARGET_FPMS has been deprecated, please use PIXI.settings.TARGET_FPMS');
-
-                return core.settings.TARGET_FPMS;
-            },
-            set: function set(value) {
-                warn('PIXI.TARGET_FPMS has been deprecated, please use PIXI.settings.TARGET_FPMS');
-
-                core.settings.TARGET_FPMS = value;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.FILTER_RESOLUTION
-         * @see PIXI.settings.FILTER_RESOLUTION
-         * @deprecated since version 4.2.0
-         */
-        FILTER_RESOLUTION: {
-            get: function get() {
-                warn('PIXI.FILTER_RESOLUTION has been deprecated, please use PIXI.settings.FILTER_RESOLUTION');
-
-                return core.settings.FILTER_RESOLUTION;
-            },
-            set: function set(value) {
-                warn('PIXI.FILTER_RESOLUTION has been deprecated, please use PIXI.settings.FILTER_RESOLUTION');
-
-                core.settings.FILTER_RESOLUTION = value;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.RESOLUTION
-         * @see PIXI.settings.RESOLUTION
-         * @deprecated since version 4.2.0
-         */
-        RESOLUTION: {
-            get: function get() {
-                warn('PIXI.RESOLUTION has been deprecated, please use PIXI.settings.RESOLUTION');
-
-                return core.settings.RESOLUTION;
-            },
-            set: function set(value) {
-                warn('PIXI.RESOLUTION has been deprecated, please use PIXI.settings.RESOLUTION');
-
-                core.settings.RESOLUTION = value;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.MIPMAP_TEXTURES
-         * @see PIXI.settings.MIPMAP_TEXTURES
-         * @deprecated since version 4.2.0
-         */
-        MIPMAP_TEXTURES: {
-            get: function get() {
-                warn('PIXI.MIPMAP_TEXTURES has been deprecated, please use PIXI.settings.MIPMAP_TEXTURES');
-
-                return core.settings.MIPMAP_TEXTURES;
-            },
-            set: function set(value) {
-                warn('PIXI.MIPMAP_TEXTURES has been deprecated, please use PIXI.settings.MIPMAP_TEXTURES');
-
-                core.settings.MIPMAP_TEXTURES = value;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.SPRITE_BATCH_SIZE
-         * @see PIXI.settings.SPRITE_BATCH_SIZE
-         * @deprecated since version 4.2.0
-         */
-        SPRITE_BATCH_SIZE: {
-            get: function get() {
-                warn('PIXI.SPRITE_BATCH_SIZE has been deprecated, please use PIXI.settings.SPRITE_BATCH_SIZE');
-
-                return core.settings.SPRITE_BATCH_SIZE;
-            },
-            set: function set(value) {
-                warn('PIXI.SPRITE_BATCH_SIZE has been deprecated, please use PIXI.settings.SPRITE_BATCH_SIZE');
-
-                core.settings.SPRITE_BATCH_SIZE = value;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.SPRITE_MAX_TEXTURES
-         * @see PIXI.settings.SPRITE_MAX_TEXTURES
-         * @deprecated since version 4.2.0
-         */
-        SPRITE_MAX_TEXTURES: {
-            get: function get() {
-                warn('PIXI.SPRITE_MAX_TEXTURES has been deprecated, please use PIXI.settings.SPRITE_MAX_TEXTURES');
-
-                return core.settings.SPRITE_MAX_TEXTURES;
-            },
-            set: function set(value) {
-                warn('PIXI.SPRITE_MAX_TEXTURES has been deprecated, please use PIXI.settings.SPRITE_MAX_TEXTURES');
-
-                core.settings.SPRITE_MAX_TEXTURES = value;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.RETINA_PREFIX
-         * @see PIXI.settings.RETINA_PREFIX
-         * @deprecated since version 4.2.0
-         */
-        RETINA_PREFIX: {
-            get: function get() {
-                warn('PIXI.RETINA_PREFIX has been deprecated, please use PIXI.settings.RETINA_PREFIX');
-
-                return core.settings.RETINA_PREFIX;
-            },
-            set: function set(value) {
-                warn('PIXI.RETINA_PREFIX has been deprecated, please use PIXI.settings.RETINA_PREFIX');
-
-                core.settings.RETINA_PREFIX = value;
-            }
-        },
-
-        /**
-         * @static
-         * @constant
-         * @name PIXI.DEFAULT_RENDER_OPTIONS
-         * @see PIXI.settings.RENDER_OPTIONS
-         * @deprecated since version 4.2.0
-         */
-        DEFAULT_RENDER_OPTIONS: {
-            get: function get() {
-                warn('PIXI.DEFAULT_RENDER_OPTIONS has been deprecated, please use PIXI.settings.DEFAULT_RENDER_OPTIONS');
-
-                return core.settings.RENDER_OPTIONS;
-            }
-        }
-    });
-
-    // Move the default properties to settings
-    var defaults = [{ parent: 'TRANSFORM_MODE', target: 'TRANSFORM_MODE' }, { parent: 'GC_MODES', target: 'GC_MODE' }, { parent: 'WRAP_MODES', target: 'WRAP_MODE' }, { parent: 'SCALE_MODES', target: 'SCALE_MODE' }, { parent: 'PRECISION', target: 'PRECISION_FRAGMENT' }];
-
-    var _loop = function _loop(i) {
-        var deprecation = defaults[i];
-
-        Object.defineProperty(core[deprecation.parent], 'DEFAULT', {
-            get: function get() {
-                warn('PIXI.' + deprecation.parent + '.DEFAULT has been deprecated, ' + ('please use PIXI.settings.' + deprecation.target));
-
-                return core.settings[deprecation.target];
-            },
-            set: function set(value) {
-                warn('PIXI.' + deprecation.parent + '.DEFAULT has been deprecated, ' + ('please use PIXI.settings.' + deprecation.target));
-
-                core.settings[deprecation.target] = value;
-            }
-        });
-    };
-
-    for (var i = 0; i < defaults.length; i++) {
-        _loop(i);
-    }
-
-    Object.defineProperties(core.settings, {
-
-        /**
-         * @static
-         * @name PRECISION
-         * @memberof PIXI.settings
-         * @see PIXI.PRECISION
-         * @deprecated since version 4.4.0
-         */
-        PRECISION: {
-            get: function get() {
-                warn('PIXI.settings.PRECISION has been deprecated, please use PIXI.settings.PRECISION_FRAGMENT');
-
-                return core.settings.PRECISION_FRAGMENT;
-            },
-            set: function set(value) {
-                warn('PIXI.settings.PRECISION has been deprecated, please use PIXI.settings.PRECISION_FRAGMENT');
-
-                core.settings.PRECISION_FRAGMENT = value;
-            }
-        }
-    });
-
-    if (extras.AnimatedSprite) {
-        Object.defineProperties(extras, {
-
-            /**
-             * @class
-             * @name MovieClip
-             * @memberof PIXI.extras
-             * @see PIXI.extras.AnimatedSprite
-             * @deprecated since version 4.2.0
-             */
-            MovieClip: {
-                get: function get() {
-                    warn('The MovieClip class has been renamed to AnimatedSprite, please use AnimatedSprite from now on.');
-
-                    return extras.AnimatedSprite;
-                }
-            }
-        });
-    }
-
-    core.DisplayObject.prototype.generateTexture = function generateTexture(renderer, scaleMode, resolution) {
-        warn('generateTexture has moved to the renderer, please use renderer.generateTexture(displayObject)');
-
-        return renderer.generateTexture(this, scaleMode, resolution);
-    };
-
-    core.Graphics.prototype.generateTexture = function generateTexture(scaleMode, resolution) {
-        warn('graphics generate texture has moved to the renderer. ' + 'Or to render a graphics to a texture using canvas please use generateCanvasTexture');
-
-        return this.generateCanvasTexture(scaleMode, resolution);
-    };
-
-    core.RenderTexture.prototype.render = function render(displayObject, matrix, clear, updateTransform) {
-        this.legacyRenderer.render(displayObject, this, clear, matrix, !updateTransform);
-        warn('RenderTexture.render is now deprecated, please use renderer.render(displayObject, renderTexture)');
-    };
-
-    core.RenderTexture.prototype.getImage = function getImage(target) {
-        warn('RenderTexture.getImage is now deprecated, please use renderer.extract.image(target)');
-
-        return this.legacyRenderer.extract.image(target);
-    };
-
-    core.RenderTexture.prototype.getBase64 = function getBase64(target) {
-        warn('RenderTexture.getBase64 is now deprecated, please use renderer.extract.base64(target)');
-
-        return this.legacyRenderer.extract.base64(target);
-    };
-
-    core.RenderTexture.prototype.getCanvas = function getCanvas(target) {
-        warn('RenderTexture.getCanvas is now deprecated, please use renderer.extract.canvas(target)');
-
-        return this.legacyRenderer.extract.canvas(target);
-    };
-
-    core.RenderTexture.prototype.getPixels = function getPixels(target) {
-        warn('RenderTexture.getPixels is now deprecated, please use renderer.extract.pixels(target)');
-
-        return this.legacyRenderer.pixels(target);
-    };
-
-    /**
-     * @method
-     * @private
-     * @name PIXI.Sprite#setTexture
-     * @see PIXI.Sprite#texture
-     * @deprecated since version 3.0.0
-     * @param {PIXI.Texture} texture - The texture to set to.
-     */
-    core.Sprite.prototype.setTexture = function setTexture(texture) {
-        this.texture = texture;
-        warn('setTexture is now deprecated, please use the texture property, e.g : sprite.texture = texture;');
-    };
-
-    if (extras.BitmapText) {
-        /**
-         * @method
-         * @name PIXI.extras.BitmapText#setText
-         * @see PIXI.extras.BitmapText#text
-         * @deprecated since version 3.0.0
-         * @param {string} text - The text to set to.
-         */
-        extras.BitmapText.prototype.setText = function setText(text) {
-            this.text = text;
-            warn('setText is now deprecated, please use the text property, e.g : myBitmapText.text = \'my text\';');
-        };
-    }
-
-    /**
-     * @method
-     * @name PIXI.Text#setText
-     * @see PIXI.Text#text
-     * @deprecated since version 3.0.0
-     * @param {string} text - The text to set to.
-     */
-    core.Text.prototype.setText = function setText(text) {
-        this.text = text;
-        warn('setText is now deprecated, please use the text property, e.g : myText.text = \'my text\';');
-    };
-
-    /**
-     * Calculates the ascent, descent and fontSize of a given fontStyle
-     *
-     * @name PIXI.Text.calculateFontProperties
-     * @see PIXI.TextMetrics.measureFont
-     * @deprecated since version 4.5.0
-     * @param {string} font - String representing the style of the font
-     * @return {Object} Font properties object
-     */
-    core.Text.calculateFontProperties = function calculateFontProperties(font) {
-        warn('Text.calculateFontProperties is now deprecated, please use the TextMetrics.measureFont');
-
-        return core.TextMetrics.measureFont(font);
-    };
-
-    Object.defineProperties(core.Text, {
-        fontPropertiesCache: {
-            get: function get() {
-                warn('Text.fontPropertiesCache is deprecated');
-
-                return core.TextMetrics._fonts;
-            }
-        },
-        fontPropertiesCanvas: {
-            get: function get() {
-                warn('Text.fontPropertiesCanvas is deprecated');
-
-                return core.TextMetrics._canvas;
-            }
-        },
-        fontPropertiesContext: {
-            get: function get() {
-                warn('Text.fontPropertiesContext is deprecated');
-
-                return core.TextMetrics._context;
-            }
-        }
-    });
-
-    /**
-     * @method
-     * @name PIXI.Text#setStyle
-     * @see PIXI.Text#style
-     * @deprecated since version 3.0.0
-     * @param {*} style - The style to set to.
-     */
-    core.Text.prototype.setStyle = function setStyle(style) {
-        this.style = style;
-        warn('setStyle is now deprecated, please use the style property, e.g : myText.style = style;');
-    };
-
-    /**
-     * @method
-     * @name PIXI.Text#determineFontProperties
-     * @see PIXI.Text#measureFontProperties
-     * @deprecated since version 4.2.0
-     * @private
-     * @param {string} fontStyle - String representing the style of the font
-     * @return {Object} Font properties object
-     */
-    core.Text.prototype.determineFontProperties = function determineFontProperties(fontStyle) {
-        warn('determineFontProperties is now deprecated, please use TextMetrics.measureFont method');
-
-        return core.TextMetrics.measureFont(fontStyle);
-    };
-
-    /**
-     * @method
-     * @name PIXI.Text.getFontStyle
-     * @see PIXI.TextMetrics.getFontStyle
-     * @deprecated since version 4.5.0
-     * @param {PIXI.TextStyle} style - The style to use.
-     * @return {string} Font string
-     */
-    core.Text.getFontStyle = function getFontStyle(style) {
-        warn('getFontStyle is now deprecated, please use TextStyle.toFontString() instead');
-
-        style = style || {};
-
-        if (!(style instanceof core.TextStyle)) {
-            style = new core.TextStyle(style);
-        }
-
-        return style.toFontString();
-    };
-
-    Object.defineProperties(core.TextStyle.prototype, {
-        /**
-         * Set all properties of a font as a single string
-         *
-         * @name PIXI.TextStyle#font
-         * @deprecated since version 4.0.0
-         */
-        font: {
-            get: function get() {
-                warn('text style property \'font\' is now deprecated, please use the ' + '\'fontFamily\', \'fontSize\', \'fontStyle\', \'fontVariant\' and \'fontWeight\' properties from now on');
-
-                var fontSizeString = typeof this._fontSize === 'number' ? this._fontSize + 'px' : this._fontSize;
-
-                return this._fontStyle + ' ' + this._fontVariant + ' ' + this._fontWeight + ' ' + fontSizeString + ' ' + this._fontFamily;
-            },
-            set: function set(font) {
-                warn('text style property \'font\' is now deprecated, please use the ' + '\'fontFamily\',\'fontSize\',fontStyle\',\'fontVariant\' and \'fontWeight\' properties from now on');
-
-                // can work out fontStyle from search of whole string
-                if (font.indexOf('italic') > 1) {
-                    this._fontStyle = 'italic';
-                } else if (font.indexOf('oblique') > -1) {
-                    this._fontStyle = 'oblique';
-                } else {
-                    this._fontStyle = 'normal';
-                }
-
-                // can work out fontVariant from search of whole string
-                if (font.indexOf('small-caps') > -1) {
-                    this._fontVariant = 'small-caps';
-                } else {
-                    this._fontVariant = 'normal';
-                }
-
-                // fontWeight and fontFamily are tricker to find, but it's easier to find the fontSize due to it's units
-                var splits = font.split(' ');
-                var fontSizeIndex = -1;
-
-                this._fontSize = 26;
-                for (var i = 0; i < splits.length; ++i) {
-                    if (splits[i].match(/(px|pt|em|%)/)) {
-                        fontSizeIndex = i;
-                        this._fontSize = splits[i];
-                        break;
-                    }
-                }
-
-                // we can now search for fontWeight as we know it must occur before the fontSize
-                this._fontWeight = 'normal';
-                for (var _i = 0; _i < fontSizeIndex; ++_i) {
-                    if (splits[_i].match(/(bold|bolder|lighter|100|200|300|400|500|600|700|800|900)/)) {
-                        this._fontWeight = splits[_i];
-                        break;
-                    }
-                }
-
-                // and finally join everything together after the fontSize in case the font family has multiple words
-                if (fontSizeIndex > -1 && fontSizeIndex < splits.length - 1) {
-                    this._fontFamily = '';
-                    for (var _i2 = fontSizeIndex + 1; _i2 < splits.length; ++_i2) {
-                        this._fontFamily += splits[_i2] + ' ';
-                    }
-
-                    this._fontFamily = this._fontFamily.slice(0, -1);
-                } else {
-                    this._fontFamily = 'Arial';
-                }
-
-                this.styleID++;
-            }
-        }
-    });
-
-    /**
-     * @method
-     * @name PIXI.Texture#setFrame
-     * @see PIXI.Texture#setFrame
-     * @deprecated since version 3.0.0
-     * @param {PIXI.Rectangle} frame - The frame to set.
-     */
-    core.Texture.prototype.setFrame = function setFrame(frame) {
-        this.frame = frame;
-        warn('setFrame is now deprecated, please use the frame property, e.g: myTexture.frame = frame;');
-    };
-
-    /**
-     * @static
-     * @function
-     * @name PIXI.Texture.addTextureToCache
-     * @see PIXI.Texture.addToCache
-     * @deprecated since 4.5.0
-     * @param {PIXI.Texture} texture - The Texture to add to the cache.
-     * @param {string} id - The id that the texture will be stored against.
-     */
-    core.Texture.addTextureToCache = function addTextureToCache(texture, id) {
-        core.Texture.addToCache(texture, id);
-        warn('Texture.addTextureToCache is deprecated, please use Texture.addToCache from now on.');
-    };
-
-    /**
-     * @static
-     * @function
-     * @name PIXI.Texture.removeTextureFromCache
-     * @see PIXI.Texture.removeFromCache
-     * @deprecated since 4.5.0
-     * @param {string} id - The id of the texture to be removed
-     * @return {PIXI.Texture|null} The texture that was removed
-     */
-    core.Texture.removeTextureFromCache = function removeTextureFromCache(id) {
-        warn('Texture.removeTextureFromCache is deprecated, please use Texture.removeFromCache from now on. ' + 'Be aware that Texture.removeFromCache does not automatically its BaseTexture from the BaseTextureCache. ' + 'For that, use BaseTexture.removeFromCache');
-
-        core.BaseTexture.removeFromCache(id);
-
-        return core.Texture.removeFromCache(id);
-    };
-
-    Object.defineProperties(filters, {
-
-        /**
-         * @class
-         * @private
-         * @name PIXI.filters.AbstractFilter
-         * @see PIXI.AbstractFilter
-         * @deprecated since version 3.0.6
-         */
-        AbstractFilter: {
-            get: function get() {
-                warn('AstractFilter has been renamed to Filter, please use PIXI.Filter');
-
-                return core.AbstractFilter;
-            }
-        },
-
-        /**
-         * @class
-         * @private
-         * @name PIXI.filters.SpriteMaskFilter
-         * @see PIXI.SpriteMaskFilter
-         * @deprecated since version 3.0.6
-         */
-        SpriteMaskFilter: {
-            get: function get() {
-                warn('filters.SpriteMaskFilter is an undocumented alias, please use SpriteMaskFilter from now on.');
-
-                return core.SpriteMaskFilter;
-            }
-        }
-    });
-
-    /**
-     * @method
-     * @name PIXI.utils.uuid
-     * @see PIXI.utils.uid
-     * @deprecated since version 3.0.6
-     * @return {number} The uid
-     */
-    core.utils.uuid = function () {
-        warn('utils.uuid() is deprecated, please use utils.uid() from now on.');
-
-        return core.utils.uid();
-    };
-
-    /**
-     * @method
-     * @name PIXI.utils.canUseNewCanvasBlendModes
-     * @see PIXI.CanvasTinter
-     * @deprecated
-     * @return {boolean} Can use blend modes.
-     */
-    core.utils.canUseNewCanvasBlendModes = function () {
-        warn('utils.canUseNewCanvasBlendModes() is deprecated, please use CanvasTinter.canUseMultiply from now on');
-
-        return core.CanvasTinter.canUseMultiply;
-    };
-
-    var saidHello = true;
-
-    /**
-     * @name PIXI.utils._saidHello
-     * @type {boolean}
-     * @see PIXI.utils.skipHello
-     * @deprecated since 4.1.0
-     */
-    Object.defineProperty(core.utils, '_saidHello', {
-        set: function set(bool) {
-            if (bool) {
-                warn('PIXI.utils._saidHello is deprecated, please use PIXI.utils.skipHello()');
-                this.skipHello();
-            }
-            saidHello = bool;
-        },
-        get: function get() {
-            return saidHello;
-        }
-    });
-
-    if (prepare.BasePrepare) {
-        /**
-         * @method
-         * @name PIXI.prepare.BasePrepare#register
-         * @see PIXI.prepare.BasePrepare#registerFindHook
-         * @deprecated since version 4.4.2
-         * @param {Function} [addHook] - Function call that takes two parameters: `item:*, queue:Array`
-         *        function must return `true` if it was able to add item to the queue.
-         * @param {Function} [uploadHook] - Function call that takes two parameters: `prepare:CanvasPrepare, item:*` and
-         *        function must return `true` if it was able to handle upload of item.
-         * @return {PIXI.BasePrepare} Instance of plugin for chaining.
-         */
-        prepare.BasePrepare.prototype.register = function register(addHook, uploadHook) {
-            warn('renderer.plugins.prepare.register is now deprecated, ' + 'please use renderer.plugins.prepare.registerFindHook & renderer.plugins.prepare.registerUploadHook');
-
-            if (addHook) {
-                this.registerFindHook(addHook);
-            }
-
-            if (uploadHook) {
-                this.registerUploadHook(uploadHook);
-            }
-
-            return this;
-        };
-    }
-
-    if (prepare.canvas) {
-        /**
-         * The number of graphics or textures to upload to the GPU.
-         *
-         * @name PIXI.prepare.canvas.UPLOADS_PER_FRAME
-         * @static
-         * @type {number}
-         * @see PIXI.prepare.BasePrepare.limiter
-         * @deprecated since 4.2.0
-         */
-        Object.defineProperty(prepare.canvas, 'UPLOADS_PER_FRAME', {
-            set: function set() {
-                warn('PIXI.CanvasPrepare.UPLOADS_PER_FRAME has been removed. Please set ' + 'renderer.plugins.prepare.limiter.maxItemsPerFrame on your renderer');
-                // because we don't have a reference to the renderer, we can't actually set
-                // the uploads per frame, so we'll have to stick with the warning.
-            },
-            get: function get() {
-                warn('PIXI.CanvasPrepare.UPLOADS_PER_FRAME has been removed. Please use ' + 'renderer.plugins.prepare.limiter');
-
-                return NaN;
-            }
-        });
-    }
-
-    if (prepare.webgl) {
-        /**
-         * The number of graphics or textures to upload to the GPU.
-         *
-         * @name PIXI.prepare.webgl.UPLOADS_PER_FRAME
-         * @static
-         * @type {number}
-         * @see PIXI.prepare.BasePrepare.limiter
-         * @deprecated since 4.2.0
-         */
-        Object.defineProperty(prepare.webgl, 'UPLOADS_PER_FRAME', {
-            set: function set() {
-                warn('PIXI.WebGLPrepare.UPLOADS_PER_FRAME has been removed. Please set ' + 'renderer.plugins.prepare.limiter.maxItemsPerFrame on your renderer');
-                // because we don't have a reference to the renderer, we can't actually set
-                // the uploads per frame, so we'll have to stick with the warning.
-            },
-            get: function get() {
-                warn('PIXI.WebGLPrepare.UPLOADS_PER_FRAME has been removed. Please use ' + 'renderer.plugins.prepare.limiter');
-
-                return NaN;
-            }
-        });
-    }
-
-    if (loaders.Loader) {
-        var Resource = loaders.Resource;
-        var Loader = loaders.Loader;
-
-        Object.defineProperties(Resource.prototype, {
-            isJson: {
-                get: function get() {
-                    warn('The isJson property is deprecated, please use `resource.type === Resource.TYPE.JSON`.');
-
-                    return this.type === Resource.TYPE.JSON;
-                }
-            },
-            isXml: {
-                get: function get() {
-                    warn('The isXml property is deprecated, please use `resource.type === Resource.TYPE.XML`.');
-
-                    return this.type === Resource.TYPE.XML;
-                }
-            },
-            isImage: {
-                get: function get() {
-                    warn('The isImage property is deprecated, please use `resource.type === Resource.TYPE.IMAGE`.');
-
-                    return this.type === Resource.TYPE.IMAGE;
-                }
-            },
-            isAudio: {
-                get: function get() {
-                    warn('The isAudio property is deprecated, please use `resource.type === Resource.TYPE.AUDIO`.');
-
-                    return this.type === Resource.TYPE.AUDIO;
-                }
-            },
-            isVideo: {
-                get: function get() {
-                    warn('The isVideo property is deprecated, please use `resource.type === Resource.TYPE.VIDEO`.');
-
-                    return this.type === Resource.TYPE.VIDEO;
-                }
-            }
-        });
-
-        Object.defineProperties(Loader.prototype, {
-            before: {
-                get: function get() {
-                    warn('The before() method is deprecated, please use pre().');
-
-                    return this.pre;
-                }
-            },
-            after: {
-                get: function get() {
-                    warn('The after() method is deprecated, please use use().');
-
-                    return this.use;
-                }
-            }
-        });
-    }
-
-    if (interaction.interactiveTarget) {
-        /**
-         * @name PIXI.interaction.interactiveTarget#defaultCursor
-         * @static
-         * @type {number}
-         * @see PIXI.interaction.interactiveTarget#cursor
-         * @deprecated since 4.3.0
-         */
-        Object.defineProperty(interaction.interactiveTarget, 'defaultCursor', {
-            set: function set(value) {
-                warn('Property defaultCursor has been replaced with \'cursor\'. ');
-                this.cursor = value;
-            },
-            get: function get() {
-                warn('Property defaultCursor has been replaced with \'cursor\'. ');
-
-                return this.cursor;
-            }
-        });
-    }
-
-    if (interaction.InteractionManager) {
-        /**
-         * @name PIXI.interaction.InteractionManager#defaultCursorStyle
-         * @static
-         * @type {string}
-         * @see PIXI.interaction.InteractionManager#cursorStyles
-         * @deprecated since 4.3.0
-         */
-        Object.defineProperty(interaction.InteractionManager, 'defaultCursorStyle', {
-            set: function set(value) {
-                warn('Property defaultCursorStyle has been replaced with \'cursorStyles.default\'. ');
-                this.cursorStyles.default = value;
-            },
-            get: function get() {
-                warn('Property defaultCursorStyle has been replaced with \'cursorStyles.default\'. ');
-
-                return this.cursorStyles.default;
-            }
-        });
-
-        /**
-         * @name PIXI.interaction.InteractionManager#currentCursorStyle
-         * @static
-         * @type {string}
-         * @see PIXI.interaction.InteractionManager#cursorStyles
-         * @deprecated since 4.3.0
-         */
-        Object.defineProperty(interaction.InteractionManager, 'currentCursorStyle', {
-            set: function set(value) {
-                warn('Property currentCursorStyle has been removed.' + 'See the currentCursorMode property, which works differently.');
-                this.currentCursorMode = value;
-            },
-            get: function get() {
-                warn('Property currentCursorStyle has been removed.' + 'See the currentCursorMode property, which works differently.');
-
-                return this.currentCursorMode;
-            }
-        });
-    }
-}
-
-},{}],131:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var TEMP_RECT = new core.Rectangle();
-
-/**
- * The extract manager provides functionality to export content from the renderers.
- *
- * An instance of this class is automatically created by default, and can be found at renderer.plugins.extract
- *
- * @class
- * @memberof PIXI.extract
- */
-
-var CanvasExtract = function () {
-    /**
-     * @param {PIXI.CanvasRenderer} renderer - A reference to the current renderer
-     */
-    function CanvasExtract(renderer) {
-        _classCallCheck(this, CanvasExtract);
-
-        this.renderer = renderer;
-        /**
-         * Collection of methods for extracting data (image, pixels, etc.) from a display object or render texture
-         *
-         * @member {PIXI.extract.CanvasExtract} extract
-         * @memberof PIXI.CanvasRenderer#
-         * @see PIXI.extract.CanvasExtract
-         */
-        renderer.extract = this;
-    }
-
-    /**
-     * Will return a HTML Image of the target
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {HTMLImageElement} HTML Image of the target
-     */
-
-
-    CanvasExtract.prototype.image = function image(target) {
-        var image = new Image();
-
-        image.src = this.base64(target);
-
-        return image;
-    };
-
-    /**
-     * Will return a a base64 encoded string of this target. It works by calling
-     *  `CanvasExtract.getCanvas` and then running toDataURL on that.
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {string} A base64 encoded string of the texture.
-     */
-
-
-    CanvasExtract.prototype.base64 = function base64(target) {
-        return this.canvas(target).toDataURL();
-    };
-
-    /**
-     * Creates a Canvas element, renders this target to it and then returns it.
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {HTMLCanvasElement} A Canvas element with the texture rendered on.
-     */
-
-
-    CanvasExtract.prototype.canvas = function canvas(target) {
-        var renderer = this.renderer;
-        var context = void 0;
-        var resolution = void 0;
-        var frame = void 0;
-        var renderTexture = void 0;
-
-        if (target) {
-            if (target instanceof core.RenderTexture) {
-                renderTexture = target;
-            } else {
-                renderTexture = renderer.generateTexture(target);
-            }
-        }
-
-        if (renderTexture) {
-            context = renderTexture.baseTexture._canvasRenderTarget.context;
-            resolution = renderTexture.baseTexture._canvasRenderTarget.resolution;
-            frame = renderTexture.frame;
-        } else {
-            context = renderer.rootContext;
-
-            frame = TEMP_RECT;
-            frame.width = this.renderer.width;
-            frame.height = this.renderer.height;
-        }
-
-        var width = frame.width * resolution;
-        var height = frame.height * resolution;
-
-        var canvasBuffer = new core.CanvasRenderTarget(width, height);
-        var canvasData = context.getImageData(frame.x * resolution, frame.y * resolution, width, height);
-
-        canvasBuffer.context.putImageData(canvasData, 0, 0);
-
-        // send the canvas back..
-        return canvasBuffer.canvas;
-    };
-
-    /**
-     * Will return a one-dimensional array containing the pixel data of the entire texture in RGBA
-     * order, with integer values between 0 and 255 (included).
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {Uint8ClampedArray} One-dimensional array containing the pixel data of the entire texture
-     */
-
-
-    CanvasExtract.prototype.pixels = function pixels(target) {
-        var renderer = this.renderer;
-        var context = void 0;
-        var resolution = void 0;
-        var frame = void 0;
-        var renderTexture = void 0;
-
-        if (target) {
-            if (target instanceof core.RenderTexture) {
-                renderTexture = target;
-            } else {
-                renderTexture = renderer.generateTexture(target);
-            }
-        }
-
-        if (renderTexture) {
-            context = renderTexture.baseTexture._canvasRenderTarget.context;
-            resolution = renderTexture.baseTexture._canvasRenderTarget.resolution;
-            frame = renderTexture.frame;
-        } else {
-            context = renderer.rootContext;
-
-            frame = TEMP_RECT;
-            frame.width = renderer.width;
-            frame.height = renderer.height;
-        }
-
-        return context.getImageData(0, 0, frame.width * resolution, frame.height * resolution).data;
-    };
-
-    /**
-     * Destroys the extract
-     *
-     */
-
-
-    CanvasExtract.prototype.destroy = function destroy() {
-        this.renderer.extract = null;
-        this.renderer = null;
-    };
-
-    return CanvasExtract;
-}();
-
-exports.default = CanvasExtract;
-
-
-core.CanvasRenderer.registerPlugin('extract', CanvasExtract);
-
-},{"../../core":65}],132:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _WebGLExtract = require('./webgl/WebGLExtract');
-
-Object.defineProperty(exports, 'webgl', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_WebGLExtract).default;
-  }
-});
-
-var _CanvasExtract = require('./canvas/CanvasExtract');
-
-Object.defineProperty(exports, 'canvas', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CanvasExtract).default;
-  }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./canvas/CanvasExtract":131,"./webgl/WebGLExtract":133}],133:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var TEMP_RECT = new core.Rectangle();
-var BYTES_PER_PIXEL = 4;
-
-/**
- * The extract manager provides functionality to export content from the renderers.
- *
- * An instance of this class is automatically created by default, and can be found at renderer.plugins.extract
- *
- * @class
- * @memberof PIXI.extract
- */
-
-var WebGLExtract = function () {
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - A reference to the current renderer
-     */
-    function WebGLExtract(renderer) {
-        _classCallCheck(this, WebGLExtract);
-
-        this.renderer = renderer;
-        /**
-         * Collection of methods for extracting data (image, pixels, etc.) from a display object or render texture
-         *
-         * @member {PIXI.extract.WebGLExtract} extract
-         * @memberof PIXI.WebGLRenderer#
-         * @see PIXI.extract.WebGLExtract
-         */
-        renderer.extract = this;
-    }
-
-    /**
-     * Will return a HTML Image of the target
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {HTMLImageElement} HTML Image of the target
-     */
-
-
-    WebGLExtract.prototype.image = function image(target) {
-        var image = new Image();
-
-        image.src = this.base64(target);
-
-        return image;
-    };
-
-    /**
-     * Will return a a base64 encoded string of this target. It works by calling
-     *  `WebGLExtract.getCanvas` and then running toDataURL on that.
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {string} A base64 encoded string of the texture.
-     */
-
-
-    WebGLExtract.prototype.base64 = function base64(target) {
-        return this.canvas(target).toDataURL();
-    };
-
-    /**
-     * Creates a Canvas element, renders this target to it and then returns it.
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {HTMLCanvasElement} A Canvas element with the texture rendered on.
-     */
-
-
-    WebGLExtract.prototype.canvas = function canvas(target) {
-        var renderer = this.renderer;
-        var textureBuffer = void 0;
-        var resolution = void 0;
-        var frame = void 0;
-        var flipY = false;
-        var renderTexture = void 0;
-
-        if (target) {
-            if (target instanceof core.RenderTexture) {
-                renderTexture = target;
-            } else {
-                renderTexture = this.renderer.generateTexture(target);
-            }
-        }
-
-        if (renderTexture) {
-            textureBuffer = renderTexture.baseTexture._glRenderTargets[this.renderer.CONTEXT_UID];
-            resolution = textureBuffer.resolution;
-            frame = renderTexture.frame;
-            flipY = false;
-        } else {
-            textureBuffer = this.renderer.rootRenderTarget;
-            resolution = textureBuffer.resolution;
-            flipY = true;
-
-            frame = TEMP_RECT;
-            frame.width = textureBuffer.size.width;
-            frame.height = textureBuffer.size.height;
-        }
-
-        var width = frame.width * resolution;
-        var height = frame.height * resolution;
-
-        var canvasBuffer = new core.CanvasRenderTarget(width, height);
-
-        if (textureBuffer) {
-            // bind the buffer
-            renderer.bindRenderTarget(textureBuffer);
-
-            // set up an array of pixels
-            var webglPixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
-
-            // read pixels to the array
-            var gl = renderer.gl;
-
-            gl.readPixels(frame.x * resolution, frame.y * resolution, width, height, gl.RGBA, gl.UNSIGNED_BYTE, webglPixels);
-
-            // add the pixels to the canvas
-            var canvasData = canvasBuffer.context.getImageData(0, 0, width, height);
-
-            canvasData.data.set(webglPixels);
-
-            canvasBuffer.context.putImageData(canvasData, 0, 0);
-
-            // pulling pixels
-            if (flipY) {
-                canvasBuffer.context.scale(1, -1);
-                canvasBuffer.context.drawImage(canvasBuffer.canvas, 0, -height);
-            }
-        }
-
-        // send the canvas back..
-        return canvasBuffer.canvas;
-    };
-
-    /**
-     * Will return a one-dimensional array containing the pixel data of the entire texture in RGBA
-     * order, with integer values between 0 and 255 (included).
-     *
-     * @param {PIXI.DisplayObject|PIXI.RenderTexture} target - A displayObject or renderTexture
-     *  to convert. If left empty will use use the main renderer
-     * @return {Uint8ClampedArray} One-dimensional array containing the pixel data of the entire texture
-     */
-
-
-    WebGLExtract.prototype.pixels = function pixels(target) {
-        var renderer = this.renderer;
-        var textureBuffer = void 0;
-        var resolution = void 0;
-        var frame = void 0;
-        var renderTexture = void 0;
-
-        if (target) {
-            if (target instanceof core.RenderTexture) {
-                renderTexture = target;
-            } else {
-                renderTexture = this.renderer.generateTexture(target);
-            }
-        }
-
-        if (renderTexture) {
-            textureBuffer = renderTexture.baseTexture._glRenderTargets[this.renderer.CONTEXT_UID];
-            resolution = textureBuffer.resolution;
-            frame = renderTexture.frame;
-        } else {
-            textureBuffer = this.renderer.rootRenderTarget;
-            resolution = textureBuffer.resolution;
-
-            frame = TEMP_RECT;
-            frame.width = textureBuffer.size.width;
-            frame.height = textureBuffer.size.height;
-        }
-
-        var width = frame.width * resolution;
-        var height = frame.height * resolution;
-
-        var webglPixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
-
-        if (textureBuffer) {
-            // bind the buffer
-            renderer.bindRenderTarget(textureBuffer);
-            // read pixels to the array
-            var gl = renderer.gl;
-
-            gl.readPixels(frame.x * resolution, frame.y * resolution, width, height, gl.RGBA, gl.UNSIGNED_BYTE, webglPixels);
-        }
-
-        return webglPixels;
-    };
-
-    /**
-     * Destroys the extract
-     *
-     */
-
-
-    WebGLExtract.prototype.destroy = function destroy() {
-        this.renderer.extract = null;
-        this.renderer = null;
-    };
-
-    return WebGLExtract;
-}();
-
-exports.default = WebGLExtract;
-
-
-core.WebGLRenderer.registerPlugin('extract', WebGLExtract);
-
-},{"../../core":65}],134:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * @typedef FrameObject
- * @type {object}
- * @property {PIXI.Texture} texture - The {@link PIXI.Texture} of the frame
- * @property {number} time - the duration of the frame in ms
- */
-
-/**
- * An AnimatedSprite is a simple way to display an animation depicted by a list of textures.
- *
- * ```js
- * let alienImages = ["image_sequence_01.png","image_sequence_02.png","image_sequence_03.png","image_sequence_04.png"];
- * let textureArray = [];
- *
- * for (let i=0; i < 4; i++)
- * {
- *      let texture = PIXI.Texture.fromImage(alienImages[i]);
- *      textureArray.push(texture);
- * };
- *
- * let mc = new PIXI.AnimatedSprite(textureArray);
- * ```
- *
- * @class
- * @extends PIXI.Sprite
- * @memberof PIXI.extras
- */
-var AnimatedSprite = function (_core$Sprite) {
-    _inherits(AnimatedSprite, _core$Sprite);
-
-    /**
-     * @param {PIXI.Texture[]|FrameObject[]} textures - an array of {@link PIXI.Texture} or frame
-     *  objects that make up the animation
-     * @param {boolean} [autoUpdate=true] - Whether to use PIXI.ticker.shared to auto update animation time.
-     */
-    function AnimatedSprite(textures, autoUpdate) {
-        _classCallCheck(this, AnimatedSprite);
-
-        /**
-         * @private
-         */
-        var _this = _possibleConstructorReturn(this, _core$Sprite.call(this, textures[0] instanceof core.Texture ? textures[0] : textures[0].texture));
-
-        _this._textures = null;
-
-        /**
-         * @private
-         */
-        _this._durations = null;
-
-        _this.textures = textures;
-
-        /**
-         * `true` uses PIXI.ticker.shared to auto update animation time.
-         * @type {boolean}
-         * @default true
-         * @private
-         */
-        _this._autoUpdate = autoUpdate !== false;
-
-        /**
-         * The speed that the AnimatedSprite will play at. Higher is faster, lower is slower
-         *
-         * @member {number}
-         * @default 1
-         */
-        _this.animationSpeed = 1;
-
-        /**
-         * Whether or not the animate sprite repeats after playing.
-         *
-         * @member {boolean}
-         * @default true
-         */
-        _this.loop = true;
-
-        /**
-         * Function to call when a AnimatedSprite finishes playing
-         *
-         * @member {Function}
-         */
-        _this.onComplete = null;
-
-        /**
-         * Function to call when a AnimatedSprite changes which texture is being rendered
-         *
-         * @member {Function}
-         */
-        _this.onFrameChange = null;
-
-        /**
-        * Function to call when 'loop' is true, and an AnimatedSprite is played and loops around to start again
-        *
-        * @member {Function}
-        */
-        _this.onLoop = null;
-
-        /**
-         * Elapsed time since animation has been started, used internally to display current texture
-         *
-         * @member {number}
-         * @private
-         */
-        _this._currentTime = 0;
-
-        /**
-         * Indicates if the AnimatedSprite is currently playing
-         *
-         * @member {boolean}
-         * @readonly
-         */
-        _this.playing = false;
-        return _this;
-    }
-
-    /**
-     * Stops the AnimatedSprite
-     *
-     */
-
-
-    AnimatedSprite.prototype.stop = function stop() {
-        if (!this.playing) {
-            return;
-        }
-
-        this.playing = false;
-        if (this._autoUpdate) {
-            core.ticker.shared.remove(this.update, this);
-        }
-    };
-
-    /**
-     * Plays the AnimatedSprite
-     *
-     */
-
-
-    AnimatedSprite.prototype.play = function play() {
-        if (this.playing) {
-            return;
-        }
-
-        this.playing = true;
-        if (this._autoUpdate) {
-            core.ticker.shared.add(this.update, this, core.UPDATE_PRIORITY.HIGH);
-        }
-    };
-
-    /**
-     * Stops the AnimatedSprite and goes to a specific frame
-     *
-     * @param {number} frameNumber - frame index to stop at
-     */
-
-
-    AnimatedSprite.prototype.gotoAndStop = function gotoAndStop(frameNumber) {
-        this.stop();
-
-        var previousFrame = this.currentFrame;
-
-        this._currentTime = frameNumber;
-
-        if (previousFrame !== this.currentFrame) {
-            this.updateTexture();
-        }
-    };
-
-    /**
-     * Goes to a specific frame and begins playing the AnimatedSprite
-     *
-     * @param {number} frameNumber - frame index to start at
-     */
-
-
-    AnimatedSprite.prototype.gotoAndPlay = function gotoAndPlay(frameNumber) {
-        var previousFrame = this.currentFrame;
-
-        this._currentTime = frameNumber;
-
-        if (previousFrame !== this.currentFrame) {
-            this.updateTexture();
-        }
-
-        this.play();
-    };
-
-    /**
-     * Updates the object transform for rendering.
-     *
-     * @private
-     * @param {number} deltaTime - Time since last tick.
-     */
-
-
-    AnimatedSprite.prototype.update = function update(deltaTime) {
-        var elapsed = this.animationSpeed * deltaTime;
-        var previousFrame = this.currentFrame;
-
-        if (this._durations !== null) {
-            var lag = this._currentTime % 1 * this._durations[this.currentFrame];
-
-            lag += elapsed / 60 * 1000;
-
-            while (lag < 0) {
-                this._currentTime--;
-                lag += this._durations[this.currentFrame];
-            }
-
-            var sign = Math.sign(this.animationSpeed * deltaTime);
-
-            this._currentTime = Math.floor(this._currentTime);
-
-            while (lag >= this._durations[this.currentFrame]) {
-                lag -= this._durations[this.currentFrame] * sign;
-                this._currentTime += sign;
-            }
-
-            this._currentTime += lag / this._durations[this.currentFrame];
-        } else {
-            this._currentTime += elapsed;
-        }
-
-        if (this._currentTime < 0 && !this.loop) {
-            this.gotoAndStop(0);
-
-            if (this.onComplete) {
-                this.onComplete();
-            }
-        } else if (this._currentTime >= this._textures.length && !this.loop) {
-            this.gotoAndStop(this._textures.length - 1);
-
-            if (this.onComplete) {
-                this.onComplete();
-            }
-        } else if (previousFrame !== this.currentFrame) {
-            if (this.loop && this.onLoop) {
-                if (this.animationSpeed > 0 && this.currentFrame < previousFrame) {
-                    this.onLoop();
-                } else if (this.animationSpeed < 0 && this.currentFrame > previousFrame) {
-                    this.onLoop();
-                }
-            }
-
-            this.updateTexture();
-        }
-    };
-
-    /**
-     * Updates the displayed texture to match the current frame index
-     *
-     * @private
-     */
-
-
-    AnimatedSprite.prototype.updateTexture = function updateTexture() {
-        this._texture = this._textures[this.currentFrame];
-        this._textureID = -1;
-
-        if (this.onFrameChange) {
-            this.onFrameChange(this.currentFrame);
-        }
-    };
-
-    /**
-     * Stops the AnimatedSprite and destroys it
-     *
-     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-     *  have been set to that value
-     * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
-     *      method called as well. 'options' will be passed on to those calls.
-     * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well
-     * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well
-     */
-
-
-    AnimatedSprite.prototype.destroy = function destroy(options) {
-        this.stop();
-        _core$Sprite.prototype.destroy.call(this, options);
-    };
-
-    /**
-     * A short hand way of creating a movieclip from an array of frame ids
-     *
-     * @static
-     * @param {string[]} frames - The array of frames ids the movieclip will use as its texture frames
-     * @return {AnimatedSprite} The new animated sprite with the specified frames.
-     */
-
-
-    AnimatedSprite.fromFrames = function fromFrames(frames) {
-        var textures = [];
-
-        for (var i = 0; i < frames.length; ++i) {
-            textures.push(core.Texture.fromFrame(frames[i]));
-        }
-
-        return new AnimatedSprite(textures);
-    };
-
-    /**
-     * A short hand way of creating a movieclip from an array of image ids
-     *
-     * @static
-     * @param {string[]} images - the array of image urls the movieclip will use as its texture frames
-     * @return {AnimatedSprite} The new animate sprite with the specified images as frames.
-     */
-
-
-    AnimatedSprite.fromImages = function fromImages(images) {
-        var textures = [];
-
-        for (var i = 0; i < images.length; ++i) {
-            textures.push(core.Texture.fromImage(images[i]));
-        }
-
-        return new AnimatedSprite(textures);
-    };
-
-    /**
-     * totalFrames is the total number of frames in the AnimatedSprite. This is the same as number of textures
-     * assigned to the AnimatedSprite.
-     *
-     * @readonly
-     * @member {number}
-     * @default 0
-     */
-
-
-    _createClass(AnimatedSprite, [{
-        key: 'totalFrames',
-        get: function get() {
-            return this._textures.length;
-        }
-
-        /**
-         * The array of textures used for this AnimatedSprite
-         *
-         * @member {PIXI.Texture[]}
-         */
-
-    }, {
-        key: 'textures',
-        get: function get() {
-            return this._textures;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (value[0] instanceof core.Texture) {
-                this._textures = value;
-                this._durations = null;
-            } else {
-                this._textures = [];
-                this._durations = [];
-
-                for (var i = 0; i < value.length; i++) {
-                    this._textures.push(value[i].texture);
-                    this._durations.push(value[i].time);
-                }
-            }
-            this.gotoAndStop(0);
-            this.updateTexture();
-        }
-
-        /**
-        * The AnimatedSprites current frame index
-        *
-        * @member {number}
-        * @readonly
-        */
-
-    }, {
-        key: 'currentFrame',
-        get: function get() {
-            var currentFrame = Math.floor(this._currentTime) % this._textures.length;
-
-            if (currentFrame < 0) {
-                currentFrame += this._textures.length;
-            }
-
-            return currentFrame;
-        }
-    }]);
-
-    return AnimatedSprite;
-}(core.Sprite);
-
-exports.default = AnimatedSprite;
-
-},{"../core":65}],135:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _ObservablePoint = require('../core/math/ObservablePoint');
-
-var _ObservablePoint2 = _interopRequireDefault(_ObservablePoint);
-
-var _settings = require('../core/settings');
-
-var _settings2 = _interopRequireDefault(_settings);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * A BitmapText object will create a line or multiple lines of text using bitmap font. To
- * split a line you can use '\n', '\r' or '\r\n' in your string. You can generate the fnt files using:
- *
- * A BitmapText can only be created when the font is loaded
- *
- * ```js
- * // in this case the font is in a file called 'desyrel.fnt'
- * let bitmapText = new PIXI.extras.BitmapText("text using a fancy font!", {font: "35px Desyrel", align: "right"});
- * ```
- *
- * http://www.angelcode.com/products/bmfont/ for windows or
- * http://www.bmglyph.com/ for mac.
- *
- * @class
- * @extends PIXI.Container
- * @memberof PIXI.extras
- */
-var BitmapText = function (_core$Container) {
-    _inherits(BitmapText, _core$Container);
-
-    /**
-     * @param {string} text - The copy that you would like the text to display
-     * @param {object} style - The style parameters
-     * @param {string|object} style.font - The font descriptor for the object, can be passed as a string of form
-     *      "24px FontName" or "FontName" or as an object with explicit name/size properties.
-     * @param {string} [style.font.name] - The bitmap font id
-     * @param {number} [style.font.size] - The size of the font in pixels, e.g. 24
-     * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center' or 'right'), does not affect
-     *      single line text
-     * @param {number} [style.tint=0xFFFFFF] - The tint color
-     */
-    function BitmapText(text) {
-        var style = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-        _classCallCheck(this, BitmapText);
-
-        /**
-         * Private tracker for the width of the overall text
-         *
-         * @member {number}
-         * @private
-         */
-        var _this = _possibleConstructorReturn(this, _core$Container.call(this));
-
-        _this._textWidth = 0;
-
-        /**
-         * Private tracker for the height of the overall text
-         *
-         * @member {number}
-         * @private
-         */
-        _this._textHeight = 0;
-
-        /**
-         * Private tracker for the letter sprite pool.
-         *
-         * @member {PIXI.Sprite[]}
-         * @private
-         */
-        _this._glyphs = [];
-
-        /**
-         * Private tracker for the current style.
-         *
-         * @member {object}
-         * @private
-         */
-        _this._font = {
-            tint: style.tint !== undefined ? style.tint : 0xFFFFFF,
-            align: style.align || 'left',
-            name: null,
-            size: 0
-        };
-
-        /**
-         * Private tracker for the current font.
-         *
-         * @member {object}
-         * @private
-         */
-        _this.font = style.font; // run font setter
-
-        /**
-         * Private tracker for the current text.
-         *
-         * @member {string}
-         * @private
-         */
-        _this._text = text;
-
-        /**
-         * The max width of this bitmap text in pixels. If the text provided is longer than the
-         * value provided, line breaks will be automatically inserted in the last whitespace.
-         * Disable by setting value to 0
-         *
-         * @member {number}
-         * @private
-         */
-        _this._maxWidth = 0;
-
-        /**
-         * The max line height. This is useful when trying to use the total height of the Text,
-         * ie: when trying to vertically align.
-         *
-         * @member {number}
-         * @private
-         */
-        _this._maxLineHeight = 0;
-
-        /**
-         * Text anchor. read-only
-         *
-         * @member {PIXI.ObservablePoint}
-         * @private
-         */
-        _this._anchor = new _ObservablePoint2.default(function () {
-            _this.dirty = true;
-        }, _this, 0, 0);
-
-        /**
-         * The dirty state of this object.
-         *
-         * @member {boolean}
-         */
-        _this.dirty = false;
-
-        _this.updateText();
-        return _this;
-    }
-
-    /**
-     * Renders text and updates it when needed
-     *
-     * @private
-     */
-
-
-    BitmapText.prototype.updateText = function updateText() {
-        var data = BitmapText.fonts[this._font.name];
-        var scale = this._font.size / data.size;
-        var pos = new core.Point();
-        var chars = [];
-        var lineWidths = [];
-
-        var prevCharCode = null;
-        var lastLineWidth = 0;
-        var maxLineWidth = 0;
-        var line = 0;
-        var lastSpace = -1;
-        var lastSpaceWidth = 0;
-        var spacesRemoved = 0;
-        var maxLineHeight = 0;
-
-        for (var i = 0; i < this.text.length; i++) {
-            var charCode = this.text.charCodeAt(i);
-
-            if (/(\s)/.test(this.text.charAt(i))) {
-                lastSpace = i;
-                lastSpaceWidth = lastLineWidth;
-            }
-
-            if (/(?:\r\n|\r|\n)/.test(this.text.charAt(i))) {
-                lineWidths.push(lastLineWidth);
-                maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
-                line++;
-
-                pos.x = 0;
-                pos.y += data.lineHeight;
-                prevCharCode = null;
-                continue;
-            }
-
-            if (lastSpace !== -1 && this._maxWidth > 0 && pos.x * scale > this._maxWidth) {
-                core.utils.removeItems(chars, lastSpace - spacesRemoved, i - lastSpace);
-                i = lastSpace;
-                lastSpace = -1;
-                ++spacesRemoved;
-
-                lineWidths.push(lastSpaceWidth);
-                maxLineWidth = Math.max(maxLineWidth, lastSpaceWidth);
-                line++;
-
-                pos.x = 0;
-                pos.y += data.lineHeight;
-                prevCharCode = null;
-                continue;
-            }
-
-            var charData = data.chars[charCode];
-
-            if (!charData) {
-                continue;
-            }
-
-            if (prevCharCode && charData.kerning[prevCharCode]) {
-                pos.x += charData.kerning[prevCharCode];
-            }
-
-            chars.push({
-                texture: charData.texture,
-                line: line,
-                charCode: charCode,
-                position: new core.Point(pos.x + charData.xOffset, pos.y + charData.yOffset)
-            });
-            lastLineWidth = pos.x + (charData.texture.width + charData.xOffset);
-            pos.x += charData.xAdvance;
-            maxLineHeight = Math.max(maxLineHeight, charData.yOffset + charData.texture.height);
-            prevCharCode = charCode;
-        }
-
-        lineWidths.push(lastLineWidth);
-        maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
-
-        var lineAlignOffsets = [];
-
-        for (var _i = 0; _i <= line; _i++) {
-            var alignOffset = 0;
-
-            if (this._font.align === 'right') {
-                alignOffset = maxLineWidth - lineWidths[_i];
-            } else if (this._font.align === 'center') {
-                alignOffset = (maxLineWidth - lineWidths[_i]) / 2;
-            }
-
-            lineAlignOffsets.push(alignOffset);
-        }
-
-        var lenChars = chars.length;
-        var tint = this.tint;
-
-        for (var _i2 = 0; _i2 < lenChars; _i2++) {
-            var c = this._glyphs[_i2]; // get the next glyph sprite
-
-            if (c) {
-                c.texture = chars[_i2].texture;
-            } else {
-                c = new core.Sprite(chars[_i2].texture);
-                this._glyphs.push(c);
-            }
-
-            c.position.x = (chars[_i2].position.x + lineAlignOffsets[chars[_i2].line]) * scale;
-            c.position.y = chars[_i2].position.y * scale;
-            c.scale.x = c.scale.y = scale;
-            c.tint = tint;
-
-            if (!c.parent) {
-                this.addChild(c);
-            }
-        }
-
-        // remove unnecessary children.
-        for (var _i3 = lenChars; _i3 < this._glyphs.length; ++_i3) {
-            this.removeChild(this._glyphs[_i3]);
-        }
-
-        this._textWidth = maxLineWidth * scale;
-        this._textHeight = (pos.y + data.lineHeight) * scale;
-
-        // apply anchor
-        if (this.anchor.x !== 0 || this.anchor.y !== 0) {
-            for (var _i4 = 0; _i4 < lenChars; _i4++) {
-                this._glyphs[_i4].x -= this._textWidth * this.anchor.x;
-                this._glyphs[_i4].y -= this._textHeight * this.anchor.y;
-            }
-        }
-        this._maxLineHeight = maxLineHeight * scale;
-    };
-
-    /**
-     * Updates the transform of this object
-     *
-     * @private
-     */
-
-
-    BitmapText.prototype.updateTransform = function updateTransform() {
-        this.validate();
-        this.containerUpdateTransform();
-    };
-
-    /**
-     * Validates text before calling parent's getLocalBounds
-     *
-     * @return {PIXI.Rectangle} The rectangular bounding area
-     */
-
-
-    BitmapText.prototype.getLocalBounds = function getLocalBounds() {
-        this.validate();
-
-        return _core$Container.prototype.getLocalBounds.call(this);
-    };
-
-    /**
-     * Updates text when needed
-     *
-     * @private
-     */
-
-
-    BitmapText.prototype.validate = function validate() {
-        if (this.dirty) {
-            this.updateText();
-            this.dirty = false;
-        }
-    };
-
-    /**
-     * The tint of the BitmapText object
-     *
-     * @member {number}
-     */
-
-
-    /**
-     * Register a bitmap font with data and a texture.
-     *
-     * @static
-     * @param {XMLDocument} xml - The XML document data.
-     * @param {PIXI.Texture} texture - Texture with all symbols.
-     * @return {Object} Result font object with font, size, lineHeight and char fields.
-     */
-    BitmapText.registerFont = function registerFont(xml, texture) {
-        var data = {};
-        var info = xml.getElementsByTagName('info')[0];
-        var common = xml.getElementsByTagName('common')[0];
-        var res = texture.baseTexture.resolution || _settings2.default.RESOLUTION;
-
-        data.font = info.getAttribute('face');
-        data.size = parseInt(info.getAttribute('size'), 10);
-        data.lineHeight = parseInt(common.getAttribute('lineHeight'), 10) / res;
-        data.chars = {};
-
-        // parse letters
-        var letters = xml.getElementsByTagName('char');
-
-        for (var i = 0; i < letters.length; i++) {
-            var letter = letters[i];
-            var charCode = parseInt(letter.getAttribute('id'), 10);
-
-            var textureRect = new core.Rectangle(parseInt(letter.getAttribute('x'), 10) / res + texture.frame.x / res, parseInt(letter.getAttribute('y'), 10) / res + texture.frame.y / res, parseInt(letter.getAttribute('width'), 10) / res, parseInt(letter.getAttribute('height'), 10) / res);
-
-            data.chars[charCode] = {
-                xOffset: parseInt(letter.getAttribute('xoffset'), 10) / res,
-                yOffset: parseInt(letter.getAttribute('yoffset'), 10) / res,
-                xAdvance: parseInt(letter.getAttribute('xadvance'), 10) / res,
-                kerning: {},
-                texture: new core.Texture(texture.baseTexture, textureRect)
-
-            };
-        }
-
-        // parse kernings
-        var kernings = xml.getElementsByTagName('kerning');
-
-        for (var _i5 = 0; _i5 < kernings.length; _i5++) {
-            var kerning = kernings[_i5];
-            var first = parseInt(kerning.getAttribute('first'), 10) / res;
-            var second = parseInt(kerning.getAttribute('second'), 10) / res;
-            var amount = parseInt(kerning.getAttribute('amount'), 10) / res;
-
-            if (data.chars[second]) {
-                data.chars[second].kerning[first] = amount;
-            }
-        }
-
-        // I'm leaving this as a temporary fix so we can test the bitmap fonts in v3
-        // but it's very likely to change
-        BitmapText.fonts[data.font] = data;
-
-        return data;
-    };
-
-    _createClass(BitmapText, [{
-        key: 'tint',
-        get: function get() {
-            return this._font.tint;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._font.tint = typeof value === 'number' && value >= 0 ? value : 0xFFFFFF;
-
-            this.dirty = true;
-        }
-
-        /**
-         * The alignment of the BitmapText object
-         *
-         * @member {string}
-         * @default 'left'
-         */
-
-    }, {
-        key: 'align',
-        get: function get() {
-            return this._font.align;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._font.align = value || 'left';
-
-            this.dirty = true;
-        }
-
-        /**
-         * The anchor sets the origin point of the text.
-         * The default is 0,0 this means the text's origin is the top left
-         * Setting the anchor to 0.5,0.5 means the text's origin is centered
-         * Setting the anchor to 1,1 would mean the text's origin point will be the bottom right corner
-         *
-         * @member {PIXI.Point | number}
-         */
-
-    }, {
-        key: 'anchor',
-        get: function get() {
-            return this._anchor;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (typeof value === 'number') {
-                this._anchor.set(value);
-            } else {
-                this._anchor.copy(value);
-            }
-        }
-
-        /**
-         * The font descriptor of the BitmapText object
-         *
-         * @member {string|object}
-         */
-
-    }, {
-        key: 'font',
-        get: function get() {
-            return this._font;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (!value) {
-                return;
-            }
-
-            if (typeof value === 'string') {
-                value = value.split(' ');
-
-                this._font.name = value.length === 1 ? value[0] : value.slice(1).join(' ');
-                this._font.size = value.length >= 2 ? parseInt(value[0], 10) : BitmapText.fonts[this._font.name].size;
-            } else {
-                this._font.name = value.name;
-                this._font.size = typeof value.size === 'number' ? value.size : parseInt(value.size, 10);
-            }
-
-            this.dirty = true;
-        }
-
-        /**
-         * The text of the BitmapText object
-         *
-         * @member {string}
-         */
-
-    }, {
-        key: 'text',
-        get: function get() {
-            return this._text;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            value = value.toString() || ' ';
-            if (this._text === value) {
-                return;
-            }
-            this._text = value;
-            this.dirty = true;
-        }
-
-        /**
-         * The max width of this bitmap text in pixels. If the text provided is longer than the
-         * value provided, line breaks will be automatically inserted in the last whitespace.
-         * Disable by setting value to 0
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'maxWidth',
-        get: function get() {
-            return this._maxWidth;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            if (this._maxWidth === value) {
-                return;
-            }
-            this._maxWidth = value;
-            this.dirty = true;
-        }
-
-        /**
-         * The max line height. This is useful when trying to use the total height of the Text,
-         * ie: when trying to vertically align.
-         *
-         * @member {number}
-         * @readonly
-         */
-
-    }, {
-        key: 'maxLineHeight',
-        get: function get() {
-            this.validate();
-
-            return this._maxLineHeight;
-        }
-
-        /**
-         * The width of the overall text, different from fontSize,
-         * which is defined in the style object
-         *
-         * @member {number}
-         * @readonly
-         */
-
-    }, {
-        key: 'textWidth',
-        get: function get() {
-            this.validate();
-
-            return this._textWidth;
-        }
-
-        /**
-         * The height of the overall text, different from fontSize,
-         * which is defined in the style object
-         *
-         * @member {number}
-         * @readonly
-         */
-
-    }, {
-        key: 'textHeight',
-        get: function get() {
-            this.validate();
-
-            return this._textHeight;
-        }
-    }]);
-
-    return BitmapText;
-}(core.Container);
-
-exports.default = BitmapText;
-
-
-BitmapText.fonts = {};
-
-},{"../core":65,"../core/math/ObservablePoint":68,"../core/settings":101}],136:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _Matrix = require('../core/math/Matrix');
-
-var _Matrix2 = _interopRequireDefault(_Matrix);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var tempMat = new _Matrix2.default();
-
-/**
- * class controls uv transform and frame clamp for texture
- *
- * @class
- * @memberof PIXI.extras
- */
-
-var TextureTransform = function () {
-    /**
-     *
-     * @param {PIXI.Texture} texture observed texture
-     * @param {number} [clampMargin] Changes frame clamping, 0.5 by default. Use -0.5 for extra border.
-     * @constructor
-     */
-    function TextureTransform(texture, clampMargin) {
-        _classCallCheck(this, TextureTransform);
-
-        this._texture = texture;
-
-        this.mapCoord = new _Matrix2.default();
-
-        this.uClampFrame = new Float32Array(4);
-
-        this.uClampOffset = new Float32Array(2);
-
-        this._lastTextureID = -1;
-
-        /**
-         * Changes frame clamping
-         * Works with TilingSprite and Mesh
-         * Change to 1.5 if you texture has repeated right and bottom lines, that leads to smoother borders
-         *
-         * @default 0
-         * @member {number}
-         */
-        this.clampOffset = 0;
-
-        /**
-         * Changes frame clamping
-         * Works with TilingSprite and Mesh
-         * Change to -0.5 to add a pixel to the edge, recommended for transparent trimmed textures in atlas
-         *
-         * @default 0.5
-         * @member {number}
-         */
-        this.clampMargin = typeof clampMargin === 'undefined' ? 0.5 : clampMargin;
-    }
-
-    /**
-     * texture property
-     * @member {PIXI.Texture}
-     */
-
-
-    /**
-     * Multiplies uvs array to transform
-     * @param {Float32Array} uvs mesh uvs
-     * @param {Float32Array} [out=uvs] output
-     * @returns {Float32Array} output
-     */
-    TextureTransform.prototype.multiplyUvs = function multiplyUvs(uvs, out) {
-        if (out === undefined) {
-            out = uvs;
-        }
-
-        var mat = this.mapCoord;
-
-        for (var i = 0; i < uvs.length; i += 2) {
-            var x = uvs[i];
-            var y = uvs[i + 1];
-
-            out[i] = x * mat.a + y * mat.c + mat.tx;
-            out[i + 1] = x * mat.b + y * mat.d + mat.ty;
-        }
-
-        return out;
-    };
-
-    /**
-     * updates matrices if texture was changed
-     * @param {boolean} forceUpdate if true, matrices will be updated any case
-     * @returns {boolean} whether or not it was updated
-     */
-
-
-    TextureTransform.prototype.update = function update(forceUpdate) {
-        var tex = this._texture;
-
-        if (!tex || !tex.valid) {
-            return false;
-        }
-
-        if (!forceUpdate && this._lastTextureID === tex._updateID) {
-            return false;
-        }
-
-        this._lastTextureID = tex._updateID;
-
-        var uvs = tex._uvs;
-
-        this.mapCoord.set(uvs.x1 - uvs.x0, uvs.y1 - uvs.y0, uvs.x3 - uvs.x0, uvs.y3 - uvs.y0, uvs.x0, uvs.y0);
-
-        var orig = tex.orig;
-        var trim = tex.trim;
-
-        if (trim) {
-            tempMat.set(orig.width / trim.width, 0, 0, orig.height / trim.height, -trim.x / trim.width, -trim.y / trim.height);
-            this.mapCoord.append(tempMat);
-        }
-
-        var texBase = tex.baseTexture;
-        var frame = this.uClampFrame;
-        var margin = this.clampMargin / texBase.resolution;
-        var offset = this.clampOffset;
-
-        frame[0] = (tex._frame.x + margin + offset) / texBase.width;
-        frame[1] = (tex._frame.y + margin + offset) / texBase.height;
-        frame[2] = (tex._frame.x + tex._frame.width - margin + offset) / texBase.width;
-        frame[3] = (tex._frame.y + tex._frame.height - margin + offset) / texBase.height;
-        this.uClampOffset[0] = offset / texBase.realWidth;
-        this.uClampOffset[1] = offset / texBase.realHeight;
-
-        return true;
-    };
-
-    _createClass(TextureTransform, [{
-        key: 'texture',
-        get: function get() {
-            return this._texture;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._texture = value;
-            this._lastTextureID = -1;
-        }
-    }]);
-
-    return TextureTransform;
-}();
-
-exports.default = TextureTransform;
-
-},{"../core/math/Matrix":67}],137:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _CanvasTinter = require('../core/sprites/canvas/CanvasTinter');
-
-var _CanvasTinter2 = _interopRequireDefault(_CanvasTinter);
-
-var _TextureTransform = require('./TextureTransform');
-
-var _TextureTransform2 = _interopRequireDefault(_TextureTransform);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var tempPoint = new core.Point();
-
-/**
- * A tiling sprite is a fast way of rendering a tiling image
- *
- * @class
- * @extends PIXI.Sprite
- * @memberof PIXI.extras
- */
-
-var TilingSprite = function (_core$Sprite) {
-    _inherits(TilingSprite, _core$Sprite);
-
-    /**
-     * @param {PIXI.Texture} texture - the texture of the tiling sprite
-     * @param {number} [width=100] - the width of the tiling sprite
-     * @param {number} [height=100] - the height of the tiling sprite
-     */
-    function TilingSprite(texture) {
-        var width = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
-        var height = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
-
-        _classCallCheck(this, TilingSprite);
-
-        /**
-         * Tile transform
-         *
-         * @member {PIXI.TransformStatic}
-         */
-        var _this = _possibleConstructorReturn(this, _core$Sprite.call(this, texture));
-
-        _this.tileTransform = new core.TransformStatic();
-
-        // /// private
-
-        /**
-         * The with of the tiling sprite
-         *
-         * @member {number}
-         * @private
-         */
-        _this._width = width;
-
-        /**
-         * The height of the tiling sprite
-         *
-         * @member {number}
-         * @private
-         */
-        _this._height = height;
-
-        /**
-         * Canvas pattern
-         *
-         * @type {CanvasPattern}
-         * @private
-         */
-        _this._canvasPattern = null;
-
-        /**
-         * transform that is applied to UV to get the texture coords
-         *
-         * @member {PIXI.extras.TextureTransform}
-         */
-        _this.uvTransform = texture.transform || new _TextureTransform2.default(texture);
-
-        /**
-         * Plugin that is responsible for rendering this element.
-         * Allows to customize the rendering process without overriding '_renderWebGL' method.
-         *
-         * @member {string}
-         * @default 'tilingSprite'
-         */
-        _this.pluginName = 'tilingSprite';
-
-        /**
-         * Whether or not anchor affects uvs
-         *
-         * @member {boolean}
-         * @default false
-         */
-        _this.uvRespectAnchor = false;
-        return _this;
-    }
-    /**
-     * Changes frame clamping in corresponding textureTransform, shortcut
-     * Change to -0.5 to add a pixel to the edge, recommended for transparent trimmed textures in atlas
-     *
-     * @default 0.5
-     * @member {number}
-     */
-
-
-    /**
-     * @private
-     */
-    TilingSprite.prototype._onTextureUpdate = function _onTextureUpdate() {
-        if (this.uvTransform) {
-            this.uvTransform.texture = this._texture;
-        }
-    };
-
-    /**
-     * Renders the object using the WebGL renderer
-     *
-     * @private
-     * @param {PIXI.WebGLRenderer} renderer - The renderer
-     */
-
-
-    TilingSprite.prototype._renderWebGL = function _renderWebGL(renderer) {
-        // tweak our texture temporarily..
-        var texture = this._texture;
-
-        if (!texture || !texture.valid) {
-            return;
-        }
-
-        this.tileTransform.updateLocalTransform();
-        this.uvTransform.update();
-
-        renderer.setObjectRenderer(renderer.plugins[this.pluginName]);
-        renderer.plugins[this.pluginName].render(this);
-    };
-
-    /**
-     * Renders the object using the Canvas renderer
-     *
-     * @private
-     * @param {PIXI.CanvasRenderer} renderer - a reference to the canvas renderer
-     */
-
-
-    TilingSprite.prototype._renderCanvas = function _renderCanvas(renderer) {
-        var texture = this._texture;
-
-        if (!texture.baseTexture.hasLoaded) {
-            return;
-        }
-
-        var context = renderer.context;
-        var transform = this.worldTransform;
-        var resolution = renderer.resolution;
-        var baseTexture = texture.baseTexture;
-        var baseTextureResolution = baseTexture.resolution;
-        var modX = this.tilePosition.x / this.tileScale.x % texture._frame.width * baseTextureResolution;
-        var modY = this.tilePosition.y / this.tileScale.y % texture._frame.height * baseTextureResolution;
-
-        // create a nice shiny pattern!
-        // TODO this needs to be refreshed if texture changes..
-        if (!this._canvasPattern) {
-            // cut an object from a spritesheet..
-            var tempCanvas = new core.CanvasRenderTarget(texture._frame.width, texture._frame.height, baseTextureResolution);
-
-            // Tint the tiling sprite
-            if (this.tint !== 0xFFFFFF) {
-                if (this.cachedTint !== this.tint) {
-                    this.cachedTint = this.tint;
-
-                    this.tintedTexture = _CanvasTinter2.default.getTintedTexture(this, this.tint);
-                }
-                tempCanvas.context.drawImage(this.tintedTexture, 0, 0);
-            } else {
-                tempCanvas.context.drawImage(baseTexture.source, -texture._frame.x * baseTextureResolution, -texture._frame.y * baseTextureResolution);
-            }
-            this._canvasPattern = tempCanvas.context.createPattern(tempCanvas.canvas, 'repeat');
-        }
-
-        // set context state..
-        context.globalAlpha = this.worldAlpha;
-        context.setTransform(transform.a * resolution, transform.b * resolution, transform.c * resolution, transform.d * resolution, transform.tx * resolution, transform.ty * resolution);
-
-        renderer.setBlendMode(this.blendMode);
-
-        // fill the pattern!
-        context.fillStyle = this._canvasPattern;
-
-        // TODO - this should be rolled into the setTransform above..
-        context.scale(this.tileScale.x / baseTextureResolution, this.tileScale.y / baseTextureResolution);
-
-        var anchorX = this.anchor.x * -this._width;
-        var anchorY = this.anchor.y * -this._height;
-
-        if (this.uvRespectAnchor) {
-            context.translate(modX, modY);
-
-            context.fillRect(-modX + anchorX, -modY + anchorY, this._width / this.tileScale.x * baseTextureResolution, this._height / this.tileScale.y * baseTextureResolution);
-        } else {
-            context.translate(modX + anchorX, modY + anchorY);
-
-            context.fillRect(-modX, -modY, this._width / this.tileScale.x * baseTextureResolution, this._height / this.tileScale.y * baseTextureResolution);
-        }
-    };
-
-    /**
-     * Updates the bounds of the tiling sprite.
-     *
-     * @private
-     */
-
-
-    TilingSprite.prototype._calculateBounds = function _calculateBounds() {
-        var minX = this._width * -this._anchor._x;
-        var minY = this._height * -this._anchor._y;
-        var maxX = this._width * (1 - this._anchor._x);
-        var maxY = this._height * (1 - this._anchor._y);
-
-        this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);
-    };
-
-    /**
-     * Gets the local bounds of the sprite object.
-     *
-     * @param {PIXI.Rectangle} rect - The output rectangle.
-     * @return {PIXI.Rectangle} The bounds.
-     */
-
-
-    TilingSprite.prototype.getLocalBounds = function getLocalBounds(rect) {
-        // we can do a fast local bounds if the sprite has no children!
-        if (this.children.length === 0) {
-            this._bounds.minX = this._width * -this._anchor._x;
-            this._bounds.minY = this._height * -this._anchor._y;
-            this._bounds.maxX = this._width * (1 - this._anchor._x);
-            this._bounds.maxY = this._height * (1 - this._anchor._x);
-
-            if (!rect) {
-                if (!this._localBoundsRect) {
-                    this._localBoundsRect = new core.Rectangle();
-                }
-
-                rect = this._localBoundsRect;
-            }
-
-            return this._bounds.getRectangle(rect);
-        }
-
-        return _core$Sprite.prototype.getLocalBounds.call(this, rect);
-    };
-
-    /**
-     * Checks if a point is inside this tiling sprite.
-     *
-     * @param {PIXI.Point} point - the point to check
-     * @return {boolean} Whether or not the sprite contains the point.
-     */
-
-
-    TilingSprite.prototype.containsPoint = function containsPoint(point) {
-        this.worldTransform.applyInverse(point, tempPoint);
-
-        var width = this._width;
-        var height = this._height;
-        var x1 = -width * this.anchor._x;
-
-        if (tempPoint.x >= x1 && tempPoint.x < x1 + width) {
-            var y1 = -height * this.anchor._y;
-
-            if (tempPoint.y >= y1 && tempPoint.y < y1 + height) {
-                return true;
-            }
-        }
-
-        return false;
-    };
-
-    /**
-     * Destroys this sprite and optionally its texture and children
-     *
-     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-     *  have been set to that value
-     * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
-     *      method called as well. 'options' will be passed on to those calls.
-     * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well
-     * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well
-     */
-
-
-    TilingSprite.prototype.destroy = function destroy(options) {
-        _core$Sprite.prototype.destroy.call(this, options);
-
-        this.tileTransform = null;
-        this.uvTransform = null;
-    };
-
-    /**
-     * Helper function that creates a new tiling sprite based on the source you provide.
-     * The source can be - frame id, image url, video url, canvas element, video element, base texture
-     *
-     * @static
-     * @param {number|string|PIXI.BaseTexture|HTMLCanvasElement|HTMLVideoElement} source - Source to create texture from
-     * @param {number} width - the width of the tiling sprite
-     * @param {number} height - the height of the tiling sprite
-     * @return {PIXI.Texture} The newly created texture
-     */
-
-
-    TilingSprite.from = function from(source, width, height) {
-        return new TilingSprite(core.Texture.from(source), width, height);
-    };
-
-    /**
-     * Helper function that creates a tiling sprite that will use a texture from the TextureCache based on the frameId
-     * The frame ids are created when a Texture packer file has been loaded
-     *
-     * @static
-     * @param {string} frameId - The frame Id of the texture in the cache
-     * @param {number} width - the width of the tiling sprite
-     * @param {number} height - the height of the tiling sprite
-     * @return {PIXI.extras.TilingSprite} A new TilingSprite using a texture from the texture cache matching the frameId
-     */
-
-
-    TilingSprite.fromFrame = function fromFrame(frameId, width, height) {
-        var texture = core.utils.TextureCache[frameId];
-
-        if (!texture) {
-            throw new Error('The frameId "' + frameId + '" does not exist in the texture cache ' + this);
-        }
-
-        return new TilingSprite(texture, width, height);
-    };
-
-    /**
-     * Helper function that creates a sprite that will contain a texture based on an image url
-     * If the image is not in the texture cache it will be loaded
-     *
-     * @static
-     * @param {string} imageId - The image url of the texture
-     * @param {number} width - the width of the tiling sprite
-     * @param {number} height - the height of the tiling sprite
-     * @param {boolean} [crossorigin] - if you want to specify the cross-origin parameter
-     * @param {number} [scaleMode=PIXI.settings.SCALE_MODE] - if you want to specify the scale mode,
-     *  see {@link PIXI.SCALE_MODES} for possible values
-     * @return {PIXI.extras.TilingSprite} A new TilingSprite using a texture from the texture cache matching the image id
-     */
-
-
-    TilingSprite.fromImage = function fromImage(imageId, width, height, crossorigin, scaleMode) {
-        return new TilingSprite(core.Texture.fromImage(imageId, crossorigin, scaleMode), width, height);
-    };
-
-    /**
-     * The width of the sprite, setting this will actually modify the scale to achieve the value set
-     *
-     * @member {number}
-     */
-
-
-    _createClass(TilingSprite, [{
-        key: 'clampMargin',
-        get: function get() {
-            return this.uvTransform.clampMargin;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.uvTransform.clampMargin = value;
-            this.uvTransform.update(true);
-        }
-
-        /**
-         * The scaling of the image that is being tiled
-         *
-         * @member {PIXI.ObservablePoint}
-         */
-
-    }, {
-        key: 'tileScale',
-        get: function get() {
-            return this.tileTransform.scale;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.tileTransform.scale.copy(value);
-        }
-
-        /**
-         * The offset of the image that is being tiled
-         *
-         * @member {PIXI.ObservablePoint}
-         */
-
-    }, {
-        key: 'tilePosition',
-        get: function get() {
-            return this.tileTransform.position;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.tileTransform.position.copy(value);
-        }
-    }, {
-        key: 'width',
-        get: function get() {
-            return this._width;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._width = value;
-        }
-
-        /**
-         * The height of the TilingSprite, setting this will actually modify the scale to achieve the value set
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'height',
-        get: function get() {
-            return this._height;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._height = value;
-        }
-    }]);
-
-    return TilingSprite;
-}(core.Sprite);
-
-exports.default = TilingSprite;
-
-},{"../core":65,"../core/sprites/canvas/CanvasTinter":104,"./TextureTransform":136}],138:[function(require,module,exports){
-'use strict';
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _Texture = require('../core/textures/Texture');
-
-var _Texture2 = _interopRequireDefault(_Texture);
-
-var _BaseTexture = require('../core/textures/BaseTexture');
-
-var _BaseTexture2 = _interopRequireDefault(_BaseTexture);
-
-var _utils = require('../core/utils');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var DisplayObject = core.DisplayObject;
-var _tempMatrix = new core.Matrix();
-
-DisplayObject.prototype._cacheAsBitmap = false;
-DisplayObject.prototype._cacheData = false;
-
-// figured theres no point adding ALL the extra variables to prototype.
-// this model can hold the information needed. This can also be generated on demand as
-// most objects are not cached as bitmaps.
-/**
- * @class
- * @ignore
- */
-
-var CacheData =
-/**
- *
- */
-function CacheData() {
-    _classCallCheck(this, CacheData);
-
-    this.textureCacheId = null;
-
-    this.originalRenderWebGL = null;
-    this.originalRenderCanvas = null;
-    this.originalCalculateBounds = null;
-    this.originalGetLocalBounds = null;
-
-    this.originalUpdateTransform = null;
-    this.originalHitTest = null;
-    this.originalDestroy = null;
-    this.originalMask = null;
-    this.originalFilterArea = null;
-    this.sprite = null;
-};
-
-Object.defineProperties(DisplayObject.prototype, {
-    /**
-     * Set this to true if you want this display object to be cached as a bitmap.
-     * This basically takes a snap shot of the display object as it is at that moment. It can
-     * provide a performance benefit for complex static displayObjects.
-     * To remove simply set this property to 'false'
-     *
-     * IMPORTANT GOTCHA - make sure that all your textures are preloaded BEFORE setting this property to true
-     * as it will take a snapshot of what is currently there. If the textures have not loaded then they will not appear.
-     *
-     * @member {boolean}
-     * @memberof PIXI.DisplayObject#
-     */
-    cacheAsBitmap: {
-        get: function get() {
-            return this._cacheAsBitmap;
-        },
-        set: function set(value) {
-            if (this._cacheAsBitmap === value) {
-                return;
-            }
-
-            this._cacheAsBitmap = value;
-
-            var data = void 0;
-
-            if (value) {
-                if (!this._cacheData) {
-                    this._cacheData = new CacheData();
-                }
-
-                data = this._cacheData;
-
-                data.originalRenderWebGL = this.renderWebGL;
-                data.originalRenderCanvas = this.renderCanvas;
-
-                data.originalUpdateTransform = this.updateTransform;
-                data.originalCalculateBounds = this._calculateBounds;
-                data.originalGetLocalBounds = this.getLocalBounds;
-
-                data.originalDestroy = this.destroy;
-
-                data.originalContainsPoint = this.containsPoint;
-
-                data.originalMask = this._mask;
-                data.originalFilterArea = this.filterArea;
-
-                this.renderWebGL = this._renderCachedWebGL;
-                this.renderCanvas = this._renderCachedCanvas;
-
-                this.destroy = this._cacheAsBitmapDestroy;
-            } else {
-                data = this._cacheData;
-
-                if (data.sprite) {
-                    this._destroyCachedDisplayObject();
-                }
-
-                this.renderWebGL = data.originalRenderWebGL;
-                this.renderCanvas = data.originalRenderCanvas;
-                this._calculateBounds = data.originalCalculateBounds;
-                this.getLocalBounds = data.originalGetLocalBounds;
-
-                this.destroy = data.originalDestroy;
-
-                this.updateTransform = data.originalUpdateTransform;
-                this.containsPoint = data.originalContainsPoint;
-
-                this._mask = data.originalMask;
-                this.filterArea = data.originalFilterArea;
-            }
-        }
-    }
-});
-
-/**
- * Renders a cached version of the sprite with WebGL
- *
- * @private
- * @memberof PIXI.DisplayObject#
- * @param {PIXI.WebGLRenderer} renderer - the WebGL renderer
- */
-DisplayObject.prototype._renderCachedWebGL = function _renderCachedWebGL(renderer) {
-    if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
-        return;
-    }
-
-    this._initCachedDisplayObject(renderer);
-
-    this._cacheData.sprite._transformID = -1;
-    this._cacheData.sprite.worldAlpha = this.worldAlpha;
-    this._cacheData.sprite._renderWebGL(renderer);
-};
-
-/**
- * Prepares the WebGL renderer to cache the sprite
- *
- * @private
- * @memberof PIXI.DisplayObject#
- * @param {PIXI.WebGLRenderer} renderer - the WebGL renderer
- */
-DisplayObject.prototype._initCachedDisplayObject = function _initCachedDisplayObject(renderer) {
-    if (this._cacheData && this._cacheData.sprite) {
-        return;
-    }
-
-    // make sure alpha is set to 1 otherwise it will get rendered as invisible!
-    var cacheAlpha = this.alpha;
-
-    this.alpha = 1;
-
-    // first we flush anything left in the renderer (otherwise it would get rendered to the cached texture)
-    renderer.currentRenderer.flush();
-    // this.filters= [];
-
-    // next we find the dimensions of the untransformed object
-    // this function also calls updatetransform on all its children as part of the measuring.
-    // This means we don't need to update the transform again in this function
-    // TODO pass an object to clone too? saves having to create a new one each time!
-    var bounds = this.getLocalBounds().clone();
-
-    // add some padding!
-    if (this._filters) {
-        var padding = this._filters[0].padding;
-
-        bounds.pad(padding);
-    }
-
-    // for now we cache the current renderTarget that the webGL renderer is currently using.
-    // this could be more elegent..
-    var cachedRenderTarget = renderer._activeRenderTarget;
-    // We also store the filter stack - I will definitely look to change how this works a little later down the line.
-    var stack = renderer.filterManager.filterStack;
-
-    // this renderTexture will be used to store the cached DisplayObject
-
-    var renderTexture = core.RenderTexture.create(bounds.width | 0, bounds.height | 0);
-
-    var textureCacheId = 'cacheAsBitmap_' + (0, _utils.uid)();
-
-    this._cacheData.textureCacheId = textureCacheId;
-
-    _BaseTexture2.default.addToCache(renderTexture.baseTexture, textureCacheId);
-    _Texture2.default.addToCache(renderTexture, textureCacheId);
-
-    // need to set //
-    var m = _tempMatrix;
-
-    m.tx = -bounds.x;
-    m.ty = -bounds.y;
-
-    // reset
-    this.transform.worldTransform.identity();
-
-    // set all properties to there original so we can render to a texture
-    this.renderWebGL = this._cacheData.originalRenderWebGL;
-
-    renderer.render(this, renderTexture, true, m, true);
-    // now restore the state be setting the new properties
-
-    renderer.bindRenderTarget(cachedRenderTarget);
-
-    renderer.filterManager.filterStack = stack;
-
-    this.renderWebGL = this._renderCachedWebGL;
-    this.updateTransform = this.displayObjectUpdateTransform;
-
-    this._mask = null;
-    this.filterArea = null;
-
-    // create our cached sprite
-    var cachedSprite = new core.Sprite(renderTexture);
-
-    cachedSprite.transform.worldTransform = this.transform.worldTransform;
-    cachedSprite.anchor.x = -(bounds.x / bounds.width);
-    cachedSprite.anchor.y = -(bounds.y / bounds.height);
-    cachedSprite.alpha = cacheAlpha;
-    cachedSprite._bounds = this._bounds;
-
-    // easy bounds..
-    this._calculateBounds = this._calculateCachedBounds;
-    this.getLocalBounds = this._getCachedLocalBounds;
-
-    this._cacheData.sprite = cachedSprite;
-
-    this.transform._parentID = -1;
-    // restore the transform of the cached sprite to avoid the nasty flicker..
-    if (!this.parent) {
-        this.parent = renderer._tempDisplayObjectParent;
-        this.updateTransform();
-        this.parent = null;
-    } else {
-        this.updateTransform();
-    }
-
-    // map the hit test..
-    this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
-};
-
-/**
- * Renders a cached version of the sprite with canvas
- *
- * @private
- * @memberof PIXI.DisplayObject#
- * @param {PIXI.WebGLRenderer} renderer - the WebGL renderer
- */
-DisplayObject.prototype._renderCachedCanvas = function _renderCachedCanvas(renderer) {
-    if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
-        return;
-    }
-
-    this._initCachedDisplayObjectCanvas(renderer);
-
-    this._cacheData.sprite.worldAlpha = this.worldAlpha;
-
-    this._cacheData.sprite.renderCanvas(renderer);
-};
-
-// TODO this can be the same as the webGL verison.. will need to do a little tweaking first though..
-/**
- * Prepares the Canvas renderer to cache the sprite
- *
- * @private
- * @memberof PIXI.DisplayObject#
- * @param {PIXI.WebGLRenderer} renderer - the WebGL renderer
- */
-DisplayObject.prototype._initCachedDisplayObjectCanvas = function _initCachedDisplayObjectCanvas(renderer) {
-    if (this._cacheData && this._cacheData.sprite) {
-        return;
-    }
-
-    // get bounds actually transforms the object for us already!
-    var bounds = this.getLocalBounds();
-
-    var cacheAlpha = this.alpha;
-
-    this.alpha = 1;
-
-    var cachedRenderTarget = renderer.context;
-
-    var renderTexture = core.RenderTexture.create(bounds.width | 0, bounds.height | 0);
-
-    var textureCacheId = 'cacheAsBitmap_' + (0, _utils.uid)();
-
-    this._cacheData.textureCacheId = textureCacheId;
-
-    _BaseTexture2.default.addToCache(renderTexture.baseTexture, textureCacheId);
-    _Texture2.default.addToCache(renderTexture, textureCacheId);
-
-    // need to set //
-    var m = _tempMatrix;
-
-    this.transform.localTransform.copy(m);
-    m.invert();
-
-    m.tx -= bounds.x;
-    m.ty -= bounds.y;
-
-    // m.append(this.transform.worldTransform.)
-    // set all properties to there original so we can render to a texture
-    this.renderCanvas = this._cacheData.originalRenderCanvas;
-
-    // renderTexture.render(this, m, true);
-    renderer.render(this, renderTexture, true, m, false);
-
-    // now restore the state be setting the new properties
-    renderer.context = cachedRenderTarget;
-
-    this.renderCanvas = this._renderCachedCanvas;
-    this._calculateBounds = this._calculateCachedBounds;
-
-    this._mask = null;
-    this.filterArea = null;
-
-    // create our cached sprite
-    var cachedSprite = new core.Sprite(renderTexture);
-
-    cachedSprite.transform.worldTransform = this.transform.worldTransform;
-    cachedSprite.anchor.x = -(bounds.x / bounds.width);
-    cachedSprite.anchor.y = -(bounds.y / bounds.height);
-    cachedSprite._bounds = this._bounds;
-    cachedSprite.alpha = cacheAlpha;
-
-    if (!this.parent) {
-        this.parent = renderer._tempDisplayObjectParent;
-        this.updateTransform();
-        this.parent = null;
-    } else {
-        this.updateTransform();
-    }
-
-    this.updateTransform = this.displayObjectUpdateTransform;
-
-    this._cacheData.sprite = cachedSprite;
-
-    this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
-};
-
-/**
- * Calculates the bounds of the cached sprite
- *
- * @private
- */
-DisplayObject.prototype._calculateCachedBounds = function _calculateCachedBounds() {
-    this._cacheData.sprite._calculateBounds();
-};
-
-/**
- * Gets the bounds of the cached sprite.
- *
- * @private
- * @return {Rectangle} The local bounds.
- */
-DisplayObject.prototype._getCachedLocalBounds = function _getCachedLocalBounds() {
-    return this._cacheData.sprite.getLocalBounds();
-};
-
-/**
- * Destroys the cached sprite.
- *
- * @private
- */
-DisplayObject.prototype._destroyCachedDisplayObject = function _destroyCachedDisplayObject() {
-    this._cacheData.sprite._texture.destroy(true);
-    this._cacheData.sprite = null;
-
-    _BaseTexture2.default.removeFromCache(this._cacheData.textureCacheId);
-    _Texture2.default.removeFromCache(this._cacheData.textureCacheId);
-
-    this._cacheData.textureCacheId = null;
-};
-
-/**
- * Destroys the cached object.
- *
- * @private
- * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
- *  have been set to that value.
- *  Used when destroying containers, see the Container.destroy method.
- */
-DisplayObject.prototype._cacheAsBitmapDestroy = function _cacheAsBitmapDestroy(options) {
-    this.cacheAsBitmap = false;
-    this.destroy(options);
-};
-
-},{"../core":65,"../core/textures/BaseTexture":112,"../core/textures/Texture":115,"../core/utils":124}],139:[function(require,module,exports){
-'use strict';
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-/**
- * The instance name of the object.
- *
- * @memberof PIXI.DisplayObject#
- * @member {string}
- */
-core.DisplayObject.prototype.name = null;
-
-/**
- * Returns the display object in the container
- *
- * @memberof PIXI.Container#
- * @param {string} name - instance name
- * @return {PIXI.DisplayObject} The child with the specified name.
- */
-core.Container.prototype.getChildByName = function getChildByName(name) {
-    for (var i = 0; i < this.children.length; i++) {
-        if (this.children[i].name === name) {
-            return this.children[i];
-        }
-    }
-
-    return null;
-};
-
-},{"../core":65}],140:[function(require,module,exports){
-'use strict';
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-/**
- * Returns the global position of the displayObject. Does not depend on object scale, rotation and pivot.
- *
- * @memberof PIXI.DisplayObject#
- * @param {Point} point - the point to write the global value to. If null a new point will be returned
- * @param {boolean} skipUpdate - setting to true will stop the transforms of the scene graph from
- *  being updated. This means the calculation returned MAY be out of date BUT will give you a
- *  nice performance boost
- * @return {Point} The updated point
- */
-core.DisplayObject.prototype.getGlobalPosition = function getGlobalPosition() {
-    var point = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new core.Point();
-    var skipUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
-    if (this.parent) {
-        this.parent.toGlobal(this.position, point, skipUpdate);
-    } else {
-        point.x = this.position.x;
-        point.y = this.position.y;
-    }
-
-    return point;
-};
-
-},{"../core":65}],141:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.BitmapText = exports.TilingSpriteRenderer = exports.TilingSprite = exports.TextureTransform = exports.AnimatedSprite = undefined;
-
-var _AnimatedSprite = require('./AnimatedSprite');
-
-Object.defineProperty(exports, 'AnimatedSprite', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_AnimatedSprite).default;
-  }
-});
-
-var _TextureTransform = require('./TextureTransform');
-
-Object.defineProperty(exports, 'TextureTransform', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TextureTransform).default;
-  }
-});
-
-var _TilingSprite = require('./TilingSprite');
-
-Object.defineProperty(exports, 'TilingSprite', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TilingSprite).default;
-  }
-});
-
-var _TilingSpriteRenderer = require('./webgl/TilingSpriteRenderer');
-
-Object.defineProperty(exports, 'TilingSpriteRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TilingSpriteRenderer).default;
-  }
-});
-
-var _BitmapText = require('./BitmapText');
-
-Object.defineProperty(exports, 'BitmapText', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_BitmapText).default;
-  }
-});
-
-require('./cacheAsBitmap');
-
-require('./getChildByName');
-
-require('./getGlobalPosition');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// imported for side effect of extending the prototype only, contains no exports
-
-},{"./AnimatedSprite":134,"./BitmapText":135,"./TextureTransform":136,"./TilingSprite":137,"./cacheAsBitmap":138,"./getChildByName":139,"./getGlobalPosition":140,"./webgl/TilingSpriteRenderer":142}],142:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _const = require('../../core/const');
-
-var _path = require('path');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var tempMat = new core.Matrix();
-
-/**
- * WebGL renderer plugin for tiling sprites
- *
- * @class
- * @memberof PIXI.extras
- * @extends PIXI.ObjectRenderer
- */
-
-var TilingSpriteRenderer = function (_core$ObjectRenderer) {
-    _inherits(TilingSpriteRenderer, _core$ObjectRenderer);
-
-    /**
-     * constructor for renderer
-     *
-     * @param {WebGLRenderer} renderer The renderer this tiling awesomeness works for.
-     */
-    function TilingSpriteRenderer(renderer) {
-        _classCallCheck(this, TilingSpriteRenderer);
-
-        var _this = _possibleConstructorReturn(this, _core$ObjectRenderer.call(this, renderer));
-
-        _this.shader = null;
-        _this.simpleShader = null;
-        _this.quad = null;
-        return _this;
-    }
-
-    /**
-     * Sets up the renderer context and necessary buffers.
-     *
-     * @private
-     */
-
-
-    TilingSpriteRenderer.prototype.onContextChange = function onContextChange() {
-        var gl = this.renderer.gl;
-
-        this.shader = new core.Shader(gl, 'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n', 'varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\nuniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;\n\nvoid main(void)\n{\n    vec2 coord = mod(vTextureCoord - uClampOffset, vec2(1.0, 1.0)) + uClampOffset;\n    coord = (uMapCoord * vec3(coord, 1.0)).xy;\n    coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);\n\n    vec4 sample = texture2D(uSampler, coord);\n    gl_FragColor = sample * uColor;\n}\n');
-        this.simpleShader = new core.Shader(gl, 'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n', 'varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\n\nvoid main(void)\n{\n    vec4 sample = texture2D(uSampler, vTextureCoord);\n    gl_FragColor = sample * uColor;\n}\n');
-
-        this.renderer.bindVao(null);
-        this.quad = new core.Quad(gl, this.renderer.state.attribState);
-        this.quad.initVao(this.shader);
-    };
-
-    /**
-     *
-     * @param {PIXI.extras.TilingSprite} ts tilingSprite to be rendered
-     */
-
-
-    TilingSpriteRenderer.prototype.render = function render(ts) {
-        var renderer = this.renderer;
-        var quad = this.quad;
-
-        renderer.bindVao(quad.vao);
-
-        var vertices = quad.vertices;
-
-        vertices[0] = vertices[6] = ts._width * -ts.anchor.x;
-        vertices[1] = vertices[3] = ts._height * -ts.anchor.y;
-
-        vertices[2] = vertices[4] = ts._width * (1.0 - ts.anchor.x);
-        vertices[5] = vertices[7] = ts._height * (1.0 - ts.anchor.y);
-
-        if (ts.uvRespectAnchor) {
-            vertices = quad.uvs;
-
-            vertices[0] = vertices[6] = -ts.anchor.x;
-            vertices[1] = vertices[3] = -ts.anchor.y;
-
-            vertices[2] = vertices[4] = 1.0 - ts.anchor.x;
-            vertices[5] = vertices[7] = 1.0 - ts.anchor.y;
-        }
-
-        quad.upload();
-
-        var tex = ts._texture;
-        var baseTex = tex.baseTexture;
-        var lt = ts.tileTransform.localTransform;
-        var uv = ts.uvTransform;
-        var isSimple = baseTex.isPowerOfTwo && tex.frame.width === baseTex.width && tex.frame.height === baseTex.height;
-
-        // auto, force repeat wrapMode for big tiling textures
-        if (isSimple) {
-            if (!baseTex._glTextures[renderer.CONTEXT_UID]) {
-                if (baseTex.wrapMode === _const.WRAP_MODES.CLAMP) {
-                    baseTex.wrapMode = _const.WRAP_MODES.REPEAT;
-                }
-            } else {
-                isSimple = baseTex.wrapMode !== _const.WRAP_MODES.CLAMP;
-            }
-        }
-
-        var shader = isSimple ? this.simpleShader : this.shader;
-
-        renderer.bindShader(shader);
-
-        var w = tex.width;
-        var h = tex.height;
-        var W = ts._width;
-        var H = ts._height;
-
-        tempMat.set(lt.a * w / W, lt.b * w / H, lt.c * h / W, lt.d * h / H, lt.tx / W, lt.ty / H);
-
-        // that part is the same as above:
-        // tempMat.identity();
-        // tempMat.scale(tex.width, tex.height);
-        // tempMat.prepend(lt);
-        // tempMat.scale(1.0 / ts._width, 1.0 / ts._height);
-
-        tempMat.invert();
-        if (isSimple) {
-            tempMat.prepend(uv.mapCoord);
-        } else {
-            shader.uniforms.uMapCoord = uv.mapCoord.toArray(true);
-            shader.uniforms.uClampFrame = uv.uClampFrame;
-            shader.uniforms.uClampOffset = uv.uClampOffset;
-        }
-
-        shader.uniforms.uTransform = tempMat.toArray(true);
-        shader.uniforms.uColor = core.utils.premultiplyTintToRgba(ts.tint, ts.worldAlpha, shader.uniforms.uColor, baseTex.premultipliedAlpha);
-        shader.uniforms.translationMatrix = ts.transform.worldTransform.toArray(true);
-
-        shader.uniforms.uSampler = renderer.bindTexture(tex);
-
-        renderer.setBlendMode(core.utils.correctBlendMode(ts.blendMode, baseTex.premultipliedAlpha));
-
-        quad.vao.draw(this.renderer.gl.TRIANGLES, 6, 0);
-    };
-
-    return TilingSpriteRenderer;
-}(core.ObjectRenderer);
-
-exports.default = TilingSpriteRenderer;
-
-
-core.WebGLRenderer.registerPlugin('tilingSprite', TilingSpriteRenderer);
-
-},{"../../core":65,"../../core/const":46,"path":23}],143:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _BlurXFilter = require('./BlurXFilter');
-
-var _BlurXFilter2 = _interopRequireDefault(_BlurXFilter);
-
-var _BlurYFilter = require('./BlurYFilter');
-
-var _BlurYFilter2 = _interopRequireDefault(_BlurYFilter);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The BlurFilter applies a Gaussian blur to an object.
- * The strength of the blur can be set for x- and y-axis separately.
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- */
-var BlurFilter = function (_core$Filter) {
-    _inherits(BlurFilter, _core$Filter);
-
-    /**
-     * @param {number} strength - The strength of the blur filter.
-     * @param {number} quality - The quality of the blur filter.
-     * @param {number} resolution - The resolution of the blur filter.
-     * @param {number} [kernelSize=5] - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.
-     */
-    function BlurFilter(strength, quality, resolution, kernelSize) {
-        _classCallCheck(this, BlurFilter);
-
-        var _this = _possibleConstructorReturn(this, _core$Filter.call(this));
-
-        _this.blurXFilter = new _BlurXFilter2.default(strength, quality, resolution, kernelSize);
-        _this.blurYFilter = new _BlurYFilter2.default(strength, quality, resolution, kernelSize);
-
-        _this.padding = 0;
-        _this.resolution = resolution || core.settings.RESOLUTION;
-        _this.quality = quality || 4;
-        _this.blur = strength || 8;
-        return _this;
-    }
-
-    /**
-     * Applies the filter.
-     *
-     * @param {PIXI.FilterManager} filterManager - The manager.
-     * @param {PIXI.RenderTarget} input - The input target.
-     * @param {PIXI.RenderTarget} output - The output target.
-     */
-
-
-    BlurFilter.prototype.apply = function apply(filterManager, input, output) {
-        var renderTarget = filterManager.getRenderTarget(true);
-
-        this.blurXFilter.apply(filterManager, input, renderTarget, true);
-        this.blurYFilter.apply(filterManager, renderTarget, output, false);
-
-        filterManager.returnRenderTarget(renderTarget);
-    };
-
-    /**
-     * Sets the strength of both the blurX and blurY properties simultaneously
-     *
-     * @member {number}
-     * @default 2
-     */
-
-
-    _createClass(BlurFilter, [{
-        key: 'blur',
-        get: function get() {
-            return this.blurXFilter.blur;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.blurXFilter.blur = this.blurYFilter.blur = value;
-            this.padding = Math.max(Math.abs(this.blurXFilter.strength), Math.abs(this.blurYFilter.strength)) * 2;
-        }
-
-        /**
-         * Sets the number of passes for blur. More passes means higher quaility bluring.
-         *
-         * @member {number}
-         * @default 1
-         */
-
-    }, {
-        key: 'quality',
-        get: function get() {
-            return this.blurXFilter.quality;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.blurXFilter.quality = this.blurYFilter.quality = value;
-        }
-
-        /**
-         * Sets the strength of the blurX property
-         *
-         * @member {number}
-         * @default 2
-         */
-
-    }, {
-        key: 'blurX',
-        get: function get() {
-            return this.blurXFilter.blur;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.blurXFilter.blur = value;
-            this.padding = Math.max(Math.abs(this.blurXFilter.strength), Math.abs(this.blurYFilter.strength)) * 2;
-        }
-
-        /**
-         * Sets the strength of the blurY property
-         *
-         * @member {number}
-         * @default 2
-         */
-
-    }, {
-        key: 'blurY',
-        get: function get() {
-            return this.blurYFilter.blur;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.blurYFilter.blur = value;
-            this.padding = Math.max(Math.abs(this.blurXFilter.strength), Math.abs(this.blurYFilter.strength)) * 2;
-        }
-
-        /**
-         * Sets the blendmode of the filter
-         *
-         * @member {number}
-         * @default PIXI.BLEND_MODES.NORMAL
-         */
-
-    }, {
-        key: 'blendMode',
-        get: function get() {
-            return this.blurYFilter._blendMode;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.blurYFilter._blendMode = value;
-        }
-    }]);
-
-    return BlurFilter;
-}(core.Filter);
-
-exports.default = BlurFilter;
-
-},{"../../core":65,"./BlurXFilter":144,"./BlurYFilter":145}],144:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _generateBlurVertSource = require('./generateBlurVertSource');
-
-var _generateBlurVertSource2 = _interopRequireDefault(_generateBlurVertSource);
-
-var _generateBlurFragSource = require('./generateBlurFragSource');
-
-var _generateBlurFragSource2 = _interopRequireDefault(_generateBlurFragSource);
-
-var _getMaxBlurKernelSize = require('./getMaxBlurKernelSize');
-
-var _getMaxBlurKernelSize2 = _interopRequireDefault(_getMaxBlurKernelSize);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The BlurXFilter applies a horizontal Gaussian blur to an object.
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- */
-var BlurXFilter = function (_core$Filter) {
-    _inherits(BlurXFilter, _core$Filter);
-
-    /**
-     * @param {number} strength - The strength of the blur filter.
-     * @param {number} quality - The quality of the blur filter.
-     * @param {number} resolution - The resolution of the blur filter.
-     * @param {number} [kernelSize=5] - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.
-     */
-    function BlurXFilter(strength, quality, resolution, kernelSize) {
-        _classCallCheck(this, BlurXFilter);
-
-        kernelSize = kernelSize || 5;
-        var vertSrc = (0, _generateBlurVertSource2.default)(kernelSize, true);
-        var fragSrc = (0, _generateBlurFragSource2.default)(kernelSize);
-
-        var _this = _possibleConstructorReturn(this, _core$Filter.call(this,
-        // vertex shader
-        vertSrc,
-        // fragment shader
-        fragSrc));
-
-        _this.resolution = resolution || core.settings.RESOLUTION;
-
-        _this._quality = 0;
-
-        _this.quality = quality || 4;
-        _this.strength = strength || 8;
-
-        _this.firstRun = true;
-        return _this;
-    }
-
-    /**
-     * Applies the filter.
-     *
-     * @param {PIXI.FilterManager} filterManager - The manager.
-     * @param {PIXI.RenderTarget} input - The input target.
-     * @param {PIXI.RenderTarget} output - The output target.
-     * @param {boolean} clear - Should the output be cleared before rendering?
-     */
-
-
-    BlurXFilter.prototype.apply = function apply(filterManager, input, output, clear) {
-        if (this.firstRun) {
-            var gl = filterManager.renderer.gl;
-            var kernelSize = (0, _getMaxBlurKernelSize2.default)(gl);
-
-            this.vertexSrc = (0, _generateBlurVertSource2.default)(kernelSize, true);
-            this.fragmentSrc = (0, _generateBlurFragSource2.default)(kernelSize);
-
-            this.firstRun = false;
-        }
-
-        this.uniforms.strength = 1 / output.size.width * (output.size.width / input.size.width);
-
-        // screen space!
-        this.uniforms.strength *= this.strength;
-        this.uniforms.strength /= this.passes; // / this.passes//Math.pow(1, this.passes);
-
-        if (this.passes === 1) {
-            filterManager.applyFilter(this, input, output, clear);
-        } else {
-            var renderTarget = filterManager.getRenderTarget(true);
-            var flip = input;
-            var flop = renderTarget;
-
-            for (var i = 0; i < this.passes - 1; i++) {
-                filterManager.applyFilter(this, flip, flop, true);
-
-                var temp = flop;
-
-                flop = flip;
-                flip = temp;
-            }
-
-            filterManager.applyFilter(this, flip, output, clear);
-
-            filterManager.returnRenderTarget(renderTarget);
-        }
-    };
-
-    /**
-     * Sets the strength of both the blur.
-     *
-     * @member {number}
-     * @default 16
-     */
-
-
-    _createClass(BlurXFilter, [{
-        key: 'blur',
-        get: function get() {
-            return this.strength;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.padding = Math.abs(value) * 2;
-            this.strength = value;
-        }
-
-        /**
-        * Sets the quality of the blur by modifying the number of passes. More passes means higher
-        * quaility bluring but the lower the performance.
-        *
-        * @member {number}
-        * @default 4
-        */
-
-    }, {
-        key: 'quality',
-        get: function get() {
-            return this._quality;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._quality = value;
-            this.passes = value;
-        }
-    }]);
-
-    return BlurXFilter;
-}(core.Filter);
-
-exports.default = BlurXFilter;
-
-},{"../../core":65,"./generateBlurFragSource":146,"./generateBlurVertSource":147,"./getMaxBlurKernelSize":148}],145:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _generateBlurVertSource = require('./generateBlurVertSource');
-
-var _generateBlurVertSource2 = _interopRequireDefault(_generateBlurVertSource);
-
-var _generateBlurFragSource = require('./generateBlurFragSource');
-
-var _generateBlurFragSource2 = _interopRequireDefault(_generateBlurFragSource);
-
-var _getMaxBlurKernelSize = require('./getMaxBlurKernelSize');
-
-var _getMaxBlurKernelSize2 = _interopRequireDefault(_getMaxBlurKernelSize);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The BlurYFilter applies a horizontal Gaussian blur to an object.
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- */
-var BlurYFilter = function (_core$Filter) {
-    _inherits(BlurYFilter, _core$Filter);
-
-    /**
-     * @param {number} strength - The strength of the blur filter.
-     * @param {number} quality - The quality of the blur filter.
-     * @param {number} resolution - The resolution of the blur filter.
-     * @param {number} [kernelSize=5] - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.
-     */
-    function BlurYFilter(strength, quality, resolution, kernelSize) {
-        _classCallCheck(this, BlurYFilter);
-
-        kernelSize = kernelSize || 5;
-        var vertSrc = (0, _generateBlurVertSource2.default)(kernelSize, false);
-        var fragSrc = (0, _generateBlurFragSource2.default)(kernelSize);
-
-        var _this = _possibleConstructorReturn(this, _core$Filter.call(this,
-        // vertex shader
-        vertSrc,
-        // fragment shader
-        fragSrc));
-
-        _this.resolution = resolution || core.settings.RESOLUTION;
-
-        _this._quality = 0;
-
-        _this.quality = quality || 4;
-        _this.strength = strength || 8;
-
-        _this.firstRun = true;
-        return _this;
-    }
-
-    /**
-     * Applies the filter.
-     *
-     * @param {PIXI.FilterManager} filterManager - The manager.
-     * @param {PIXI.RenderTarget} input - The input target.
-     * @param {PIXI.RenderTarget} output - The output target.
-     * @param {boolean} clear - Should the output be cleared before rendering?
-     */
-
-
-    BlurYFilter.prototype.apply = function apply(filterManager, input, output, clear) {
-        if (this.firstRun) {
-            var gl = filterManager.renderer.gl;
-            var kernelSize = (0, _getMaxBlurKernelSize2.default)(gl);
-
-            this.vertexSrc = (0, _generateBlurVertSource2.default)(kernelSize, false);
-            this.fragmentSrc = (0, _generateBlurFragSource2.default)(kernelSize);
-
-            this.firstRun = false;
-        }
-
-        this.uniforms.strength = 1 / output.size.height * (output.size.height / input.size.height);
-
-        this.uniforms.strength *= this.strength;
-        this.uniforms.strength /= this.passes;
-
-        if (this.passes === 1) {
-            filterManager.applyFilter(this, input, output, clear);
-        } else {
-            var renderTarget = filterManager.getRenderTarget(true);
-            var flip = input;
-            var flop = renderTarget;
-
-            for (var i = 0; i < this.passes - 1; i++) {
-                filterManager.applyFilter(this, flip, flop, true);
-
-                var temp = flop;
-
-                flop = flip;
-                flip = temp;
-            }
-
-            filterManager.applyFilter(this, flip, output, clear);
-
-            filterManager.returnRenderTarget(renderTarget);
-        }
-    };
-
-    /**
-     * Sets the strength of both the blur.
-     *
-     * @member {number}
-     * @default 2
-     */
-
-
-    _createClass(BlurYFilter, [{
-        key: 'blur',
-        get: function get() {
-            return this.strength;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.padding = Math.abs(value) * 2;
-            this.strength = value;
-        }
-
-        /**
-         * Sets the quality of the blur by modifying the number of passes. More passes means higher
-         * quaility bluring but the lower the performance.
-         *
-         * @member {number}
-         * @default 4
-         */
-
-    }, {
-        key: 'quality',
-        get: function get() {
-            return this._quality;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._quality = value;
-            this.passes = value;
-        }
-    }]);
-
-    return BlurYFilter;
-}(core.Filter);
-
-exports.default = BlurYFilter;
-
-},{"../../core":65,"./generateBlurFragSource":146,"./generateBlurVertSource":147,"./getMaxBlurKernelSize":148}],146:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = generateFragBlurSource;
-var GAUSSIAN_VALUES = {
-    5: [0.153388, 0.221461, 0.250301],
-    7: [0.071303, 0.131514, 0.189879, 0.214607],
-    9: [0.028532, 0.067234, 0.124009, 0.179044, 0.20236],
-    11: [0.0093, 0.028002, 0.065984, 0.121703, 0.175713, 0.198596],
-    13: [0.002406, 0.009255, 0.027867, 0.065666, 0.121117, 0.174868, 0.197641],
-    15: [0.000489, 0.002403, 0.009246, 0.02784, 0.065602, 0.120999, 0.174697, 0.197448]
-};
-
-var fragTemplate = ['varying vec2 vBlurTexCoords[%size%];', 'uniform sampler2D uSampler;', 'void main(void)', '{', '    gl_FragColor = vec4(0.0);', '    %blur%', '}'].join('\n');
-
-function generateFragBlurSource(kernelSize) {
-    var kernel = GAUSSIAN_VALUES[kernelSize];
-    var halfLength = kernel.length;
-
-    var fragSource = fragTemplate;
-
-    var blurLoop = '';
-    var template = 'gl_FragColor += texture2D(uSampler, vBlurTexCoords[%index%]) * %value%;';
-    var value = void 0;
-
-    for (var i = 0; i < kernelSize; i++) {
-        var blur = template.replace('%index%', i);
-
-        value = i;
-
-        if (i >= halfLength) {
-            value = kernelSize - i - 1;
-        }
-
-        blur = blur.replace('%value%', kernel[value]);
-
-        blurLoop += blur;
-        blurLoop += '\n';
-    }
-
-    fragSource = fragSource.replace('%blur%', blurLoop);
-    fragSource = fragSource.replace('%size%', kernelSize);
-
-    return fragSource;
-}
-
-},{}],147:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.default = generateVertBlurSource;
-var vertTemplate = ['attribute vec2 aVertexPosition;', 'attribute vec2 aTextureCoord;', 'uniform float strength;', 'uniform mat3 projectionMatrix;', 'varying vec2 vBlurTexCoords[%size%];', 'void main(void)', '{', 'gl_Position = vec4((projectionMatrix * vec3((aVertexPosition), 1.0)).xy, 0.0, 1.0);', '%blur%', '}'].join('\n');
-
-function generateVertBlurSource(kernelSize, x) {
-    var halfLength = Math.ceil(kernelSize / 2);
-
-    var vertSource = vertTemplate;
-
-    var blurLoop = '';
-    var template = void 0;
-    // let value;
-
-    if (x) {
-        template = 'vBlurTexCoords[%index%] = aTextureCoord + vec2(%sampleIndex% * strength, 0.0);';
-    } else {
-        template = 'vBlurTexCoords[%index%] = aTextureCoord + vec2(0.0, %sampleIndex% * strength);';
-    }
-
-    for (var i = 0; i < kernelSize; i++) {
-        var blur = template.replace('%index%', i);
-
-        // value = i;
-
-        // if(i >= halfLength)
-        // {
-        //     value = kernelSize - i - 1;
-        // }
-
-        blur = blur.replace('%sampleIndex%', i - (halfLength - 1) + '.0');
-
-        blurLoop += blur;
-        blurLoop += '\n';
-    }
-
-    vertSource = vertSource.replace('%blur%', blurLoop);
-    vertSource = vertSource.replace('%size%', kernelSize);
-
-    return vertSource;
-}
-
-},{}],148:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-exports.default = getMaxKernelSize;
-function getMaxKernelSize(gl) {
-    var maxVaryings = gl.getParameter(gl.MAX_VARYING_VECTORS);
-    var kernelSize = 15;
-
-    while (kernelSize > maxVaryings) {
-        kernelSize -= 2;
-    }
-
-    return kernelSize;
-}
-
-},{}],149:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _path = require('path');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The ColorMatrixFilter class lets you apply a 5x4 matrix transformation on the RGBA
- * color and alpha values of every pixel on your displayObject to produce a result
- * with a new set of RGBA color and alpha values. It's pretty powerful!
- *
- * ```js
- *  let colorMatrix = new PIXI.ColorMatrixFilter();
- *  container.filters = [colorMatrix];
- *  colorMatrix.contrast(2);
- * ```
- * @author Clément Chenebault <clement@goodboydigital.com>
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- */
-var ColorMatrixFilter = function (_core$Filter) {
-    _inherits(ColorMatrixFilter, _core$Filter);
-
-    /**
-     *
-     */
-    function ColorMatrixFilter() {
-        _classCallCheck(this, ColorMatrixFilter);
-
-        var _this = _possibleConstructorReturn(this, _core$Filter.call(this,
-        // vertex shader
-        'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n}',
-        // fragment shader
-        'varying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float m[20];\nuniform float uAlpha;\n\nvoid main(void)\n{\n    vec4 c = texture2D(uSampler, vTextureCoord);\n\n    if (uAlpha == 0.0) {\n        gl_FragColor = c;\n        return;\n    }\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (c.a > 0.0) {\n      c.rgb /= c.a;\n    }\n\n    vec4 result;\n\n    result.r = (m[0] * c.r);\n        result.r += (m[1] * c.g);\n        result.r += (m[2] * c.b);\n        result.r += (m[3] * c.a);\n        result.r += m[4];\n\n    result.g = (m[5] * c.r);\n        result.g += (m[6] * c.g);\n        result.g += (m[7] * c.b);\n        result.g += (m[8] * c.a);\n        result.g += m[9];\n\n    result.b = (m[10] * c.r);\n       result.b += (m[11] * c.g);\n       result.b += (m[12] * c.b);\n       result.b += (m[13] * c.a);\n       result.b += m[14];\n\n    result.a = (m[15] * c.r);\n       result.a += (m[16] * c.g);\n       result.a += (m[17] * c.b);\n       result.a += (m[18] * c.a);\n       result.a += m[19];\n\n    vec3 rgb = mix(c.rgb, result.rgb, uAlpha);\n\n    // Premultiply alpha again.\n    rgb *= result.a;\n\n    gl_FragColor = vec4(rgb, result.a);\n}\n'));
-
-        _this.uniforms.m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
-
-        _this.alpha = 1;
-        return _this;
-    }
-
-    /**
-     * Transforms current matrix and set the new one
-     *
-     * @param {number[]} matrix - 5x4 matrix
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype._loadMatrix = function _loadMatrix(matrix) {
-        var multiply = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
-        var newMatrix = matrix;
-
-        if (multiply) {
-            this._multiply(newMatrix, this.uniforms.m, matrix);
-            newMatrix = this._colorMatrix(newMatrix);
-        }
-
-        // set the new matrix
-        this.uniforms.m = newMatrix;
-    };
-
-    /**
-     * Multiplies two mat5's
-     *
-     * @private
-     * @param {number[]} out - 5x4 matrix the receiving matrix
-     * @param {number[]} a - 5x4 matrix the first operand
-     * @param {number[]} b - 5x4 matrix the second operand
-     * @returns {number[]} 5x4 matrix
-     */
-
-
-    ColorMatrixFilter.prototype._multiply = function _multiply(out, a, b) {
-        // Red Channel
-        out[0] = a[0] * b[0] + a[1] * b[5] + a[2] * b[10] + a[3] * b[15];
-        out[1] = a[0] * b[1] + a[1] * b[6] + a[2] * b[11] + a[3] * b[16];
-        out[2] = a[0] * b[2] + a[1] * b[7] + a[2] * b[12] + a[3] * b[17];
-        out[3] = a[0] * b[3] + a[1] * b[8] + a[2] * b[13] + a[3] * b[18];
-        out[4] = a[0] * b[4] + a[1] * b[9] + a[2] * b[14] + a[3] * b[19] + a[4];
-
-        // Green Channel
-        out[5] = a[5] * b[0] + a[6] * b[5] + a[7] * b[10] + a[8] * b[15];
-        out[6] = a[5] * b[1] + a[6] * b[6] + a[7] * b[11] + a[8] * b[16];
-        out[7] = a[5] * b[2] + a[6] * b[7] + a[7] * b[12] + a[8] * b[17];
-        out[8] = a[5] * b[3] + a[6] * b[8] + a[7] * b[13] + a[8] * b[18];
-        out[9] = a[5] * b[4] + a[6] * b[9] + a[7] * b[14] + a[8] * b[19] + a[9];
-
-        // Blue Channel
-        out[10] = a[10] * b[0] + a[11] * b[5] + a[12] * b[10] + a[13] * b[15];
-        out[11] = a[10] * b[1] + a[11] * b[6] + a[12] * b[11] + a[13] * b[16];
-        out[12] = a[10] * b[2] + a[11] * b[7] + a[12] * b[12] + a[13] * b[17];
-        out[13] = a[10] * b[3] + a[11] * b[8] + a[12] * b[13] + a[13] * b[18];
-        out[14] = a[10] * b[4] + a[11] * b[9] + a[12] * b[14] + a[13] * b[19] + a[14];
-
-        // Alpha Channel
-        out[15] = a[15] * b[0] + a[16] * b[5] + a[17] * b[10] + a[18] * b[15];
-        out[16] = a[15] * b[1] + a[16] * b[6] + a[17] * b[11] + a[18] * b[16];
-        out[17] = a[15] * b[2] + a[16] * b[7] + a[17] * b[12] + a[18] * b[17];
-        out[18] = a[15] * b[3] + a[16] * b[8] + a[17] * b[13] + a[18] * b[18];
-        out[19] = a[15] * b[4] + a[16] * b[9] + a[17] * b[14] + a[18] * b[19] + a[19];
-
-        return out;
-    };
-
-    /**
-     * Create a Float32 Array and normalize the offset component to 0-1
-     *
-     * @private
-     * @param {number[]} matrix - 5x4 matrix
-     * @return {number[]} 5x4 matrix with all values between 0-1
-     */
-
-
-    ColorMatrixFilter.prototype._colorMatrix = function _colorMatrix(matrix) {
-        // Create a Float32 Array and normalize the offset component to 0-1
-        var m = new Float32Array(matrix);
-
-        m[4] /= 255;
-        m[9] /= 255;
-        m[14] /= 255;
-        m[19] /= 255;
-
-        return m;
-    };
-
-    /**
-     * Adjusts brightness
-     *
-     * @param {number} b - value of the brigthness (0-1, where 0 is black)
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.brightness = function brightness(b, multiply) {
-        var matrix = [b, 0, 0, 0, 0, 0, b, 0, 0, 0, 0, 0, b, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Set the matrices in grey scales
-     *
-     * @param {number} scale - value of the grey (0-1, where 0 is black)
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.greyscale = function greyscale(scale, multiply) {
-        var matrix = [scale, scale, scale, 0, 0, scale, scale, scale, 0, 0, scale, scale, scale, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Set the black and white matrice.
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.blackAndWhite = function blackAndWhite(multiply) {
-        var matrix = [0.3, 0.6, 0.1, 0, 0, 0.3, 0.6, 0.1, 0, 0, 0.3, 0.6, 0.1, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Set the hue property of the color
-     *
-     * @param {number} rotation - in degrees
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.hue = function hue(rotation, multiply) {
-        rotation = (rotation || 0) / 180 * Math.PI;
-
-        var cosR = Math.cos(rotation);
-        var sinR = Math.sin(rotation);
-        var sqrt = Math.sqrt;
-
-        /* a good approximation for hue rotation
-         This matrix is far better than the versions with magic luminance constants
-         formerly used here, but also used in the starling framework (flash) and known from this
-         old part of the internet: quasimondo.com/archives/000565.php
-          This new matrix is based on rgb cube rotation in space. Look here for a more descriptive
-         implementation as a shader not a general matrix:
-         https://github.com/evanw/glfx.js/blob/58841c23919bd59787effc0333a4897b43835412/src/filters/adjust/huesaturation.js
-          This is the source for the code:
-         see http://stackoverflow.com/questions/8507885/shift-hue-of-an-rgb-color/8510751#8510751
-         */
-
-        var w = 1 / 3;
-        var sqrW = sqrt(w); // weight is
-
-        var a00 = cosR + (1.0 - cosR) * w;
-        var a01 = w * (1.0 - cosR) - sqrW * sinR;
-        var a02 = w * (1.0 - cosR) + sqrW * sinR;
-
-        var a10 = w * (1.0 - cosR) + sqrW * sinR;
-        var a11 = cosR + w * (1.0 - cosR);
-        var a12 = w * (1.0 - cosR) - sqrW * sinR;
-
-        var a20 = w * (1.0 - cosR) - sqrW * sinR;
-        var a21 = w * (1.0 - cosR) + sqrW * sinR;
-        var a22 = cosR + w * (1.0 - cosR);
-
-        var matrix = [a00, a01, a02, 0, 0, a10, a11, a12, 0, 0, a20, a21, a22, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Set the contrast matrix, increase the separation between dark and bright
-     * Increase contrast : shadows darker and highlights brighter
-     * Decrease contrast : bring the shadows up and the highlights down
-     *
-     * @param {number} amount - value of the contrast (0-1)
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.contrast = function contrast(amount, multiply) {
-        var v = (amount || 0) + 1;
-        var o = -0.5 * (v - 1);
-
-        var matrix = [v, 0, 0, 0, o, 0, v, 0, 0, o, 0, 0, v, 0, o, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Set the saturation matrix, increase the separation between colors
-     * Increase saturation : increase contrast, brightness, and sharpness
-     *
-     * @param {number} amount - The saturation amount (0-1)
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.saturate = function saturate() {
-        var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-        var multiply = arguments[1];
-
-        var x = amount * 2 / 3 + 1;
-        var y = (x - 1) * -0.5;
-
-        var matrix = [x, y, y, 0, 0, y, x, y, 0, 0, y, y, x, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Desaturate image (remove color)
-     *
-     * Call the saturate function
-     *
-     */
-
-
-    ColorMatrixFilter.prototype.desaturate = function desaturate() // eslint-disable-line no-unused-vars
-    {
-        this.saturate(-1);
-    };
-
-    /**
-     * Negative image (inverse of classic rgb matrix)
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.negative = function negative(multiply) {
-        var matrix = [0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Sepia image
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.sepia = function sepia(multiply) {
-        var matrix = [0.393, 0.7689999, 0.18899999, 0, 0, 0.349, 0.6859999, 0.16799999, 0, 0, 0.272, 0.5339999, 0.13099999, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Color motion picture process invented in 1916 (thanks Dominic Szablewski)
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.technicolor = function technicolor(multiply) {
-        var matrix = [1.9125277891456083, -0.8545344976951645, -0.09155508482755585, 0, 11.793603434377337, -0.3087833385928097, 1.7658908555458428, -0.10601743074722245, 0, -70.35205161461398, -0.231103377548616, -0.7501899197440212, 1.847597816108189, 0, 30.950940869491138, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Polaroid filter
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.polaroid = function polaroid(multiply) {
-        var matrix = [1.438, -0.062, -0.062, 0, 0, -0.122, 1.378, -0.122, 0, 0, -0.016, -0.016, 1.483, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Filter who transforms : Red -> Blue and Blue -> Red
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.toBGR = function toBGR(multiply) {
-        var matrix = [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Color reversal film introduced by Eastman Kodak in 1935. (thanks Dominic Szablewski)
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.kodachrome = function kodachrome(multiply) {
-        var matrix = [1.1285582396593525, -0.3967382283601348, -0.03992559172921793, 0, 63.72958762196502, -0.16404339962244616, 1.0835251566291304, -0.05498805115633132, 0, 24.732407896706203, -0.16786010706155763, -0.5603416277695248, 1.6014850761964943, 0, 35.62982807460946, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Brown delicious browni filter (thanks Dominic Szablewski)
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.browni = function browni(multiply) {
-        var matrix = [0.5997023498159715, 0.34553243048391263, -0.2708298674538042, 0, 47.43192855600873, -0.037703249837783157, 0.8609577587992641, 0.15059552388459913, 0, -36.96841498319127, 0.24113635128153335, -0.07441037908422492, 0.44972182064877153, 0, -7.562075277591283, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Vintage filter (thanks Dominic Szablewski)
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.vintage = function vintage(multiply) {
-        var matrix = [0.6279345635605994, 0.3202183420819367, -0.03965408211312453, 0, 9.651285835294123, 0.02578397704808868, 0.6441188644374771, 0.03259127616149294, 0, 7.462829176470591, 0.0466055556782719, -0.0851232987247891, 0.5241648018700465, 0, 5.159190588235296, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * We don't know exactly what it does, kind of gradient map, but funny to play with!
-     *
-     * @param {number} desaturation - Tone values.
-     * @param {number} toned - Tone values.
-     * @param {string} lightColor - Tone values, example: `0xFFE580`
-     * @param {string} darkColor - Tone values, example: `0xFFE580`
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.colorTone = function colorTone(desaturation, toned, lightColor, darkColor, multiply) {
-        desaturation = desaturation || 0.2;
-        toned = toned || 0.15;
-        lightColor = lightColor || 0xFFE580;
-        darkColor = darkColor || 0x338000;
-
-        var lR = (lightColor >> 16 & 0xFF) / 255;
-        var lG = (lightColor >> 8 & 0xFF) / 255;
-        var lB = (lightColor & 0xFF) / 255;
-
-        var dR = (darkColor >> 16 & 0xFF) / 255;
-        var dG = (darkColor >> 8 & 0xFF) / 255;
-        var dB = (darkColor & 0xFF) / 255;
-
-        var matrix = [0.3, 0.59, 0.11, 0, 0, lR, lG, lB, desaturation, 0, dR, dG, dB, toned, 0, lR - dR, lG - dG, lB - dB, 0, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Night effect
-     *
-     * @param {number} intensity - The intensity of the night effect.
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.night = function night(intensity, multiply) {
-        intensity = intensity || 0.1;
-        var matrix = [intensity * -2.0, -intensity, 0, 0, 0, -intensity, 0, intensity, 0, 0, 0, intensity, intensity * 2.0, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Predator effect
-     *
-     * Erase the current matrix by setting a new indepent one
-     *
-     * @param {number} amount - how much the predator feels his future victim
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.predator = function predator(amount, multiply) {
-        var matrix = [
-        // row 1
-        11.224130630493164 * amount, -4.794486999511719 * amount, -2.8746118545532227 * amount, 0 * amount, 0.40342438220977783 * amount,
-        // row 2
-        -3.6330697536468506 * amount, 9.193157196044922 * amount, -2.951810836791992 * amount, 0 * amount, -1.316135048866272 * amount,
-        // row 3
-        -3.2184197902679443 * amount, -4.2375030517578125 * amount, 7.476448059082031 * amount, 0 * amount, 0.8044459223747253 * amount,
-        // row 4
-        0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * LSD effect
-     *
-     * Multiply the current matrix
-     *
-     * @param {boolean} multiply - if true, current matrix and matrix are multiplied. If false,
-     *  just set the current matrix with @param matrix
-     */
-
-
-    ColorMatrixFilter.prototype.lsd = function lsd(multiply) {
-        var matrix = [2, -0.4, 0.5, 0, 0, -0.5, 2, -0.4, 0, 0, -0.4, -0.5, 3, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, multiply);
-    };
-
-    /**
-     * Erase the current matrix by setting the default one
-     *
-     */
-
-
-    ColorMatrixFilter.prototype.reset = function reset() {
-        var matrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
-
-        this._loadMatrix(matrix, false);
-    };
-
-    /**
-     * The matrix of the color matrix filter
-     *
-     * @member {number[]}
-     * @default [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]
-     */
-
-
-    _createClass(ColorMatrixFilter, [{
-        key: 'matrix',
-        get: function get() {
-            return this.uniforms.m;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.uniforms.m = value;
-        }
-
-        /**
-         * The opacity value to use when mixing the original and resultant colors.
-         *
-         * When the value is 0, the original color is used without modification.
-         * When the value is 1, the result color is used.
-         * When in the range (0, 1) the color is interpolated between the original and result by this amount.
-         *
-         * @member {number}
-         * @default 1
-         */
-
-    }, {
-        key: 'alpha',
-        get: function get() {
-            return this.uniforms.uAlpha;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.uniforms.uAlpha = value;
-        }
-    }]);
-
-    return ColorMatrixFilter;
-}(core.Filter);
-
-// Americanized alias
-
-
-exports.default = ColorMatrixFilter;
-ColorMatrixFilter.prototype.grayscale = ColorMatrixFilter.prototype.greyscale;
-
-},{"../../core":65,"path":23}],150:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _path = require('path');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The DisplacementFilter class uses the pixel values from the specified texture
- * (called the displacement map) to perform a displacement of an object. You can
- * use this filter to apply all manor of crazy warping effects. Currently the r
- * property of the texture is used to offset the x and the g property of the texture
- * is used to offset the y.
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- */
-var DisplacementFilter = function (_core$Filter) {
-    _inherits(DisplacementFilter, _core$Filter);
-
-    /**
-     * @param {PIXI.Sprite} sprite - The sprite used for the displacement map. (make sure its added to the scene!)
-     * @param {number} scale - The scale of the displacement
-     */
-    function DisplacementFilter(sprite, scale) {
-        _classCallCheck(this, DisplacementFilter);
-
-        var maskMatrix = new core.Matrix();
-
-        sprite.renderable = false;
-
-        var _this = _possibleConstructorReturn(this, _core$Filter.call(this,
-        // vertex shader
-        'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 filterMatrix;\n\nvarying vec2 vTextureCoord;\nvarying vec2 vFilterCoord;\n\nvoid main(void)\n{\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n   vFilterCoord = ( filterMatrix * vec3( aTextureCoord, 1.0)  ).xy;\n   vTextureCoord = aTextureCoord;\n}',
-        // fragment shader
-        'varying vec2 vFilterCoord;\nvarying vec2 vTextureCoord;\n\nuniform vec2 scale;\n\nuniform sampler2D uSampler;\nuniform sampler2D mapSampler;\n\nuniform vec4 filterClamp;\n\nvoid main(void)\n{\n   vec4 map =  texture2D(mapSampler, vFilterCoord);\n\n   map -= 0.5;\n   map.xy *= scale;\n\n   gl_FragColor = texture2D(uSampler, clamp(vec2(vTextureCoord.x + map.x, vTextureCoord.y + map.y), filterClamp.xy, filterClamp.zw));\n}\n'));
-
-        _this.maskSprite = sprite;
-        _this.maskMatrix = maskMatrix;
-
-        _this.uniforms.mapSampler = sprite._texture;
-        _this.uniforms.filterMatrix = maskMatrix;
-        _this.uniforms.scale = { x: 1, y: 1 };
-
-        if (scale === null || scale === undefined) {
-            scale = 20;
-        }
-
-        _this.scale = new core.Point(scale, scale);
-        return _this;
-    }
-
-    /**
-     * Applies the filter.
-     *
-     * @param {PIXI.FilterManager} filterManager - The manager.
-     * @param {PIXI.RenderTarget} input - The input target.
-     * @param {PIXI.RenderTarget} output - The output target.
-     */
-
-
-    DisplacementFilter.prototype.apply = function apply(filterManager, input, output) {
-        var ratio = 1 / output.destinationFrame.width * (output.size.width / input.size.width);
-
-        this.uniforms.filterMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, this.maskSprite);
-        this.uniforms.scale.x = this.scale.x * ratio;
-        this.uniforms.scale.y = this.scale.y * ratio;
-
-        // draw the filter...
-        filterManager.applyFilter(this, input, output);
-    };
-
-    /**
-     * The texture used for the displacement map. Must be power of 2 sized texture.
-     *
-     * @member {PIXI.Texture}
-     */
-
-
-    _createClass(DisplacementFilter, [{
-        key: 'map',
-        get: function get() {
-            return this.uniforms.mapSampler;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.uniforms.mapSampler = value;
-        }
-    }]);
-
-    return DisplacementFilter;
-}(core.Filter);
-
-exports.default = DisplacementFilter;
-
-},{"../../core":65,"path":23}],151:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _path = require('path');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- *
- * Basic FXAA implementation based on the code on geeks3d.com with the
- * modification that the texture2DLod stuff was removed since it's
- * unsupported by WebGL.
- *
- * @see https://github.com/mitsuhiko/webgl-meincraft
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- *
- */
-var FXAAFilter = function (_core$Filter) {
-    _inherits(FXAAFilter, _core$Filter);
-
-    /**
-     *
-     */
-    function FXAAFilter() {
-        _classCallCheck(this, FXAAFilter);
-
-        // TODO - needs work
-        return _possibleConstructorReturn(this, _core$Filter.call(this,
-        // vertex shader
-        '\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nuniform vec4 filterArea;\n\nvarying vec2 vTextureCoord;\n\nvec2 mapCoord( vec2 coord )\n{\n    coord *= filterArea.xy;\n    coord += filterArea.zw;\n\n    return coord;\n}\n\nvec2 unmapCoord( vec2 coord )\n{\n    coord -= filterArea.zw;\n    coord /= filterArea.xy;\n\n    return coord;\n}\n\nvoid texcoords(vec2 fragCoord, vec2 resolution,\n               out vec2 v_rgbNW, out vec2 v_rgbNE,\n               out vec2 v_rgbSW, out vec2 v_rgbSE,\n               out vec2 v_rgbM) {\n    vec2 inverseVP = 1.0 / resolution.xy;\n    v_rgbNW = (fragCoord + vec2(-1.0, -1.0)) * inverseVP;\n    v_rgbNE = (fragCoord + vec2(1.0, -1.0)) * inverseVP;\n    v_rgbSW = (fragCoord + vec2(-1.0, 1.0)) * inverseVP;\n    v_rgbSE = (fragCoord + vec2(1.0, 1.0)) * inverseVP;\n    v_rgbM = vec2(fragCoord * inverseVP);\n}\n\nvoid main(void) {\n\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n   vTextureCoord = aTextureCoord;\n\n   vec2 fragCoord = vTextureCoord * filterArea.xy;\n\n   texcoords(fragCoord, filterArea.xy, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n}',
-        // fragment shader
-        'varying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform vec4 filterArea;\n\n/**\n Basic FXAA implementation based on the code on geeks3d.com with the\n modification that the texture2DLod stuff was removed since it\'s\n unsupported by WebGL.\n \n --\n \n From:\n https://github.com/mitsuhiko/webgl-meincraft\n \n Copyright (c) 2011 by Armin Ronacher.\n \n Some rights reserved.\n \n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are\n met:\n \n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n \n * Redistributions in binary form must reproduce the above\n copyright notice, this list of conditions and the following\n disclaimer in the documentation and/or other materials provided\n with the distribution.\n \n * The names of the contributors may not be used to endorse or\n promote products derived from this software without specific\n prior written permission.\n \n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef FXAA_REDUCE_MIN\n#define FXAA_REDUCE_MIN   (1.0/ 128.0)\n#endif\n#ifndef FXAA_REDUCE_MUL\n#define FXAA_REDUCE_MUL   (1.0 / 8.0)\n#endif\n#ifndef FXAA_SPAN_MAX\n#define FXAA_SPAN_MAX     8.0\n#endif\n\n//optimized version for mobile, where dependent\n//texture reads can be a bottleneck\nvec4 fxaa(sampler2D tex, vec2 fragCoord, vec2 resolution,\n          vec2 v_rgbNW, vec2 v_rgbNE,\n          vec2 v_rgbSW, vec2 v_rgbSE,\n          vec2 v_rgbM) {\n    vec4 color;\n    mediump vec2 inverseVP = vec2(1.0 / resolution.x, 1.0 / resolution.y);\n    vec3 rgbNW = texture2D(tex, v_rgbNW).xyz;\n    vec3 rgbNE = texture2D(tex, v_rgbNE).xyz;\n    vec3 rgbSW = texture2D(tex, v_rgbSW).xyz;\n    vec3 rgbSE = texture2D(tex, v_rgbSE).xyz;\n    vec4 texColor = texture2D(tex, v_rgbM);\n    vec3 rgbM  = texColor.xyz;\n    vec3 luma = vec3(0.299, 0.587, 0.114);\n    float lumaNW = dot(rgbNW, luma);\n    float lumaNE = dot(rgbNE, luma);\n    float lumaSW = dot(rgbSW, luma);\n    float lumaSE = dot(rgbSE, luma);\n    float lumaM  = dot(rgbM,  luma);\n    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));\n    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));\n    \n    mediump vec2 dir;\n    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));\n    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));\n    \n    float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) *\n                          (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);\n    \n    float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);\n    dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX),\n              max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),\n                  dir * rcpDirMin)) * inverseVP;\n    \n    vec3 rgbA = 0.5 * (\n                       texture2D(tex, fragCoord * inverseVP + dir * (1.0 / 3.0 - 0.5)).xyz +\n                       texture2D(tex, fragCoord * inverseVP + dir * (2.0 / 3.0 - 0.5)).xyz);\n    vec3 rgbB = rgbA * 0.5 + 0.25 * (\n                                     texture2D(tex, fragCoord * inverseVP + dir * -0.5).xyz +\n                                     texture2D(tex, fragCoord * inverseVP + dir * 0.5).xyz);\n    \n    float lumaB = dot(rgbB, luma);\n    if ((lumaB < lumaMin) || (lumaB > lumaMax))\n        color = vec4(rgbA, texColor.a);\n    else\n        color = vec4(rgbB, texColor.a);\n    return color;\n}\n\nvoid main() {\n\n      vec2 fragCoord = vTextureCoord * filterArea.xy;\n\n      vec4 color;\n\n    color = fxaa(uSampler, fragCoord, filterArea.xy, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n\n      gl_FragColor = color;\n}\n'));
-    }
-
-    return FXAAFilter;
-}(core.Filter);
-
-exports.default = FXAAFilter;
-
-},{"../../core":65,"path":23}],152:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _FXAAFilter = require('./fxaa/FXAAFilter');
-
-Object.defineProperty(exports, 'FXAAFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_FXAAFilter).default;
-  }
-});
-
-var _NoiseFilter = require('./noise/NoiseFilter');
-
-Object.defineProperty(exports, 'NoiseFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_NoiseFilter).default;
-  }
-});
-
-var _DisplacementFilter = require('./displacement/DisplacementFilter');
-
-Object.defineProperty(exports, 'DisplacementFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_DisplacementFilter).default;
-  }
-});
-
-var _BlurFilter = require('./blur/BlurFilter');
-
-Object.defineProperty(exports, 'BlurFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_BlurFilter).default;
-  }
-});
-
-var _BlurXFilter = require('./blur/BlurXFilter');
-
-Object.defineProperty(exports, 'BlurXFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_BlurXFilter).default;
-  }
-});
-
-var _BlurYFilter = require('./blur/BlurYFilter');
-
-Object.defineProperty(exports, 'BlurYFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_BlurYFilter).default;
-  }
-});
-
-var _ColorMatrixFilter = require('./colormatrix/ColorMatrixFilter');
-
-Object.defineProperty(exports, 'ColorMatrixFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_ColorMatrixFilter).default;
-  }
-});
-
-var _VoidFilter = require('./void/VoidFilter');
-
-Object.defineProperty(exports, 'VoidFilter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_VoidFilter).default;
-  }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./blur/BlurFilter":143,"./blur/BlurXFilter":144,"./blur/BlurYFilter":145,"./colormatrix/ColorMatrixFilter":149,"./displacement/DisplacementFilter":150,"./fxaa/FXAAFilter":151,"./noise/NoiseFilter":153,"./void/VoidFilter":154}],153:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _path = require('path');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * @author Vico @vicocotea
- * original filter: https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/noise.js
- */
-
-/**
- * A Noise effect filter.
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- */
-var NoiseFilter = function (_core$Filter) {
-    _inherits(NoiseFilter, _core$Filter);
-
-    /**
-     * @param {number} noise - The noise intensity, should be a normalized value in the range [0, 1].
-     * @param {number} seed - A random seed for the noise generation. Default is `Math.random()`.
-     */
-    function NoiseFilter() {
-        var noise = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.5;
-        var seed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Math.random();
-
-        _classCallCheck(this, NoiseFilter);
-
-        var _this = _possibleConstructorReturn(this, _core$Filter.call(this,
-        // vertex shader
-        'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n}',
-        // fragment shader
-        'precision highp float;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform float uNoise;\nuniform float uSeed;\nuniform sampler2D uSampler;\n\nfloat rand(vec2 co)\n{\n    return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvoid main()\n{\n    vec4 color = texture2D(uSampler, vTextureCoord);\n    float randomValue = rand(gl_FragCoord.xy * uSeed);\n    float diff = (randomValue - 0.5) * uNoise;\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (color.a > 0.0) {\n        color.rgb /= color.a;\n    }\n\n    color.r += diff;\n    color.g += diff;\n    color.b += diff;\n\n    // Premultiply alpha again.\n    color.rgb *= color.a;\n\n    gl_FragColor = color;\n}\n'));
-
-        _this.noise = noise;
-        _this.seed = seed;
-        return _this;
-    }
-
-    /**
-     * The amount of noise to apply, this value should be in the range (0, 1].
-     *
-     * @member {number}
-     * @default 0.5
-     */
-
-
-    _createClass(NoiseFilter, [{
-        key: 'noise',
-        get: function get() {
-            return this.uniforms.uNoise;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.uniforms.uNoise = value;
-        }
-
-        /**
-         * A seed value to apply to the random noise generation. `Math.random()` is a good value to use.
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'seed',
-        get: function get() {
-            return this.uniforms.uSeed;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this.uniforms.uSeed = value;
-        }
-    }]);
-
-    return NoiseFilter;
-}(core.Filter);
-
-exports.default = NoiseFilter;
-
-},{"../../core":65,"path":23}],154:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _path = require('path');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * Does nothing. Very handy.
- *
- * @class
- * @extends PIXI.Filter
- * @memberof PIXI.filters
- */
-var VoidFilter = function (_core$Filter) {
-    _inherits(VoidFilter, _core$Filter);
-
-    /**
-     *
-     */
-    function VoidFilter() {
-        _classCallCheck(this, VoidFilter);
-
-        var _this = _possibleConstructorReturn(this, _core$Filter.call(this,
-        // vertex shader
-        'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n}',
-        // fragment shader
-        'varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\n\nvoid main(void)\n{\n   gl_FragColor = texture2D(uSampler, vTextureCoord);\n}\n'));
-
-        _this.glShaderKey = 'void';
-        return _this;
-    }
-
-    return VoidFilter;
-}(core.Filter);
-
-exports.default = VoidFilter;
-
-},{"../../core":65,"path":23}],155:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Holds all information related to an Interaction event
- *
- * @class
- * @memberof PIXI.interaction
- */
-var InteractionData = function () {
-  /**
-   *
-   */
-  function InteractionData() {
-    _classCallCheck(this, InteractionData);
-
-    /**
-     * This point stores the global coords of where the touch/mouse event happened
-     *
-     * @member {PIXI.Point}
-     */
-    this.global = new core.Point();
-
-    /**
-     * The target DisplayObject that was interacted with
-     *
-     * @member {PIXI.DisplayObject}
-     */
-    this.target = null;
-
-    /**
-     * When passed to an event handler, this will be the original DOM Event that was captured
-     *
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent
-     * @member {MouseEvent|TouchEvent|PointerEvent}
-     */
-    this.originalEvent = null;
-
-    /**
-     * Unique identifier for this interaction
-     *
-     * @member {number}
-     */
-    this.identifier = null;
-
-    /**
-     * Indicates whether or not the pointer device that created the event is the primary pointer.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/isPrimary
-     * @type {Boolean}
-     */
-    this.isPrimary = false;
-
-    /**
-     * Indicates which button was pressed on the mouse or pointer device to trigger the event.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
-     * @type {number}
-     */
-    this.button = 0;
-
-    /**
-     * Indicates which buttons are pressed on the mouse or pointer device when the event is triggered.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
-     * @type {number}
-     */
-    this.buttons = 0;
-
-    /**
-     * The width of the pointer's contact along the x-axis, measured in CSS pixels.
-     * radiusX of TouchEvents will be represented by this value.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/width
-     * @type {number}
-     */
-    this.width = 0;
-
-    /**
-     * The height of the pointer's contact along the y-axis, measured in CSS pixels.
-     * radiusY of TouchEvents will be represented by this value.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/height
-     * @type {number}
-     */
-    this.height = 0;
-
-    /**
-     * The angle, in degrees, between the pointer device and the screen.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/tiltX
-     * @type {number}
-     */
-    this.tiltX = 0;
-
-    /**
-     * The angle, in degrees, between the pointer device and the screen.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/tiltY
-     * @type {number}
-     */
-    this.tiltY = 0;
-
-    /**
-     * The type of pointer that triggered the event.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerType
-     * @type {string}
-     */
-    this.pointerType = null;
-
-    /**
-     * Pressure applied by the pointing device during the event. A Touch's force property
-     * will be represented by this value.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pressure
-     * @type {number}
-     */
-    this.pressure = 0;
-
-    /**
-     * From TouchEvents (not PointerEvents triggered by touches), the rotationAngle of the Touch.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Touch/rotationAngle
-     * @type {number}
-     */
-    this.rotationAngle = 0;
-
-    /**
-     * Twist of a stylus pointer.
-     * @see https://w3c.github.io/pointerevents/#pointerevent-interface
-     * @type {number}
-     */
-    this.twist = 0;
-
-    /**
-     * Barrel pressure on a stylus pointer.
-     * @see https://w3c.github.io/pointerevents/#pointerevent-interface
-     * @type {number}
-     */
-    this.tangentialPressure = 0;
-  }
-
-  /**
-   * The unique identifier of the pointer. It will be the same as `identifier`.
-   * @readonly
-   * @member {number}
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId
-   */
-
-
-  /**
-   * This will return the local coordinates of the specified displayObject for this InteractionData
-   *
-   * @param {PIXI.DisplayObject} displayObject - The DisplayObject that you would like the local
-   *  coords off
-   * @param {PIXI.Point} [point] - A Point object in which to store the value, optional (otherwise
-   *  will create a new point)
-   * @param {PIXI.Point} [globalPos] - A Point object containing your custom global coords, optional
-   *  (otherwise will use the current global coords)
-   * @return {PIXI.Point} A point containing the coordinates of the InteractionData position relative
-   *  to the DisplayObject
-   */
-  InteractionData.prototype.getLocalPosition = function getLocalPosition(displayObject, point, globalPos) {
-    return displayObject.worldTransform.applyInverse(globalPos || this.global, point);
-  };
-
-  /**
-   * Copies properties from normalized event data.
-   *
-   * @param {Touch|MouseEvent|PointerEvent} event The normalized event data
-   * @private
-   */
-
-
-  InteractionData.prototype._copyEvent = function _copyEvent(event) {
-    // isPrimary should only change on touchstart/pointerdown, so we don't want to overwrite
-    // it with "false" on later events when our shim for it on touch events might not be
-    // accurate
-    if (event.isPrimary) {
-      this.isPrimary = true;
-    }
-    this.button = event.button;
-    this.buttons = event.buttons;
-    this.width = event.width;
-    this.height = event.height;
-    this.tiltX = event.tiltX;
-    this.tiltY = event.tiltY;
-    this.pointerType = event.pointerType;
-    this.pressure = event.pressure;
-    this.rotationAngle = event.rotationAngle;
-    this.twist = event.twist || 0;
-    this.tangentialPressure = event.tangentialPressure || 0;
-  };
-
-  /**
-   * Resets the data for pooling.
-   *
-   * @private
-   */
-
-
-  InteractionData.prototype._reset = function _reset() {
-    // isPrimary is the only property that we really need to reset - everything else is
-    // guaranteed to be overwritten
-    this.isPrimary = false;
-  };
-
-  _createClass(InteractionData, [{
-    key: 'pointerId',
-    get: function get() {
-      return this.identifier;
-    }
-  }]);
-
-  return InteractionData;
-}();
-
-exports.default = InteractionData;
-
-},{"../core":65}],156:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Event class that mimics native DOM events.
- *
- * @class
- * @memberof PIXI.interaction
- */
-var InteractionEvent = function () {
-  /**
-   *
-   */
-  function InteractionEvent() {
-    _classCallCheck(this, InteractionEvent);
-
-    /**
-     * Whether this event will continue propagating in the tree
-     *
-     * @member {boolean}
-     */
-    this.stopped = false;
-
-    /**
-     * The object which caused this event to be dispatched.
-     * For listener callback see {@link PIXI.interaction.InteractionEvent.currentTarget}.
-     *
-     * @member {PIXI.DisplayObject}
-     */
-    this.target = null;
-
-    /**
-     * The object whose event listener’s callback is currently being invoked.
-     *
-     * @member {PIXI.DisplayObject}
-     */
-    this.currentTarget = null;
-
-    /**
-     * Type of the event
-     *
-     * @member {string}
-     */
-    this.type = null;
-
-    /**
-     * InteractionData related to this event
-     *
-     * @member {PIXI.interaction.InteractionData}
-     */
-    this.data = null;
-  }
-
-  /**
-   * Prevents event from reaching any objects other than the current object.
-   *
-   */
-
-
-  InteractionEvent.prototype.stopPropagation = function stopPropagation() {
-    this.stopped = true;
-  };
-
-  /**
-   * Resets the event.
-   *
-   * @private
-   */
-
-
-  InteractionEvent.prototype._reset = function _reset() {
-    this.stopped = false;
-    this.currentTarget = null;
-    this.target = null;
-  };
-
-  return InteractionEvent;
-}();
-
-exports.default = InteractionEvent;
-
-},{}],157:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _InteractionData = require('./InteractionData');
-
-var _InteractionData2 = _interopRequireDefault(_InteractionData);
-
-var _InteractionEvent = require('./InteractionEvent');
-
-var _InteractionEvent2 = _interopRequireDefault(_InteractionEvent);
-
-var _InteractionTrackingData = require('./InteractionTrackingData');
-
-var _InteractionTrackingData2 = _interopRequireDefault(_InteractionTrackingData);
-
-var _eventemitter = require('eventemitter3');
-
-var _eventemitter2 = _interopRequireDefault(_eventemitter);
-
-var _interactiveTarget = require('./interactiveTarget');
-
-var _interactiveTarget2 = _interopRequireDefault(_interactiveTarget);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-// Mix interactiveTarget into core.DisplayObject.prototype, after deprecation has been handled
-core.utils.mixins.delayMixin(core.DisplayObject.prototype, _interactiveTarget2.default);
-
-var MOUSE_POINTER_ID = 'MOUSE';
-
-// helpers for hitTest() - only used inside hitTest()
-var hitTestEvent = {
-    target: null,
-    data: {
-        global: null
-    }
-};
-
-/**
- * The interaction manager deals with mouse, touch and pointer events. Any DisplayObject can be interactive
- * if its interactive parameter is set to true
- * This manager also supports multitouch.
- *
- * An instance of this class is automatically created by default, and can be found at renderer.plugins.interaction
- *
- * @class
- * @extends EventEmitter
- * @memberof PIXI.interaction
- */
-
-var InteractionManager = function (_EventEmitter) {
-    _inherits(InteractionManager, _EventEmitter);
-
-    /**
-     * @param {PIXI.CanvasRenderer|PIXI.WebGLRenderer} renderer - A reference to the current renderer
-     * @param {object} [options] - The options for the manager.
-     * @param {boolean} [options.autoPreventDefault=true] - Should the manager automatically prevent default browser actions.
-     * @param {number} [options.interactionFrequency=10] - Frequency increases the interaction events will be checked.
-     */
-    function InteractionManager(renderer, options) {
-        _classCallCheck(this, InteractionManager);
-
-        var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
-
-        options = options || {};
-
-        /**
-         * The renderer this interaction manager works for.
-         *
-         * @member {PIXI.SystemRenderer}
-         */
-        _this.renderer = renderer;
-
-        /**
-         * Should default browser actions automatically be prevented.
-         * Does not apply to pointer events for backwards compatibility
-         * preventDefault on pointer events stops mouse events from firing
-         * Thus, for every pointer event, there will always be either a mouse of touch event alongside it.
-         *
-         * @member {boolean}
-         * @default true
-         */
-        _this.autoPreventDefault = options.autoPreventDefault !== undefined ? options.autoPreventDefault : true;
-
-        /**
-         * Frequency in milliseconds that the mousemove, moveover & mouseout interaction events will be checked.
-         *
-         * @member {number}
-         * @default 10
-         */
-        _this.interactionFrequency = options.interactionFrequency || 10;
-
-        /**
-         * The mouse data
-         *
-         * @member {PIXI.interaction.InteractionData}
-         */
-        _this.mouse = new _InteractionData2.default();
-        _this.mouse.identifier = MOUSE_POINTER_ID;
-
-        // setting the mouse to start off far off screen will mean that mouse over does
-        //  not get called before we even move the mouse.
-        _this.mouse.global.set(-999999);
-
-        /**
-         * Actively tracked InteractionData
-         *
-         * @private
-         * @member {Object.<number,PIXI.interation.InteractionData>}
-         */
-        _this.activeInteractionData = {};
-        _this.activeInteractionData[MOUSE_POINTER_ID] = _this.mouse;
-
-        /**
-         * Pool of unused InteractionData
-         *
-         * @private
-         * @member {PIXI.interation.InteractionData[]}
-         */
-        _this.interactionDataPool = [];
-
-        /**
-         * An event data object to handle all the event tracking/dispatching
-         *
-         * @member {object}
-         */
-        _this.eventData = new _InteractionEvent2.default();
-
-        /**
-         * The DOM element to bind to.
-         *
-         * @private
-         * @member {HTMLElement}
-         */
-        _this.interactionDOMElement = null;
-
-        /**
-         * This property determines if mousemove and touchmove events are fired only when the cursor
-         * is over the object.
-         * Setting to true will make things work more in line with how the DOM verison works.
-         * Setting to false can make things easier for things like dragging
-         * It is currently set to false as this is how PixiJS used to work. This will be set to true in
-         * future versions of pixi.
-         *
-         * @member {boolean}
-         * @default false
-         */
-        _this.moveWhenInside = false;
-
-        /**
-         * Have events been attached to the dom element?
-         *
-         * @private
-         * @member {boolean}
-         */
-        _this.eventsAdded = false;
-
-        /**
-         * Is the mouse hovering over the renderer?
-         *
-         * @private
-         * @member {boolean}
-         */
-        _this.mouseOverRenderer = false;
-
-        /**
-         * Does the device support touch events
-         * https://www.w3.org/TR/touch-events/
-         *
-         * @readonly
-         * @member {boolean}
-         */
-        _this.supportsTouchEvents = 'ontouchstart' in window;
-
-        /**
-         * Does the device support pointer events
-         * https://www.w3.org/Submission/pointer-events/
-         *
-         * @readonly
-         * @member {boolean}
-         */
-        _this.supportsPointerEvents = !!window.PointerEvent;
-
-        // this will make it so that you don't have to call bind all the time
-
-        /**
-         * @private
-         * @member {Function}
-         */
-        _this.onPointerUp = _this.onPointerUp.bind(_this);
-        _this.processPointerUp = _this.processPointerUp.bind(_this);
-
-        /**
-         * @private
-         * @member {Function}
-         */
-        _this.onPointerCancel = _this.onPointerCancel.bind(_this);
-        _this.processPointerCancel = _this.processPointerCancel.bind(_this);
-
-        /**
-         * @private
-         * @member {Function}
-         */
-        _this.onPointerDown = _this.onPointerDown.bind(_this);
-        _this.processPointerDown = _this.processPointerDown.bind(_this);
-
-        /**
-         * @private
-         * @member {Function}
-         */
-        _this.onPointerMove = _this.onPointerMove.bind(_this);
-        _this.processPointerMove = _this.processPointerMove.bind(_this);
-
-        /**
-         * @private
-         * @member {Function}
-         */
-        _this.onPointerOut = _this.onPointerOut.bind(_this);
-        _this.processPointerOverOut = _this.processPointerOverOut.bind(_this);
-
-        /**
-         * @private
-         * @member {Function}
-         */
-        _this.onPointerOver = _this.onPointerOver.bind(_this);
-
-        /**
-         * Dictionary of how different cursor modes are handled. Strings are handled as CSS cursor
-         * values, objects are handled as dictionaries of CSS values for interactionDOMElement,
-         * and functions are called instead of changing the CSS.
-         * Default CSS cursor values are provided for 'default' and 'pointer' modes.
-         * @member {Object.<string, (string|Function|Object.<string, string>)>}
-         */
-        _this.cursorStyles = {
-            default: 'inherit',
-            pointer: 'pointer'
-        };
-
-        /**
-         * The mode of the cursor that is being used.
-         * The value of this is a key from the cursorStyles dictionary.
-         *
-         * @member {string}
-         */
-        _this.currentCursorMode = null;
-
-        /**
-         * Internal cached let.
-         *
-         * @private
-         * @member {string}
-         */
-        _this.cursor = null;
-
-        /**
-         * Internal cached let.
-         *
-         * @private
-         * @member {PIXI.Point}
-         */
-        _this._tempPoint = new core.Point();
-
-        /**
-         * The current resolution / device pixel ratio.
-         *
-         * @member {number}
-         * @default 1
-         */
-        _this.resolution = 1;
-
-        _this.setTargetElement(_this.renderer.view, _this.renderer.resolution);
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is pressed on the display
-         * object.
-         *
-         * @event PIXI.interaction.InteractionManager#mousedown
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-         * on the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#rightdown
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is released over the display
-         * object.
-         *
-         * @event PIXI.interaction.InteractionManager#mouseup
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is released
-         * over the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#rightup
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is pressed and released on
-         * the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#click
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-         * and released on the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#rightclick
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is released outside the
-         * display object that initially registered a
-         * [mousedown]{@link PIXI.interaction.InteractionManager#event:mousedown}.
-         *
-         * @event PIXI.interaction.InteractionManager#mouseupoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is released
-         * outside the display object that initially registered a
-         * [rightdown]{@link PIXI.interaction.InteractionManager#event:rightdown}.
-         *
-         * @event PIXI.interaction.InteractionManager#rightupoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device (usually a mouse) is moved while over the display object
-         *
-         * @event PIXI.interaction.InteractionManager#mousemove
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device (usually a mouse) is moved onto the display object
-         *
-         * @event PIXI.interaction.InteractionManager#mouseover
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device (usually a mouse) is moved off the display object
-         *
-         * @event PIXI.interaction.InteractionManager#mouseout
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is pressed on the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#pointerdown
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is released over the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#pointerup
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when the operating system cancels a pointer event
-         *
-         * @event PIXI.interaction.InteractionManager#pointercancel
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is pressed and released on the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#pointertap
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is released outside the display object that initially
-         * registered a [pointerdown]{@link PIXI.interaction.InteractionManager#event:pointerdown}.
-         *
-         * @event PIXI.interaction.InteractionManager#pointerupoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device is moved while over the display object
-         *
-         * @event PIXI.interaction.InteractionManager#pointermove
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device is moved onto the display object
-         *
-         * @event PIXI.interaction.InteractionManager#pointerover
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device is moved off the display object
-         *
-         * @event PIXI.interaction.InteractionManager#pointerout
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is placed on the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#touchstart
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is removed from the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#touchend
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when the operating system cancels a touch
-         *
-         * @event PIXI.interaction.InteractionManager#touchcancel
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is placed and removed from the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#tap
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is removed outside of the display object that initially
-         * registered a [touchstart]{@link PIXI.interaction.InteractionManager#event:touchstart}.
-         *
-         * @event PIXI.interaction.InteractionManager#touchendoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is moved along the display object.
-         *
-         * @event PIXI.interaction.InteractionManager#touchmove
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is pressed on the display.
-         * object. DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#mousedown
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-         * on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#rightdown
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is released over the display
-         * object. DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#mouseup
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is released
-         * over the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#rightup
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is pressed and released on
-         * the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#click
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-         * and released on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#rightclick
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button (usually a mouse left-button) is released outside the
-         * display object that initially registered a
-         * [mousedown]{@link PIXI.DisplayObject#event:mousedown}.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#mouseupoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device secondary button (usually a mouse right-button) is released
-         * outside the display object that initially registered a
-         * [rightdown]{@link PIXI.DisplayObject#event:rightdown}.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#rightupoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device (usually a mouse) is moved while over the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#mousemove
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device (usually a mouse) is moved onto the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#mouseover
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device (usually a mouse) is moved off the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#mouseout
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is pressed on the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointerdown
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is released over the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointerup
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when the operating system cancels a pointer event.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointercancel
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is pressed and released on the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointertap
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device button is released outside the display object that initially
-         * registered a [pointerdown]{@link PIXI.DisplayObject#event:pointerdown}.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointerupoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device is moved while over the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointermove
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device is moved onto the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointerover
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a pointer device is moved off the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#pointerout
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is placed on the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#touchstart
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is removed from the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#touchend
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when the operating system cancels a touch.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#touchcancel
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is placed and removed from the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#tap
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is removed outside of the display object that initially
-         * registered a [touchstart]{@link PIXI.DisplayObject#event:touchstart}.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#touchendoutside
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-
-        /**
-         * Fired when a touch point is moved along the display object.
-         * DisplayObject's `interactive` property must be set to `true` to fire event.
-         *
-         * @event PIXI.DisplayObject#touchmove
-         * @param {PIXI.interaction.InteractionEvent} event - Interaction event
-         */
-        return _this;
-    }
-
-    /**
-     * Hit tests a point against the display tree, returning the first interactive object that is hit.
-     *
-     * @param {PIXI.Point} globalPoint - A point to hit test with, in global space.
-     * @param {PIXI.Container} [root] - The root display object to start from. If omitted, defaults
-     * to the last rendered root of the associated renderer.
-     * @return {PIXI.DisplayObject} The hit display object, if any.
-     */
-
-
-    InteractionManager.prototype.hitTest = function hitTest(globalPoint, root) {
-        // clear the target for our hit test
-        hitTestEvent.target = null;
-        // assign the global point
-        hitTestEvent.data.global = globalPoint;
-        // ensure safety of the root
-        if (!root) {
-            root = this.renderer._lastObjectRendered;
-        }
-        // run the hit test
-        this.processInteractive(hitTestEvent, root, null, true);
-        // return our found object - it'll be null if we didn't hit anything
-
-        return hitTestEvent.target;
-    };
-
-    /**
-     * Sets the DOM element which will receive mouse/touch events. This is useful for when you have
-     * other DOM elements on top of the renderers Canvas element. With this you'll be bale to deletegate
-     * another DOM element to receive those events.
-     *
-     * @param {HTMLCanvasElement} element - the DOM element which will receive mouse and touch events.
-     * @param {number} [resolution=1] - The resolution / device pixel ratio of the new element (relative to the canvas).
-     * @private
-     */
-
-
-    InteractionManager.prototype.setTargetElement = function setTargetElement(element) {
-        var resolution = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-
-        this.removeEvents();
-
-        this.interactionDOMElement = element;
-
-        this.resolution = resolution;
-
-        this.addEvents();
-    };
-
-    /**
-     * Registers all the DOM events
-     *
-     * @private
-     */
-
-
-    InteractionManager.prototype.addEvents = function addEvents() {
-        if (!this.interactionDOMElement) {
-            return;
-        }
-
-        core.ticker.shared.add(this.update, this, core.UPDATE_PRIORITY.INTERACTION);
-
-        if (window.navigator.msPointerEnabled) {
-            this.interactionDOMElement.style['-ms-content-zooming'] = 'none';
-            this.interactionDOMElement.style['-ms-touch-action'] = 'none';
-        } else if (this.supportsPointerEvents) {
-            this.interactionDOMElement.style['touch-action'] = 'none';
-        }
-
-        /**
-         * These events are added first, so that if pointer events are normalised, they are fired
-         * in the same order as non-normalised events. ie. pointer event 1st, mouse / touch 2nd
-         */
-        if (this.supportsPointerEvents) {
-            window.document.addEventListener('pointermove', this.onPointerMove, true);
-            this.interactionDOMElement.addEventListener('pointerdown', this.onPointerDown, true);
-            // pointerout is fired in addition to pointerup (for touch events) and pointercancel
-            // we already handle those, so for the purposes of what we do in onPointerOut, we only
-            // care about the pointerleave event
-            this.interactionDOMElement.addEventListener('pointerleave', this.onPointerOut, true);
-            this.interactionDOMElement.addEventListener('pointerover', this.onPointerOver, true);
-            window.addEventListener('pointercancel', this.onPointerCancel, true);
-            window.addEventListener('pointerup', this.onPointerUp, true);
-        } else {
-            window.document.addEventListener('mousemove', this.onPointerMove, true);
-            this.interactionDOMElement.addEventListener('mousedown', this.onPointerDown, true);
-            this.interactionDOMElement.addEventListener('mouseout', this.onPointerOut, true);
-            this.interactionDOMElement.addEventListener('mouseover', this.onPointerOver, true);
-            window.addEventListener('mouseup', this.onPointerUp, true);
-        }
-
-        // always look directly for touch events so that we can provide original data
-        // In a future version we should change this to being just a fallback and rely solely on
-        // PointerEvents whenever available
-        if (this.supportsTouchEvents) {
-            this.interactionDOMElement.addEventListener('touchstart', this.onPointerDown, true);
-            this.interactionDOMElement.addEventListener('touchcancel', this.onPointerCancel, true);
-            this.interactionDOMElement.addEventListener('touchend', this.onPointerUp, true);
-            this.interactionDOMElement.addEventListener('touchmove', this.onPointerMove, true);
-        }
-
-        this.eventsAdded = true;
-    };
-
-    /**
-     * Removes all the DOM events that were previously registered
-     *
-     * @private
-     */
-
-
-    InteractionManager.prototype.removeEvents = function removeEvents() {
-        if (!this.interactionDOMElement) {
-            return;
-        }
-
-        core.ticker.shared.remove(this.update, this);
-
-        if (window.navigator.msPointerEnabled) {
-            this.interactionDOMElement.style['-ms-content-zooming'] = '';
-            this.interactionDOMElement.style['-ms-touch-action'] = '';
-        } else if (this.supportsPointerEvents) {
-            this.interactionDOMElement.style['touch-action'] = '';
-        }
-
-        if (this.supportsPointerEvents) {
-            window.document.removeEventListener('pointermove', this.onPointerMove, true);
-            this.interactionDOMElement.removeEventListener('pointerdown', this.onPointerDown, true);
-            this.interactionDOMElement.removeEventListener('pointerleave', this.onPointerOut, true);
-            this.interactionDOMElement.removeEventListener('pointerover', this.onPointerOver, true);
-            window.removeEventListener('pointercancel', this.onPointerCancel, true);
-            window.removeEventListener('pointerup', this.onPointerUp, true);
-        } else {
-            window.document.removeEventListener('mousemove', this.onPointerMove, true);
-            this.interactionDOMElement.removeEventListener('mousedown', this.onPointerDown, true);
-            this.interactionDOMElement.removeEventListener('mouseout', this.onPointerOut, true);
-            this.interactionDOMElement.removeEventListener('mouseover', this.onPointerOver, true);
-            window.removeEventListener('mouseup', this.onPointerUp, true);
-        }
-
-        if (this.supportsTouchEvents) {
-            this.interactionDOMElement.removeEventListener('touchstart', this.onPointerDown, true);
-            this.interactionDOMElement.removeEventListener('touchcancel', this.onPointerCancel, true);
-            this.interactionDOMElement.removeEventListener('touchend', this.onPointerUp, true);
-            this.interactionDOMElement.removeEventListener('touchmove', this.onPointerMove, true);
-        }
-
-        this.interactionDOMElement = null;
-
-        this.eventsAdded = false;
-    };
-
-    /**
-     * Updates the state of interactive objects.
-     * Invoked by a throttled ticker update from {@link PIXI.ticker.shared}.
-     *
-     * @param {number} deltaTime - time delta since last tick
-     */
-
-
-    InteractionManager.prototype.update = function update(deltaTime) {
-        this._deltaTime += deltaTime;
-
-        if (this._deltaTime < this.interactionFrequency) {
-            return;
-        }
-
-        this._deltaTime = 0;
-
-        if (!this.interactionDOMElement) {
-            return;
-        }
-
-        // if the user move the mouse this check has already been done using the mouse move!
-        if (this.didMove) {
-            this.didMove = false;
-
-            return;
-        }
-
-        this.cursor = null;
-
-        // Resets the flag as set by a stopPropagation call. This flag is usually reset by a user interaction of any kind,
-        // but there was a scenario of a display object moving under a static mouse cursor.
-        // In this case, mouseover and mouseevents would not pass the flag test in dispatchEvent function
-        for (var k in this.activeInteractionData) {
-            // eslint-disable-next-line no-prototype-builtins
-            if (this.activeInteractionData.hasOwnProperty(k)) {
-                var interactionData = this.activeInteractionData[k];
-
-                if (interactionData.originalEvent && interactionData.pointerType !== 'touch') {
-                    var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, interactionData.originalEvent, interactionData);
-
-                    this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerOverOut, true);
-                }
-            }
-        }
-
-        this.setCursorMode(this.cursor);
-
-        // TODO
-    };
-
-    /**
-     * Sets the current cursor mode, handling any callbacks or CSS style changes.
-     *
-     * @param {string} mode - cursor mode, a key from the cursorStyles dictionary
-     */
-
-
-    InteractionManager.prototype.setCursorMode = function setCursorMode(mode) {
-        mode = mode || 'default';
-        // if the mode didn't actually change, bail early
-        if (this.currentCursorMode === mode) {
-            return;
-        }
-        this.currentCursorMode = mode;
-        var style = this.cursorStyles[mode];
-
-        // only do things if there is a cursor style for it
-        if (style) {
-            switch (typeof style === 'undefined' ? 'undefined' : _typeof(style)) {
-                case 'string':
-                    // string styles are handled as cursor CSS
-                    this.interactionDOMElement.style.cursor = style;
-                    break;
-                case 'function':
-                    // functions are just called, and passed the cursor mode
-                    style(mode);
-                    break;
-                case 'object':
-                    // if it is an object, assume that it is a dictionary of CSS styles,
-                    // apply it to the interactionDOMElement
-                    Object.assign(this.interactionDOMElement.style, style);
-                    break;
-            }
-        } else if (typeof mode === 'string' && !Object.prototype.hasOwnProperty.call(this.cursorStyles, mode)) {
-            // if it mode is a string (not a Symbol) and cursorStyles doesn't have any entry
-            // for the mode, then assume that the dev wants it to be CSS for the cursor.
-            this.interactionDOMElement.style.cursor = mode;
-        }
-    };
-
-    /**
-     * Dispatches an event on the display object that was interacted with
-     *
-     * @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - the display object in question
-     * @param {string} eventString - the name of the event (e.g, mousedown)
-     * @param {object} eventData - the event data object
-     * @private
-     */
-
-
-    InteractionManager.prototype.dispatchEvent = function dispatchEvent(displayObject, eventString, eventData) {
-        if (!eventData.stopped) {
-            eventData.currentTarget = displayObject;
-            eventData.type = eventString;
-
-            displayObject.emit(eventString, eventData);
-
-            if (displayObject[eventString]) {
-                displayObject[eventString](eventData);
-            }
-        }
-    };
-
-    /**
-     * Maps x and y coords from a DOM object and maps them correctly to the PixiJS view. The
-     * resulting value is stored in the point. This takes into account the fact that the DOM
-     * element could be scaled and positioned anywhere on the screen.
-     *
-     * @param  {PIXI.Point} point - the point that the result will be stored in
-     * @param  {number} x - the x coord of the position to map
-     * @param  {number} y - the y coord of the position to map
-     */
-
-
-    InteractionManager.prototype.mapPositionToPoint = function mapPositionToPoint(point, x, y) {
-        var rect = void 0;
-
-        // IE 11 fix
-        if (!this.interactionDOMElement.parentElement) {
-            rect = { x: 0, y: 0, width: 0, height: 0 };
-        } else {
-            rect = this.interactionDOMElement.getBoundingClientRect();
-        }
-
-        var resolutionMultiplier = navigator.isCocoonJS ? this.resolution : 1.0 / this.resolution;
-
-        point.x = (x - rect.left) * (this.interactionDOMElement.width / rect.width) * resolutionMultiplier;
-        point.y = (y - rect.top) * (this.interactionDOMElement.height / rect.height) * resolutionMultiplier;
-    };
-
-    /**
-     * This function is provides a neat way of crawling through the scene graph and running a
-     * specified function on all interactive objects it finds. It will also take care of hit
-     * testing the interactive objects and passes the hit across in the function.
-     *
-     * @private
-     * @param {PIXI.interaction.InteractionEvent} interactionEvent - event containing the point that
-     *  is tested for collision
-     * @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - the displayObject
-     *  that will be hit test (recursively crawls its children)
-     * @param {Function} [func] - the function that will be called on each interactive object. The
-     *  interactionEvent, displayObject and hit will be passed to the function
-     * @param {boolean} [hitTest] - this indicates if the objects inside should be hit test against the point
-     * @param {boolean} [interactive] - Whether the displayObject is interactive
-     * @return {boolean} returns true if the displayObject hit the point
-     */
-
-
-    InteractionManager.prototype.processInteractive = function processInteractive(interactionEvent, displayObject, func, hitTest, interactive) {
-        if (!displayObject || !displayObject.visible) {
-            return false;
-        }
-
-        var point = interactionEvent.data.global;
-
-        // Took a little while to rework this function correctly! But now it is done and nice and optimised. ^_^
-        //
-        // This function will now loop through all objects and then only hit test the objects it HAS
-        // to, not all of them. MUCH faster..
-        // An object will be hit test if the following is true:
-        //
-        // 1: It is interactive.
-        // 2: It belongs to a parent that is interactive AND one of the parents children have not already been hit.
-        //
-        // As another little optimisation once an interactive object has been hit we can carry on
-        // through the scenegraph, but we know that there will be no more hits! So we can avoid extra hit tests
-        // A final optimisation is that an object is not hit test directly if a child has already been hit.
-
-        interactive = displayObject.interactive || interactive;
-
-        var hit = false;
-        var interactiveParent = interactive;
-
-        // if the displayobject has a hitArea, then it does not need to hitTest children.
-        if (displayObject.hitArea) {
-            interactiveParent = false;
-        }
-        // it has a mask! Then lets hit test that before continuing
-        else if (hitTest && displayObject._mask) {
-                if (!displayObject._mask.containsPoint(point)) {
-                    hitTest = false;
-                }
-            }
-
-        // ** FREE TIP **! If an object is not interactive or has no buttons in it
-        // (such as a game scene!) set interactiveChildren to false for that displayObject.
-        // This will allow PixiJS to completely ignore and bypass checking the displayObjects children.
-        if (displayObject.interactiveChildren && displayObject.children) {
-            var children = displayObject.children;
-
-            for (var i = children.length - 1; i >= 0; i--) {
-                var child = children[i];
-
-                // time to get recursive.. if this function will return if something is hit..
-                var childHit = this.processInteractive(interactionEvent, child, func, hitTest, interactiveParent);
-
-                if (childHit) {
-                    // its a good idea to check if a child has lost its parent.
-                    // this means it has been removed whilst looping so its best
-                    if (!child.parent) {
-                        continue;
-                    }
-
-                    // we no longer need to hit test any more objects in this container as we we
-                    // now know the parent has been hit
-                    interactiveParent = false;
-
-                    // If the child is interactive , that means that the object hit was actually
-                    // interactive and not just the child of an interactive object.
-                    // This means we no longer need to hit test anything else. We still need to run
-                    // through all objects, but we don't need to perform any hit tests.
-
-                    if (childHit) {
-                        if (interactionEvent.target) {
-                            hitTest = false;
-                        }
-                        hit = true;
-                    }
-                }
-            }
-        }
-
-        // no point running this if the item is not interactive or does not have an interactive parent.
-        if (interactive) {
-            // if we are hit testing (as in we have no hit any objects yet)
-            // We also don't need to worry about hit testing if once of the displayObjects children
-            // has already been hit - but only if it was interactive, otherwise we need to keep
-            // looking for an interactive child, just in case we hit one
-            if (hitTest && !interactionEvent.target) {
-                if (displayObject.hitArea) {
-                    displayObject.worldTransform.applyInverse(point, this._tempPoint);
-                    if (displayObject.hitArea.contains(this._tempPoint.x, this._tempPoint.y)) {
-                        hit = true;
-                    }
-                } else if (displayObject.containsPoint) {
-                    if (displayObject.containsPoint(point)) {
-                        hit = true;
-                    }
-                }
-            }
-
-            if (displayObject.interactive) {
-                if (hit && !interactionEvent.target) {
-                    interactionEvent.target = displayObject;
-                }
-
-                if (func) {
-                    func(interactionEvent, displayObject, !!hit);
-                }
-            }
-        }
-
-        return hit;
-    };
-
-    /**
-     * Is called when the pointer button is pressed down on the renderer element
-     *
-     * @private
-     * @param {PointerEvent} originalEvent - The DOM event of a pointer button being pressed down
-     */
-
-
-    InteractionManager.prototype.onPointerDown = function onPointerDown(originalEvent) {
-        // if we support touch events, then only use those for touch events, not pointer events
-        if (this.supportsTouchEvents && originalEvent.pointerType === 'touch') return;
-
-        var events = this.normalizeToPointerData(originalEvent);
-
-        /**
-         * No need to prevent default on natural pointer events, as there are no side effects
-         * Normalized events, however, may have the double mousedown/touchstart issue on the native android browser,
-         * so still need to be prevented.
-         */
-
-        // Guaranteed that there will be at least one event in events, and all events must have the same pointer type
-
-        if (this.autoPreventDefault && events[0].isNormalized) {
-            originalEvent.preventDefault();
-        }
-
-        var eventLen = events.length;
-
-        for (var i = 0; i < eventLen; i++) {
-            var event = events[i];
-
-            var interactionData = this.getInteractionDataForPointerId(event);
-
-            var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-
-            interactionEvent.data.originalEvent = originalEvent;
-
-            this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerDown, true);
-
-            this.emit('pointerdown', interactionEvent);
-            if (event.pointerType === 'touch') {
-                this.emit('touchstart', interactionEvent);
-            }
-            // emit a mouse event for "pen" pointers, the way a browser would emit a fallback event
-            else if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-                    var isRightButton = event.button === 2;
-
-                    this.emit(isRightButton ? 'rightdown' : 'mousedown', this.eventData);
-                }
-        }
-    };
-
-    /**
-     * Processes the result of the pointer down check and dispatches the event if need be
-     *
-     * @private
-     * @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
-     * @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
-     * @param {boolean} hit - the result of the hit test on the display object
-     */
-
-
-    InteractionManager.prototype.processPointerDown = function processPointerDown(interactionEvent, displayObject, hit) {
-        var data = interactionEvent.data;
-        var id = interactionEvent.data.identifier;
-
-        if (hit) {
-            if (!displayObject.trackedPointers[id]) {
-                displayObject.trackedPointers[id] = new _InteractionTrackingData2.default(id);
-            }
-            this.dispatchEvent(displayObject, 'pointerdown', interactionEvent);
-
-            if (data.pointerType === 'touch') {
-                this.dispatchEvent(displayObject, 'touchstart', interactionEvent);
-            } else if (data.pointerType === 'mouse' || data.pointerType === 'pen') {
-                var isRightButton = data.button === 2;
-
-                if (isRightButton) {
-                    displayObject.trackedPointers[id].rightDown = true;
-                } else {
-                    displayObject.trackedPointers[id].leftDown = true;
-                }
-
-                this.dispatchEvent(displayObject, isRightButton ? 'rightdown' : 'mousedown', interactionEvent);
-            }
-        }
-    };
-
-    /**
-     * Is called when the pointer button is released on the renderer element
-     *
-     * @private
-     * @param {PointerEvent} originalEvent - The DOM event of a pointer button being released
-     * @param {boolean} cancelled - true if the pointer is cancelled
-     * @param {Function} func - Function passed to {@link processInteractive}
-     */
-
-
-    InteractionManager.prototype.onPointerComplete = function onPointerComplete(originalEvent, cancelled, func) {
-        var events = this.normalizeToPointerData(originalEvent);
-
-        var eventLen = events.length;
-
-        // if the event wasn't targeting our canvas, then consider it to be pointerupoutside
-        // in all cases (unless it was a pointercancel)
-        var eventAppend = originalEvent.target !== this.interactionDOMElement ? 'outside' : '';
-
-        for (var i = 0; i < eventLen; i++) {
-            var event = events[i];
-
-            var interactionData = this.getInteractionDataForPointerId(event);
-
-            var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-
-            interactionEvent.data.originalEvent = originalEvent;
-
-            // perform hit testing for events targeting our canvas or cancel events
-            this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, func, cancelled || !eventAppend);
-
-            this.emit(cancelled ? 'pointercancel' : 'pointerup' + eventAppend, interactionEvent);
-
-            if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-                var isRightButton = event.button === 2;
-
-                this.emit(isRightButton ? 'rightup' + eventAppend : 'mouseup' + eventAppend, interactionEvent);
-            } else if (event.pointerType === 'touch') {
-                this.emit(cancelled ? 'touchcancel' : 'touchend' + eventAppend, interactionEvent);
-                this.releaseInteractionDataForPointerId(event.pointerId, interactionData);
-            }
-        }
-    };
-
-    /**
-     * Is called when the pointer button is cancelled
-     *
-     * @private
-     * @param {PointerEvent} event - The DOM event of a pointer button being released
-     */
-
-
-    InteractionManager.prototype.onPointerCancel = function onPointerCancel(event) {
-        // if we support touch events, then only use those for touch events, not pointer events
-        if (this.supportsTouchEvents && event.pointerType === 'touch') return;
-
-        this.onPointerComplete(event, true, this.processPointerCancel);
-    };
-
-    /**
-     * Processes the result of the pointer cancel check and dispatches the event if need be
-     *
-     * @private
-     * @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
-     * @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
-     */
-
-
-    InteractionManager.prototype.processPointerCancel = function processPointerCancel(interactionEvent, displayObject) {
-        var data = interactionEvent.data;
-
-        var id = interactionEvent.data.identifier;
-
-        if (displayObject.trackedPointers[id] !== undefined) {
-            delete displayObject.trackedPointers[id];
-            this.dispatchEvent(displayObject, 'pointercancel', interactionEvent);
-
-            if (data.pointerType === 'touch') {
-                this.dispatchEvent(displayObject, 'touchcancel', interactionEvent);
-            }
-        }
-    };
-
-    /**
-     * Is called when the pointer button is released on the renderer element
-     *
-     * @private
-     * @param {PointerEvent} event - The DOM event of a pointer button being released
-     */
-
-
-    InteractionManager.prototype.onPointerUp = function onPointerUp(event) {
-        // if we support touch events, then only use those for touch events, not pointer events
-        if (this.supportsTouchEvents && event.pointerType === 'touch') return;
-
-        this.onPointerComplete(event, false, this.processPointerUp);
-    };
-
-    /**
-     * Processes the result of the pointer up check and dispatches the event if need be
-     *
-     * @private
-     * @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
-     * @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
-     * @param {boolean} hit - the result of the hit test on the display object
-     */
-
-
-    InteractionManager.prototype.processPointerUp = function processPointerUp(interactionEvent, displayObject, hit) {
-        var data = interactionEvent.data;
-
-        var id = interactionEvent.data.identifier;
-
-        var trackingData = displayObject.trackedPointers[id];
-
-        var isTouch = data.pointerType === 'touch';
-
-        var isMouse = data.pointerType === 'mouse' || data.pointerType === 'pen';
-
-        // Mouse only
-        if (isMouse) {
-            var isRightButton = data.button === 2;
-
-            var flags = _InteractionTrackingData2.default.FLAGS;
-
-            var test = isRightButton ? flags.RIGHT_DOWN : flags.LEFT_DOWN;
-
-            var isDown = trackingData !== undefined && trackingData.flags & test;
-
-            if (hit) {
-                this.dispatchEvent(displayObject, isRightButton ? 'rightup' : 'mouseup', interactionEvent);
-
-                if (isDown) {
-                    this.dispatchEvent(displayObject, isRightButton ? 'rightclick' : 'click', interactionEvent);
-                }
-            } else if (isDown) {
-                this.dispatchEvent(displayObject, isRightButton ? 'rightupoutside' : 'mouseupoutside', interactionEvent);
-            }
-            // update the down state of the tracking data
-            if (trackingData) {
-                if (isRightButton) {
-                    trackingData.rightDown = false;
-                } else {
-                    trackingData.leftDown = false;
-                }
-            }
-        }
-
-        // Pointers and Touches, and Mouse
-        if (hit) {
-            this.dispatchEvent(displayObject, 'pointerup', interactionEvent);
-            if (isTouch) this.dispatchEvent(displayObject, 'touchend', interactionEvent);
-
-            if (trackingData) {
-                this.dispatchEvent(displayObject, 'pointertap', interactionEvent);
-                if (isTouch) {
-                    this.dispatchEvent(displayObject, 'tap', interactionEvent);
-                    // touches are no longer over (if they ever were) when we get the touchend
-                    // so we should ensure that we don't keep pretending that they are
-                    trackingData.over = false;
-                }
-            }
-        } else if (trackingData) {
-            this.dispatchEvent(displayObject, 'pointerupoutside', interactionEvent);
-            if (isTouch) this.dispatchEvent(displayObject, 'touchendoutside', interactionEvent);
-        }
-        // Only remove the tracking data if there is no over/down state still associated with it
-        if (trackingData && trackingData.none) {
-            delete displayObject.trackedPointers[id];
-        }
-    };
-
-    /**
-     * Is called when the pointer moves across the renderer element
-     *
-     * @private
-     * @param {PointerEvent} originalEvent - The DOM event of a pointer moving
-     */
-
-
-    InteractionManager.prototype.onPointerMove = function onPointerMove(originalEvent) {
-        // if we support touch events, then only use those for touch events, not pointer events
-        if (this.supportsTouchEvents && originalEvent.pointerType === 'touch') return;
-
-        var events = this.normalizeToPointerData(originalEvent);
-
-        if (events[0].pointerType === 'mouse') {
-            this.didMove = true;
-
-            this.cursor = null;
-        }
-
-        var eventLen = events.length;
-
-        for (var i = 0; i < eventLen; i++) {
-            var event = events[i];
-
-            var interactionData = this.getInteractionDataForPointerId(event);
-
-            var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-
-            interactionEvent.data.originalEvent = originalEvent;
-
-            var interactive = event.pointerType === 'touch' ? this.moveWhenInside : true;
-
-            this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerMove, interactive);
-            this.emit('pointermove', interactionEvent);
-            if (event.pointerType === 'touch') this.emit('touchmove', interactionEvent);
-            if (event.pointerType === 'mouse' || event.pointerType === 'pen') this.emit('mousemove', interactionEvent);
-        }
-
-        if (events[0].pointerType === 'mouse') {
-            this.setCursorMode(this.cursor);
-
-            // TODO BUG for parents interactive object (border order issue)
-        }
-    };
-
-    /**
-     * Processes the result of the pointer move check and dispatches the event if need be
-     *
-     * @private
-     * @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
-     * @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
-     * @param {boolean} hit - the result of the hit test on the display object
-     */
-
-
-    InteractionManager.prototype.processPointerMove = function processPointerMove(interactionEvent, displayObject, hit) {
-        var data = interactionEvent.data;
-
-        var isTouch = data.pointerType === 'touch';
-
-        var isMouse = data.pointerType === 'mouse' || data.pointerType === 'pen';
-
-        if (isMouse) {
-            this.processPointerOverOut(interactionEvent, displayObject, hit);
-        }
-
-        if (!this.moveWhenInside || hit) {
-            this.dispatchEvent(displayObject, 'pointermove', interactionEvent);
-            if (isTouch) this.dispatchEvent(displayObject, 'touchmove', interactionEvent);
-            if (isMouse) this.dispatchEvent(displayObject, 'mousemove', interactionEvent);
-        }
-    };
-
-    /**
-     * Is called when the pointer is moved out of the renderer element
-     *
-     * @private
-     * @param {PointerEvent} originalEvent - The DOM event of a pointer being moved out
-     */
-
-
-    InteractionManager.prototype.onPointerOut = function onPointerOut(originalEvent) {
-        // if we support touch events, then only use those for touch events, not pointer events
-        if (this.supportsTouchEvents && originalEvent.pointerType === 'touch') return;
-
-        var events = this.normalizeToPointerData(originalEvent);
-
-        // Only mouse and pointer can call onPointerOut, so events will always be length 1
-        var event = events[0];
-
-        if (event.pointerType === 'mouse') {
-            this.mouseOverRenderer = false;
-            this.setCursorMode(null);
-        }
-
-        var interactionData = this.getInteractionDataForPointerId(event);
-
-        var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-
-        interactionEvent.data.originalEvent = event;
-
-        this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerOverOut, false);
-
-        this.emit('pointerout', interactionEvent);
-        if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-            this.emit('mouseout', interactionEvent);
-        } else {
-            // we can get touchleave events after touchend, so we want to make sure we don't
-            // introduce memory leaks
-            this.releaseInteractionDataForPointerId(interactionData.identifier);
-        }
-    };
-
-    /**
-     * Processes the result of the pointer over/out check and dispatches the event if need be
-     *
-     * @private
-     * @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
-     * @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
-     * @param {boolean} hit - the result of the hit test on the display object
-     */
-
-
-    InteractionManager.prototype.processPointerOverOut = function processPointerOverOut(interactionEvent, displayObject, hit) {
-        var data = interactionEvent.data;
-
-        var id = interactionEvent.data.identifier;
-
-        var isMouse = data.pointerType === 'mouse' || data.pointerType === 'pen';
-
-        var trackingData = displayObject.trackedPointers[id];
-
-        // if we just moused over the display object, then we need to track that state
-        if (hit && !trackingData) {
-            trackingData = displayObject.trackedPointers[id] = new _InteractionTrackingData2.default(id);
-        }
-
-        if (trackingData === undefined) return;
-
-        if (hit && this.mouseOverRenderer) {
-            if (!trackingData.over) {
-                trackingData.over = true;
-                this.dispatchEvent(displayObject, 'pointerover', interactionEvent);
-                if (isMouse) {
-                    this.dispatchEvent(displayObject, 'mouseover', interactionEvent);
-                }
-            }
-
-            // only change the cursor if it has not already been changed (by something deeper in the
-            // display tree)
-            if (isMouse && this.cursor === null) {
-                this.cursor = displayObject.cursor;
-            }
-        } else if (trackingData.over) {
-            trackingData.over = false;
-            this.dispatchEvent(displayObject, 'pointerout', this.eventData);
-            if (isMouse) {
-                this.dispatchEvent(displayObject, 'mouseout', interactionEvent);
-            }
-            // if there is no mouse down information for the pointer, then it is safe to delete
-            if (trackingData.none) {
-                delete displayObject.trackedPointers[id];
-            }
-        }
-    };
-
-    /**
-     * Is called when the pointer is moved into the renderer element
-     *
-     * @private
-     * @param {PointerEvent} originalEvent - The DOM event of a pointer button being moved into the renderer view
-     */
-
-
-    InteractionManager.prototype.onPointerOver = function onPointerOver(originalEvent) {
-        var events = this.normalizeToPointerData(originalEvent);
-
-        // Only mouse and pointer can call onPointerOver, so events will always be length 1
-        var event = events[0];
-
-        var interactionData = this.getInteractionDataForPointerId(event);
-
-        var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-
-        interactionEvent.data.originalEvent = event;
-
-        if (event.pointerType === 'mouse') {
-            this.mouseOverRenderer = true;
-        }
-
-        this.emit('pointerover', interactionEvent);
-        if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-            this.emit('mouseover', interactionEvent);
-        }
-    };
-
-    /**
-     * Get InteractionData for a given pointerId. Store that data as well
-     *
-     * @private
-     * @param {PointerEvent} event - Normalized pointer event, output from normalizeToPointerData
-     * @return {PIXI.interaction.InteractionData} - Interaction data for the given pointer identifier
-     */
-
-
-    InteractionManager.prototype.getInteractionDataForPointerId = function getInteractionDataForPointerId(event) {
-        var pointerId = event.pointerId;
-
-        var interactionData = void 0;
-
-        if (pointerId === MOUSE_POINTER_ID || event.pointerType === 'mouse') {
-            interactionData = this.mouse;
-        } else if (this.activeInteractionData[pointerId]) {
-            interactionData = this.activeInteractionData[pointerId];
-        } else {
-            interactionData = this.interactionDataPool.pop() || new _InteractionData2.default();
-            interactionData.identifier = pointerId;
-            this.activeInteractionData[pointerId] = interactionData;
-        }
-        // copy properties from the event, so that we can make sure that touch/pointer specific
-        // data is available
-        interactionData._copyEvent(event);
-
-        return interactionData;
-    };
-
-    /**
-     * Return unused InteractionData to the pool, for a given pointerId
-     *
-     * @private
-     * @param {number} pointerId - Identifier from a pointer event
-     */
-
-
-    InteractionManager.prototype.releaseInteractionDataForPointerId = function releaseInteractionDataForPointerId(pointerId) {
-        var interactionData = this.activeInteractionData[pointerId];
-
-        if (interactionData) {
-            delete this.activeInteractionData[pointerId];
-            interactionData._reset();
-            this.interactionDataPool.push(interactionData);
-        }
-    };
-
-    /**
-     * Configure an InteractionEvent to wrap a DOM PointerEvent and InteractionData
-     *
-     * @private
-     * @param {PIXI.interaction.InteractionEvent} interactionEvent - The event to be configured
-     * @param {PointerEvent} pointerEvent - The DOM event that will be paired with the InteractionEvent
-     * @param {PIXI.interaction.InteractionData} interactionData - The InteractionData that will be paired
-     *        with the InteractionEvent
-     * @return {PIXI.interaction.InteractionEvent} the interaction event that was passed in
-     */
-
-
-    InteractionManager.prototype.configureInteractionEventForDOMEvent = function configureInteractionEventForDOMEvent(interactionEvent, pointerEvent, interactionData) {
-        interactionEvent.data = interactionData;
-
-        this.mapPositionToPoint(interactionData.global, pointerEvent.clientX, pointerEvent.clientY);
-
-        // This is the way InteractionManager processed touch events before the refactoring, so I've kept
-        // it here. But it doesn't make that much sense to me, since mapPositionToPoint already factors
-        // in this.resolution, so this just divides by this.resolution twice for touch events...
-        if (navigator.isCocoonJS && pointerEvent.pointerType === 'touch') {
-            interactionData.global.x = interactionData.global.x / this.resolution;
-            interactionData.global.y = interactionData.global.y / this.resolution;
-        }
-
-        // Not really sure why this is happening, but it's how a previous version handled things
-        if (pointerEvent.pointerType === 'touch') {
-            pointerEvent.globalX = interactionData.global.x;
-            pointerEvent.globalY = interactionData.global.y;
-        }
-
-        interactionData.originalEvent = pointerEvent;
-        interactionEvent._reset();
-
-        return interactionEvent;
-    };
-
-    /**
-     * Ensures that the original event object contains all data that a regular pointer event would have
-     *
-     * @private
-     * @param {TouchEvent|MouseEvent|PointerEvent} event - The original event data from a touch or mouse event
-     * @return {PointerEvent[]} An array containing a single normalized pointer event, in the case of a pointer
-     *  or mouse event, or a multiple normalized pointer events if there are multiple changed touches
-     */
-
-
-    InteractionManager.prototype.normalizeToPointerData = function normalizeToPointerData(event) {
-        var normalizedEvents = [];
-
-        if (this.supportsTouchEvents && event instanceof TouchEvent) {
-            for (var i = 0, li = event.changedTouches.length; i < li; i++) {
-                var touch = event.changedTouches[i];
-
-                if (typeof touch.button === 'undefined') touch.button = event.touches.length ? 1 : 0;
-                if (typeof touch.buttons === 'undefined') touch.buttons = event.touches.length ? 1 : 0;
-                if (typeof touch.isPrimary === 'undefined') {
-                    touch.isPrimary = event.touches.length === 1 && event.type === 'touchstart';
-                }
-                if (typeof touch.width === 'undefined') touch.width = touch.radiusX || 1;
-                if (typeof touch.height === 'undefined') touch.height = touch.radiusY || 1;
-                if (typeof touch.tiltX === 'undefined') touch.tiltX = 0;
-                if (typeof touch.tiltY === 'undefined') touch.tiltY = 0;
-                if (typeof touch.pointerType === 'undefined') touch.pointerType = 'touch';
-                if (typeof touch.pointerId === 'undefined') touch.pointerId = touch.identifier || 0;
-                if (typeof touch.pressure === 'undefined') touch.pressure = touch.force || 0.5;
-                touch.twist = 0;
-                touch.tangentialPressure = 0;
-                // TODO: Remove these, as layerX/Y is not a standard, is deprecated, has uneven
-                // support, and the fill ins are not quite the same
-                // offsetX/Y might be okay, but is not the same as clientX/Y when the canvas's top
-                // left is not 0,0 on the page
-                if (typeof touch.layerX === 'undefined') touch.layerX = touch.offsetX = touch.clientX;
-                if (typeof touch.layerY === 'undefined') touch.layerY = touch.offsetY = touch.clientY;
-
-                // mark the touch as normalized, just so that we know we did it
-                touch.isNormalized = true;
-
-                normalizedEvents.push(touch);
-            }
-        }
-        // apparently PointerEvent subclasses MouseEvent, so yay
-        else if (event instanceof MouseEvent && (!this.supportsPointerEvents || !(event instanceof window.PointerEvent))) {
-                if (typeof event.isPrimary === 'undefined') event.isPrimary = true;
-                if (typeof event.width === 'undefined') event.width = 1;
-                if (typeof event.height === 'undefined') event.height = 1;
-                if (typeof event.tiltX === 'undefined') event.tiltX = 0;
-                if (typeof event.tiltY === 'undefined') event.tiltY = 0;
-                if (typeof event.pointerType === 'undefined') event.pointerType = 'mouse';
-                if (typeof event.pointerId === 'undefined') event.pointerId = MOUSE_POINTER_ID;
-                if (typeof event.pressure === 'undefined') event.pressure = 0.5;
-                event.twist = 0;
-                event.tangentialPressure = 0;
-
-                // mark the mouse event as normalized, just so that we know we did it
-                event.isNormalized = true;
-
-                normalizedEvents.push(event);
-            } else {
-                normalizedEvents.push(event);
-            }
-
-        return normalizedEvents;
-    };
-
-    /**
-     * Destroys the interaction manager
-     *
-     */
-
-
-    InteractionManager.prototype.destroy = function destroy() {
-        this.removeEvents();
-
-        this.removeAllListeners();
-
-        this.renderer = null;
-
-        this.mouse = null;
-
-        this.eventData = null;
-
-        this.interactionDOMElement = null;
-
-        this.onPointerDown = null;
-        this.processPointerDown = null;
-
-        this.onPointerUp = null;
-        this.processPointerUp = null;
-
-        this.onPointerCancel = null;
-        this.processPointerCancel = null;
-
-        this.onPointerMove = null;
-        this.processPointerMove = null;
-
-        this.onPointerOut = null;
-        this.processPointerOverOut = null;
-
-        this.onPointerOver = null;
-
-        this._tempPoint = null;
-    };
-
-    return InteractionManager;
-}(_eventemitter2.default);
-
-exports.default = InteractionManager;
-
-
-core.WebGLRenderer.registerPlugin('interaction', InteractionManager);
-core.CanvasRenderer.registerPlugin('interaction', InteractionManager);
-
-},{"../core":65,"./InteractionData":155,"./InteractionEvent":156,"./InteractionTrackingData":158,"./interactiveTarget":160,"eventemitter3":3}],158:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * DisplayObjects with the {@link PIXI.interaction.interactiveTarget} mixin use this class to track interactions
- *
- * @class
- * @private
- * @memberof PIXI.interaction
- */
-var InteractionTrackingData = function () {
-    /**
-     * @param {number} pointerId - Unique pointer id of the event
-     */
-    function InteractionTrackingData(pointerId) {
-        _classCallCheck(this, InteractionTrackingData);
-
-        this._pointerId = pointerId;
-        this._flags = InteractionTrackingData.FLAGS.NONE;
-    }
-
-    /**
-     *
-     * @private
-     * @param {number} flag - The interaction flag to set
-     * @param {boolean} yn - Should the flag be set or unset
-     */
-
-
-    InteractionTrackingData.prototype._doSet = function _doSet(flag, yn) {
-        if (yn) {
-            this._flags = this._flags | flag;
-        } else {
-            this._flags = this._flags & ~flag;
-        }
-    };
-
-    /**
-     * Unique pointer id of the event
-     *
-     * @readonly
-     * @member {number}
-     */
-
-
-    _createClass(InteractionTrackingData, [{
-        key: "pointerId",
-        get: function get() {
-            return this._pointerId;
-        }
-
-        /**
-         * State of the tracking data, expressed as bit flags
-         *
-         * @member {number}
-         * @memberof PIXI.interaction.InteractionTrackingData#
-         */
-
-    }, {
-        key: "flags",
-        get: function get() {
-            return this._flags;
-        }
-
-        /**
-         * Set the flags for the tracking data
-         *
-         * @param {number} flags - Flags to set
-         */
-        ,
-        set: function set(flags) {
-            this._flags = flags;
-        }
-
-        /**
-         * Is the tracked event inactive (not over or down)?
-         *
-         * @member {number}
-         * @memberof PIXI.interaction.InteractionTrackingData#
-         */
-
-    }, {
-        key: "none",
-        get: function get() {
-            return this._flags === this.constructor.FLAGS.NONE;
-        }
-
-        /**
-         * Is the tracked event over the DisplayObject?
-         *
-         * @member {boolean}
-         * @memberof PIXI.interaction.InteractionTrackingData#
-         */
-
-    }, {
-        key: "over",
-        get: function get() {
-            return (this._flags & this.constructor.FLAGS.OVER) !== 0;
-        }
-
-        /**
-         * Set the over flag
-         *
-         * @param {boolean} yn - Is the event over?
-         */
-        ,
-        set: function set(yn) {
-            this._doSet(this.constructor.FLAGS.OVER, yn);
-        }
-
-        /**
-         * Did the right mouse button come down in the DisplayObject?
-         *
-         * @member {boolean}
-         * @memberof PIXI.interaction.InteractionTrackingData#
-         */
-
-    }, {
-        key: "rightDown",
-        get: function get() {
-            return (this._flags & this.constructor.FLAGS.RIGHT_DOWN) !== 0;
-        }
-
-        /**
-         * Set the right down flag
-         *
-         * @param {boolean} yn - Is the right mouse button down?
-         */
-        ,
-        set: function set(yn) {
-            this._doSet(this.constructor.FLAGS.RIGHT_DOWN, yn);
-        }
-
-        /**
-         * Did the left mouse button come down in the DisplayObject?
-         *
-         * @member {boolean}
-         * @memberof PIXI.interaction.InteractionTrackingData#
-         */
-
-    }, {
-        key: "leftDown",
-        get: function get() {
-            return (this._flags & this.constructor.FLAGS.LEFT_DOWN) !== 0;
-        }
-
-        /**
-         * Set the left down flag
-         *
-         * @param {boolean} yn - Is the left mouse button down?
-         */
-        ,
-        set: function set(yn) {
-            this._doSet(this.constructor.FLAGS.LEFT_DOWN, yn);
-        }
-    }]);
-
-    return InteractionTrackingData;
-}();
-
-exports.default = InteractionTrackingData;
-
-
-InteractionTrackingData.FLAGS = Object.freeze({
-    NONE: 0,
-    OVER: 1 << 0,
-    LEFT_DOWN: 1 << 1,
-    RIGHT_DOWN: 1 << 2
-});
-
-},{}],159:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _InteractionData = require('./InteractionData');
-
-Object.defineProperty(exports, 'InteractionData', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_InteractionData).default;
-  }
-});
-
-var _InteractionManager = require('./InteractionManager');
-
-Object.defineProperty(exports, 'InteractionManager', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_InteractionManager).default;
-  }
-});
-
-var _interactiveTarget = require('./interactiveTarget');
-
-Object.defineProperty(exports, 'interactiveTarget', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_interactiveTarget).default;
-  }
-});
-
-var _InteractionTrackingData = require('./InteractionTrackingData');
-
-Object.defineProperty(exports, 'InteractionTrackingData', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_InteractionTrackingData).default;
-  }
-});
-
-var _InteractionEvent = require('./InteractionEvent');
-
-Object.defineProperty(exports, 'InteractionEvent', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_InteractionEvent).default;
-  }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./InteractionData":155,"./InteractionEvent":156,"./InteractionManager":157,"./InteractionTrackingData":158,"./interactiveTarget":160}],160:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-/**
- * Default property values of interactive objects
- * Used by {@link PIXI.interaction.InteractionManager} to automatically give all DisplayObjects these properties
- *
- * @private
- * @name interactiveTarget
- * @memberof PIXI.interaction
- * @example
- *      function MyObject() {}
- *
- *      Object.assign(
- *          core.DisplayObject.prototype,
- *          PIXI.interaction.interactiveTarget
- *      );
- */
-exports.default = {
-
-  /**
-   * Enable interaction events for the DisplayObject. Touch, pointer and mouse
-   * events will not be emitted unless `interactive` is set to `true`.
-   *
-   * @example
-   * const sprite = new PIXI.Sprite(texture);
-   * sprite.interactive = true;
-   * sprite.on('tap', (event) => {
-   *    //handle event
-   * });
-   * @member {boolean}
-   * @memberof PIXI.DisplayObject#
-   */
-  interactive: false,
-
-  /**
-   * Determines if the children to the displayObject can be clicked/touched
-   * Setting this to false allows PixiJS to bypass a recursive `hitTest` function
-   *
-   * @member {boolean}
-   * @memberof PIXI.Container#
-   */
-  interactiveChildren: true,
-
-  /**
-   * Interaction shape. Children will be hit first, then this shape will be checked.
-   * Setting this will cause this shape to be checked in hit tests rather than the displayObject's bounds.
-   *
-   * @example
-   * const sprite = new PIXI.Sprite(texture);
-   * sprite.interactive = true;
-   * sprite.hitArea = new PIXI.Rectangle(0, 0, 100, 100);
-   * @member {PIXI.Rectangle|PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.RoundedRectangle}
-   * @memberof PIXI.DisplayObject#
-   */
-  hitArea: null,
-
-  /**
-   * If enabled, the mouse cursor use the pointer behavior when hovered over the displayObject if it is interactive
-   * Setting this changes the 'cursor' property to `'pointer'`.
-   *
-   * @example
-   * const sprite = new PIXI.Sprite(texture);
-   * sprite.interactive = true;
-   * sprite.buttonMode = true;
-   * @member {boolean}
-   * @memberof PIXI.DisplayObject#
-   */
-  get buttonMode() {
-    return this.cursor === 'pointer';
-  },
-  set buttonMode(value) {
-    if (value) {
-      this.cursor = 'pointer';
-    } else if (this.cursor === 'pointer') {
-      this.cursor = null;
-    }
-  },
-
-  /**
-   * This defines what cursor mode is used when the mouse cursor
-   * is hovered over the displayObject.
-   *
-   * @example
-   * const sprite = new PIXI.Sprite(texture);
-   * sprite.interactive = true;
-   * sprite.cursor = 'wait';
-   * @see https://developer.mozilla.org/en/docs/Web/CSS/cursor
-   *
-   * @member {string}
-   * @memberof PIXI.DisplayObject#
-   */
-  cursor: null,
-
-  /**
-   * Internal set of all active pointers, by identifier
-   *
-   * @member {Map<number, InteractionTrackingData>}
-   * @memberof PIXI.DisplayObject#
-   * @private
-   */
-  get trackedPointers() {
-    if (this._trackedPointers === undefined) this._trackedPointers = {};
-
-    return this._trackedPointers;
-  },
-
-  /**
-   * Map of all tracked pointers, by identifier. Use trackedPointers to access.
-   *
-   * @private
-   * @type {Map<number, InteractionTrackingData>}
-   */
-  _trackedPointers: undefined
-};
-
-},{}],161:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.parse = parse;
-
-exports.default = function () {
-    return function bitmapFontParser(resource, next) {
-        // skip if no data or not xml data
-        if (!resource.data || resource.type !== _resourceLoader.Resource.TYPE.XML) {
-            next();
-
-            return;
-        }
-
-        // skip if not bitmap font data, using some silly duck-typing
-        if (resource.data.getElementsByTagName('page').length === 0 || resource.data.getElementsByTagName('info').length === 0 || resource.data.getElementsByTagName('info')[0].getAttribute('face') === null) {
-            next();
-
-            return;
-        }
-
-        var xmlUrl = !resource.isDataUrl ? path.dirname(resource.url) : '';
-
-        if (resource.isDataUrl) {
-            if (xmlUrl === '.') {
-                xmlUrl = '';
-            }
-
-            if (this.baseUrl && xmlUrl) {
-                // if baseurl has a trailing slash then add one to xmlUrl so the replace works below
-                if (this.baseUrl.charAt(this.baseUrl.length - 1) === '/') {
-                    xmlUrl += '/';
-                }
-            }
-        }
-
-        // remove baseUrl from xmlUrl
-        xmlUrl = xmlUrl.replace(this.baseUrl, '');
-
-        // if there is an xmlUrl now, it needs a trailing slash. Ensure that it does if the string isn't empty.
-        if (xmlUrl && xmlUrl.charAt(xmlUrl.length - 1) !== '/') {
-            xmlUrl += '/';
-        }
-
-        var textureUrl = xmlUrl + resource.data.getElementsByTagName('page')[0].getAttribute('file');
-
-        if (_core.utils.TextureCache[textureUrl]) {
-            // reuse existing texture
-            parse(resource, _core.utils.TextureCache[textureUrl]);
-            next();
-        } else {
-            var loadOptions = {
-                crossOrigin: resource.crossOrigin,
-                loadType: _resourceLoader.Resource.LOAD_TYPE.IMAGE,
-                metadata: resource.metadata.imageMetadata,
-                parentResource: resource
-            };
-
-            // load the texture for the font
-            this.add(resource.name + '_image', textureUrl, loadOptions, function (res) {
-                parse(resource, res.texture);
-                next();
-            });
-        }
-    };
-};
-
-var _path = require('path');
-
-var path = _interopRequireWildcard(_path);
-
-var _core = require('../core');
-
-var _resourceLoader = require('resource-loader');
-
-var _extras = require('../extras');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-/**
- * Register a BitmapText font from loader resource.
- *
- * @function parseBitmapFontData
- * @memberof PIXI.loaders
- * @param {PIXI.loaders.Resource} resource - Loader resource.
- * @param {PIXI.Texture} texture - Reference to texture.
- */
-function parse(resource, texture) {
-    resource.bitmapFont = _extras.BitmapText.registerFont(resource.data, texture);
-}
-
-},{"../core":65,"../extras":141,"path":23,"resource-loader":36}],162:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-exports.shared = exports.Resource = exports.textureParser = exports.getResourcePath = exports.spritesheetParser = exports.parseBitmapFontData = exports.bitmapFontParser = exports.Loader = undefined;
-
-var _bitmapFontParser = require('./bitmapFontParser');
-
-Object.defineProperty(exports, 'bitmapFontParser', {
-    enumerable: true,
-    get: function get() {
-        return _interopRequireDefault(_bitmapFontParser).default;
-    }
-});
-Object.defineProperty(exports, 'parseBitmapFontData', {
-    enumerable: true,
-    get: function get() {
-        return _bitmapFontParser.parse;
-    }
-});
-
-var _spritesheetParser = require('./spritesheetParser');
-
-Object.defineProperty(exports, 'spritesheetParser', {
-    enumerable: true,
-    get: function get() {
-        return _interopRequireDefault(_spritesheetParser).default;
-    }
-});
-Object.defineProperty(exports, 'getResourcePath', {
-    enumerable: true,
-    get: function get() {
-        return _spritesheetParser.getResourcePath;
-    }
-});
-
-var _textureParser = require('./textureParser');
-
-Object.defineProperty(exports, 'textureParser', {
-    enumerable: true,
-    get: function get() {
-        return _interopRequireDefault(_textureParser).default;
-    }
-});
-
-var _resourceLoader = require('resource-loader');
-
-Object.defineProperty(exports, 'Resource', {
-    enumerable: true,
-    get: function get() {
-        return _resourceLoader.Resource;
-    }
-});
-
-var _Application = require('../core/Application');
-
-var _Application2 = _interopRequireDefault(_Application);
-
-var _loader = require('./loader');
-
-var _loader2 = _interopRequireDefault(_loader);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * This namespace contains APIs which extends the {@link https://github.com/englercj/resource-loader resource-loader} module
- * for loading assets, data, and other resources dynamically.
- * @example
- * const loader = new PIXI.loaders.Loader();
- * loader.add('bunny', 'data/bunny.png')
- *       .add('spaceship', 'assets/spritesheet.json');
- * loader.load((loader, resources) => {
- *    // resources.bunny
- *    // resources.spaceship
- * });
- * @namespace PIXI.loaders
- */
-exports.Loader = _loader2.default;
-
-
-/**
- * A premade instance of the loader that can be used to load resources.
- * @name shared
- * @memberof PIXI.loaders
- * @type {PIXI.loaders.Loader}
- */
-var shared = new _loader2.default();
-
-shared.destroy = function () {
-    // protect destroying shared loader
-};
-
-exports.shared = shared;
-
-// Mixin the loader construction
-
-var AppPrototype = _Application2.default.prototype;
-
-AppPrototype._loader = null;
-
-/**
- * Loader instance to help with asset loading.
- * @name PIXI.Application#loader
- * @type {PIXI.loaders.Loader}
- */
-Object.defineProperty(AppPrototype, 'loader', {
-    get: function get() {
-        if (!this._loader) {
-            var sharedLoader = this._options.sharedLoader;
-
-            this._loader = sharedLoader ? shared : new _loader2.default();
-        }
-
-        return this._loader;
-    }
-});
-
-// Override the destroy function
-// making sure to destroy the current Loader
-AppPrototype._parentDestroy = AppPrototype.destroy;
-AppPrototype.destroy = function destroy(removeView) {
-    if (this._loader) {
-        this._loader.destroy();
-        this._loader = null;
-    }
-    this._parentDestroy(removeView);
-};
-
-},{"../core/Application":43,"./bitmapFontParser":161,"./loader":163,"./spritesheetParser":164,"./textureParser":165,"resource-loader":36}],163:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _resourceLoader = require('resource-loader');
-
-var _resourceLoader2 = _interopRequireDefault(_resourceLoader);
-
-var _blob = require('resource-loader/lib/middlewares/parsing/blob');
-
-var _eventemitter = require('eventemitter3');
-
-var _eventemitter2 = _interopRequireDefault(_eventemitter);
-
-var _textureParser = require('./textureParser');
-
-var _textureParser2 = _interopRequireDefault(_textureParser);
-
-var _spritesheetParser = require('./spritesheetParser');
-
-var _spritesheetParser2 = _interopRequireDefault(_spritesheetParser);
-
-var _bitmapFontParser = require('./bitmapFontParser');
-
-var _bitmapFontParser2 = _interopRequireDefault(_bitmapFontParser);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- *
- * The new loader, extends Resource Loader by Chad Engler: https://github.com/englercj/resource-loader
- *
- * ```js
- * const loader = PIXI.loader; // PixiJS exposes a premade instance for you to use.
- * //or
- * const loader = new PIXI.loaders.Loader(); // you can also create your own if you want
- *
- * const sprites = {};
- *
- * // Chainable `add` to enqueue a resource
- * loader.add('bunny', 'data/bunny.png')
- *       .add('spaceship', 'assets/spritesheet.json');
- * loader.add('scoreFont', 'assets/score.fnt');
- *
- * // Chainable `pre` to add a middleware that runs for each resource, *before* loading that resource.
- * // This is useful to implement custom caching modules (using filesystem, indexeddb, memory, etc).
- * loader.pre(cachingMiddleware);
- *
- * // Chainable `use` to add a middleware that runs for each resource, *after* loading that resource.
- * // This is useful to implement custom parsing modules (like spritesheet parsers, spine parser, etc).
- * loader.use(parsingMiddleware);
- *
- * // The `load` method loads the queue of resources, and calls the passed in callback called once all
- * // resources have loaded.
- * loader.load((loader, resources) => {
- *     // resources is an object where the key is the name of the resource loaded and the value is the resource object.
- *     // They have a couple default properties:
- *     // - `url`: The URL that the resource was loaded from
- *     // - `error`: The error that happened when trying to load (if any)
- *     // - `data`: The raw data that was loaded
- *     // also may contain other properties based on the middleware that runs.
- *     sprites.bunny = new PIXI.TilingSprite(resources.bunny.texture);
- *     sprites.spaceship = new PIXI.TilingSprite(resources.spaceship.texture);
- *     sprites.scoreFont = new PIXI.TilingSprite(resources.scoreFont.texture);
- * });
- *
- * // throughout the process multiple signals can be dispatched.
- * loader.onProgress.add(() => {}); // called once per loaded/errored file
- * loader.onError.add(() => {}); // called once per errored file
- * loader.onLoad.add(() => {}); // called once per loaded file
- * loader.onComplete.add(() => {}); // called once when the queued resources all load.
- * ```
- *
- * @see https://github.com/englercj/resource-loader
- *
- * @class
- * @extends module:resource-loader.ResourceLoader
- * @memberof PIXI.loaders
- */
-var Loader = function (_ResourceLoader) {
-    _inherits(Loader, _ResourceLoader);
-
-    /**
-     * @param {string} [baseUrl=''] - The base url for all resources loaded by this loader.
-     * @param {number} [concurrency=10] - The number of resources to load concurrently.
-     */
-    function Loader(baseUrl, concurrency) {
-        _classCallCheck(this, Loader);
-
-        var _this = _possibleConstructorReturn(this, _ResourceLoader.call(this, baseUrl, concurrency));
-
-        _eventemitter2.default.call(_this);
-
-        for (var i = 0; i < Loader._pixiMiddleware.length; ++i) {
-            _this.use(Loader._pixiMiddleware[i]());
-        }
-
-        // Compat layer, translate the new v2 signals into old v1 events.
-        _this.onStart.add(function (l) {
-            return _this.emit('start', l);
-        });
-        _this.onProgress.add(function (l, r) {
-            return _this.emit('progress', l, r);
-        });
-        _this.onError.add(function (e, l, r) {
-            return _this.emit('error', e, l, r);
-        });
-        _this.onLoad.add(function (l, r) {
-            return _this.emit('load', l, r);
-        });
-        _this.onComplete.add(function (l, r) {
-            return _this.emit('complete', l, r);
-        });
-        return _this;
-    }
-
-    /**
-     * Adds a default middleware to the PixiJS loader.
-     *
-     * @static
-     * @param {Function} fn - The middleware to add.
-     */
-
-
-    Loader.addPixiMiddleware = function addPixiMiddleware(fn) {
-        Loader._pixiMiddleware.push(fn);
-    };
-
-    /**
-     * Destroy the loader, removes references.
-     */
-
-
-    Loader.prototype.destroy = function destroy() {
-        this.removeAllListeners();
-        this.reset();
-    };
-
-    return Loader;
-}(_resourceLoader2.default);
-
-// Copy EE3 prototype (mixin)
-
-
-exports.default = Loader;
-for (var k in _eventemitter2.default.prototype) {
-    Loader.prototype[k] = _eventemitter2.default.prototype[k];
-}
-
-Loader._pixiMiddleware = [
-// parse any blob into more usable objects (e.g. Image)
-_blob.blobMiddlewareFactory,
-// parse any Image objects into textures
-_textureParser2.default,
-// parse any spritesheet data into multiple textures
-_spritesheetParser2.default,
-// parse bitmap font data into multiple textures
-_bitmapFontParser2.default];
-
-// Add custom extentions
-var Resource = _resourceLoader2.default.Resource;
-
-Resource.setExtensionXhrType('fnt', Resource.XHR_RESPONSE_TYPE.DOCUMENT);
-
-},{"./bitmapFontParser":161,"./spritesheetParser":164,"./textureParser":165,"eventemitter3":3,"resource-loader":36,"resource-loader/lib/middlewares/parsing/blob":37}],164:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-exports.default = function () {
-    return function spritesheetParser(resource, next) {
-        var imageResourceName = resource.name + '_image';
-
-        // skip if no data, its not json, it isn't spritesheet data, or the image resource already exists
-        if (!resource.data || resource.type !== _resourceLoader.Resource.TYPE.JSON || !resource.data.frames || this.resources[imageResourceName]) {
-            next();
-
-            return;
-        }
-
-        var loadOptions = {
-            crossOrigin: resource.crossOrigin,
-            loadType: _resourceLoader.Resource.LOAD_TYPE.IMAGE,
-            metadata: resource.metadata.imageMetadata,
-            parentResource: resource
-        };
-
-        var resourcePath = getResourcePath(resource, this.baseUrl);
-
-        // load the image for this sheet
-        this.add(imageResourceName, resourcePath, loadOptions, function onImageLoad(res) {
-            var spritesheet = new _core.Spritesheet(res.texture.baseTexture, resource.data, resource.url);
-
-            spritesheet.parse(function () {
-                resource.spritesheet = spritesheet;
-                resource.textures = spritesheet.textures;
-                next();
-            });
-        });
-    };
-};
-
-exports.getResourcePath = getResourcePath;
-
-var _resourceLoader = require('resource-loader');
-
-var _url = require('url');
-
-var _url2 = _interopRequireDefault(_url);
-
-var _core = require('../core');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function getResourcePath(resource, baseUrl) {
-    // Prepend url path unless the resource image is a data url
-    if (resource.isDataUrl) {
-        return resource.data.meta.image;
-    }
-
-    return _url2.default.resolve(resource.url.replace(baseUrl, ''), resource.data.meta.image);
-}
-
-},{"../core":65,"resource-loader":36,"url":29}],165:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-exports.default = function () {
-    return function textureParser(resource, next) {
-        // create a new texture if the data is an Image object
-        if (resource.data && resource.type === _resourceLoader.Resource.TYPE.IMAGE) {
-            resource.texture = _Texture2.default.fromLoader(resource.data, resource.url, resource.name);
-        }
-        next();
-    };
-};
-
-var _resourceLoader = require('resource-loader');
-
-var _Texture = require('../core/textures/Texture');
-
-var _Texture2 = _interopRequireDefault(_Texture);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"../core/textures/Texture":115,"resource-loader":36}],166:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _TextureTransform = require('../extras/TextureTransform');
-
-var _TextureTransform2 = _interopRequireDefault(_TextureTransform);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var tempPoint = new core.Point();
-var tempPolygon = new core.Polygon();
-
-/**
- * Base mesh class
- * @class
- * @extends PIXI.Container
- * @memberof PIXI.mesh
- */
-
-var Mesh = function (_core$Container) {
-  _inherits(Mesh, _core$Container);
-
-  /**
-   * @param {PIXI.Texture} texture - The texture to use
-   * @param {Float32Array} [vertices] - if you want to specify the vertices
-   * @param {Float32Array} [uvs] - if you want to specify the uvs
-   * @param {Uint16Array} [indices] - if you want to specify the indices
-   * @param {number} [drawMode] - the drawMode, can be any of the Mesh.DRAW_MODES consts
-   */
-  function Mesh(texture, vertices, uvs, indices, drawMode) {
-    _classCallCheck(this, Mesh);
-
-    /**
-     * The texture of the Mesh
-     *
-     * @member {PIXI.Texture}
-     * @private
-     */
-    var _this = _possibleConstructorReturn(this, _core$Container.call(this));
-
-    _this._texture = texture;
-
-    /**
-     * The Uvs of the Mesh
-     *
-     * @member {Float32Array}
-     */
-    _this.uvs = uvs || new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
-
-    /**
-     * An array of vertices
-     *
-     * @member {Float32Array}
-     */
-    _this.vertices = vertices || new Float32Array([0, 0, 100, 0, 100, 100, 0, 100]);
-
-    /**
-     * An array containing the indices of the vertices
-     *
-     * @member {Uint16Array}
-     */
-    //  TODO auto generate this based on draw mode!
-    _this.indices = indices || new Uint16Array([0, 1, 3, 2]);
-
-    /**
-     * Version of mesh uvs are dirty or not
-     *
-     * @member {number}
-     */
-    _this.dirty = 0;
-
-    /**
-     * Version of mesh indices
-     *
-     * @member {number}
-     */
-    _this.indexDirty = 0;
-
-    /**
-     * The blend mode to be applied to the sprite. Set to `PIXI.BLEND_MODES.NORMAL` to remove
-     * any blend mode.
-     *
-     * @member {number}
-     * @default PIXI.BLEND_MODES.NORMAL
-     * @see PIXI.BLEND_MODES
-     */
-    _this.blendMode = core.BLEND_MODES.NORMAL;
-
-    /**
-     * Triangles in canvas mode are automatically antialiased, use this value to force triangles
-     * to overlap a bit with each other.
-     *
-     * @member {number}
-     */
-    _this.canvasPadding = 0;
-
-    /**
-     * The way the Mesh should be drawn, can be any of the {@link PIXI.mesh.Mesh.DRAW_MODES} consts
-     *
-     * @member {number}
-     * @see PIXI.mesh.Mesh.DRAW_MODES
-     */
-    _this.drawMode = drawMode || Mesh.DRAW_MODES.TRIANGLE_MESH;
-
-    /**
-     * The default shader that is used if a mesh doesn't have a more specific one.
-     *
-     * @member {PIXI.Shader}
-     */
-    _this.shader = null;
-
-    /**
-     * The tint applied to the mesh. This is a [r,g,b] value. A value of [1,1,1] will remove any
-     * tint effect.
-     *
-     * @member {number}
-     */
-    _this.tintRgb = new Float32Array([1, 1, 1]);
-
-    /**
-     * A map of renderer IDs to webgl render data
-     *
-     * @private
-     * @member {object<number, object>}
-     */
-    _this._glDatas = {};
-
-    /**
-     * transform that is applied to UV to get the texture coords
-     * its updated independently from texture uvTransform
-     * updates of uvs are tied to that thing
-     *
-     * @member {PIXI.extras.TextureTransform}
-     * @private
-     */
-    _this._uvTransform = new _TextureTransform2.default(texture);
-
-    /**
-     * whether or not upload uvTransform to shader
-     * if its false, then uvs should be pre-multiplied
-     * if you change it for generated mesh, please call 'refresh(true)'
-     * @member {boolean}
-     * @default false
-     */
-    _this.uploadUvTransform = false;
-
-    /**
-     * Plugin that is responsible for rendering this element.
-     * Allows to customize the rendering process without overriding '_renderWebGL' & '_renderCanvas' methods.
-     * @member {string}
-     * @default 'mesh'
-     */
-    _this.pluginName = 'mesh';
-    return _this;
-  }
-
-  /**
-   * Renders the object using the WebGL renderer
-   *
-   * @private
-   * @param {PIXI.WebGLRenderer} renderer - a reference to the WebGL renderer
-   */
-
-
-  Mesh.prototype._renderWebGL = function _renderWebGL(renderer) {
-    this.refresh();
-    renderer.setObjectRenderer(renderer.plugins[this.pluginName]);
-    renderer.plugins[this.pluginName].render(this);
-  };
-
-  /**
-   * Renders the object using the Canvas renderer
-   *
-   * @private
-   * @param {PIXI.CanvasRenderer} renderer - The canvas renderer.
-   */
-
-
-  Mesh.prototype._renderCanvas = function _renderCanvas(renderer) {
-    this.refresh();
-    renderer.plugins[this.pluginName].render(this);
-  };
-
-  /**
-   * When the texture is updated, this event will fire to update the scale and frame
-   *
-   * @private
-   */
-
-
-  Mesh.prototype._onTextureUpdate = function _onTextureUpdate() {
-    this._uvTransform.texture = this._texture;
-    this.refresh();
-  };
-
-  /**
-   * multiplies uvs only if uploadUvTransform is false
-   * call it after you change uvs manually
-   * make sure that texture is valid
-   */
-
-
-  Mesh.prototype.multiplyUvs = function multiplyUvs() {
-    if (!this.uploadUvTransform) {
-      this._uvTransform.multiplyUvs(this.uvs);
-    }
-  };
-
-  /**
-   * Refreshes uvs for generated meshes (rope, plane)
-   * sometimes refreshes vertices too
-   *
-   * @param {boolean} [forceUpdate=false] if true, matrices will be updated any case
-   */
-
-
-  Mesh.prototype.refresh = function refresh(forceUpdate) {
-    if (this._uvTransform.update(forceUpdate)) {
-      this._refresh();
-    }
-  };
-
-  /**
-   * re-calculates mesh coords
-   * @protected
-   */
-
-
-  Mesh.prototype._refresh = function _refresh() {}
-  /* empty */
-
-
-  /**
-   * Returns the bounds of the mesh as a rectangle. The bounds calculation takes the worldTransform into account.
-   *
-   */
-  ;
-
-  Mesh.prototype._calculateBounds = function _calculateBounds() {
-    // TODO - we can cache local bounds and use them if they are dirty (like graphics)
-    this._bounds.addVertices(this.transform, this.vertices, 0, this.vertices.length);
-  };
-
-  /**
-   * Tests if a point is inside this mesh. Works only for TRIANGLE_MESH
-   *
-   * @param {PIXI.Point} point - the point to test
-   * @return {boolean} the result of the test
-   */
-
-
-  Mesh.prototype.containsPoint = function containsPoint(point) {
-    if (!this.getBounds().contains(point.x, point.y)) {
-      return false;
-    }
-
-    this.worldTransform.applyInverse(point, tempPoint);
-
-    var vertices = this.vertices;
-    var points = tempPolygon.points;
-    var indices = this.indices;
-    var len = this.indices.length;
-    var step = this.drawMode === Mesh.DRAW_MODES.TRIANGLES ? 3 : 1;
-
-    for (var i = 0; i + 2 < len; i += step) {
-      var ind0 = indices[i] * 2;
-      var ind1 = indices[i + 1] * 2;
-      var ind2 = indices[i + 2] * 2;
-
-      points[0] = vertices[ind0];
-      points[1] = vertices[ind0 + 1];
-      points[2] = vertices[ind1];
-      points[3] = vertices[ind1 + 1];
-      points[4] = vertices[ind2];
-      points[5] = vertices[ind2 + 1];
-
-      if (tempPolygon.contains(tempPoint.x, tempPoint.y)) {
-        return true;
-      }
-    }
-
-    return false;
-  };
-
-  /**
-   * The texture that the mesh uses.
-   *
-   * @member {PIXI.Texture}
-   */
-
-
-  _createClass(Mesh, [{
-    key: 'texture',
-    get: function get() {
-      return this._texture;
-    },
-    set: function set(value) // eslint-disable-line require-jsdoc
-    {
-      if (this._texture === value) {
-        return;
-      }
-
-      this._texture = value;
-
-      if (value) {
-        // wait for the texture to load
-        if (value.baseTexture.hasLoaded) {
-          this._onTextureUpdate();
-        } else {
-          value.once('update', this._onTextureUpdate, this);
-        }
-      }
-    }
-
-    /**
-     * The tint applied to the mesh. This is a hex value. A value of 0xFFFFFF will remove any tint effect.
-     *
-     * @member {number}
-     * @default 0xFFFFFF
-     */
-
-  }, {
-    key: 'tint',
-    get: function get() {
-      return core.utils.rgb2hex(this.tintRgb);
-    },
-    set: function set(value) // eslint-disable-line require-jsdoc
-    {
-      this.tintRgb = core.utils.hex2rgb(value, this.tintRgb);
-    }
-  }]);
-
-  return Mesh;
-}(core.Container);
-
-/**
- * Different drawing buffer modes supported
- *
- * @static
- * @constant
- * @type {object}
- * @property {number} TRIANGLE_MESH
- * @property {number} TRIANGLES
- */
-
-
-exports.default = Mesh;
-Mesh.DRAW_MODES = {
-  TRIANGLE_MESH: 0,
-  TRIANGLES: 1
-};
-
-},{"../core":65,"../extras/TextureTransform":136}],167:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _Plane2 = require('./Plane');
-
-var _Plane3 = _interopRequireDefault(_Plane2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var DEFAULT_BORDER_SIZE = 10;
-
-/**
- * The NineSlicePlane allows you to stretch a texture using 9-slice scaling. The corners will remain unscaled (useful
- * for buttons with rounded corners for example) and the other areas will be scaled horizontally and or vertically
- *
- *```js
- * let Plane9 = new PIXI.NineSlicePlane(PIXI.Texture.fromImage('BoxWithRoundedCorners.png'), 15, 15, 15, 15);
- *  ```
- * <pre>
- *      A                          B
- *    +---+----------------------+---+
- *  C | 1 |          2           | 3 |
- *    +---+----------------------+---+
- *    |   |                      |   |
- *    | 4 |          5           | 6 |
- *    |   |                      |   |
- *    +---+----------------------+---+
- *  D | 7 |          8           | 9 |
- *    +---+----------------------+---+
-
- *  When changing this objects width and/or height:
- *     areas 1 3 7 and 9 will remain unscaled.
- *     areas 2 and 8 will be stretched horizontally
- *     areas 4 and 6 will be stretched vertically
- *     area 5 will be stretched both horizontally and vertically
- * </pre>
- *
- * @class
- * @extends PIXI.mesh.Plane
- * @memberof PIXI.mesh
- *
- */
-
-var NineSlicePlane = function (_Plane) {
-    _inherits(NineSlicePlane, _Plane);
-
-    /**
-     * @param {PIXI.Texture} texture - The texture to use on the NineSlicePlane.
-     * @param {int} [leftWidth=10] size of the left vertical bar (A)
-     * @param {int} [topHeight=10] size of the top horizontal bar (C)
-     * @param {int} [rightWidth=10] size of the right vertical bar (B)
-     * @param {int} [bottomHeight=10] size of the bottom horizontal bar (D)
-     */
-    function NineSlicePlane(texture, leftWidth, topHeight, rightWidth, bottomHeight) {
-        _classCallCheck(this, NineSlicePlane);
-
-        var _this = _possibleConstructorReturn(this, _Plane.call(this, texture, 4, 4));
-
-        _this._origWidth = texture.orig.width;
-        _this._origHeight = texture.orig.height;
-
-        /**
-         * The width of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane
-         *
-         * @member {number}
-         * @memberof PIXI.NineSlicePlane#
-         * @override
-         */
-        _this._width = _this._origWidth;
-
-        /**
-         * The height of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane
-         *
-         * @member {number}
-         * @memberof PIXI.NineSlicePlane#
-         * @override
-         */
-        _this._height = _this._origHeight;
-
-        /**
-         * The width of the left column (a)
-         *
-         * @member {number}
-         * @memberof PIXI.NineSlicePlane#
-         * @override
-         */
-        _this.leftWidth = typeof leftWidth !== 'undefined' ? leftWidth : DEFAULT_BORDER_SIZE;
-
-        /**
-         * The width of the right column (b)
-         *
-         * @member {number}
-         * @memberof PIXI.NineSlicePlane#
-         * @override
-         */
-        _this.rightWidth = typeof rightWidth !== 'undefined' ? rightWidth : DEFAULT_BORDER_SIZE;
-
-        /**
-         * The height of the top row (c)
-         *
-         * @member {number}
-         * @memberof PIXI.NineSlicePlane#
-         * @override
-         */
-        _this.topHeight = typeof topHeight !== 'undefined' ? topHeight : DEFAULT_BORDER_SIZE;
-
-        /**
-         * The height of the bottom row (d)
-         *
-         * @member {number}
-         * @memberof PIXI.NineSlicePlane#
-         * @override
-         */
-        _this.bottomHeight = typeof bottomHeight !== 'undefined' ? bottomHeight : DEFAULT_BORDER_SIZE;
-
-        _this.refresh(true);
-        return _this;
-    }
-
-    /**
-     * Updates the horizontal vertices.
-     *
-     */
-
-
-    NineSlicePlane.prototype.updateHorizontalVertices = function updateHorizontalVertices() {
-        var vertices = this.vertices;
-
-        vertices[9] = vertices[11] = vertices[13] = vertices[15] = this._topHeight;
-        vertices[17] = vertices[19] = vertices[21] = vertices[23] = this._height - this._bottomHeight;
-        vertices[25] = vertices[27] = vertices[29] = vertices[31] = this._height;
-    };
-
-    /**
-     * Updates the vertical vertices.
-     *
-     */
-
-
-    NineSlicePlane.prototype.updateVerticalVertices = function updateVerticalVertices() {
-        var vertices = this.vertices;
-
-        vertices[2] = vertices[10] = vertices[18] = vertices[26] = this._leftWidth;
-        vertices[4] = vertices[12] = vertices[20] = vertices[28] = this._width - this._rightWidth;
-        vertices[6] = vertices[14] = vertices[22] = vertices[30] = this._width;
-    };
-
-    /**
-     * Renders the object using the Canvas renderer
-     *
-     * @private
-     * @param {PIXI.CanvasRenderer} renderer - The canvas renderer to render with.
-     */
-
-
-    NineSlicePlane.prototype._renderCanvas = function _renderCanvas(renderer) {
-        var context = renderer.context;
-
-        context.globalAlpha = this.worldAlpha;
-
-        var transform = this.worldTransform;
-        var res = renderer.resolution;
-
-        if (renderer.roundPixels) {
-            context.setTransform(transform.a * res, transform.b * res, transform.c * res, transform.d * res, transform.tx * res | 0, transform.ty * res | 0);
-        } else {
-            context.setTransform(transform.a * res, transform.b * res, transform.c * res, transform.d * res, transform.tx * res, transform.ty * res);
-        }
-
-        var base = this._texture.baseTexture;
-        var textureSource = base.source;
-        var w = base.width;
-        var h = base.height;
-
-        this.drawSegment(context, textureSource, w, h, 0, 1, 10, 11);
-        this.drawSegment(context, textureSource, w, h, 2, 3, 12, 13);
-        this.drawSegment(context, textureSource, w, h, 4, 5, 14, 15);
-        this.drawSegment(context, textureSource, w, h, 8, 9, 18, 19);
-        this.drawSegment(context, textureSource, w, h, 10, 11, 20, 21);
-        this.drawSegment(context, textureSource, w, h, 12, 13, 22, 23);
-        this.drawSegment(context, textureSource, w, h, 16, 17, 26, 27);
-        this.drawSegment(context, textureSource, w, h, 18, 19, 28, 29);
-        this.drawSegment(context, textureSource, w, h, 20, 21, 30, 31);
-    };
-
-    /**
-     * Renders one segment of the plane.
-     * to mimic the exact drawing behavior of stretching the image like WebGL does, we need to make sure
-     * that the source area is at least 1 pixel in size, otherwise nothing gets drawn when a slice size of 0 is used.
-     *
-     * @private
-     * @param {CanvasRenderingContext2D} context - The context to draw with.
-     * @param {CanvasImageSource} textureSource - The source to draw.
-     * @param {number} w - width of the texture
-     * @param {number} h - height of the texture
-     * @param {number} x1 - x index 1
-     * @param {number} y1 - y index 1
-     * @param {number} x2 - x index 2
-     * @param {number} y2 - y index 2
-     */
-
-
-    NineSlicePlane.prototype.drawSegment = function drawSegment(context, textureSource, w, h, x1, y1, x2, y2) {
-        // otherwise you get weird results when using slices of that are 0 wide or high.
-        var uvs = this.uvs;
-        var vertices = this.vertices;
-
-        var sw = (uvs[x2] - uvs[x1]) * w;
-        var sh = (uvs[y2] - uvs[y1]) * h;
-        var dw = vertices[x2] - vertices[x1];
-        var dh = vertices[y2] - vertices[y1];
-
-        // make sure the source is at least 1 pixel wide and high, otherwise nothing will be drawn.
-        if (sw < 1) {
-            sw = 1;
-        }
-
-        if (sh < 1) {
-            sh = 1;
-        }
-
-        // make sure destination is at least 1 pixel wide and high, otherwise you get
-        // lines when rendering close to original size.
-        if (dw < 1) {
-            dw = 1;
-        }
-
-        if (dh < 1) {
-            dh = 1;
-        }
-
-        context.drawImage(textureSource, uvs[x1] * w, uvs[y1] * h, sw, sh, vertices[x1], vertices[y1], dw, dh);
-    };
-
-    /**
-     * The width of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane
-     *
-     * @member {number}
-     */
-
-
-    /**
-     * Refreshes NineSlicePlane coords. All of them.
-     */
-    NineSlicePlane.prototype._refresh = function _refresh() {
-        _Plane.prototype._refresh.call(this);
-
-        var uvs = this.uvs;
-        var texture = this._texture;
-
-        this._origWidth = texture.orig.width;
-        this._origHeight = texture.orig.height;
-
-        var _uvw = 1.0 / this._origWidth;
-        var _uvh = 1.0 / this._origHeight;
-
-        uvs[0] = uvs[8] = uvs[16] = uvs[24] = 0;
-        uvs[1] = uvs[3] = uvs[5] = uvs[7] = 0;
-        uvs[6] = uvs[14] = uvs[22] = uvs[30] = 1;
-        uvs[25] = uvs[27] = uvs[29] = uvs[31] = 1;
-
-        uvs[2] = uvs[10] = uvs[18] = uvs[26] = _uvw * this._leftWidth;
-        uvs[4] = uvs[12] = uvs[20] = uvs[28] = 1 - _uvw * this._rightWidth;
-        uvs[9] = uvs[11] = uvs[13] = uvs[15] = _uvh * this._topHeight;
-        uvs[17] = uvs[19] = uvs[21] = uvs[23] = 1 - _uvh * this._bottomHeight;
-
-        this.updateHorizontalVertices();
-        this.updateVerticalVertices();
-
-        this.dirty = true;
-
-        this.multiplyUvs();
-    };
-
-    _createClass(NineSlicePlane, [{
-        key: 'width',
-        get: function get() {
-            return this._width;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._width = value;
-            this._refresh();
-        }
-
-        /**
-         * The height of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'height',
-        get: function get() {
-            return this._height;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._height = value;
-            this._refresh();
-        }
-
-        /**
-         * The width of the left column
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'leftWidth',
-        get: function get() {
-            return this._leftWidth;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._leftWidth = value;
-            this._refresh();
-        }
-
-        /**
-         * The width of the right column
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'rightWidth',
-        get: function get() {
-            return this._rightWidth;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._rightWidth = value;
-            this._refresh();
-        }
-
-        /**
-         * The height of the top row
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'topHeight',
-        get: function get() {
-            return this._topHeight;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._topHeight = value;
-            this._refresh();
-        }
-
-        /**
-         * The height of the bottom row
-         *
-         * @member {number}
-         */
-
-    }, {
-        key: 'bottomHeight',
-        get: function get() {
-            return this._bottomHeight;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._bottomHeight = value;
-            this._refresh();
-        }
-    }]);
-
-    return NineSlicePlane;
-}(_Plane3.default);
-
-exports.default = NineSlicePlane;
-
-},{"./Plane":168}],168:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Mesh2 = require('./Mesh');
-
-var _Mesh3 = _interopRequireDefault(_Mesh2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The Plane allows you to draw a texture across several points and them manipulate these points
- *
- *```js
- * for (let i = 0; i < 20; i++) {
- *     points.push(new PIXI.Point(i * 50, 0));
- * };
- * let Plane = new PIXI.Plane(PIXI.Texture.fromImage("snake.png"), points);
- *  ```
- *
- * @class
- * @extends PIXI.mesh.Mesh
- * @memberof PIXI.mesh
- *
- */
-var Plane = function (_Mesh) {
-    _inherits(Plane, _Mesh);
-
-    /**
-     * @param {PIXI.Texture} texture - The texture to use on the Plane.
-     * @param {number} verticesX - The number of vertices in the x-axis
-     * @param {number} verticesY - The number of vertices in the y-axis
-     */
-    function Plane(texture, verticesX, verticesY) {
-        _classCallCheck(this, Plane);
-
-        /**
-         * Tracker for if the Plane is ready to be drawn. Needed because Mesh ctor can
-         * call _onTextureUpdated which could call refresh too early.
-         *
-         * @member {boolean}
-         * @private
-         */
-        var _this = _possibleConstructorReturn(this, _Mesh.call(this, texture));
-
-        _this._ready = true;
-
-        _this.verticesX = verticesX || 10;
-        _this.verticesY = verticesY || 10;
-
-        _this.drawMode = _Mesh3.default.DRAW_MODES.TRIANGLES;
-        _this.refresh();
-        return _this;
-    }
-
-    /**
-     * Refreshes plane coordinates
-     *
-     */
-
-
-    Plane.prototype._refresh = function _refresh() {
-        var texture = this._texture;
-        var total = this.verticesX * this.verticesY;
-        var verts = [];
-        var colors = [];
-        var uvs = [];
-        var indices = [];
-
-        var segmentsX = this.verticesX - 1;
-        var segmentsY = this.verticesY - 1;
-
-        var sizeX = texture.width / segmentsX;
-        var sizeY = texture.height / segmentsY;
-
-        for (var i = 0; i < total; i++) {
-            var x = i % this.verticesX;
-            var y = i / this.verticesX | 0;
-
-            verts.push(x * sizeX, y * sizeY);
-
-            uvs.push(x / segmentsX, y / segmentsY);
-        }
-
-        //  cons
-
-        var totalSub = segmentsX * segmentsY;
-
-        for (var _i = 0; _i < totalSub; _i++) {
-            var xpos = _i % segmentsX;
-            var ypos = _i / segmentsX | 0;
-
-            var value = ypos * this.verticesX + xpos;
-            var value2 = ypos * this.verticesX + xpos + 1;
-            var value3 = (ypos + 1) * this.verticesX + xpos;
-            var value4 = (ypos + 1) * this.verticesX + xpos + 1;
-
-            indices.push(value, value2, value3);
-            indices.push(value2, value4, value3);
-        }
-
-        // console.log(indices)
-        this.vertices = new Float32Array(verts);
-        this.uvs = new Float32Array(uvs);
-        this.colors = new Float32Array(colors);
-        this.indices = new Uint16Array(indices);
-        this.indexDirty = true;
-
-        this.multiplyUvs();
-    };
-
-    /**
-     * Clear texture UVs when new texture is set
-     *
-     * @private
-     */
-
-
-    Plane.prototype._onTextureUpdate = function _onTextureUpdate() {
-        _Mesh3.default.prototype._onTextureUpdate.call(this);
-
-        // wait for the Plane ctor to finish before calling refresh
-        if (this._ready) {
-            this.refresh();
-        }
-    };
-
-    return Plane;
-}(_Mesh3.default);
-
-exports.default = Plane;
-
-},{"./Mesh":166}],169:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Mesh2 = require('./Mesh');
-
-var _Mesh3 = _interopRequireDefault(_Mesh2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The rope allows you to draw a texture across several points and them manipulate these points
- *
- *```js
- * for (let i = 0; i < 20; i++) {
- *     points.push(new PIXI.Point(i * 50, 0));
- * };
- * let rope = new PIXI.Rope(PIXI.Texture.fromImage("snake.png"), points);
- *  ```
- *
- * @class
- * @extends PIXI.mesh.Mesh
- * @memberof PIXI.mesh
- *
- */
-var Rope = function (_Mesh) {
-    _inherits(Rope, _Mesh);
-
-    /**
-     * @param {PIXI.Texture} texture - The texture to use on the rope.
-     * @param {PIXI.Point[]} points - An array of {@link PIXI.Point} objects to construct this rope.
-     */
-    function Rope(texture, points) {
-        _classCallCheck(this, Rope);
-
-        /**
-         * An array of points that determine the rope
-         *
-         * @member {PIXI.Point[]}
-         */
-        var _this = _possibleConstructorReturn(this, _Mesh.call(this, texture));
-
-        _this.points = points;
-
-        /**
-         * An array of vertices used to construct this rope.
-         *
-         * @member {Float32Array}
-         */
-        _this.vertices = new Float32Array(points.length * 4);
-
-        /**
-         * The WebGL Uvs of the rope.
-         *
-         * @member {Float32Array}
-         */
-        _this.uvs = new Float32Array(points.length * 4);
-
-        /**
-         * An array containing the color components
-         *
-         * @member {Float32Array}
-         */
-        _this.colors = new Float32Array(points.length * 2);
-
-        /**
-         * An array containing the indices of the vertices
-         *
-         * @member {Uint16Array}
-         */
-        _this.indices = new Uint16Array(points.length * 2);
-
-        /**
-         * refreshes vertices on every updateTransform
-         * @member {boolean}
-         * @default true
-         */
-        _this.autoUpdate = true;
-
-        _this.refresh();
-        return _this;
-    }
-
-    /**
-     * Refreshes
-     *
-     */
-
-
-    Rope.prototype._refresh = function _refresh() {
-        var points = this.points;
-
-        // if too little points, or texture hasn't got UVs set yet just move on.
-        if (points.length < 1 || !this._texture._uvs) {
-            return;
-        }
-
-        // if the number of points has changed we will need to recreate the arraybuffers
-        if (this.vertices.length / 4 !== points.length) {
-            this.vertices = new Float32Array(points.length * 4);
-            this.uvs = new Float32Array(points.length * 4);
-            this.colors = new Float32Array(points.length * 2);
-            this.indices = new Uint16Array(points.length * 2);
-        }
-
-        var uvs = this.uvs;
-
-        var indices = this.indices;
-        var colors = this.colors;
-
-        uvs[0] = 0;
-        uvs[1] = 0;
-        uvs[2] = 0;
-        uvs[3] = 1;
-
-        colors[0] = 1;
-        colors[1] = 1;
-
-        indices[0] = 0;
-        indices[1] = 1;
-
-        var total = points.length;
-
-        for (var i = 1; i < total; i++) {
-            // time to do some smart drawing!
-            var index = i * 4;
-            var amount = i / (total - 1);
-
-            uvs[index] = amount;
-            uvs[index + 1] = 0;
-
-            uvs[index + 2] = amount;
-            uvs[index + 3] = 1;
-
-            index = i * 2;
-            colors[index] = 1;
-            colors[index + 1] = 1;
-
-            index = i * 2;
-            indices[index] = index;
-            indices[index + 1] = index + 1;
-        }
-
-        // ensure that the changes are uploaded
-        this.dirty++;
-        this.indexDirty++;
-
-        this.multiplyUvs();
-        this.refreshVertices();
-    };
-
-    /**
-     * refreshes vertices of Rope mesh
-     */
-
-
-    Rope.prototype.refreshVertices = function refreshVertices() {
-        var points = this.points;
-
-        if (points.length < 1) {
-            return;
-        }
-
-        var lastPoint = points[0];
-        var nextPoint = void 0;
-        var perpX = 0;
-        var perpY = 0;
-
-        // this.count -= 0.2;
-
-        var vertices = this.vertices;
-        var total = points.length;
-
-        for (var i = 0; i < total; i++) {
-            var point = points[i];
-            var index = i * 4;
-
-            if (i < points.length - 1) {
-                nextPoint = points[i + 1];
-            } else {
-                nextPoint = point;
-            }
-
-            perpY = -(nextPoint.x - lastPoint.x);
-            perpX = nextPoint.y - lastPoint.y;
-
-            var ratio = (1 - i / (total - 1)) * 10;
-
-            if (ratio > 1) {
-                ratio = 1;
-            }
-
-            var perpLength = Math.sqrt(perpX * perpX + perpY * perpY);
-            var num = this._texture.height / 2; // (20 + Math.abs(Math.sin((i + this.count) * 0.3) * 50) )* ratio;
-
-            perpX /= perpLength;
-            perpY /= perpLength;
-
-            perpX *= num;
-            perpY *= num;
-
-            vertices[index] = point.x + perpX;
-            vertices[index + 1] = point.y + perpY;
-            vertices[index + 2] = point.x - perpX;
-            vertices[index + 3] = point.y - perpY;
-
-            lastPoint = point;
-        }
-    };
-
-    /**
-     * Updates the object transform for rendering
-     *
-     * @private
-     */
-
-
-    Rope.prototype.updateTransform = function updateTransform() {
-        if (this.autoUpdate) {
-            this.refreshVertices();
-        }
-        this.containerUpdateTransform();
-    };
-
-    return Rope;
-}(_Mesh3.default);
-
-exports.default = Rope;
-
-},{"./Mesh":166}],170:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _Mesh = require('../Mesh');
-
-var _Mesh2 = _interopRequireDefault(_Mesh);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * Renderer dedicated to meshes.
- *
- * @class
- * @private
- * @memberof PIXI
- */
-var MeshSpriteRenderer = function () {
-    /**
-     * @param {PIXI.CanvasRenderer} renderer - The renderer this downport works for
-     */
-    function MeshSpriteRenderer(renderer) {
-        _classCallCheck(this, MeshSpriteRenderer);
-
-        this.renderer = renderer;
-    }
-
-    /**
-     * Renders the Mesh
-     *
-     * @param {PIXI.mesh.Mesh} mesh - the Mesh to render
-     */
-
-
-    MeshSpriteRenderer.prototype.render = function render(mesh) {
-        var renderer = this.renderer;
-        var context = renderer.context;
-
-        var transform = mesh.worldTransform;
-        var res = renderer.resolution;
-
-        if (renderer.roundPixels) {
-            context.setTransform(transform.a * res, transform.b * res, transform.c * res, transform.d * res, transform.tx * res | 0, transform.ty * res | 0);
-        } else {
-            context.setTransform(transform.a * res, transform.b * res, transform.c * res, transform.d * res, transform.tx * res, transform.ty * res);
-        }
-
-        renderer.setBlendMode(mesh.blendMode);
-
-        if (mesh.drawMode === _Mesh2.default.DRAW_MODES.TRIANGLE_MESH) {
-            this._renderTriangleMesh(mesh);
-        } else {
-            this._renderTriangles(mesh);
-        }
-    };
-
-    /**
-     * Draws the object in Triangle Mesh mode
-     *
-     * @private
-     * @param {PIXI.mesh.Mesh} mesh - the Mesh to render
-     */
-
-
-    MeshSpriteRenderer.prototype._renderTriangleMesh = function _renderTriangleMesh(mesh) {
-        // draw triangles!!
-        var length = mesh.vertices.length / 2;
-
-        for (var i = 0; i < length - 2; i++) {
-            // draw some triangles!
-            var index = i * 2;
-
-            this._renderDrawTriangle(mesh, index, index + 2, index + 4);
-        }
-    };
-
-    /**
-     * Draws the object in triangle mode using canvas
-     *
-     * @private
-     * @param {PIXI.mesh.Mesh} mesh - the current mesh
-     */
-
-
-    MeshSpriteRenderer.prototype._renderTriangles = function _renderTriangles(mesh) {
-        // draw triangles!!
-        var indices = mesh.indices;
-        var length = indices.length;
-
-        for (var i = 0; i < length; i += 3) {
-            // draw some triangles!
-            var index0 = indices[i] * 2;
-            var index1 = indices[i + 1] * 2;
-            var index2 = indices[i + 2] * 2;
-
-            this._renderDrawTriangle(mesh, index0, index1, index2);
-        }
-    };
-
-    /**
-     * Draws one of the triangles that from the Mesh
-     *
-     * @private
-     * @param {PIXI.mesh.Mesh} mesh - the current mesh
-     * @param {number} index0 - the index of the first vertex
-     * @param {number} index1 - the index of the second vertex
-     * @param {number} index2 - the index of the third vertex
-     */
-
-
-    MeshSpriteRenderer.prototype._renderDrawTriangle = function _renderDrawTriangle(mesh, index0, index1, index2) {
-        var context = this.renderer.context;
-        var uvs = mesh.uvs;
-        var vertices = mesh.vertices;
-        var texture = mesh._texture;
-
-        if (!texture.valid) {
-            return;
-        }
-
-        var base = texture.baseTexture;
-        var textureSource = base.source;
-        var textureWidth = base.width;
-        var textureHeight = base.height;
-
-        var u0 = void 0;
-        var u1 = void 0;
-        var u2 = void 0;
-        var v0 = void 0;
-        var v1 = void 0;
-        var v2 = void 0;
-
-        if (mesh.uploadUvTransform) {
-            var ut = mesh._uvTransform.mapCoord;
-
-            u0 = (uvs[index0] * ut.a + uvs[index0 + 1] * ut.c + ut.tx) * base.width;
-            u1 = (uvs[index1] * ut.a + uvs[index1 + 1] * ut.c + ut.tx) * base.width;
-            u2 = (uvs[index2] * ut.a + uvs[index2 + 1] * ut.c + ut.tx) * base.width;
-            v0 = (uvs[index0] * ut.b + uvs[index0 + 1] * ut.d + ut.ty) * base.height;
-            v1 = (uvs[index1] * ut.b + uvs[index1 + 1] * ut.d + ut.ty) * base.height;
-            v2 = (uvs[index2] * ut.b + uvs[index2 + 1] * ut.d + ut.ty) * base.height;
-        } else {
-            u0 = uvs[index0] * base.width;
-            u1 = uvs[index1] * base.width;
-            u2 = uvs[index2] * base.width;
-            v0 = uvs[index0 + 1] * base.height;
-            v1 = uvs[index1 + 1] * base.height;
-            v2 = uvs[index2 + 1] * base.height;
-        }
-
-        var x0 = vertices[index0];
-        var x1 = vertices[index1];
-        var x2 = vertices[index2];
-        var y0 = vertices[index0 + 1];
-        var y1 = vertices[index1 + 1];
-        var y2 = vertices[index2 + 1];
-
-        if (mesh.canvasPadding > 0) {
-            var paddingX = mesh.canvasPadding / mesh.worldTransform.a;
-            var paddingY = mesh.canvasPadding / mesh.worldTransform.d;
-            var centerX = (x0 + x1 + x2) / 3;
-            var centerY = (y0 + y1 + y2) / 3;
-
-            var normX = x0 - centerX;
-            var normY = y0 - centerY;
-
-            var dist = Math.sqrt(normX * normX + normY * normY);
-
-            x0 = centerX + normX / dist * (dist + paddingX);
-            y0 = centerY + normY / dist * (dist + paddingY);
-
-            //
-
-            normX = x1 - centerX;
-            normY = y1 - centerY;
-
-            dist = Math.sqrt(normX * normX + normY * normY);
-            x1 = centerX + normX / dist * (dist + paddingX);
-            y1 = centerY + normY / dist * (dist + paddingY);
-
-            normX = x2 - centerX;
-            normY = y2 - centerY;
-
-            dist = Math.sqrt(normX * normX + normY * normY);
-            x2 = centerX + normX / dist * (dist + paddingX);
-            y2 = centerY + normY / dist * (dist + paddingY);
-        }
-
-        context.save();
-        context.beginPath();
-
-        context.moveTo(x0, y0);
-        context.lineTo(x1, y1);
-        context.lineTo(x2, y2);
-
-        context.closePath();
-
-        context.clip();
-
-        // Compute matrix transform
-        var delta = u0 * v1 + v0 * u2 + u1 * v2 - v1 * u2 - v0 * u1 - u0 * v2;
-        var deltaA = x0 * v1 + v0 * x2 + x1 * v2 - v1 * x2 - v0 * x1 - x0 * v2;
-        var deltaB = u0 * x1 + x0 * u2 + u1 * x2 - x1 * u2 - x0 * u1 - u0 * x2;
-        var deltaC = u0 * v1 * x2 + v0 * x1 * u2 + x0 * u1 * v2 - x0 * v1 * u2 - v0 * u1 * x2 - u0 * x1 * v2;
-        var deltaD = y0 * v1 + v0 * y2 + y1 * v2 - v1 * y2 - v0 * y1 - y0 * v2;
-        var deltaE = u0 * y1 + y0 * u2 + u1 * y2 - y1 * u2 - y0 * u1 - u0 * y2;
-        var deltaF = u0 * v1 * y2 + v0 * y1 * u2 + y0 * u1 * v2 - y0 * v1 * u2 - v0 * u1 * y2 - u0 * y1 * v2;
-
-        context.transform(deltaA / delta, deltaD / delta, deltaB / delta, deltaE / delta, deltaC / delta, deltaF / delta);
-
-        context.drawImage(textureSource, 0, 0, textureWidth * base.resolution, textureHeight * base.resolution, 0, 0, textureWidth, textureHeight);
-
-        context.restore();
-    };
-
-    /**
-     * Renders a flat Mesh
-     *
-     * @private
-     * @param {PIXI.mesh.Mesh} mesh - The Mesh to render
-     */
-
-
-    MeshSpriteRenderer.prototype.renderMeshFlat = function renderMeshFlat(mesh) {
-        var context = this.renderer.context;
-        var vertices = mesh.vertices;
-        var length = vertices.length / 2;
-
-        // this.count++;
-
-        context.beginPath();
-
-        for (var i = 1; i < length - 2; ++i) {
-            // draw some triangles!
-            var index = i * 2;
-
-            var x0 = vertices[index];
-            var y0 = vertices[index + 1];
-
-            var x1 = vertices[index + 2];
-            var y1 = vertices[index + 3];
-
-            var x2 = vertices[index + 4];
-            var y2 = vertices[index + 5];
-
-            context.moveTo(x0, y0);
-            context.lineTo(x1, y1);
-            context.lineTo(x2, y2);
-        }
-
-        context.fillStyle = '#FF0000';
-        context.fill();
-        context.closePath();
-    };
-
-    /**
-     * destroy the the renderer.
-     *
-     */
-
-
-    MeshSpriteRenderer.prototype.destroy = function destroy() {
-        this.renderer = null;
-    };
-
-    return MeshSpriteRenderer;
-}();
-
-exports.default = MeshSpriteRenderer;
-
-
-core.CanvasRenderer.registerPlugin('mesh', MeshSpriteRenderer);
-
-},{"../../core":65,"../Mesh":166}],171:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _Mesh = require('./Mesh');
-
-Object.defineProperty(exports, 'Mesh', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Mesh).default;
-  }
-});
-
-var _MeshRenderer = require('./webgl/MeshRenderer');
-
-Object.defineProperty(exports, 'MeshRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_MeshRenderer).default;
-  }
-});
-
-var _CanvasMeshRenderer = require('./canvas/CanvasMeshRenderer');
-
-Object.defineProperty(exports, 'CanvasMeshRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CanvasMeshRenderer).default;
-  }
-});
-
-var _Plane = require('./Plane');
-
-Object.defineProperty(exports, 'Plane', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Plane).default;
-  }
-});
-
-var _NineSlicePlane = require('./NineSlicePlane');
-
-Object.defineProperty(exports, 'NineSlicePlane', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_NineSlicePlane).default;
-  }
-});
-
-var _Rope = require('./Rope');
-
-Object.defineProperty(exports, 'Rope', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_Rope).default;
-  }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./Mesh":166,"./NineSlicePlane":167,"./Plane":168,"./Rope":169,"./canvas/CanvasMeshRenderer":170,"./webgl/MeshRenderer":172}],172:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-var _Mesh = require('../Mesh');
-
-var _Mesh2 = _interopRequireDefault(_Mesh);
-
-var _path = require('path');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var matrixIdentity = core.Matrix.IDENTITY;
-
-/**
- * WebGL renderer plugin for tiling sprites
- *
- * @class
- * @memberof PIXI
- * @extends PIXI.ObjectRenderer
- */
-
-var MeshRenderer = function (_core$ObjectRenderer) {
-    _inherits(MeshRenderer, _core$ObjectRenderer);
-
-    /**
-     * constructor for renderer
-     *
-     * @param {WebGLRenderer} renderer The renderer this tiling awesomeness works for.
-     */
-    function MeshRenderer(renderer) {
-        _classCallCheck(this, MeshRenderer);
-
-        var _this = _possibleConstructorReturn(this, _core$ObjectRenderer.call(this, renderer));
-
-        _this.shader = null;
-        return _this;
-    }
-
-    /**
-     * Sets up the renderer context and necessary buffers.
-     *
-     * @private
-     */
-
-
-    MeshRenderer.prototype.onContextChange = function onContextChange() {
-        var gl = this.renderer.gl;
-
-        this.shader = new core.Shader(gl, 'attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n', 'varying vec2 vTextureCoord;\nuniform vec4 uColor;\n\nuniform sampler2D uSampler;\n\nvoid main(void)\n{\n    gl_FragColor = texture2D(uSampler, vTextureCoord) * uColor;\n}\n');
-    };
-
-    /**
-     * renders mesh
-     *
-     * @param {PIXI.mesh.Mesh} mesh mesh instance
-     */
-
-
-    MeshRenderer.prototype.render = function render(mesh) {
-        var renderer = this.renderer;
-        var gl = renderer.gl;
-        var texture = mesh._texture;
-
-        if (!texture.valid) {
-            return;
-        }
-
-        var glData = mesh._glDatas[renderer.CONTEXT_UID];
-
-        if (!glData) {
-            renderer.bindVao(null);
-
-            glData = {
-                shader: this.shader,
-                vertexBuffer: _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl, mesh.vertices, gl.STREAM_DRAW),
-                uvBuffer: _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl, mesh.uvs, gl.STREAM_DRAW),
-                indexBuffer: _pixiGlCore2.default.GLBuffer.createIndexBuffer(gl, mesh.indices, gl.STATIC_DRAW),
-                // build the vao object that will render..
-                vao: null,
-                dirty: mesh.dirty,
-                indexDirty: mesh.indexDirty
-            };
-
-            // build the vao object that will render..
-            glData.vao = new _pixiGlCore2.default.VertexArrayObject(gl).addIndex(glData.indexBuffer).addAttribute(glData.vertexBuffer, glData.shader.attributes.aVertexPosition, gl.FLOAT, false, 2 * 4, 0).addAttribute(glData.uvBuffer, glData.shader.attributes.aTextureCoord, gl.FLOAT, false, 2 * 4, 0);
-
-            mesh._glDatas[renderer.CONTEXT_UID] = glData;
-        }
-
-        renderer.bindVao(glData.vao);
-
-        if (mesh.dirty !== glData.dirty) {
-            glData.dirty = mesh.dirty;
-            glData.uvBuffer.upload(mesh.uvs);
-        }
-
-        if (mesh.indexDirty !== glData.indexDirty) {
-            glData.indexDirty = mesh.indexDirty;
-            glData.indexBuffer.upload(mesh.indices);
-        }
-
-        glData.vertexBuffer.upload(mesh.vertices);
-
-        renderer.bindShader(glData.shader);
-
-        glData.shader.uniforms.uSampler = renderer.bindTexture(texture);
-
-        renderer.state.setBlendMode(core.utils.correctBlendMode(mesh.blendMode, texture.baseTexture.premultipliedAlpha));
-
-        if (glData.shader.uniforms.uTransform) {
-            if (mesh.uploadUvTransform) {
-                glData.shader.uniforms.uTransform = mesh._uvTransform.mapCoord.toArray(true);
-            } else {
-                glData.shader.uniforms.uTransform = matrixIdentity.toArray(true);
-            }
-        }
-        glData.shader.uniforms.translationMatrix = mesh.worldTransform.toArray(true);
-
-        glData.shader.uniforms.uColor = core.utils.premultiplyRgba(mesh.tintRgb, mesh.worldAlpha, glData.shader.uniforms.uColor, texture.baseTexture.premultipliedAlpha);
-
-        var drawMode = mesh.drawMode === _Mesh2.default.DRAW_MODES.TRIANGLE_MESH ? gl.TRIANGLE_STRIP : gl.TRIANGLES;
-
-        glData.vao.draw(drawMode, mesh.indices.length, 0);
-    };
-
-    return MeshRenderer;
-}(core.ObjectRenderer);
-
-exports.default = MeshRenderer;
-
-
-core.WebGLRenderer.registerPlugin('mesh', MeshRenderer);
-
-},{"../../core":65,"../Mesh":166,"path":23,"pixi-gl-core":12}],173:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _core = require('../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _utils = require('../core/utils');
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The ParticleContainer class is a really fast version of the Container built solely for speed,
- * so use when you need a lot of sprites or particles. The tradeoff of the ParticleContainer is that advanced
- * functionality will not work. ParticleContainer implements only the basic object transform (position, scale, rotation).
- * Any other functionality like tinting, masking, etc will not work on sprites in this batch.
- *
- * It's extremely easy to use :
- *
- * ```js
- * let container = new ParticleContainer();
- *
- * for (let i = 0; i < 100; ++i)
- * {
- *     let sprite = new PIXI.Sprite.fromImage("myImage.png");
- *     container.addChild(sprite);
- * }
- * ```
- *
- * And here you have a hundred sprites that will be rendered at the speed of light.
- *
- * @class
- * @extends PIXI.Container
- * @memberof PIXI.particles
- */
-var ParticleContainer = function (_core$Container) {
-    _inherits(ParticleContainer, _core$Container);
-
-    /**
-     * @param {number} [maxSize=15000] - The maximum number of particles that can be renderer by the container.
-     * @param {object} [properties] - The properties of children that should be uploaded to the gpu and applied.
-     * @param {boolean} [properties.scale=false] - When true, scale be uploaded and applied.
-     * @param {boolean} [properties.position=true] - When true, position be uploaded and applied.
-     * @param {boolean} [properties.rotation=false] - When true, rotation be uploaded and applied.
-     * @param {boolean} [properties.uvs=false] - When true, uvs be uploaded and applied.
-     * @param {boolean} [properties.alpha=false] - When true, alpha be uploaded and applied.
-     * @param {number} [batchSize=15000] - Number of particles per batch.
-     */
-    function ParticleContainer() {
-        var maxSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1500;
-        var properties = arguments[1];
-        var batchSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 16384;
-
-        _classCallCheck(this, ParticleContainer);
-
-        // Making sure the batch size is valid
-        // 65535 is max vertex index in the index buffer (see ParticleRenderer)
-        // so max number of particles is 65536 / 4 = 16384
-        var _this = _possibleConstructorReturn(this, _core$Container.call(this));
-
-        var maxBatchSize = 16384;
-
-        if (batchSize > maxBatchSize) {
-            batchSize = maxBatchSize;
-        }
-
-        if (batchSize > maxSize) {
-            batchSize = maxSize;
-        }
-
-        /**
-         * Set properties to be dynamic (true) / static (false)
-         *
-         * @member {boolean[]}
-         * @private
-         */
-        _this._properties = [false, true, false, false, false];
-
-        /**
-         * @member {number}
-         * @private
-         */
-        _this._maxSize = maxSize;
-
-        /**
-         * @member {number}
-         * @private
-         */
-        _this._batchSize = batchSize;
-
-        /**
-         * @member {object<number, WebGLBuffer>}
-         * @private
-         */
-        _this._glBuffers = {};
-
-        /**
-         * @member {number}
-         * @private
-         */
-        _this._bufferToUpdate = 0;
-
-        /**
-         * @member {boolean}
-         *
-         */
-        _this.interactiveChildren = false;
-
-        /**
-         * The blend mode to be applied to the sprite. Apply a value of `PIXI.BLEND_MODES.NORMAL`
-         * to reset the blend mode.
-         *
-         * @member {number}
-         * @default PIXI.BLEND_MODES.NORMAL
-         * @see PIXI.BLEND_MODES
-         */
-        _this.blendMode = core.BLEND_MODES.NORMAL;
-
-        /**
-         * Used for canvas renderering. If true then the elements will be positioned at the
-         * nearest pixel. This provides a nice speed boost.
-         *
-         * @member {boolean}
-         * @default true;
-         */
-        _this.roundPixels = true;
-
-        /**
-         * The texture used to render the children.
-         *
-         * @readonly
-         * @member {BaseTexture}
-         */
-        _this.baseTexture = null;
-
-        _this.setProperties(properties);
-
-        /**
-         * The tint applied to the container.
-         * This is a hex value. A value of 0xFFFFFF will remove any tint effect.
-         *
-         * @private
-         * @member {number}
-         * @default 0xFFFFFF
-         */
-        _this._tint = 0;
-        _this.tintRgb = new Float32Array(4);
-        _this.tint = 0xFFFFFF;
-        return _this;
-    }
-
-    /**
-     * Sets the private properties array to dynamic / static based on the passed properties object
-     *
-     * @param {object} properties - The properties to be uploaded
-     */
-
-
-    ParticleContainer.prototype.setProperties = function setProperties(properties) {
-        if (properties) {
-            this._properties[0] = 'scale' in properties ? !!properties.scale : this._properties[0];
-            this._properties[1] = 'position' in properties ? !!properties.position : this._properties[1];
-            this._properties[2] = 'rotation' in properties ? !!properties.rotation : this._properties[2];
-            this._properties[3] = 'uvs' in properties ? !!properties.uvs : this._properties[3];
-            this._properties[4] = 'alpha' in properties ? !!properties.alpha : this._properties[4];
-        }
-    };
-
-    /**
-     * Updates the object transform for rendering
-     *
-     * @private
-     */
-
-
-    ParticleContainer.prototype.updateTransform = function updateTransform() {
-        // TODO don't need to!
-        this.displayObjectUpdateTransform();
-        //  PIXI.Container.prototype.updateTransform.call( this );
-    };
-
-    /**
-     * The tint applied to the container. This is a hex value.
-     * A value of 0xFFFFFF will remove any tint effect.
-     ** IMPORTANT: This is a webGL only feature and will be ignored by the canvas renderer.
-     * @member {number}
-     * @default 0xFFFFFF
-     */
-
-
-    /**
-     * Renders the container using the WebGL renderer
-     *
-     * @private
-     * @param {PIXI.WebGLRenderer} renderer - The webgl renderer
-     */
-    ParticleContainer.prototype.renderWebGL = function renderWebGL(renderer) {
-        var _this2 = this;
-
-        if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable) {
-            return;
-        }
-
-        if (!this.baseTexture) {
-            this.baseTexture = this.children[0]._texture.baseTexture;
-            if (!this.baseTexture.hasLoaded) {
-                this.baseTexture.once('update', function () {
-                    return _this2.onChildrenChange(0);
-                });
-            }
-        }
-
-        renderer.setObjectRenderer(renderer.plugins.particle);
-        renderer.plugins.particle.render(this);
-    };
-
-    /**
-     * Set the flag that static data should be updated to true
-     *
-     * @private
-     * @param {number} smallestChildIndex - The smallest child index
-     */
-
-
-    ParticleContainer.prototype.onChildrenChange = function onChildrenChange(smallestChildIndex) {
-        var bufferIndex = Math.floor(smallestChildIndex / this._batchSize);
-
-        if (bufferIndex < this._bufferToUpdate) {
-            this._bufferToUpdate = bufferIndex;
-        }
-    };
-
-    /**
-     * Renders the object using the Canvas renderer
-     *
-     * @private
-     * @param {PIXI.CanvasRenderer} renderer - The canvas renderer
-     */
-
-
-    ParticleContainer.prototype.renderCanvas = function renderCanvas(renderer) {
-        if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable) {
-            return;
-        }
-
-        var context = renderer.context;
-        var transform = this.worldTransform;
-        var isRotated = true;
-
-        var positionX = 0;
-        var positionY = 0;
-
-        var finalWidth = 0;
-        var finalHeight = 0;
-
-        var compositeOperation = renderer.blendModes[this.blendMode];
-
-        if (compositeOperation !== context.globalCompositeOperation) {
-            context.globalCompositeOperation = compositeOperation;
-        }
-
-        context.globalAlpha = this.worldAlpha;
-
-        this.displayObjectUpdateTransform();
-
-        for (var i = 0; i < this.children.length; ++i) {
-            var child = this.children[i];
-
-            if (!child.visible) {
-                continue;
-            }
-
-            var frame = child._texture.frame;
-
-            context.globalAlpha = this.worldAlpha * child.alpha;
-
-            if (child.rotation % (Math.PI * 2) === 0) {
-                // this is the fastest  way to optimise! - if rotation is 0 then we can avoid any kind of setTransform call
-                if (isRotated) {
-                    context.setTransform(transform.a, transform.b, transform.c, transform.d, transform.tx * renderer.resolution, transform.ty * renderer.resolution);
-
-                    isRotated = false;
-                }
-
-                positionX = child.anchor.x * (-frame.width * child.scale.x) + child.position.x + 0.5;
-                positionY = child.anchor.y * (-frame.height * child.scale.y) + child.position.y + 0.5;
-
-                finalWidth = frame.width * child.scale.x;
-                finalHeight = frame.height * child.scale.y;
-            } else {
-                if (!isRotated) {
-                    isRotated = true;
-                }
-
-                child.displayObjectUpdateTransform();
-
-                var childTransform = child.worldTransform;
-
-                if (renderer.roundPixels) {
-                    context.setTransform(childTransform.a, childTransform.b, childTransform.c, childTransform.d, childTransform.tx * renderer.resolution | 0, childTransform.ty * renderer.resolution | 0);
-                } else {
-                    context.setTransform(childTransform.a, childTransform.b, childTransform.c, childTransform.d, childTransform.tx * renderer.resolution, childTransform.ty * renderer.resolution);
-                }
-
-                positionX = child.anchor.x * -frame.width + 0.5;
-                positionY = child.anchor.y * -frame.height + 0.5;
-
-                finalWidth = frame.width;
-                finalHeight = frame.height;
-            }
-
-            var resolution = child._texture.baseTexture.resolution;
-
-            context.drawImage(child._texture.baseTexture.source, frame.x * resolution, frame.y * resolution, frame.width * resolution, frame.height * resolution, positionX * renderer.resolution, positionY * renderer.resolution, finalWidth * renderer.resolution, finalHeight * renderer.resolution);
-        }
-    };
-
-    /**
-     * Destroys the container
-     *
-     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-     *  have been set to that value
-     * @param {boolean} [options.children=false] - if set to true, all the children will have their
-     *  destroy method called as well. 'options' will be passed on to those calls.
-     * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
-     *  Should it destroy the texture of the child sprite
-     * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
-     *  Should it destroy the base texture of the child sprite
-     */
-
-
-    ParticleContainer.prototype.destroy = function destroy(options) {
-        _core$Container.prototype.destroy.call(this, options);
-
-        if (this._buffers) {
-            for (var i = 0; i < this._buffers.length; ++i) {
-                this._buffers[i].destroy();
-            }
-        }
-
-        this._properties = null;
-        this._buffers = null;
-    };
-
-    _createClass(ParticleContainer, [{
-        key: 'tint',
-        get: function get() {
-            return this._tint;
-        },
-        set: function set(value) // eslint-disable-line require-jsdoc
-        {
-            this._tint = value;
-            (0, _utils.hex2rgb)(value, this.tintRgb);
-        }
-    }]);
-
-    return ParticleContainer;
-}(core.Container);
-
-exports.default = ParticleContainer;
-
-},{"../core":65,"../core/utils":124}],174:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _ParticleContainer = require('./ParticleContainer');
-
-Object.defineProperty(exports, 'ParticleContainer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_ParticleContainer).default;
-  }
-});
-
-var _ParticleRenderer = require('./webgl/ParticleRenderer');
-
-Object.defineProperty(exports, 'ParticleRenderer', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_ParticleRenderer).default;
-  }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./ParticleContainer":173,"./webgl/ParticleRenderer":176}],175:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _pixiGlCore = require('pixi-gl-core');
-
-var _pixiGlCore2 = _interopRequireDefault(_pixiGlCore);
-
-var _createIndicesForQuads = require('../../core/utils/createIndicesForQuads');
-
-var _createIndicesForQuads2 = _interopRequireDefault(_createIndicesForQuads);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * @author Mat Groves
- *
- * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
- * for creating the original PixiJS version!
- * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that
- * they now share 4 bytes on the vertex buffer
- *
- * Heavily inspired by LibGDX's ParticleBuffer:
- * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleBuffer.java
- */
-
-/**
- * The particle buffer manages the static and dynamic buffers for a particle container.
- *
- * @class
- * @private
- * @memberof PIXI
- */
-var ParticleBuffer = function () {
-    /**
-     * @param {WebGLRenderingContext} gl - The rendering context.
-     * @param {object} properties - The properties to upload.
-     * @param {boolean[]} dynamicPropertyFlags - Flags for which properties are dynamic.
-     * @param {number} size - The size of the batch.
-     */
-    function ParticleBuffer(gl, properties, dynamicPropertyFlags, size) {
-        _classCallCheck(this, ParticleBuffer);
-
-        /**
-         * The current WebGL drawing context.
-         *
-         * @member {WebGLRenderingContext}
-         */
-        this.gl = gl;
-
-        /**
-         * Size of a single vertex.
-         *
-         * @member {number}
-         */
-        this.vertSize = 2;
-
-        /**
-         * Size of a single vertex in bytes.
-         *
-         * @member {number}
-         */
-        this.vertByteSize = this.vertSize * 4;
-
-        /**
-         * The number of particles the buffer can hold
-         *
-         * @member {number}
-         */
-        this.size = size;
-
-        /**
-         * A list of the properties that are dynamic.
-         *
-         * @member {object[]}
-         */
-        this.dynamicProperties = [];
-
-        /**
-         * A list of the properties that are static.
-         *
-         * @member {object[]}
-         */
-        this.staticProperties = [];
-
-        for (var i = 0; i < properties.length; ++i) {
-            var property = properties[i];
-
-            // Make copy of properties object so that when we edit the offset it doesn't
-            // change all other instances of the object literal
-            property = {
-                attribute: property.attribute,
-                size: property.size,
-                uploadFunction: property.uploadFunction,
-                offset: property.offset
-            };
-
-            if (dynamicPropertyFlags[i]) {
-                this.dynamicProperties.push(property);
-            } else {
-                this.staticProperties.push(property);
-            }
-        }
-
-        this.staticStride = 0;
-        this.staticBuffer = null;
-        this.staticData = null;
-
-        this.dynamicStride = 0;
-        this.dynamicBuffer = null;
-        this.dynamicData = null;
-
-        this.initBuffers();
-    }
-
-    /**
-     * Sets up the renderer context and necessary buffers.
-     *
-     * @private
-     */
-
-
-    ParticleBuffer.prototype.initBuffers = function initBuffers() {
-        var gl = this.gl;
-        var dynamicOffset = 0;
-
-        /**
-         * Holds the indices of the geometry (quads) to draw
-         *
-         * @member {Uint16Array}
-         */
-        this.indices = (0, _createIndicesForQuads2.default)(this.size);
-        this.indexBuffer = _pixiGlCore2.default.GLBuffer.createIndexBuffer(gl, this.indices, gl.STATIC_DRAW);
-
-        this.dynamicStride = 0;
-
-        for (var i = 0; i < this.dynamicProperties.length; ++i) {
-            var property = this.dynamicProperties[i];
-
-            property.offset = dynamicOffset;
-            dynamicOffset += property.size;
-            this.dynamicStride += property.size;
-        }
-
-        this.dynamicData = new Float32Array(this.size * this.dynamicStride * 4);
-        this.dynamicBuffer = _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl, this.dynamicData, gl.STREAM_DRAW);
-
-        // static //
-        var staticOffset = 0;
-
-        this.staticStride = 0;
-
-        for (var _i = 0; _i < this.staticProperties.length; ++_i) {
-            var _property = this.staticProperties[_i];
-
-            _property.offset = staticOffset;
-            staticOffset += _property.size;
-            this.staticStride += _property.size;
-        }
-
-        this.staticData = new Float32Array(this.size * this.staticStride * 4);
-        this.staticBuffer = _pixiGlCore2.default.GLBuffer.createVertexBuffer(gl, this.staticData, gl.STATIC_DRAW);
-
-        this.vao = new _pixiGlCore2.default.VertexArrayObject(gl).addIndex(this.indexBuffer);
-
-        for (var _i2 = 0; _i2 < this.dynamicProperties.length; ++_i2) {
-            var _property2 = this.dynamicProperties[_i2];
-
-            this.vao.addAttribute(this.dynamicBuffer, _property2.attribute, gl.FLOAT, false, this.dynamicStride * 4, _property2.offset * 4);
-        }
-
-        for (var _i3 = 0; _i3 < this.staticProperties.length; ++_i3) {
-            var _property3 = this.staticProperties[_i3];
-
-            this.vao.addAttribute(this.staticBuffer, _property3.attribute, gl.FLOAT, false, this.staticStride * 4, _property3.offset * 4);
-        }
-    };
-
-    /**
-     * Uploads the dynamic properties.
-     *
-     * @param {PIXI.DisplayObject[]} children - The children to upload.
-     * @param {number} startIndex - The index to start at.
-     * @param {number} amount - The number to upload.
-     */
-
-
-    ParticleBuffer.prototype.uploadDynamic = function uploadDynamic(children, startIndex, amount) {
-        for (var i = 0; i < this.dynamicProperties.length; i++) {
-            var property = this.dynamicProperties[i];
-
-            property.uploadFunction(children, startIndex, amount, this.dynamicData, this.dynamicStride, property.offset);
-        }
-
-        this.dynamicBuffer.upload();
-    };
-
-    /**
-     * Uploads the static properties.
-     *
-     * @param {PIXI.DisplayObject[]} children - The children to upload.
-     * @param {number} startIndex - The index to start at.
-     * @param {number} amount - The number to upload.
-     */
-
-
-    ParticleBuffer.prototype.uploadStatic = function uploadStatic(children, startIndex, amount) {
-        for (var i = 0; i < this.staticProperties.length; i++) {
-            var property = this.staticProperties[i];
-
-            property.uploadFunction(children, startIndex, amount, this.staticData, this.staticStride, property.offset);
-        }
-
-        this.staticBuffer.upload();
-    };
-
-    /**
-     * Destroys the ParticleBuffer.
-     *
-     */
-
-
-    ParticleBuffer.prototype.destroy = function destroy() {
-        this.dynamicProperties = null;
-        this.dynamicData = null;
-        this.dynamicBuffer.destroy();
-
-        this.staticProperties = null;
-        this.staticData = null;
-        this.staticBuffer.destroy();
-    };
-
-    return ParticleBuffer;
-}();
-
-exports.default = ParticleBuffer;
-
-},{"../../core/utils/createIndicesForQuads":122,"pixi-gl-core":12}],176:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _ParticleShader = require('./ParticleShader');
-
-var _ParticleShader2 = _interopRequireDefault(_ParticleShader);
-
-var _ParticleBuffer = require('./ParticleBuffer');
-
-var _ParticleBuffer2 = _interopRequireDefault(_ParticleBuffer);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * @author Mat Groves
- *
- * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
- * for creating the original PixiJS version!
- * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they now
- * share 4 bytes on the vertex buffer
- *
- * Heavily inspired by LibGDX's ParticleRenderer:
- * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleRenderer.java
- */
-
-/**
- *
- * @class
- * @private
- * @memberof PIXI
- */
-var ParticleRenderer = function (_core$ObjectRenderer) {
-    _inherits(ParticleRenderer, _core$ObjectRenderer);
-
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - The renderer this sprite batch works for.
-     */
-    function ParticleRenderer(renderer) {
-        _classCallCheck(this, ParticleRenderer);
-
-        // 65535 is max vertex index in the index buffer (see ParticleRenderer)
-        // so max number of particles is 65536 / 4 = 16384
-        // and max number of element in the index buffer is 16384 * 6 = 98304
-        // Creating a full index buffer, overhead is 98304 * 2 = 196Ko
-        // let numIndices = 98304;
-
-        /**
-         * The default shader that is used if a sprite doesn't have a more specific one.
-         *
-         * @member {PIXI.Shader}
-         */
-        var _this = _possibleConstructorReturn(this, _core$ObjectRenderer.call(this, renderer));
-
-        _this.shader = null;
-
-        _this.indexBuffer = null;
-
-        _this.properties = null;
-
-        _this.tempMatrix = new core.Matrix();
-
-        _this.CONTEXT_UID = 0;
-        return _this;
-    }
-
-    /**
-     * When there is a WebGL context change
-     *
-     * @private
-     */
-
-
-    ParticleRenderer.prototype.onContextChange = function onContextChange() {
-        var gl = this.renderer.gl;
-
-        this.CONTEXT_UID = this.renderer.CONTEXT_UID;
-
-        // setup default shader
-        this.shader = new _ParticleShader2.default(gl);
-
-        this.properties = [
-        // verticesData
-        {
-            attribute: this.shader.attributes.aVertexPosition,
-            size: 2,
-            uploadFunction: this.uploadVertices,
-            offset: 0
-        },
-        // positionData
-        {
-            attribute: this.shader.attributes.aPositionCoord,
-            size: 2,
-            uploadFunction: this.uploadPosition,
-            offset: 0
-        },
-        // rotationData
-        {
-            attribute: this.shader.attributes.aRotation,
-            size: 1,
-            uploadFunction: this.uploadRotation,
-            offset: 0
-        },
-        // uvsData
-        {
-            attribute: this.shader.attributes.aTextureCoord,
-            size: 2,
-            uploadFunction: this.uploadUvs,
-            offset: 0
-        },
-        // alphaData
-        {
-            attribute: this.shader.attributes.aColor,
-            size: 1,
-            uploadFunction: this.uploadAlpha,
-            offset: 0
-        }];
-    };
-
-    /**
-     * Starts a new particle batch.
-     *
-     */
-
-
-    ParticleRenderer.prototype.start = function start() {
-        this.renderer.bindShader(this.shader);
-    };
-
-    /**
-     * Renders the particle container object.
-     *
-     * @param {PIXI.ParticleContainer} container - The container to render using this ParticleRenderer
-     */
-
-
-    ParticleRenderer.prototype.render = function render(container) {
-        var children = container.children;
-        var maxSize = container._maxSize;
-        var batchSize = container._batchSize;
-        var renderer = this.renderer;
-        var totalChildren = children.length;
-
-        if (totalChildren === 0) {
-            return;
-        } else if (totalChildren > maxSize) {
-            totalChildren = maxSize;
-        }
-
-        var buffers = container._glBuffers[renderer.CONTEXT_UID];
-
-        if (!buffers) {
-            buffers = container._glBuffers[renderer.CONTEXT_UID] = this.generateBuffers(container);
-        }
-
-        var baseTexture = children[0]._texture.baseTexture;
-
-        // if the uvs have not updated then no point rendering just yet!
-        this.renderer.setBlendMode(core.utils.correctBlendMode(container.blendMode, baseTexture.premultipliedAlpha));
-
-        var gl = renderer.gl;
-
-        var m = container.worldTransform.copy(this.tempMatrix);
-
-        m.prepend(renderer._activeRenderTarget.projectionMatrix);
-
-        this.shader.uniforms.projectionMatrix = m.toArray(true);
-
-        this.shader.uniforms.uColor = core.utils.premultiplyRgba(container.tintRgb, container.worldAlpha, this.shader.uniforms.uColor, baseTexture.premultipliedAlpha);
-
-        // make sure the texture is bound..
-        this.shader.uniforms.uSampler = renderer.bindTexture(baseTexture);
-
-        // now lets upload and render the buffers..
-        for (var i = 0, j = 0; i < totalChildren; i += batchSize, j += 1) {
-            var amount = totalChildren - i;
-
-            if (amount > batchSize) {
-                amount = batchSize;
-            }
-
-            var buffer = buffers[j];
-
-            // we always upload the dynamic
-            buffer.uploadDynamic(children, i, amount);
-
-            // we only upload the static content when we have to!
-            if (container._bufferToUpdate === j) {
-                buffer.uploadStatic(children, i, amount);
-                container._bufferToUpdate = j + 1;
-            }
-
-            // bind the buffer
-            renderer.bindVao(buffer.vao);
-            buffer.vao.draw(gl.TRIANGLES, amount * 6);
-        }
-    };
-
-    /**
-     * Creates one particle buffer for each child in the container we want to render and updates internal properties
-     *
-     * @param {PIXI.ParticleContainer} container - The container to render using this ParticleRenderer
-     * @return {PIXI.ParticleBuffer[]} The buffers
-     */
-
-
-    ParticleRenderer.prototype.generateBuffers = function generateBuffers(container) {
-        var gl = this.renderer.gl;
-        var buffers = [];
-        var size = container._maxSize;
-        var batchSize = container._batchSize;
-        var dynamicPropertyFlags = container._properties;
-
-        for (var i = 0; i < size; i += batchSize) {
-            buffers.push(new _ParticleBuffer2.default(gl, this.properties, dynamicPropertyFlags, batchSize));
-        }
+  /**
+   * The ObservablePoint object represents a location in a two-dimensional coordinate system, where `x` represents
+   * the position on the horizontal axis and `y` represents the position on the vertical axis.
+   *
+   * An `ObservablePoint` is a point that triggers a callback when the point's position is changed.
+   * @memberof PIXI
+   */
+  var ObservablePoint = /** @class */ (function () {
+      /**
+       * Creates a new `ObservablePoint`
+       * @param cb - callback function triggered when `x` and/or `y` are changed
+       * @param scope - owner of callback
+       * @param {number} [x=0] - position of the point on the x axis
+       * @param {number} [y=0] - position of the point on the y axis
+       */
+      function ObservablePoint(cb, scope, x, y) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          this._x = x;
+          this._y = y;
+          this.cb = cb;
+          this.scope = scope;
+      }
+      /**
+       * Creates a clone of this point.
+       * The callback and scope params can be overridden otherwise they will default
+       * to the clone object's values.
+       * @override
+       * @param cb - The callback function triggered when `x` and/or `y` are changed
+       * @param scope - The owner of the callback
+       * @returns a copy of this observable point
+       */
+      ObservablePoint.prototype.clone = function (cb, scope) {
+          if (cb === void 0) { cb = this.cb; }
+          if (scope === void 0) { scope = this.scope; }
+          return new ObservablePoint(cb, scope, this._x, this._y);
+      };
+      /**
+       * Sets the point to a new `x` and `y` position.
+       * If `y` is omitted, both `x` and `y` will be set to `x`.
+       * @param {number} [x=0] - position of the point on the x axis
+       * @param {number} [y=x] - position of the point on the y axis
+       * @returns The observable point instance itself
+       */
+      ObservablePoint.prototype.set = function (x, y) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = x; }
+          if (this._x !== x || this._y !== y) {
+              this._x = x;
+              this._y = y;
+              this.cb.call(this.scope);
+          }
+          return this;
+      };
+      /**
+       * Copies x and y from the given point (`p`)
+       * @param p - The point to copy from. Can be any of type that is or extends `IPointData`
+       * @returns The observable point instance itself
+       */
+      ObservablePoint.prototype.copyFrom = function (p) {
+          if (this._x !== p.x || this._y !== p.y) {
+              this._x = p.x;
+              this._y = p.y;
+              this.cb.call(this.scope);
+          }
+          return this;
+      };
+      /**
+       * Copies this point's x and y into that of the given point (`p`)
+       * @param p - The point to copy to. Can be any of type that is or extends `IPointData`
+       * @returns The point (`p`) with values updated
+       */
+      ObservablePoint.prototype.copyTo = function (p) {
+          p.set(this._x, this._y);
+          return p;
+      };
+      /**
+       * Accepts another point (`p`) and returns `true` if the given point is equal to this point
+       * @param p - The point to check
+       * @returns Returns `true` if both `x` and `y` are equal
+       */
+      ObservablePoint.prototype.equals = function (p) {
+          return (p.x === this._x) && (p.y === this._y);
+      };
+      ObservablePoint.prototype.toString = function () {
+          return "[@pixi/math:ObservablePoint x=" + 0 + " y=" + 0 + " scope=" + this.scope + "]";
+      };
+      Object.defineProperty(ObservablePoint.prototype, "x", {
+          /** Position of the observable point on the x axis. */
+          get: function () {
+              return this._x;
+          },
+          set: function (value) {
+              if (this._x !== value) {
+                  this._x = value;
+                  this.cb.call(this.scope);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(ObservablePoint.prototype, "y", {
+          /** Position of the observable point on the y axis. */
+          get: function () {
+              return this._y;
+          },
+          set: function (value) {
+              if (this._y !== value) {
+                  this._y = value;
+                  this.cb.call(this.scope);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return ObservablePoint;
+  }());
 
-        return buffers;
-    };
+  /**
+   * The PixiJS Matrix as a class makes it a lot faster.
+   *
+   * Here is a representation of it:
+   * ```js
+   * | a | c | tx|
+   * | b | d | ty|
+   * | 0 | 0 | 1 |
+   * ```
+   * @memberof PIXI
+   */
+  var Matrix = /** @class */ (function () {
+      /**
+       * @param a - x scale
+       * @param b - y skew
+       * @param c - x skew
+       * @param d - y scale
+       * @param tx - x translation
+       * @param ty - y translation
+       */
+      function Matrix(a, b, c, d, tx, ty) {
+          if (a === void 0) { a = 1; }
+          if (b === void 0) { b = 0; }
+          if (c === void 0) { c = 0; }
+          if (d === void 0) { d = 1; }
+          if (tx === void 0) { tx = 0; }
+          if (ty === void 0) { ty = 0; }
+          this.array = null;
+          this.a = a;
+          this.b = b;
+          this.c = c;
+          this.d = d;
+          this.tx = tx;
+          this.ty = ty;
+      }
+      /**
+       * Creates a Matrix object based on the given array. The Element to Matrix mapping order is as follows:
+       *
+       * a = array[0]
+       * b = array[1]
+       * c = array[3]
+       * d = array[4]
+       * tx = array[2]
+       * ty = array[5]
+       * @param array - The array that the matrix will be populated from.
+       */
+      Matrix.prototype.fromArray = function (array) {
+          this.a = array[0];
+          this.b = array[1];
+          this.c = array[3];
+          this.d = array[4];
+          this.tx = array[2];
+          this.ty = array[5];
+      };
+      /**
+       * Sets the matrix properties.
+       * @param a - Matrix component
+       * @param b - Matrix component
+       * @param c - Matrix component
+       * @param d - Matrix component
+       * @param tx - Matrix component
+       * @param ty - Matrix component
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.set = function (a, b, c, d, tx, ty) {
+          this.a = a;
+          this.b = b;
+          this.c = c;
+          this.d = d;
+          this.tx = tx;
+          this.ty = ty;
+          return this;
+      };
+      /**
+       * Creates an array from the current Matrix object.
+       * @param transpose - Whether we need to transpose the matrix or not
+       * @param [out=new Float32Array(9)] - If provided the array will be assigned to out
+       * @returns The newly created array which contains the matrix
+       */
+      Matrix.prototype.toArray = function (transpose, out) {
+          if (!this.array) {
+              this.array = new Float32Array(9);
+          }
+          var array = out || this.array;
+          if (transpose) {
+              array[0] = this.a;
+              array[1] = this.b;
+              array[2] = 0;
+              array[3] = this.c;
+              array[4] = this.d;
+              array[5] = 0;
+              array[6] = this.tx;
+              array[7] = this.ty;
+              array[8] = 1;
+          }
+          else {
+              array[0] = this.a;
+              array[1] = this.c;
+              array[2] = this.tx;
+              array[3] = this.b;
+              array[4] = this.d;
+              array[5] = this.ty;
+              array[6] = 0;
+              array[7] = 0;
+              array[8] = 1;
+          }
+          return array;
+      };
+      /**
+       * Get a new position with the current transformation applied.
+       * Can be used to go from a child's coordinate space to the world coordinate space. (e.g. rendering)
+       * @param pos - The origin
+       * @param {PIXI.Point} [newPos] - The point that the new position is assigned to (allowed to be same as input)
+       * @returns {PIXI.Point} The new point, transformed through this matrix
+       */
+      Matrix.prototype.apply = function (pos, newPos) {
+          newPos = (newPos || new Point());
+          var x = pos.x;
+          var y = pos.y;
+          newPos.x = (this.a * x) + (this.c * y) + this.tx;
+          newPos.y = (this.b * x) + (this.d * y) + this.ty;
+          return newPos;
+      };
+      /**
+       * Get a new position with the inverse of the current transformation applied.
+       * Can be used to go from the world coordinate space to a child's coordinate space. (e.g. input)
+       * @param pos - The origin
+       * @param {PIXI.Point} [newPos] - The point that the new position is assigned to (allowed to be same as input)
+       * @returns {PIXI.Point} The new point, inverse-transformed through this matrix
+       */
+      Matrix.prototype.applyInverse = function (pos, newPos) {
+          newPos = (newPos || new Point());
+          var id = 1 / ((this.a * this.d) + (this.c * -this.b));
+          var x = pos.x;
+          var y = pos.y;
+          newPos.x = (this.d * id * x) + (-this.c * id * y) + (((this.ty * this.c) - (this.tx * this.d)) * id);
+          newPos.y = (this.a * id * y) + (-this.b * id * x) + (((-this.ty * this.a) + (this.tx * this.b)) * id);
+          return newPos;
+      };
+      /**
+       * Translates the matrix on the x and y.
+       * @param x - How much to translate x by
+       * @param y - How much to translate y by
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.translate = function (x, y) {
+          this.tx += x;
+          this.ty += y;
+          return this;
+      };
+      /**
+       * Applies a scale transformation to the matrix.
+       * @param x - The amount to scale horizontally
+       * @param y - The amount to scale vertically
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.scale = function (x, y) {
+          this.a *= x;
+          this.d *= y;
+          this.c *= x;
+          this.b *= y;
+          this.tx *= x;
+          this.ty *= y;
+          return this;
+      };
+      /**
+       * Applies a rotation transformation to the matrix.
+       * @param angle - The angle in radians.
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.rotate = function (angle) {
+          var cos = Math.cos(angle);
+          var sin = Math.sin(angle);
+          var a1 = this.a;
+          var c1 = this.c;
+          var tx1 = this.tx;
+          this.a = (a1 * cos) - (this.b * sin);
+          this.b = (a1 * sin) + (this.b * cos);
+          this.c = (c1 * cos) - (this.d * sin);
+          this.d = (c1 * sin) + (this.d * cos);
+          this.tx = (tx1 * cos) - (this.ty * sin);
+          this.ty = (tx1 * sin) + (this.ty * cos);
+          return this;
+      };
+      /**
+       * Appends the given Matrix to this Matrix.
+       * @param matrix - The matrix to append.
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.append = function (matrix) {
+          var a1 = this.a;
+          var b1 = this.b;
+          var c1 = this.c;
+          var d1 = this.d;
+          this.a = (matrix.a * a1) + (matrix.b * c1);
+          this.b = (matrix.a * b1) + (matrix.b * d1);
+          this.c = (matrix.c * a1) + (matrix.d * c1);
+          this.d = (matrix.c * b1) + (matrix.d * d1);
+          this.tx = (matrix.tx * a1) + (matrix.ty * c1) + this.tx;
+          this.ty = (matrix.tx * b1) + (matrix.ty * d1) + this.ty;
+          return this;
+      };
+      /**
+       * Sets the matrix based on all the available properties
+       * @param x - Position on the x axis
+       * @param y - Position on the y axis
+       * @param pivotX - Pivot on the x axis
+       * @param pivotY - Pivot on the y axis
+       * @param scaleX - Scale on the x axis
+       * @param scaleY - Scale on the y axis
+       * @param rotation - Rotation in radians
+       * @param skewX - Skew on the x axis
+       * @param skewY - Skew on the y axis
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.setTransform = function (x, y, pivotX, pivotY, scaleX, scaleY, rotation, skewX, skewY) {
+          this.a = Math.cos(rotation + skewY) * scaleX;
+          this.b = Math.sin(rotation + skewY) * scaleX;
+          this.c = -Math.sin(rotation - skewX) * scaleY;
+          this.d = Math.cos(rotation - skewX) * scaleY;
+          this.tx = x - ((pivotX * this.a) + (pivotY * this.c));
+          this.ty = y - ((pivotX * this.b) + (pivotY * this.d));
+          return this;
+      };
+      /**
+       * Prepends the given Matrix to this Matrix.
+       * @param matrix - The matrix to prepend
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.prepend = function (matrix) {
+          var tx1 = this.tx;
+          if (matrix.a !== 1 || matrix.b !== 0 || matrix.c !== 0 || matrix.d !== 1) {
+              var a1 = this.a;
+              var c1 = this.c;
+              this.a = (a1 * matrix.a) + (this.b * matrix.c);
+              this.b = (a1 * matrix.b) + (this.b * matrix.d);
+              this.c = (c1 * matrix.a) + (this.d * matrix.c);
+              this.d = (c1 * matrix.b) + (this.d * matrix.d);
+          }
+          this.tx = (tx1 * matrix.a) + (this.ty * matrix.c) + matrix.tx;
+          this.ty = (tx1 * matrix.b) + (this.ty * matrix.d) + matrix.ty;
+          return this;
+      };
+      /**
+       * Decomposes the matrix (x, y, scaleX, scaleY, and rotation) and sets the properties on to a transform.
+       * @param transform - The transform to apply the properties to.
+       * @returns The transform with the newly applied properties
+       */
+      Matrix.prototype.decompose = function (transform) {
+          // sort out rotation / skew..
+          var a = this.a;
+          var b = this.b;
+          var c = this.c;
+          var d = this.d;
+          var pivot = transform.pivot;
+          var skewX = -Math.atan2(-c, d);
+          var skewY = Math.atan2(b, a);
+          var delta = Math.abs(skewX + skewY);
+          if (delta < 0.00001 || Math.abs(PI_2 - delta) < 0.00001) {
+              transform.rotation = skewY;
+              transform.skew.x = transform.skew.y = 0;
+          }
+          else {
+              transform.rotation = 0;
+              transform.skew.x = skewX;
+              transform.skew.y = skewY;
+          }
+          // next set scale
+          transform.scale.x = Math.sqrt((a * a) + (b * b));
+          transform.scale.y = Math.sqrt((c * c) + (d * d));
+          // next set position
+          transform.position.x = this.tx + ((pivot.x * a) + (pivot.y * c));
+          transform.position.y = this.ty + ((pivot.x * b) + (pivot.y * d));
+          return transform;
+      };
+      /**
+       * Inverts this matrix
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.invert = function () {
+          var a1 = this.a;
+          var b1 = this.b;
+          var c1 = this.c;
+          var d1 = this.d;
+          var tx1 = this.tx;
+          var n = (a1 * d1) - (b1 * c1);
+          this.a = d1 / n;
+          this.b = -b1 / n;
+          this.c = -c1 / n;
+          this.d = a1 / n;
+          this.tx = ((c1 * this.ty) - (d1 * tx1)) / n;
+          this.ty = -((a1 * this.ty) - (b1 * tx1)) / n;
+          return this;
+      };
+      /**
+       * Resets this Matrix to an identity (default) matrix.
+       * @returns This matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.identity = function () {
+          this.a = 1;
+          this.b = 0;
+          this.c = 0;
+          this.d = 1;
+          this.tx = 0;
+          this.ty = 0;
+          return this;
+      };
+      /**
+       * Creates a new Matrix object with the same values as this one.
+       * @returns A copy of this matrix. Good for chaining method calls.
+       */
+      Matrix.prototype.clone = function () {
+          var matrix = new Matrix();
+          matrix.a = this.a;
+          matrix.b = this.b;
+          matrix.c = this.c;
+          matrix.d = this.d;
+          matrix.tx = this.tx;
+          matrix.ty = this.ty;
+          return matrix;
+      };
+      /**
+       * Changes the values of the given matrix to be the same as the ones in this matrix
+       * @param matrix - The matrix to copy to.
+       * @returns The matrix given in parameter with its values updated.
+       */
+      Matrix.prototype.copyTo = function (matrix) {
+          matrix.a = this.a;
+          matrix.b = this.b;
+          matrix.c = this.c;
+          matrix.d = this.d;
+          matrix.tx = this.tx;
+          matrix.ty = this.ty;
+          return matrix;
+      };
+      /**
+       * Changes the values of the matrix to be the same as the ones in given matrix
+       * @param {PIXI.Matrix} matrix - The matrix to copy from.
+       * @returns {PIXI.Matrix} this
+       */
+      Matrix.prototype.copyFrom = function (matrix) {
+          this.a = matrix.a;
+          this.b = matrix.b;
+          this.c = matrix.c;
+          this.d = matrix.d;
+          this.tx = matrix.tx;
+          this.ty = matrix.ty;
+          return this;
+      };
+      Matrix.prototype.toString = function () {
+          return "[@pixi/math:Matrix a=" + this.a + " b=" + this.b + " c=" + this.c + " d=" + this.d + " tx=" + this.tx + " ty=" + this.ty + "]";
+      };
+      Object.defineProperty(Matrix, "IDENTITY", {
+          /**
+           * A default (identity) matrix
+           * @readonly
+           */
+          get: function () {
+              return new Matrix();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Matrix, "TEMP_MATRIX", {
+          /**
+           * A temp matrix
+           * @readonly
+           */
+          get: function () {
+              return new Matrix();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return Matrix;
+  }());
+
+  // Your friendly neighbour https://en.wikipedia.org/wiki/Dihedral_group
+  /*
+   * Transform matrix for operation n is:
+   * | ux | vx |
+   * | uy | vy |
+   */
+  var ux = [1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1];
+  var uy = [0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1];
+  var vx = [0, -1, -1, -1, 0, 1, 1, 1, 0, 1, 1, 1, 0, -1, -1, -1];
+  var vy = [1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, 1, 1, 1, 0, -1];
+  /**
+   * [Cayley Table]{@link https://en.wikipedia.org/wiki/Cayley_table}
+   * for the composition of each rotation in the dihederal group D8.
+   * @type {number[][]}
+   * @private
+   */
+  var rotationCayley = [];
+  /**
+   * Matrices for each `GD8Symmetry` rotation.
+   * @type {PIXI.Matrix[]}
+   * @private
+   */
+  var rotationMatrices = [];
+  /*
+   * Alias for {@code Math.sign}.
+   */
+  var signum = Math.sign;
+  /*
+   * Initializes `rotationCayley` and `rotationMatrices`. It is called
+   * only once below.
+   */
+  function init() {
+      for (var i = 0; i < 16; i++) {
+          var row = [];
+          rotationCayley.push(row);
+          for (var j = 0; j < 16; j++) {
+              /* Multiplies rotation matrices i and j. */
+              var _ux = signum((ux[i] * ux[j]) + (vx[i] * uy[j]));
+              var _uy = signum((uy[i] * ux[j]) + (vy[i] * uy[j]));
+              var _vx = signum((ux[i] * vx[j]) + (vx[i] * vy[j]));
+              var _vy = signum((uy[i] * vx[j]) + (vy[i] * vy[j]));
+              /* Finds rotation matrix matching the product and pushes it. */
+              for (var k = 0; k < 16; k++) {
+                  if (ux[k] === _ux && uy[k] === _uy
+                      && vx[k] === _vx && vy[k] === _vy) {
+                      row.push(k);
+                      break;
+                  }
+              }
+          }
+      }
+      for (var i = 0; i < 16; i++) {
+          var mat = new Matrix();
+          mat.set(ux[i], uy[i], vx[i], vy[i], 0, 0);
+          rotationMatrices.push(mat);
+      }
+  }
+  init();
+  /**
+   * @memberof PIXI
+   * @typedef {number} GD8Symmetry
+   * @see PIXI.groupD8
+   */
+  /**
+   * Implements the dihedral group D8, which is similar to
+   * [group D4]{@link http://mathworld.wolfram.com/DihedralGroupD4.html};
+   * D8 is the same but with diagonals, and it is used for texture
+   * rotations.
+   *
+   * The directions the U- and V- axes after rotation
+   * of an angle of `a: GD8Constant` are the vectors `(uX(a), uY(a))`
+   * and `(vX(a), vY(a))`. These aren't necessarily unit vectors.
+   *
+   * **Origin:**<br>
+   *  This is the small part of gameofbombs.com portal system. It works.
+   * @see PIXI.groupD8.E
+   * @see PIXI.groupD8.SE
+   * @see PIXI.groupD8.S
+   * @see PIXI.groupD8.SW
+   * @see PIXI.groupD8.W
+   * @see PIXI.groupD8.NW
+   * @see PIXI.groupD8.N
+   * @see PIXI.groupD8.NE
+   * @author Ivan @ivanpopelyshev
+   * @namespace PIXI.groupD8
+   * @memberof PIXI
+   */
+  var groupD8 = {
+      /**
+       * | Rotation | Direction |
+       * |----------|-----------|
+       * | 0°       | East      |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      E: 0,
+      /**
+       * | Rotation | Direction |
+       * |----------|-----------|
+       * | 45°↻     | Southeast |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      SE: 1,
+      /**
+       * | Rotation | Direction |
+       * |----------|-----------|
+       * | 90°↻     | South     |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      S: 2,
+      /**
+       * | Rotation | Direction |
+       * |----------|-----------|
+       * | 135°↻    | Southwest |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      SW: 3,
+      /**
+       * | Rotation | Direction |
+       * |----------|-----------|
+       * | 180°     | West      |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      W: 4,
+      /**
+       * | Rotation    | Direction    |
+       * |-------------|--------------|
+       * | -135°/225°↻ | Northwest    |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      NW: 5,
+      /**
+       * | Rotation    | Direction    |
+       * |-------------|--------------|
+       * | -90°/270°↻  | North        |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      N: 6,
+      /**
+       * | Rotation    | Direction    |
+       * |-------------|--------------|
+       * | -45°/315°↻  | Northeast    |
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      NE: 7,
+      /**
+       * Reflection about Y-axis.
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      MIRROR_VERTICAL: 8,
+      /**
+       * Reflection about the main diagonal.
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      MAIN_DIAGONAL: 10,
+      /**
+       * Reflection about X-axis.
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      MIRROR_HORIZONTAL: 12,
+      /**
+       * Reflection about reverse diagonal.
+       * @memberof PIXI.groupD8
+       * @constant {PIXI.GD8Symmetry}
+       */
+      REVERSE_DIAGONAL: 14,
+      /**
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
+       * @returns {PIXI.GD8Symmetry} The X-component of the U-axis
+       *    after rotating the axes.
+       */
+      uX: function (ind) { return ux[ind]; },
+      /**
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
+       * @returns {PIXI.GD8Symmetry} The Y-component of the U-axis
+       *    after rotating the axes.
+       */
+      uY: function (ind) { return uy[ind]; },
+      /**
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
+       * @returns {PIXI.GD8Symmetry} The X-component of the V-axis
+       *    after rotating the axes.
+       */
+      vX: function (ind) { return vx[ind]; },
+      /**
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
+       * @returns {PIXI.GD8Symmetry} The Y-component of the V-axis
+       *    after rotating the axes.
+       */
+      vY: function (ind) { return vy[ind]; },
+      /**
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} rotation - symmetry whose opposite
+       *   is needed. Only rotations have opposite symmetries while
+       *   reflections don't.
+       * @returns {PIXI.GD8Symmetry} The opposite symmetry of `rotation`
+       */
+      inv: function (rotation) {
+          if (rotation & 8) // true only if between 8 & 15 (reflections)
+           {
+              return rotation & 15; // or rotation % 16
+          }
+          return (-rotation) & 7; // or (8 - rotation) % 8
+      },
+      /**
+       * Composes the two D8 operations.
+       *
+       * Taking `^` as reflection:
+       *
+       * |       | E=0 | S=2 | W=4 | N=6 | E^=8 | S^=10 | W^=12 | N^=14 |
+       * |-------|-----|-----|-----|-----|------|-------|-------|-------|
+       * | E=0   | E   | S   | W   | N   | E^   | S^    | W^    | N^    |
+       * | S=2   | S   | W   | N   | E   | S^   | W^    | N^    | E^    |
+       * | W=4   | W   | N   | E   | S   | W^   | N^    | E^    | S^    |
+       * | N=6   | N   | E   | S   | W   | N^   | E^    | S^    | W^    |
+       * | E^=8  | E^  | N^  | W^  | S^  | E    | N     | W     | S     |
+       * | S^=10 | S^  | E^  | N^  | W^  | S    | E     | N     | W     |
+       * | W^=12 | W^  | S^  | E^  | N^  | W    | S     | E     | N     |
+       * | N^=14 | N^  | W^  | S^  | E^  | N    | W     | S     | E     |
+       *
+       * [This is a Cayley table]{@link https://en.wikipedia.org/wiki/Cayley_table}
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} rotationSecond - Second operation, which
+       *   is the row in the above cayley table.
+       * @param {PIXI.GD8Symmetry} rotationFirst - First operation, which
+       *   is the column in the above cayley table.
+       * @returns {PIXI.GD8Symmetry} Composed operation
+       */
+      add: function (rotationSecond, rotationFirst) { return (rotationCayley[rotationSecond][rotationFirst]); },
+      /**
+       * Reverse of `add`.
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} rotationSecond - Second operation
+       * @param {PIXI.GD8Symmetry} rotationFirst - First operation
+       * @returns {PIXI.GD8Symmetry} Result
+       */
+      sub: function (rotationSecond, rotationFirst) { return (rotationCayley[rotationSecond][groupD8.inv(rotationFirst)]); },
+      /**
+       * Adds 180 degrees to rotation, which is a commutative
+       * operation.
+       * @memberof PIXI.groupD8
+       * @param {number} rotation - The number to rotate.
+       * @returns {number} Rotated number
+       */
+      rotate180: function (rotation) { return rotation ^ 4; },
+      /**
+       * Checks if the rotation angle is vertical, i.e. south
+       * or north. It doesn't work for reflections.
+       * @memberof PIXI.groupD8
+       * @param {PIXI.GD8Symmetry} rotation - The number to check.
+       * @returns {boolean} Whether or not the direction is vertical
+       */
+      isVertical: function (rotation) { return (rotation & 3) === 2; },
+      /**
+       * Approximates the vector `V(dx,dy)` into one of the
+       * eight directions provided by `groupD8`.
+       * @memberof PIXI.groupD8
+       * @param {number} dx - X-component of the vector
+       * @param {number} dy - Y-component of the vector
+       * @returns {PIXI.GD8Symmetry} Approximation of the vector into
+       *  one of the eight symmetries.
+       */
+      byDirection: function (dx, dy) {
+          if (Math.abs(dx) * 2 <= Math.abs(dy)) {
+              if (dy >= 0) {
+                  return groupD8.S;
+              }
+              return groupD8.N;
+          }
+          else if (Math.abs(dy) * 2 <= Math.abs(dx)) {
+              if (dx > 0) {
+                  return groupD8.E;
+              }
+              return groupD8.W;
+          }
+          else if (dy > 0) {
+              if (dx > 0) {
+                  return groupD8.SE;
+              }
+              return groupD8.SW;
+          }
+          else if (dx > 0) {
+              return groupD8.NE;
+          }
+          return groupD8.NW;
+      },
+      /**
+       * Helps sprite to compensate texture packer rotation.
+       * @memberof PIXI.groupD8
+       * @param {PIXI.Matrix} matrix - sprite world matrix
+       * @param {PIXI.GD8Symmetry} rotation - The rotation factor to use.
+       * @param {number} tx - sprite anchoring
+       * @param {number} ty - sprite anchoring
+       */
+      matrixAppendRotationInv: function (matrix, rotation, tx, ty) {
+          if (tx === void 0) { tx = 0; }
+          if (ty === void 0) { ty = 0; }
+          // Packer used "rotation", we use "inv(rotation)"
+          var mat = rotationMatrices[groupD8.inv(rotation)];
+          mat.tx = tx;
+          mat.ty = ty;
+          matrix.append(mat);
+      },
+  };
 
-    /**
-     * Uploads the verticies.
-     *
-     * @param {PIXI.DisplayObject[]} children - the array of display objects to render
-     * @param {number} startIndex - the index to start from in the children array
-     * @param {number} amount - the amount of children that will have their vertices uploaded
-     * @param {number[]} array - The vertices to upload.
-     * @param {number} stride - Stride to use for iteration.
-     * @param {number} offset - Offset to start at.
-     */
-
-
-    ParticleRenderer.prototype.uploadVertices = function uploadVertices(children, startIndex, amount, array, stride, offset) {
-        var w0 = 0;
-        var w1 = 0;
-        var h0 = 0;
-        var h1 = 0;
-
-        for (var i = 0; i < amount; ++i) {
-            var sprite = children[startIndex + i];
-            var texture = sprite._texture;
-            var sx = sprite.scale.x;
-            var sy = sprite.scale.y;
-            var trim = texture.trim;
-            var orig = texture.orig;
-
-            if (trim) {
-                // if the sprite is trimmed and is not a tilingsprite then we need to add the
-                // extra space before transforming the sprite coords..
-                w1 = trim.x - sprite.anchor.x * orig.width;
-                w0 = w1 + trim.width;
-
-                h1 = trim.y - sprite.anchor.y * orig.height;
-                h0 = h1 + trim.height;
-            } else {
-                w0 = orig.width * (1 - sprite.anchor.x);
-                w1 = orig.width * -sprite.anchor.x;
-
-                h0 = orig.height * (1 - sprite.anchor.y);
-                h1 = orig.height * -sprite.anchor.y;
-            }
+  /**
+   * Transform that takes care about its versions.
+   * @memberof PIXI
+   */
+  var Transform = /** @class */ (function () {
+      function Transform() {
+          this.worldTransform = new Matrix();
+          this.localTransform = new Matrix();
+          this.position = new ObservablePoint(this.onChange, this, 0, 0);
+          this.scale = new ObservablePoint(this.onChange, this, 1, 1);
+          this.pivot = new ObservablePoint(this.onChange, this, 0, 0);
+          this.skew = new ObservablePoint(this.updateSkew, this, 0, 0);
+          this._rotation = 0;
+          this._cx = 1;
+          this._sx = 0;
+          this._cy = 0;
+          this._sy = 1;
+          this._localID = 0;
+          this._currentLocalID = 0;
+          this._worldID = 0;
+          this._parentID = 0;
+      }
+      /** Called when a value changes. */
+      Transform.prototype.onChange = function () {
+          this._localID++;
+      };
+      /** Called when the skew or the rotation changes. */
+      Transform.prototype.updateSkew = function () {
+          this._cx = Math.cos(this._rotation + this.skew.y);
+          this._sx = Math.sin(this._rotation + this.skew.y);
+          this._cy = -Math.sin(this._rotation - this.skew.x); // cos, added PI/2
+          this._sy = Math.cos(this._rotation - this.skew.x); // sin, added PI/2
+          this._localID++;
+      };
+      Transform.prototype.toString = function () {
+          return "[@pixi/math:Transform "
+              + ("position=(" + this.position.x + ", " + this.position.y + ") ")
+              + ("rotation=" + this.rotation + " ")
+              + ("scale=(" + this.scale.x + ", " + this.scale.y + ") ")
+              + ("skew=(" + this.skew.x + ", " + this.skew.y + ") ")
+              + "]";
+      };
+      /** Updates the local transformation matrix. */
+      Transform.prototype.updateLocalTransform = function () {
+          var lt = this.localTransform;
+          if (this._localID !== this._currentLocalID) {
+              // get the matrix values of the displayobject based on its transform properties..
+              lt.a = this._cx * this.scale.x;
+              lt.b = this._sx * this.scale.x;
+              lt.c = this._cy * this.scale.y;
+              lt.d = this._sy * this.scale.y;
+              lt.tx = this.position.x - ((this.pivot.x * lt.a) + (this.pivot.y * lt.c));
+              lt.ty = this.position.y - ((this.pivot.x * lt.b) + (this.pivot.y * lt.d));
+              this._currentLocalID = this._localID;
+              // force an update..
+              this._parentID = -1;
+          }
+      };
+      /**
+       * Updates the local and the world transformation matrices.
+       * @param parentTransform - The parent transform
+       */
+      Transform.prototype.updateTransform = function (parentTransform) {
+          var lt = this.localTransform;
+          if (this._localID !== this._currentLocalID) {
+              // get the matrix values of the displayobject based on its transform properties..
+              lt.a = this._cx * this.scale.x;
+              lt.b = this._sx * this.scale.x;
+              lt.c = this._cy * this.scale.y;
+              lt.d = this._sy * this.scale.y;
+              lt.tx = this.position.x - ((this.pivot.x * lt.a) + (this.pivot.y * lt.c));
+              lt.ty = this.position.y - ((this.pivot.x * lt.b) + (this.pivot.y * lt.d));
+              this._currentLocalID = this._localID;
+              // force an update..
+              this._parentID = -1;
+          }
+          if (this._parentID !== parentTransform._worldID) {
+              // concat the parent matrix with the objects transform.
+              var pt = parentTransform.worldTransform;
+              var wt = this.worldTransform;
+              wt.a = (lt.a * pt.a) + (lt.b * pt.c);
+              wt.b = (lt.a * pt.b) + (lt.b * pt.d);
+              wt.c = (lt.c * pt.a) + (lt.d * pt.c);
+              wt.d = (lt.c * pt.b) + (lt.d * pt.d);
+              wt.tx = (lt.tx * pt.a) + (lt.ty * pt.c) + pt.tx;
+              wt.ty = (lt.tx * pt.b) + (lt.ty * pt.d) + pt.ty;
+              this._parentID = parentTransform._worldID;
+              // update the id of the transform..
+              this._worldID++;
+          }
+      };
+      /**
+       * Decomposes a matrix and sets the transforms properties based on it.
+       * @param matrix - The matrix to decompose
+       */
+      Transform.prototype.setFromMatrix = function (matrix) {
+          matrix.decompose(this);
+          this._localID++;
+      };
+      Object.defineProperty(Transform.prototype, "rotation", {
+          /** The rotation of the object in radians. */
+          get: function () {
+              return this._rotation;
+          },
+          set: function (value) {
+              if (this._rotation !== value) {
+                  this._rotation = value;
+                  this.updateSkew();
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** A default (identity) transform. */
+      Transform.IDENTITY = new Transform();
+      return Transform;
+  }());
+
+  /*!
+   * @pixi/display - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/display is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-            array[offset] = w1 * sx;
-            array[offset + 1] = h1 * sy;
+  /**
+   * Sets the default value for the container property 'sortableChildren'.
+   * If set to true, the container will sort its children by zIndex value
+   * when updateTransform() is called, or manually if sortChildren() is called.
+   *
+   * This actually changes the order of elements in the array, so should be treated
+   * as a basic solution that is not performant compared to other solutions,
+   * such as @link https://github.com/pixijs/pixi-display
+   *
+   * Also be aware of that this may not work nicely with the addChildAt() function,
+   * as the zIndex sorting may cause the child to automatically sorted to another position.
+   * @static
+   * @constant
+   * @name SORTABLE_CHILDREN
+   * @memberof PIXI.settings
+   * @type {boolean}
+   * @default false
+   */
+  settings.SORTABLE_CHILDREN = false;
 
-            array[offset + stride] = w0 * sx;
-            array[offset + stride + 1] = h1 * sy;
+  /**
+   * 'Builder' pattern for bounds rectangles.
+   *
+   * This could be called an Axis-Aligned Bounding Box.
+   * It is not an actual shape. It is a mutable thing; no 'EMPTY' or those kind of problems.
+   * @memberof PIXI
+   */
+  var Bounds = /** @class */ (function () {
+      function Bounds() {
+          this.minX = Infinity;
+          this.minY = Infinity;
+          this.maxX = -Infinity;
+          this.maxY = -Infinity;
+          this.rect = null;
+          this.updateID = -1;
+      }
+      /**
+       * Checks if bounds are empty.
+       * @returns - True if empty.
+       */
+      Bounds.prototype.isEmpty = function () {
+          return this.minX > this.maxX || this.minY > this.maxY;
+      };
+      /** Clears the bounds and resets. */
+      Bounds.prototype.clear = function () {
+          this.minX = Infinity;
+          this.minY = Infinity;
+          this.maxX = -Infinity;
+          this.maxY = -Infinity;
+      };
+      /**
+       * Can return Rectangle.EMPTY constant, either construct new rectangle, either use your rectangle
+       * It is not guaranteed that it will return tempRect
+       * @param rect - Temporary object will be used if AABB is not empty
+       * @returns - A rectangle of the bounds
+       */
+      Bounds.prototype.getRectangle = function (rect) {
+          if (this.minX > this.maxX || this.minY > this.maxY) {
+              return Rectangle.EMPTY;
+          }
+          rect = rect || new Rectangle(0, 0, 1, 1);
+          rect.x = this.minX;
+          rect.y = this.minY;
+          rect.width = this.maxX - this.minX;
+          rect.height = this.maxY - this.minY;
+          return rect;
+      };
+      /**
+       * This function should be inlined when its possible.
+       * @param point - The point to add.
+       */
+      Bounds.prototype.addPoint = function (point) {
+          this.minX = Math.min(this.minX, point.x);
+          this.maxX = Math.max(this.maxX, point.x);
+          this.minY = Math.min(this.minY, point.y);
+          this.maxY = Math.max(this.maxY, point.y);
+      };
+      /**
+       * Adds a point, after transformed. This should be inlined when its possible.
+       * @param matrix
+       * @param point
+       */
+      Bounds.prototype.addPointMatrix = function (matrix, point) {
+          var a = matrix.a, b = matrix.b, c = matrix.c, d = matrix.d, tx = matrix.tx, ty = matrix.ty;
+          var x = (a * point.x) + (c * point.y) + tx;
+          var y = (b * point.x) + (d * point.y) + ty;
+          this.minX = Math.min(this.minX, x);
+          this.maxX = Math.max(this.maxX, x);
+          this.minY = Math.min(this.minY, y);
+          this.maxY = Math.max(this.maxY, y);
+      };
+      /**
+       * Adds a quad, not transformed
+       * @param vertices - The verts to add.
+       */
+      Bounds.prototype.addQuad = function (vertices) {
+          var minX = this.minX;
+          var minY = this.minY;
+          var maxX = this.maxX;
+          var maxY = this.maxY;
+          var x = vertices[0];
+          var y = vertices[1];
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          x = vertices[2];
+          y = vertices[3];
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          x = vertices[4];
+          y = vertices[5];
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          x = vertices[6];
+          y = vertices[7];
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          this.minX = minX;
+          this.minY = minY;
+          this.maxX = maxX;
+          this.maxY = maxY;
+      };
+      /**
+       * Adds sprite frame, transformed.
+       * @param transform - transform to apply
+       * @param x0 - left X of frame
+       * @param y0 - top Y of frame
+       * @param x1 - right X of frame
+       * @param y1 - bottom Y of frame
+       */
+      Bounds.prototype.addFrame = function (transform, x0, y0, x1, y1) {
+          this.addFrameMatrix(transform.worldTransform, x0, y0, x1, y1);
+      };
+      /**
+       * Adds sprite frame, multiplied by matrix
+       * @param matrix - matrix to apply
+       * @param x0 - left X of frame
+       * @param y0 - top Y of frame
+       * @param x1 - right X of frame
+       * @param y1 - bottom Y of frame
+       */
+      Bounds.prototype.addFrameMatrix = function (matrix, x0, y0, x1, y1) {
+          var a = matrix.a;
+          var b = matrix.b;
+          var c = matrix.c;
+          var d = matrix.d;
+          var tx = matrix.tx;
+          var ty = matrix.ty;
+          var minX = this.minX;
+          var minY = this.minY;
+          var maxX = this.maxX;
+          var maxY = this.maxY;
+          var x = (a * x0) + (c * y0) + tx;
+          var y = (b * x0) + (d * y0) + ty;
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          x = (a * x1) + (c * y0) + tx;
+          y = (b * x1) + (d * y0) + ty;
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          x = (a * x0) + (c * y1) + tx;
+          y = (b * x0) + (d * y1) + ty;
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          x = (a * x1) + (c * y1) + tx;
+          y = (b * x1) + (d * y1) + ty;
+          minX = x < minX ? x : minX;
+          minY = y < minY ? y : minY;
+          maxX = x > maxX ? x : maxX;
+          maxY = y > maxY ? y : maxY;
+          this.minX = minX;
+          this.minY = minY;
+          this.maxX = maxX;
+          this.maxY = maxY;
+      };
+      /**
+       * Adds screen vertices from array
+       * @param vertexData - calculated vertices
+       * @param beginOffset - begin offset
+       * @param endOffset - end offset, excluded
+       */
+      Bounds.prototype.addVertexData = function (vertexData, beginOffset, endOffset) {
+          var minX = this.minX;
+          var minY = this.minY;
+          var maxX = this.maxX;
+          var maxY = this.maxY;
+          for (var i = beginOffset; i < endOffset; i += 2) {
+              var x = vertexData[i];
+              var y = vertexData[i + 1];
+              minX = x < minX ? x : minX;
+              minY = y < minY ? y : minY;
+              maxX = x > maxX ? x : maxX;
+              maxY = y > maxY ? y : maxY;
+          }
+          this.minX = minX;
+          this.minY = minY;
+          this.maxX = maxX;
+          this.maxY = maxY;
+      };
+      /**
+       * Add an array of mesh vertices
+       * @param transform - mesh transform
+       * @param vertices - mesh coordinates in array
+       * @param beginOffset - begin offset
+       * @param endOffset - end offset, excluded
+       */
+      Bounds.prototype.addVertices = function (transform, vertices, beginOffset, endOffset) {
+          this.addVerticesMatrix(transform.worldTransform, vertices, beginOffset, endOffset);
+      };
+      /**
+       * Add an array of mesh vertices.
+       * @param matrix - mesh matrix
+       * @param vertices - mesh coordinates in array
+       * @param beginOffset - begin offset
+       * @param endOffset - end offset, excluded
+       * @param padX - x padding
+       * @param padY - y padding
+       */
+      Bounds.prototype.addVerticesMatrix = function (matrix, vertices, beginOffset, endOffset, padX, padY) {
+          if (padX === void 0) { padX = 0; }
+          if (padY === void 0) { padY = padX; }
+          var a = matrix.a;
+          var b = matrix.b;
+          var c = matrix.c;
+          var d = matrix.d;
+          var tx = matrix.tx;
+          var ty = matrix.ty;
+          var minX = this.minX;
+          var minY = this.minY;
+          var maxX = this.maxX;
+          var maxY = this.maxY;
+          for (var i = beginOffset; i < endOffset; i += 2) {
+              var rawX = vertices[i];
+              var rawY = vertices[i + 1];
+              var x = (a * rawX) + (c * rawY) + tx;
+              var y = (d * rawY) + (b * rawX) + ty;
+              minX = Math.min(minX, x - padX);
+              maxX = Math.max(maxX, x + padX);
+              minY = Math.min(minY, y - padY);
+              maxY = Math.max(maxY, y + padY);
+          }
+          this.minX = minX;
+          this.minY = minY;
+          this.maxX = maxX;
+          this.maxY = maxY;
+      };
+      /**
+       * Adds other {@link Bounds}.
+       * @param bounds - The Bounds to be added
+       */
+      Bounds.prototype.addBounds = function (bounds) {
+          var minX = this.minX;
+          var minY = this.minY;
+          var maxX = this.maxX;
+          var maxY = this.maxY;
+          this.minX = bounds.minX < minX ? bounds.minX : minX;
+          this.minY = bounds.minY < minY ? bounds.minY : minY;
+          this.maxX = bounds.maxX > maxX ? bounds.maxX : maxX;
+          this.maxY = bounds.maxY > maxY ? bounds.maxY : maxY;
+      };
+      /**
+       * Adds other Bounds, masked with Bounds.
+       * @param bounds - The Bounds to be added.
+       * @param mask - TODO
+       */
+      Bounds.prototype.addBoundsMask = function (bounds, mask) {
+          var _minX = bounds.minX > mask.minX ? bounds.minX : mask.minX;
+          var _minY = bounds.minY > mask.minY ? bounds.minY : mask.minY;
+          var _maxX = bounds.maxX < mask.maxX ? bounds.maxX : mask.maxX;
+          var _maxY = bounds.maxY < mask.maxY ? bounds.maxY : mask.maxY;
+          if (_minX <= _maxX && _minY <= _maxY) {
+              var minX = this.minX;
+              var minY = this.minY;
+              var maxX = this.maxX;
+              var maxY = this.maxY;
+              this.minX = _minX < minX ? _minX : minX;
+              this.minY = _minY < minY ? _minY : minY;
+              this.maxX = _maxX > maxX ? _maxX : maxX;
+              this.maxY = _maxY > maxY ? _maxY : maxY;
+          }
+      };
+      /**
+       * Adds other Bounds, multiplied by matrix. Bounds shouldn't be empty.
+       * @param bounds - other bounds
+       * @param matrix - multiplicator
+       */
+      Bounds.prototype.addBoundsMatrix = function (bounds, matrix) {
+          this.addFrameMatrix(matrix, bounds.minX, bounds.minY, bounds.maxX, bounds.maxY);
+      };
+      /**
+       * Adds other Bounds, masked with Rectangle.
+       * @param bounds - TODO
+       * @param area - TODO
+       */
+      Bounds.prototype.addBoundsArea = function (bounds, area) {
+          var _minX = bounds.minX > area.x ? bounds.minX : area.x;
+          var _minY = bounds.minY > area.y ? bounds.minY : area.y;
+          var _maxX = bounds.maxX < area.x + area.width ? bounds.maxX : (area.x + area.width);
+          var _maxY = bounds.maxY < area.y + area.height ? bounds.maxY : (area.y + area.height);
+          if (_minX <= _maxX && _minY <= _maxY) {
+              var minX = this.minX;
+              var minY = this.minY;
+              var maxX = this.maxX;
+              var maxY = this.maxY;
+              this.minX = _minX < minX ? _minX : minX;
+              this.minY = _minY < minY ? _minY : minY;
+              this.maxX = _maxX > maxX ? _maxX : maxX;
+              this.maxY = _maxY > maxY ? _maxY : maxY;
+          }
+      };
+      /**
+       * Pads bounds object, making it grow in all directions.
+       * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
+       * @param paddingX - The horizontal padding amount.
+       * @param paddingY - The vertical padding amount.
+       */
+      Bounds.prototype.pad = function (paddingX, paddingY) {
+          if (paddingX === void 0) { paddingX = 0; }
+          if (paddingY === void 0) { paddingY = paddingX; }
+          if (!this.isEmpty()) {
+              this.minX -= paddingX;
+              this.maxX += paddingX;
+              this.minY -= paddingY;
+              this.maxY += paddingY;
+          }
+      };
+      /**
+       * Adds padded frame. (x0, y0) should be strictly less than (x1, y1)
+       * @param x0 - left X of frame
+       * @param y0 - top Y of frame
+       * @param x1 - right X of frame
+       * @param y1 - bottom Y of frame
+       * @param padX - padding X
+       * @param padY - padding Y
+       */
+      Bounds.prototype.addFramePad = function (x0, y0, x1, y1, padX, padY) {
+          x0 -= padX;
+          y0 -= padY;
+          x1 += padX;
+          y1 += padY;
+          this.minX = this.minX < x0 ? this.minX : x0;
+          this.maxX = this.maxX > x1 ? this.maxX : x1;
+          this.minY = this.minY < y0 ? this.minY : y0;
+          this.maxY = this.maxY > y1 ? this.maxY : y1;
+      };
+      return Bounds;
+  }());
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$j = function(d, b) {
+      extendStatics$j = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$j(d, b);
+  };
 
-            array[offset + stride * 2] = w0 * sx;
-            array[offset + stride * 2 + 1] = h0 * sy;
+  function __extends$j(d, b) {
+      extendStatics$j(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-            array[offset + stride * 3] = w1 * sx;
-            array[offset + stride * 3 + 1] = h0 * sy;
+  /**
+   * The base class for all objects that are rendered on the screen.
+   *
+   * This is an abstract class and can not be used on its own; rather it should be extended.
+   *
+   * ## Display objects implemented in PixiJS
+   *
+   * | Display Object                  | Description                                                           |
+   * | ------------------------------- | --------------------------------------------------------------------- |
+   * | {@link PIXI.Container}          | Adds support for `children` to DisplayObject                          |
+   * | {@link PIXI.Graphics}           | Shape-drawing display object similar to the Canvas API                |
+   * | {@link PIXI.Sprite}             | Draws textures (i.e. images)                                          |
+   * | {@link PIXI.Text}               | Draws text using the Canvas API internally                            |
+   * | {@link PIXI.BitmapText}         | More scaleable solution for text rendering, reusing glyph textures    |
+   * | {@link PIXI.TilingSprite}       | Draws textures/images in a tiled fashion                              |
+   * | {@link PIXI.AnimatedSprite}     | Draws an animation of multiple images                                 |
+   * | {@link PIXI.Mesh}               | Provides a lower-level API for drawing meshes with custom data        |
+   * | {@link PIXI.NineSlicePlane}     | Mesh-related                                                          |
+   * | {@link PIXI.SimpleMesh}         | v4-compatible mesh                                                    |
+   * | {@link PIXI.SimplePlane}        | Mesh-related                                                          |
+   * | {@link PIXI.SimpleRope}         | Mesh-related                                                          |
+   *
+   * ## Transforms
+   *
+   * The [transform]{@link DisplayObject#transform} of a display object describes the projection from its
+   * local coordinate space to its parent's local coordinate space. The following properties are derived
+   * from the transform:
+   *
+   * <table>
+   *   <thead>
+   *     <tr>
+   *       <th>Property</th>
+   *       <th>Description</th>
+   *     </tr>
+   *   </thead>
+   *   <tbody>
+   *     <tr>
+   *       <td>[pivot]{@link PIXI.DisplayObject#pivot}</td>
+   *       <td>
+   *         Invariant under rotation, scaling, and skewing. The projection of into the parent's space of the pivot
+   *         is equal to position, regardless of the other three transformations. In other words, It is the center of
+   *         rotation, scaling, and skewing.
+   *       </td>
+   *     </tr>
+   *     <tr>
+   *       <td>[position]{@link PIXI.DisplayObject#position}</td>
+   *       <td>
+   *         Translation. This is the position of the [pivot]{@link PIXI.DisplayObject#pivot} in the parent's local
+   *         space. The default value of the pivot is the origin (0,0). If the top-left corner of your display object
+   *         is (0,0) in its local space, then the position will be its top-left corner in the parent's local space.
+   *       </td>
+   *     </tr>
+   *     <tr>
+   *       <td>[scale]{@link PIXI.DisplayObject#scale}</td>
+   *       <td>
+   *         Scaling. This will stretch (or compress) the display object's projection. The scale factors are along the
+   *         local coordinate axes. In other words, the display object is scaled before rotated or skewed. The center
+   *         of scaling is the [pivot]{@link PIXI.DisplayObject#pivot}.
+   *       </td>
+   *     </tr>
+   *     <tr>
+   *       <td>[rotation]{@link PIXI.DisplayObject#rotation}</td>
+   *       <td>
+   *          Rotation. This will rotate the display object's projection by this angle (in radians).
+   *       </td>
+   *     </tr>
+   *     <tr>
+   *       <td>[skew]{@link PIXI.DisplayObject#skew}</td>
+   *       <td>
+   *         <p>Skewing. This can be used to deform a rectangular display object into a parallelogram.</p>
+   *         <p>
+   *         In PixiJS, skew has a slightly different behaviour than the conventional meaning. It can be
+   *         thought of the net rotation applied to the coordinate axes (separately). For example, if "skew.x" is
+   *         ⍺ and "skew.y" is β, then the line x = 0 will be rotated by ⍺ (y = -x*cot⍺) and the line y = 0 will be
+   *         rotated by β (y = x*tanβ). A line y = x*tanϴ (i.e. a line at angle ϴ to the x-axis in local-space) will
+   *         be rotated by an angle between ⍺ and β.
+   *         </p>
+   *         <p>
+   *         It can be observed that if skew is applied equally to both axes, then it will be equivalent to applying
+   *         a rotation. Indeed, if "skew.x" = -ϴ and "skew.y" = ϴ, it will produce an equivalent of "rotation" = ϴ.
+   *         </p>
+   *         <p>
+   *         Another quite interesting observation is that "skew.x", "skew.y", rotation are communtative operations. Indeed,
+   *         because rotation is essentially a careful combination of the two.
+   *         </p>
+   *       </td>
+   *     </tr>
+   *     <tr>
+   *       <td>angle</td>
+   *       <td>Rotation. This is an alias for [rotation]{@link PIXI.DisplayObject#rotation}, but in degrees.</td>
+   *     </tr>
+   *     <tr>
+   *       <td>x</td>
+   *       <td>Translation. This is an alias for position.x!</td>
+   *     </tr>
+   *     <tr>
+   *       <td>y</td>
+   *       <td>Translation. This is an alias for position.y!</td>
+   *     </tr>
+   *     <tr>
+   *       <td>width</td>
+   *       <td>
+   *         Implemented in [Container]{@link PIXI.Container}. Scaling. The width property calculates scale.x by dividing
+   *         the "requested" width by the local bounding box width. It is indirectly an abstraction over scale.x, and there
+   *         is no concept of user-defined width.
+   *       </td>
+   *     </tr>
+   *     <tr>
+   *       <td>height</td>
+   *       <td>
+   *         Implemented in [Container]{@link PIXI.Container}. Scaling. The height property calculates scale.y by dividing
+   *         the "requested" height by the local bounding box height. It is indirectly an abstraction over scale.y, and there
+   *         is no concept of user-defined height.
+   *       </td>
+   *     </tr>
+   *   </tbody>
+   * </table>
+   *
+   * ## Bounds
+   *
+   * The bounds of a display object is defined by the minimum axis-aligned rectangle in world space that can fit
+   * around it. The abstract `calculateBounds` method is responsible for providing it (and it should use the
+   * `worldTransform` to calculate in world space).
+   *
+   * There are a few additional types of bounding boxes:
+   *
+   * | Bounds                | Description                                                                              |
+   * | --------------------- | ---------------------------------------------------------------------------------------- |
+   * | World Bounds          | This is synonymous is the regular bounds described above. See `getBounds()`.             |
+   * | Local Bounds          | This the axis-aligned bounding box in the parent's local space. See `getLocalBounds()`.  |
+   * | Render Bounds         | The bounds, but including extra rendering effects like filter padding.                   |
+   * | Projected Bounds      | The bounds of the projected display object onto the screen. Usually equals world bounds. |
+   * | Relative Bounds       | The bounds of a display object when projected onto a ancestor's (or parent's) space.     |
+   * | Natural Bounds        | The bounds of an object in its own local space (not parent's space, like in local bounds)|
+   * | Content Bounds        | The natural bounds when excluding all children of a `Container`.                         |
+   *
+   * ### calculateBounds
+   *
+   * [Container]{@link Container} already implements `calculateBounds` in a manner that includes children.
+   *
+   * But for a non-Container display object, the `calculateBounds` method must be overridden in order for `getBounds` and
+   * `getLocalBounds` to work. This method must write the bounds into `this._bounds`.
+   *
+   * Generally, the following technique works for most simple cases: take the list of points
+   * forming the "hull" of the object (i.e. outline of the object's shape), and then add them
+   * using {@link PIXI.Bounds#addPointMatrix}.
+   *
+   * ```js
+   * calculateBounds(): void
+   * {
+   *     const points = [...];
+   *
+   *     for (let i = 0, j = points.length; i < j; i++)
+   *     {
+   *         this._bounds.addPointMatrix(this.worldTransform, points[i]);
+   *     }
+   * }
+   * ```
+   *
+   * You can optimize this for a large number of points by using {@link PIXI.Bounds#addVerticesMatrix} to pass them
+   * in one array together.
+   *
+   * ## Alpha
+   *
+   * This alpha sets a display object's **relative opacity** w.r.t its parent. For example, if the alpha of a display
+   * object is 0.5 and its parent's alpha is 0.5, then it will be rendered with 25% opacity (assuming alpha is not
+   * applied on any ancestor further up the chain).
+   *
+   * The alpha with which the display object will be rendered is called the [worldAlpha]{@link PIXI.DisplayObject#worldAlpha}.
+   *
+   * ## Renderable vs Visible
+   *
+   * The `renderable` and `visible` properties can be used to prevent a display object from being rendered to the
+   * screen. However, there is a subtle difference between the two. When using `renderable`, the transforms  of the display
+   * object (and its children subtree) will continue to be calculated. When using `visible`, the transforms will not
+   * be calculated.
+   *
+   * It is recommended that applications use the `renderable` property for culling. See
+   * [@pixi-essentials/cull]{@link https://www.npmjs.com/package/@pixi-essentials/cull} or
+   * [pixi-cull]{@link https://www.npmjs.com/package/pixi-cull} for more details.
+   *
+   * Otherwise, to prevent an object from rendering in the general-purpose sense - `visible` is the property to use. This
+   * one is also better in terms of performance.
+   * @memberof PIXI
+   */
+  var DisplayObject = /** @class */ (function (_super) {
+      __extends$j(DisplayObject, _super);
+      function DisplayObject() {
+          var _this = _super.call(this) || this;
+          _this.tempDisplayObjectParent = null;
+          // TODO: need to create Transform from factory
+          _this.transform = new Transform();
+          _this.alpha = 1;
+          _this.visible = true;
+          _this.renderable = true;
+          _this.cullable = false;
+          _this.cullArea = null;
+          _this.parent = null;
+          _this.worldAlpha = 1;
+          _this._lastSortedIndex = 0;
+          _this._zIndex = 0;
+          _this.filterArea = null;
+          _this.filters = null;
+          _this._enabledFilters = null;
+          _this._bounds = new Bounds();
+          _this._localBounds = null;
+          _this._boundsID = 0;
+          _this._boundsRect = null;
+          _this._localBoundsRect = null;
+          _this._mask = null;
+          _this._maskRefCount = 0;
+          _this._destroyed = false;
+          _this.isSprite = false;
+          _this.isMask = false;
+          return _this;
+      }
+      /**
+       * Mixes all enumerable properties and methods from a source object to DisplayObject.
+       * @param source - The source of properties and methods to mix in.
+       */
+      DisplayObject.mixin = function (source) {
+          // in ES8/ES2017, this would be really easy:
+          // Object.defineProperties(DisplayObject.prototype, Object.getOwnPropertyDescriptors(source));
+          // get all the enumerable property keys
+          var keys = Object.keys(source);
+          // loop through properties
+          for (var i = 0; i < keys.length; ++i) {
+              var propertyName = keys[i];
+              // Set the property using the property descriptor - this works for accessors and normal value properties
+              Object.defineProperty(DisplayObject.prototype, propertyName, Object.getOwnPropertyDescriptor(source, propertyName));
+          }
+      };
+      Object.defineProperty(DisplayObject.prototype, "destroyed", {
+          /**
+           * Fired when this DisplayObject is added to a Container.
+           * @instance
+           * @event added
+           * @param {PIXI.Container} container - The container added to.
+           */
+          /**
+           * Fired when this DisplayObject is removed from a Container.
+           * @instance
+           * @event removed
+           * @param {PIXI.Container} container - The container removed from.
+           */
+          /**
+           * Fired when this DisplayObject is destroyed. This event is emitted once
+           * destroy is finished.
+           * @instance
+           * @event destroyed
+           */
+          /** Readonly flag for destroyed display objects. */
+          get: function () {
+              return this._destroyed;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Recursively updates transform of all objects from the root to this one internal function for toLocal() */
+      DisplayObject.prototype._recursivePostUpdateTransform = function () {
+          if (this.parent) {
+              this.parent._recursivePostUpdateTransform();
+              this.transform.updateTransform(this.parent.transform);
+          }
+          else {
+              this.transform.updateTransform(this._tempDisplayObjectParent.transform);
+          }
+      };
+      /** Updates the object transform for rendering. TODO - Optimization pass! */
+      DisplayObject.prototype.updateTransform = function () {
+          this._boundsID++;
+          this.transform.updateTransform(this.parent.transform);
+          // multiply the alphas..
+          this.worldAlpha = this.alpha * this.parent.worldAlpha;
+      };
+      /**
+       * Calculates and returns the (world) bounds of the display object as a [Rectangle]{@link PIXI.Rectangle}.
+       *
+       * This method is expensive on containers with a large subtree (like the stage). This is because the bounds
+       * of a container depend on its children's bounds, which recursively causes all bounds in the subtree to
+       * be recalculated. The upside, however, is that calling `getBounds` once on a container will indeed update
+       * the bounds of all children (the whole subtree, in fact). This side effect should be exploited by using
+       * `displayObject._bounds.getRectangle()` when traversing through all the bounds in a scene graph. Otherwise,
+       * calling `getBounds` on each object in a subtree will cause the total cost to increase quadratically as
+       * its height increases.
+       *
+       * The transforms of all objects in a container's **subtree** and of all **ancestors** are updated.
+       * The world bounds of all display objects in a container's **subtree** will also be recalculated.
+       *
+       * The `_bounds` object stores the last calculation of the bounds. You can use to entirely skip bounds
+       * calculation if needed.
+       *
+       * ```js
+       * const lastCalculatedBounds = displayObject._bounds.getRectangle(optionalRect);
+       * ```
+       *
+       * Do know that usage of `getLocalBounds` can corrupt the `_bounds` of children (the whole subtree, actually). This
+       * is a known issue that has not been solved. See [getLocalBounds]{@link PIXI.DisplayObject#getLocalBounds} for more
+       * details.
+       *
+       * `getBounds` should be called with `skipUpdate` equal to `true` in a render() call. This is because the transforms
+       * are guaranteed to be update-to-date. In fact, recalculating inside a render() call may cause corruption in certain
+       * cases.
+       * @param skipUpdate - Setting to `true` will stop the transforms of the scene graph from
+       *  being updated. This means the calculation returned MAY be out of date BUT will give you a
+       *  nice performance boost.
+       * @param rect - Optional rectangle to store the result of the bounds calculation.
+       * @returns - The minimum axis-aligned rectangle in world space that fits around this object.
+       */
+      DisplayObject.prototype.getBounds = function (skipUpdate, rect) {
+          if (!skipUpdate) {
+              if (!this.parent) {
+                  this.parent = this._tempDisplayObjectParent;
+                  this.updateTransform();
+                  this.parent = null;
+              }
+              else {
+                  this._recursivePostUpdateTransform();
+                  this.updateTransform();
+              }
+          }
+          if (this._bounds.updateID !== this._boundsID) {
+              this.calculateBounds();
+              this._bounds.updateID = this._boundsID;
+          }
+          if (!rect) {
+              if (!this._boundsRect) {
+                  this._boundsRect = new Rectangle();
+              }
+              rect = this._boundsRect;
+          }
+          return this._bounds.getRectangle(rect);
+      };
+      /**
+       * Retrieves the local bounds of the displayObject as a rectangle object.
+       * @param rect - Optional rectangle to store the result of the bounds calculation.
+       * @returns - The rectangular bounding area.
+       */
+      DisplayObject.prototype.getLocalBounds = function (rect) {
+          if (!rect) {
+              if (!this._localBoundsRect) {
+                  this._localBoundsRect = new Rectangle();
+              }
+              rect = this._localBoundsRect;
+          }
+          if (!this._localBounds) {
+              this._localBounds = new Bounds();
+          }
+          var transformRef = this.transform;
+          var parentRef = this.parent;
+          this.parent = null;
+          this.transform = this._tempDisplayObjectParent.transform;
+          var worldBounds = this._bounds;
+          var worldBoundsID = this._boundsID;
+          this._bounds = this._localBounds;
+          var bounds = this.getBounds(false, rect);
+          this.parent = parentRef;
+          this.transform = transformRef;
+          this._bounds = worldBounds;
+          this._bounds.updateID += this._boundsID - worldBoundsID; // reflect side-effects
+          return bounds;
+      };
+      /**
+       * Calculates the global position of the display object.
+       * @param position - The world origin to calculate from.
+       * @param point - A Point object in which to store the value, optional
+       *  (otherwise will create a new Point).
+       * @param skipUpdate - Should we skip the update transform.
+       * @returns - A point object representing the position of this object.
+       */
+      DisplayObject.prototype.toGlobal = function (position, point, skipUpdate) {
+          if (skipUpdate === void 0) { skipUpdate = false; }
+          if (!skipUpdate) {
+              this._recursivePostUpdateTransform();
+              // this parent check is for just in case the item is a root object.
+              // If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
+              // this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
+              if (!this.parent) {
+                  this.parent = this._tempDisplayObjectParent;
+                  this.displayObjectUpdateTransform();
+                  this.parent = null;
+              }
+              else {
+                  this.displayObjectUpdateTransform();
+              }
+          }
+          // don't need to update the lot
+          return this.worldTransform.apply(position, point);
+      };
+      /**
+       * Calculates the local position of the display object relative to another point.
+       * @param position - The world origin to calculate from.
+       * @param from - The DisplayObject to calculate the global position from.
+       * @param point - A Point object in which to store the value, optional
+       *  (otherwise will create a new Point).
+       * @param skipUpdate - Should we skip the update transform
+       * @returns - A point object representing the position of this object
+       */
+      DisplayObject.prototype.toLocal = function (position, from, point, skipUpdate) {
+          if (from) {
+              position = from.toGlobal(position, point, skipUpdate);
+          }
+          if (!skipUpdate) {
+              this._recursivePostUpdateTransform();
+              // this parent check is for just in case the item is a root object.
+              // If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
+              // this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
+              if (!this.parent) {
+                  this.parent = this._tempDisplayObjectParent;
+                  this.displayObjectUpdateTransform();
+                  this.parent = null;
+              }
+              else {
+                  this.displayObjectUpdateTransform();
+              }
+          }
+          // simply apply the matrix..
+          return this.worldTransform.applyInverse(position, point);
+      };
+      /**
+       * Set the parent Container of this DisplayObject.
+       * @param container - The Container to add this DisplayObject to.
+       * @returns - The Container that this DisplayObject was added to.
+       */
+      DisplayObject.prototype.setParent = function (container) {
+          if (!container || !container.addChild) {
+              throw new Error('setParent: Argument must be a Container');
+          }
+          container.addChild(this);
+          return container;
+      };
+      /**
+       * Convenience function to set the position, scale, skew and pivot at once.
+       * @param x - The X position
+       * @param y - The Y position
+       * @param scaleX - The X scale value
+       * @param scaleY - The Y scale value
+       * @param rotation - The rotation
+       * @param skewX - The X skew value
+       * @param skewY - The Y skew value
+       * @param pivotX - The X pivot value
+       * @param pivotY - The Y pivot value
+       * @returns - The DisplayObject instance
+       */
+      DisplayObject.prototype.setTransform = function (x, y, scaleX, scaleY, rotation, skewX, skewY, pivotX, pivotY) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          if (scaleX === void 0) { scaleX = 1; }
+          if (scaleY === void 0) { scaleY = 1; }
+          if (rotation === void 0) { rotation = 0; }
+          if (skewX === void 0) { skewX = 0; }
+          if (skewY === void 0) { skewY = 0; }
+          if (pivotX === void 0) { pivotX = 0; }
+          if (pivotY === void 0) { pivotY = 0; }
+          this.position.x = x;
+          this.position.y = y;
+          this.scale.x = !scaleX ? 1 : scaleX;
+          this.scale.y = !scaleY ? 1 : scaleY;
+          this.rotation = rotation;
+          this.skew.x = skewX;
+          this.skew.y = skewY;
+          this.pivot.x = pivotX;
+          this.pivot.y = pivotY;
+          return this;
+      };
+      /**
+       * Base destroy method for generic display objects. This will automatically
+       * remove the display object from its parent Container as well as remove
+       * all current event listeners and internal references. Do not use a DisplayObject
+       * after calling `destroy()`.
+       * @param _options
+       */
+      DisplayObject.prototype.destroy = function (_options) {
+          if (this.parent) {
+              this.parent.removeChild(this);
+          }
+          this._destroyed = true;
+          this.transform = null;
+          this.parent = null;
+          this._bounds = null;
+          this.mask = null;
+          this.cullArea = null;
+          this.filters = null;
+          this.filterArea = null;
+          this.hitArea = null;
+          this.interactive = false;
+          this.interactiveChildren = false;
+          this.emit('destroyed');
+          this.removeAllListeners();
+      };
+      Object.defineProperty(DisplayObject.prototype, "_tempDisplayObjectParent", {
+          /**
+           * @protected
+           * @member {PIXI.Container}
+           */
+          get: function () {
+              if (this.tempDisplayObjectParent === null) {
+                  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                  this.tempDisplayObjectParent = new TemporaryDisplayObject();
+              }
+              return this.tempDisplayObjectParent;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Used in Renderer, cacheAsBitmap and other places where you call an `updateTransform` on root
+       *
+       * ```
+       * const cacheParent = elem.enableTempParent();
+       * elem.updateTransform();
+       * elem.disableTempParent(cacheParent);
+       * ```
+       * @returns - current parent
+       */
+      DisplayObject.prototype.enableTempParent = function () {
+          var myParent = this.parent;
+          this.parent = this._tempDisplayObjectParent;
+          return myParent;
+      };
+      /**
+       * Pair method for `enableTempParent`
+       * @param cacheParent - Actual parent of element
+       */
+      DisplayObject.prototype.disableTempParent = function (cacheParent) {
+          this.parent = cacheParent;
+      };
+      Object.defineProperty(DisplayObject.prototype, "x", {
+          /**
+           * The position of the displayObject on the x axis relative to the local coordinates of the parent.
+           * An alias to position.x
+           */
+          get: function () {
+              return this.position.x;
+          },
+          set: function (value) {
+              this.transform.position.x = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "y", {
+          /**
+           * The position of the displayObject on the y axis relative to the local coordinates of the parent.
+           * An alias to position.y
+           */
+          get: function () {
+              return this.position.y;
+          },
+          set: function (value) {
+              this.transform.position.y = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "worldTransform", {
+          /**
+           * Current transform of the object based on world (parent) factors.
+           * @readonly
+           */
+          get: function () {
+              return this.transform.worldTransform;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "localTransform", {
+          /**
+           * Current transform of the object based on local factors: position, scale, other stuff.
+           * @readonly
+           */
+          get: function () {
+              return this.transform.localTransform;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "position", {
+          /**
+           * The coordinate of the object relative to the local coordinates of the parent.
+           * @since 4.0.0
+           */
+          get: function () {
+              return this.transform.position;
+          },
+          set: function (value) {
+              this.transform.position.copyFrom(value);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "scale", {
+          /**
+           * The scale factors of this object along the local coordinate axes.
+           *
+           * The default scale is (1, 1).
+           * @since 4.0.0
+           */
+          get: function () {
+              return this.transform.scale;
+          },
+          set: function (value) {
+              this.transform.scale.copyFrom(value);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "pivot", {
+          /**
+           * The center of rotation, scaling, and skewing for this display object in its local space. The `position`
+           * is the projection of `pivot` in the parent's local space.
+           *
+           * By default, the pivot is the origin (0, 0).
+           * @since 4.0.0
+           */
+          get: function () {
+              return this.transform.pivot;
+          },
+          set: function (value) {
+              this.transform.pivot.copyFrom(value);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "skew", {
+          /**
+           * The skew factor for the object in radians.
+           * @since 4.0.0
+           */
+          get: function () {
+              return this.transform.skew;
+          },
+          set: function (value) {
+              this.transform.skew.copyFrom(value);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "rotation", {
+          /**
+           * The rotation of the object in radians.
+           * 'rotation' and 'angle' have the same effect on a display object; rotation is in radians, angle is in degrees.
+           */
+          get: function () {
+              return this.transform.rotation;
+          },
+          set: function (value) {
+              this.transform.rotation = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "angle", {
+          /**
+           * The angle of the object in degrees.
+           * 'rotation' and 'angle' have the same effect on a display object; rotation is in radians, angle is in degrees.
+           */
+          get: function () {
+              return this.transform.rotation * RAD_TO_DEG;
+          },
+          set: function (value) {
+              this.transform.rotation = value * DEG_TO_RAD;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "zIndex", {
+          /**
+           * The zIndex of the displayObject.
+           *
+           * If a container has the sortableChildren property set to true, children will be automatically
+           * sorted by zIndex value; a higher value will mean it will be moved towards the end of the array,
+           * and thus rendered on top of other display objects within the same container.
+           * @see PIXI.Container#sortableChildren
+           */
+          get: function () {
+              return this._zIndex;
+          },
+          set: function (value) {
+              this._zIndex = value;
+              if (this.parent) {
+                  this.parent.sortDirty = true;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "worldVisible", {
+          /**
+           * Indicates if the object is globally visible.
+           * @readonly
+           */
+          get: function () {
+              var item = this;
+              do {
+                  if (!item.visible) {
+                      return false;
+                  }
+                  item = item.parent;
+              } while (item);
+              return true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(DisplayObject.prototype, "mask", {
+          /**
+           * Sets a mask for the displayObject. A mask is an object that limits the visibility of an
+           * object to the shape of the mask applied to it. In PixiJS a regular mask must be a
+           * {@link PIXI.Graphics} or a {@link PIXI.Sprite} object. This allows for much faster masking in canvas as it
+           * utilities shape clipping. Furthermore, a mask of an object must be in the subtree of its parent.
+           * Otherwise, `getLocalBounds` may calculate incorrect bounds, which makes the container's width and height wrong.
+           * To remove a mask, set this property to `null`.
+           *
+           * For sprite mask both alpha and red channel are used. Black mask is the same as transparent mask.
+           * @example
+           * const graphics = new PIXI.Graphics();
+           * graphics.beginFill(0xFF3300);
+           * graphics.drawRect(50, 250, 100, 100);
+           * graphics.endFill();
+           *
+           * const sprite = new PIXI.Sprite(texture);
+           * sprite.mask = graphics;
+           * @todo At the moment, PIXI.CanvasRenderer doesn't support PIXI.Sprite as mask.
+           */
+          get: function () {
+              return this._mask;
+          },
+          set: function (value) {
+              if (this._mask === value) {
+                  return;
+              }
+              if (this._mask) {
+                  var maskObject = (this._mask.isMaskData
+                      ? this._mask.maskObject : this._mask);
+                  if (maskObject) {
+                      maskObject._maskRefCount--;
+                      if (maskObject._maskRefCount === 0) {
+                          maskObject.renderable = true;
+                          maskObject.isMask = false;
+                      }
+                  }
+              }
+              this._mask = value;
+              if (this._mask) {
+                  var maskObject = (this._mask.isMaskData
+                      ? this._mask.maskObject : this._mask);
+                  if (maskObject) {
+                      if (maskObject._maskRefCount === 0) {
+                          maskObject.renderable = false;
+                          maskObject.isMask = true;
+                      }
+                      maskObject._maskRefCount++;
+                  }
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return DisplayObject;
+  }(eventemitter3));
+  /**
+   * @private
+   */
+  var TemporaryDisplayObject = /** @class */ (function (_super) {
+      __extends$j(TemporaryDisplayObject, _super);
+      function TemporaryDisplayObject() {
+          var _this = _super !== null && _super.apply(this, arguments) || this;
+          _this.sortDirty = null;
+          return _this;
+      }
+      return TemporaryDisplayObject;
+  }(DisplayObject));
+  /**
+   * DisplayObject default updateTransform, does not update children of container.
+   * Will crash if there's no parent element.
+   * @memberof PIXI.DisplayObject#
+   * @method displayObjectUpdateTransform
+   */
+  DisplayObject.prototype.displayObjectUpdateTransform = DisplayObject.prototype.updateTransform;
 
-            offset += stride * 4;
-        }
-    };
+  function sortChildren(a, b) {
+      if (a.zIndex === b.zIndex) {
+          return a._lastSortedIndex - b._lastSortedIndex;
+      }
+      return a.zIndex - b.zIndex;
+  }
+  /**
+   * Container is a general-purpose display object that holds children. It also adds built-in support for advanced
+   * rendering features like masking and filtering.
+   *
+   * It is the base class of all display objects that act as a container for other objects, including Graphics
+   * and Sprite.
+   *
+   * ```js
+   * import { BlurFilter } from '@pixi/filter-blur';
+   * import { Container } from '@pixi/display';
+   * import { Graphics } from '@pixi/graphics';
+   * import { Sprite } from '@pixi/sprite';
+   *
+   * let container = new Container();
+   * let sprite = Sprite.from("https://s3-us-west-2.amazonaws.com/s.cdpn.io/693612/IaUrttj.png");
+   *
+   * sprite.width = 512;
+   * sprite.height = 512;
+   *
+   * // Adds a sprite as a child to this container. As a result, the sprite will be rendered whenever the container
+   * // is rendered.
+   * container.addChild(sprite);
+   *
+   * // Blurs whatever is rendered by the container
+   * container.filters = [new BlurFilter()];
+   *
+   * // Only the contents within a circle at the center should be rendered onto the screen.
+   * container.mask = new Graphics()
+   *  .beginFill(0xffffff)
+   *  .drawCircle(sprite.width / 2, sprite.height / 2, Math.min(sprite.width, sprite.height) / 2)
+   *  .endFill();
+   * ```
+   * @memberof PIXI
+   */
+  var Container = /** @class */ (function (_super) {
+      __extends$j(Container, _super);
+      function Container() {
+          var _this = _super.call(this) || this;
+          _this.children = [];
+          _this.sortableChildren = settings.SORTABLE_CHILDREN;
+          _this.sortDirty = false;
+          return _this;
+          /**
+           * Fired when a DisplayObject is added to this Container.
+           * @event PIXI.Container#childAdded
+           * @param {PIXI.DisplayObject} child - The child added to the Container.
+           * @param {PIXI.Container} container - The container that added the child.
+           * @param {number} index - The children's index of the added child.
+           */
+          /**
+           * Fired when a DisplayObject is removed from this Container.
+           * @event PIXI.DisplayObject#childRemoved
+           * @param {PIXI.DisplayObject} child - The child removed from the Container.
+           * @param {PIXI.Container} container - The container that removed the child.
+           * @param {number} index - The former children's index of the removed child
+           */
+      }
+      /**
+       * Overridable method that can be used by Container subclasses whenever the children array is modified.
+       * @param _length
+       */
+      Container.prototype.onChildrenChange = function (_length) {
+          /* empty */
+      };
+      /**
+       * Adds one or more children to the container.
+       *
+       * Multiple items can be added like so: `myContainer.addChild(thingOne, thingTwo, thingThree)`
+       * @param {...PIXI.DisplayObject} children - The DisplayObject(s) to add to the container
+       * @returns {PIXI.DisplayObject} - The first child that was added.
+       */
+      Container.prototype.addChild = function () {
+          var arguments$1 = arguments;
 
-    /**
-     *
-     * @param {PIXI.DisplayObject[]} children - the array of display objects to render
-     * @param {number} startIndex - the index to start from in the children array
-     * @param {number} amount - the amount of children that will have their positions uploaded
-     * @param {number[]} array - The vertices to upload.
-     * @param {number} stride - Stride to use for iteration.
-     * @param {number} offset - Offset to start at.
-     */
+          var children = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              children[_i] = arguments$1[_i];
+          }
+          // if there is only one argument we can bypass looping through the them
+          if (children.length > 1) {
+              // loop through the array and add all children
+              for (var i = 0; i < children.length; i++) {
+                  // eslint-disable-next-line prefer-rest-params
+                  this.addChild(children[i]);
+              }
+          }
+          else {
+              var child = children[0];
+              // if the child has a parent then lets remove it as PixiJS objects can only exist in one place
+              if (child.parent) {
+                  child.parent.removeChild(child);
+              }
+              child.parent = this;
+              this.sortDirty = true;
+              // ensure child transform will be recalculated
+              child.transform._parentID = -1;
+              this.children.push(child);
+              // ensure bounds will be recalculated
+              this._boundsID++;
+              // TODO - lets either do all callbacks or all events.. not both!
+              this.onChildrenChange(this.children.length - 1);
+              this.emit('childAdded', child, this, this.children.length - 1);
+              child.emit('added', this);
+          }
+          return children[0];
+      };
+      /**
+       * Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
+       * @param {PIXI.DisplayObject} child - The child to add
+       * @param {number} index - The index to place the child in
+       * @returns {PIXI.DisplayObject} The child that was added.
+       */
+      Container.prototype.addChildAt = function (child, index) {
+          if (index < 0 || index > this.children.length) {
+              throw new Error(child + "addChildAt: The index " + index + " supplied is out of bounds " + this.children.length);
+          }
+          if (child.parent) {
+              child.parent.removeChild(child);
+          }
+          child.parent = this;
+          this.sortDirty = true;
+          // ensure child transform will be recalculated
+          child.transform._parentID = -1;
+          this.children.splice(index, 0, child);
+          // ensure bounds will be recalculated
+          this._boundsID++;
+          // TODO - lets either do all callbacks or all events.. not both!
+          this.onChildrenChange(index);
+          child.emit('added', this);
+          this.emit('childAdded', child, this, index);
+          return child;
+      };
+      /**
+       * Swaps the position of 2 Display Objects within this container.
+       * @param child - First display object to swap
+       * @param child2 - Second display object to swap
+       */
+      Container.prototype.swapChildren = function (child, child2) {
+          if (child === child2) {
+              return;
+          }
+          var index1 = this.getChildIndex(child);
+          var index2 = this.getChildIndex(child2);
+          this.children[index1] = child2;
+          this.children[index2] = child;
+          this.onChildrenChange(index1 < index2 ? index1 : index2);
+      };
+      /**
+       * Returns the index position of a child DisplayObject instance
+       * @param child - The DisplayObject instance to identify
+       * @returns - The index position of the child display object to identify
+       */
+      Container.prototype.getChildIndex = function (child) {
+          var index = this.children.indexOf(child);
+          if (index === -1) {
+              throw new Error('The supplied DisplayObject must be a child of the caller');
+          }
+          return index;
+      };
+      /**
+       * Changes the position of an existing child in the display object container
+       * @param child - The child DisplayObject instance for which you want to change the index number
+       * @param index - The resulting index number for the child display object
+       */
+      Container.prototype.setChildIndex = function (child, index) {
+          if (index < 0 || index >= this.children.length) {
+              throw new Error("The index " + index + " supplied is out of bounds " + this.children.length);
+          }
+          var currentIndex = this.getChildIndex(child);
+          removeItems(this.children, currentIndex, 1); // remove from old position
+          this.children.splice(index, 0, child); // add at new position
+          this.onChildrenChange(index);
+      };
+      /**
+       * Returns the child at the specified index
+       * @param index - The index to get the child at
+       * @returns - The child at the given index, if any.
+       */
+      Container.prototype.getChildAt = function (index) {
+          if (index < 0 || index >= this.children.length) {
+              throw new Error("getChildAt: Index (" + index + ") does not exist.");
+          }
+          return this.children[index];
+      };
+      /**
+       * Removes one or more children from the container.
+       * @param {...PIXI.DisplayObject} children - The DisplayObject(s) to remove
+       * @returns {PIXI.DisplayObject} The first child that was removed.
+       */
+      Container.prototype.removeChild = function () {
+          var arguments$1 = arguments;
 
+          var children = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              children[_i] = arguments$1[_i];
+          }
+          // if there is only one argument we can bypass looping through the them
+          if (children.length > 1) {
+              // loop through the arguments property and remove all children
+              for (var i = 0; i < children.length; i++) {
+                  this.removeChild(children[i]);
+              }
+          }
+          else {
+              var child = children[0];
+              var index = this.children.indexOf(child);
+              if (index === -1)
+                  { return null; }
+              child.parent = null;
+              // ensure child transform will be recalculated
+              child.transform._parentID = -1;
+              removeItems(this.children, index, 1);
+              // ensure bounds will be recalculated
+              this._boundsID++;
+              // TODO - lets either do all callbacks or all events.. not both!
+              this.onChildrenChange(index);
+              child.emit('removed', this);
+              this.emit('childRemoved', child, this, index);
+          }
+          return children[0];
+      };
+      /**
+       * Removes a child from the specified index position.
+       * @param index - The index to get the child from
+       * @returns The child that was removed.
+       */
+      Container.prototype.removeChildAt = function (index) {
+          var child = this.getChildAt(index);
+          // ensure child transform will be recalculated..
+          child.parent = null;
+          child.transform._parentID = -1;
+          removeItems(this.children, index, 1);
+          // ensure bounds will be recalculated
+          this._boundsID++;
+          // TODO - lets either do all callbacks or all events.. not both!
+          this.onChildrenChange(index);
+          child.emit('removed', this);
+          this.emit('childRemoved', child, this, index);
+          return child;
+      };
+      /**
+       * Removes all children from this container that are within the begin and end indexes.
+       * @param beginIndex - The beginning position.
+       * @param endIndex - The ending position. Default value is size of the container.
+       * @returns - List of removed children
+       */
+      Container.prototype.removeChildren = function (beginIndex, endIndex) {
+          if (beginIndex === void 0) { beginIndex = 0; }
+          if (endIndex === void 0) { endIndex = this.children.length; }
+          var begin = beginIndex;
+          var end = endIndex;
+          var range = end - begin;
+          var removed;
+          if (range > 0 && range <= end) {
+              removed = this.children.splice(begin, range);
+              for (var i = 0; i < removed.length; ++i) {
+                  removed[i].parent = null;
+                  if (removed[i].transform) {
+                      removed[i].transform._parentID = -1;
+                  }
+              }
+              this._boundsID++;
+              this.onChildrenChange(beginIndex);
+              for (var i = 0; i < removed.length; ++i) {
+                  removed[i].emit('removed', this);
+                  this.emit('childRemoved', removed[i], this, i);
+              }
+              return removed;
+          }
+          else if (range === 0 && this.children.length === 0) {
+              return [];
+          }
+          throw new RangeError('removeChildren: numeric values are outside the acceptable range.');
+      };
+      /** Sorts children by zIndex. Previous order is maintained for 2 children with the same zIndex. */
+      Container.prototype.sortChildren = function () {
+          var sortRequired = false;
+          for (var i = 0, j = this.children.length; i < j; ++i) {
+              var child = this.children[i];
+              child._lastSortedIndex = i;
+              if (!sortRequired && child.zIndex !== 0) {
+                  sortRequired = true;
+              }
+          }
+          if (sortRequired && this.children.length > 1) {
+              this.children.sort(sortChildren);
+          }
+          this.sortDirty = false;
+      };
+      /** Updates the transform on all children of this container for rendering. */
+      Container.prototype.updateTransform = function () {
+          if (this.sortableChildren && this.sortDirty) {
+              this.sortChildren();
+          }
+          this._boundsID++;
+          this.transform.updateTransform(this.parent.transform);
+          // TODO: check render flags, how to process stuff here
+          this.worldAlpha = this.alpha * this.parent.worldAlpha;
+          for (var i = 0, j = this.children.length; i < j; ++i) {
+              var child = this.children[i];
+              if (child.visible) {
+                  child.updateTransform();
+              }
+          }
+      };
+      /**
+       * Recalculates the bounds of the container.
+       *
+       * This implementation will automatically fit the children's bounds into the calculation. Each child's bounds
+       * is limited to its mask's bounds or filterArea, if any is applied.
+       */
+      Container.prototype.calculateBounds = function () {
+          this._bounds.clear();
+          this._calculateBounds();
+          for (var i = 0; i < this.children.length; i++) {
+              var child = this.children[i];
+              if (!child.visible || !child.renderable) {
+                  continue;
+              }
+              child.calculateBounds();
+              // TODO: filter+mask, need to mask both somehow
+              if (child._mask) {
+                  var maskObject = (child._mask.isMaskData
+                      ? child._mask.maskObject : child._mask);
+                  if (maskObject) {
+                      maskObject.calculateBounds();
+                      this._bounds.addBoundsMask(child._bounds, maskObject._bounds);
+                  }
+                  else {
+                      this._bounds.addBounds(child._bounds);
+                  }
+              }
+              else if (child.filterArea) {
+                  this._bounds.addBoundsArea(child._bounds, child.filterArea);
+              }
+              else {
+                  this._bounds.addBounds(child._bounds);
+              }
+          }
+          this._bounds.updateID = this._boundsID;
+      };
+      /**
+       * Retrieves the local bounds of the displayObject as a rectangle object.
+       *
+       * Calling `getLocalBounds` may invalidate the `_bounds` of the whole subtree below. If using it inside a render()
+       * call, it is advised to call `getBounds()` immediately after to recalculate the world bounds of the subtree.
+       * @param rect - Optional rectangle to store the result of the bounds calculation.
+       * @param skipChildrenUpdate - Setting to `true` will stop re-calculation of children transforms,
+       *  it was default behaviour of pixi 4.0-5.2 and caused many problems to users.
+       * @returns - The rectangular bounding area.
+       */
+      Container.prototype.getLocalBounds = function (rect, skipChildrenUpdate) {
+          if (skipChildrenUpdate === void 0) { skipChildrenUpdate = false; }
+          var result = _super.prototype.getLocalBounds.call(this, rect);
+          if (!skipChildrenUpdate) {
+              for (var i = 0, j = this.children.length; i < j; ++i) {
+                  var child = this.children[i];
+                  if (child.visible) {
+                      child.updateTransform();
+                  }
+              }
+          }
+          return result;
+      };
+      /**
+       * Recalculates the content bounds of this object. This should be overriden to
+       * calculate the bounds of this specific object (not including children).
+       * @protected
+       */
+      Container.prototype._calculateBounds = function () {
+          // FILL IN//
+      };
+      /**
+       * Renders this object and its children with culling.
+       * @protected
+       * @param {PIXI.Renderer} renderer - The renderer
+       */
+      Container.prototype._renderWithCulling = function (renderer) {
+          var sourceFrame = renderer.renderTexture.sourceFrame;
+          // If the source frame is empty, stop rendering.
+          if (!(sourceFrame.width > 0 && sourceFrame.height > 0)) {
+              return;
+          }
+          // Render the content of the container only if its bounds intersect with the source frame.
+          // All filters are on the stack at this point, and the filter source frame is bound:
+          // therefore, even if the bounds to non intersect the filter frame, the filter
+          // is still applied and any filter padding that is in the frame is rendered correctly.
+          var bounds;
+          var transform;
+          // If cullArea is set, we use this rectangle instead of the bounds of the object. The cullArea
+          // rectangle must completely contain the container and its children including filter padding.
+          if (this.cullArea) {
+              bounds = this.cullArea;
+              transform = this.worldTransform;
+          }
+          // If the container doesn't override _render, we can skip the bounds calculation and intersection test.
+          else if (this._render !== Container.prototype._render) {
+              bounds = this.getBounds(true);
+          }
+          // Render the container if the source frame intersects the bounds.
+          if (bounds && sourceFrame.intersects(bounds, transform)) {
+              this._render(renderer);
+          }
+          // If the bounds are defined by cullArea and do not intersect with the source frame, stop rendering.
+          else if (this.cullArea) {
+              return;
+          }
+          // Unless cullArea is set, we cannot skip the children if the bounds of the container do not intersect
+          // the source frame, because the children might have filters with nonzero padding, which may intersect
+          // with the source frame while the bounds do not: filter padding is not included in the bounds.
+          // If cullArea is not set, render the children with culling temporarily enabled so that they are not rendered
+          // if they are out of frame; otherwise, render the children normally.
+          for (var i = 0, j = this.children.length; i < j; ++i) {
+              var child = this.children[i];
+              var childCullable = child.cullable;
+              child.cullable = childCullable || !this.cullArea;
+              child.render(renderer);
+              child.cullable = childCullable;
+          }
+      };
+      /**
+       * Renders the object using the WebGL renderer.
+       *
+       * The [_render]{@link PIXI.Container#_render} method is be overriden for rendering the contents of the
+       * container itself. This `render` method will invoke it, and also invoke the `render` methods of all
+       * children afterward.
+       *
+       * If `renderable` or `visible` is false or if `worldAlpha` is not positive or if `cullable` is true and
+       * the bounds of this object are out of frame, this implementation will entirely skip rendering.
+       * See {@link PIXI.DisplayObject} for choosing between `renderable` or `visible`. Generally,
+       * setting alpha to zero is not recommended for purely skipping rendering.
+       *
+       * When your scene becomes large (especially when it is larger than can be viewed in a single screen), it is
+       * advised to employ **culling** to automatically skip rendering objects outside of the current screen.
+       * See [cullable]{@link PIXI.DisplayObject#cullable} and [cullArea]{@link PIXI.DisplayObject#cullArea}.
+       * Other culling methods might be better suited for a large number static objects; see
+       * [@pixi-essentials/cull]{@link https://www.npmjs.com/package/@pixi-essentials/cull} and
+       * [pixi-cull]{@link https://www.npmjs.com/package/pixi-cull}.
+       *
+       * The [renderAdvanced]{@link PIXI.Container#renderAdvanced} method is internally used when when masking or
+       * filtering is applied on a container. This does, however, break batching and can affect performance when
+       * masking and filtering is applied extensively throughout the scene graph.
+       * @param renderer - The renderer
+       */
+      Container.prototype.render = function (renderer) {
+          // if the object is not visible or the alpha is 0 then no need to render this element
+          if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
+              return;
+          }
+          // do a quick check to see if this element has a mask or a filter.
+          if (this._mask || (this.filters && this.filters.length)) {
+              this.renderAdvanced(renderer);
+          }
+          else if (this.cullable) {
+              this._renderWithCulling(renderer);
+          }
+          else {
+              this._render(renderer);
+              for (var i = 0, j = this.children.length; i < j; ++i) {
+                  this.children[i].render(renderer);
+              }
+          }
+      };
+      /**
+       * Render the object using the WebGL renderer and advanced features.
+       * @param renderer - The renderer
+       */
+      Container.prototype.renderAdvanced = function (renderer) {
+          var filters = this.filters;
+          var mask = this._mask;
+          // push filter first as we need to ensure the stencil buffer is correct for any masking
+          if (filters) {
+              if (!this._enabledFilters) {
+                  this._enabledFilters = [];
+              }
+              this._enabledFilters.length = 0;
+              for (var i = 0; i < filters.length; i++) {
+                  if (filters[i].enabled) {
+                      this._enabledFilters.push(filters[i]);
+                  }
+              }
+          }
+          var flush = (filters && this._enabledFilters && this._enabledFilters.length)
+              || (mask && (!mask.isMaskData
+                  || (mask.enabled && (mask.autoDetect || mask.type !== exports.MASK_TYPES.NONE))));
+          if (flush) {
+              renderer.batch.flush();
+          }
+          if (filters && this._enabledFilters && this._enabledFilters.length) {
+              renderer.filter.push(this, this._enabledFilters);
+          }
+          if (mask) {
+              renderer.mask.push(this, this._mask);
+          }
+          if (this.cullable) {
+              this._renderWithCulling(renderer);
+          }
+          else {
+              this._render(renderer);
+              for (var i = 0, j = this.children.length; i < j; ++i) {
+                  this.children[i].render(renderer);
+              }
+          }
+          if (flush) {
+              renderer.batch.flush();
+          }
+          if (mask) {
+              renderer.mask.pop(this);
+          }
+          if (filters && this._enabledFilters && this._enabledFilters.length) {
+              renderer.filter.pop();
+          }
+      };
+      /**
+       * To be overridden by the subclasses.
+       * @param _renderer - The renderer
+       */
+      Container.prototype._render = function (_renderer) {
+          // this is where content itself gets rendered...
+      };
+      /**
+       * Removes all internal references and listeners as well as removes children from the display list.
+       * Do not use a Container after calling `destroy`.
+       * @param options - Options parameter. A boolean will act as if all options
+       *  have been set to that value
+       * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
+       *  method called as well. 'options' will be passed on to those calls.
+       * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
+       *  Should it destroy the texture of the child sprite
+       * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
+       *  Should it destroy the base texture of the child sprite
+       */
+      Container.prototype.destroy = function (options) {
+          _super.prototype.destroy.call(this);
+          this.sortDirty = false;
+          var destroyChildren = typeof options === 'boolean' ? options : options && options.children;
+          var oldChildren = this.removeChildren(0, this.children.length);
+          if (destroyChildren) {
+              for (var i = 0; i < oldChildren.length; ++i) {
+                  oldChildren[i].destroy(options);
+              }
+          }
+      };
+      Object.defineProperty(Container.prototype, "width", {
+          /** The width of the Container, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              return this.scale.x * this.getLocalBounds().width;
+          },
+          set: function (value) {
+              var width = this.getLocalBounds().width;
+              if (width !== 0) {
+                  this.scale.x = value / width;
+              }
+              else {
+                  this.scale.x = 1;
+              }
+              this._width = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Container.prototype, "height", {
+          /** The height of the Container, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              return this.scale.y * this.getLocalBounds().height;
+          },
+          set: function (value) {
+              var height = this.getLocalBounds().height;
+              if (height !== 0) {
+                  this.scale.y = value / height;
+              }
+              else {
+                  this.scale.y = 1;
+              }
+              this._height = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return Container;
+  }(DisplayObject));
+  /**
+   * Container default updateTransform, does update children of container.
+   * Will crash if there's no parent element.
+   * @memberof PIXI.Container#
+   * @method containerUpdateTransform
+   */
+  Container.prototype.containerUpdateTransform = Container.prototype.updateTransform;
 
-    ParticleRenderer.prototype.uploadPosition = function uploadPosition(children, startIndex, amount, array, stride, offset) {
-        for (var i = 0; i < amount; i++) {
-            var spritePosition = children[startIndex + i].position;
+  /*!
+   * @pixi/extensions - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/extensions is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+
+  var __assign$1 = function() {
+      __assign$1 = Object.assign || function __assign(t) {
+          var arguments$1 = arguments;
+
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+              s = arguments$1[i];
+              for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p)) { t[p] = s[p]; } }
+          }
+          return t;
+      };
+      return __assign$1.apply(this, arguments);
+  };
 
-            array[offset] = spritePosition.x;
-            array[offset + 1] = spritePosition.y;
+  /**
+   * Collection of valid extension types.
+   * @memberof PIXI
+   * @property {string} Application - Application plugins
+   * @property {string} RendererPlugin - Plugins for Renderer
+   * @property {string} CanvasRendererPlugin - Plugins for CanvasRenderer
+   * @property {string} Loader - Plugins to use with Loader
+   * @property {string} LoadParser - Parsers for Assets loader.
+   * @property {string} ResolveParser - Parsers for Assets resolvers.
+   * @property {string} CacheParser - Parsers for Assets cache.
+   */
+  exports.ExtensionType = void 0;
+  (function (ExtensionType) {
+      ExtensionType["Application"] = "application";
+      ExtensionType["RendererPlugin"] = "renderer-webgl-plugin";
+      ExtensionType["CanvasRendererPlugin"] = "renderer-canvas-plugin";
+      ExtensionType["Loader"] = "loader";
+      ExtensionType["LoadParser"] = "load-parser";
+      ExtensionType["ResolveParser"] = "resolve-parser";
+      ExtensionType["CacheParser"] = "cache-parser";
+      ExtensionType["DetectionParser"] = "detection-parser";
+  })(exports.ExtensionType || (exports.ExtensionType = {}));
+  /**
+   * Convert input into extension format data.
+   * @ignore
+   */
+  var normalizeExtension = function (ext) {
+      // Class/Object submission, use extension object
+      if (typeof ext === 'function' || (typeof ext === 'object' && ext.extension)) {
+          if (!ext.extension) {
+              throw new Error('Extension class must have an extension object');
+          }
+          var metadata = (typeof ext.extension !== 'object')
+              ? { type: ext.extension }
+              : ext.extension;
+          ext = __assign$1(__assign$1({}, metadata), { ref: ext });
+      }
+      if (typeof ext === 'object') {
+          ext = __assign$1({}, ext);
+      }
+      else {
+          throw new Error('Invalid extension type');
+      }
+      if (typeof ext.type === 'string') {
+          ext.type = [ext.type];
+      }
+      return ext;
+  };
+  /**
+   * Global registration of all PixiJS extensions. One-stop-shop for extensibility.
+   * @memberof PIXI
+   * @namespace extensions
+   */
+  var extensions = {
+      /** @ignore */
+      _addHandlers: null,
+      /** @ignore */
+      _removeHandlers: null,
+      /** @ignore */
+      _queue: {},
+      /**
+       * Remove extensions from PixiJS.
+       * @param extensions - Extensions to be removed.
+       * @returns {PIXI.extensions} For chaining.
+       */
+      remove: function () {
+          var arguments$1 = arguments;
 
-            array[offset + stride] = spritePosition.x;
-            array[offset + stride + 1] = spritePosition.y;
+          var _this = this;
+          var extensions = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              extensions[_i] = arguments$1[_i];
+          }
+          extensions.map(normalizeExtension).forEach(function (ext) {
+              ext.type.forEach(function (type) { var _a, _b; return (_b = (_a = _this._removeHandlers)[type]) === null || _b === void 0 ? void 0 : _b.call(_a, ext); });
+          });
+          return this;
+      },
+      /**
+       * Register new extensions with PixiJS.
+       * @param extensions - The spread of extensions to add to PixiJS.
+       * @returns {PIXI.extensions} For chaining.
+       */
+      add: function () {
+          var arguments$1 = arguments;
 
-            array[offset + stride * 2] = spritePosition.x;
-            array[offset + stride * 2 + 1] = spritePosition.y;
+          var _this = this;
+          var extensions = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              extensions[_i] = arguments$1[_i];
+          }
+          // Handle any extensions either passed as class w/ data or as data
+          extensions.map(normalizeExtension).forEach(function (ext) {
+              ext.type.forEach(function (type) {
+                  var handlers = _this._addHandlers;
+                  var queue = _this._queue;
+                  if (!handlers[type]) {
+                      queue[type] = queue[type] || [];
+                      queue[type].push(ext);
+                  }
+                  else {
+                      handlers[type](ext);
+                  }
+              });
+          });
+          return this;
+      },
+      /**
+       * Internal method to handle extensions by name.
+       * @param type - The extension type.
+       * @param onAdd  - Function for handling when extensions are added/registered passes {@link PIXI.ExtensionFormat}.
+       * @param onRemove  - Function for handling when extensions are removed/unregistered passes {@link PIXI.ExtensionFormat}.
+       * @returns {PIXI.extensions} For chaining.
+       */
+      handle: function (type, onAdd, onRemove) {
+          var addHandlers = this._addHandlers = this._addHandlers || {};
+          var removeHandlers = this._removeHandlers = this._removeHandlers || {};
+          if (addHandlers[type] || removeHandlers[type]) {
+              throw new Error("Extension type " + type + " already has a handler");
+          }
+          addHandlers[type] = onAdd;
+          removeHandlers[type] = onRemove;
+          // Process the queue
+          var queue = this._queue;
+          // Process any plugins that have been registered before the handler
+          if (queue[type]) {
+              queue[type].forEach(function (ext) { return onAdd(ext); });
+              delete queue[type];
+          }
+          return this;
+      },
+      /**
+       * Handle a type, but using a map by `name` property.
+       * @param type - Type of extension to handle.
+       * @param map - The object map of named extensions.
+       * @returns {PIXI.extensions} For chaining.
+       */
+      handleByMap: function (type, map) {
+          return this.handle(type, function (extension) {
+              map[extension.name] = extension.ref;
+          }, function (extension) {
+              delete map[extension.name];
+          });
+      },
+      /**
+       * Handle a type, but using a list of extensions.
+       * @param type - Type of extension to handle.
+       * @param list - The list of extensions.
+       * @returns {PIXI.extensions} For chaining.
+       */
+      handleByList: function (type, list) {
+          return this.handle(type, function (extension) {
+              var _a, _b;
+              if (list.includes(extension.ref)) {
+                  return;
+              }
+              list.push(extension.ref);
+              // TODO: remove me later, only added for @pixi/loaders
+              if (type === exports.ExtensionType.Loader) {
+                  (_b = (_a = extension.ref).add) === null || _b === void 0 ? void 0 : _b.call(_a);
+              }
+          }, function (extension) {
+              var index = list.indexOf(extension.ref);
+              if (index !== -1) {
+                  list.splice(index, 1);
+              }
+          });
+      },
+  };
 
-            array[offset + stride * 3] = spritePosition.x;
-            array[offset + stride * 3 + 1] = spritePosition.y;
+  /*!
+   * @pixi/runner - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/runner is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
+  /**
+   * A Runner is a highly performant and simple alternative to signals. Best used in situations
+   * where events are dispatched to many objects at high frequency (say every frame!)
+   *
+   *
+   * like a signal..
+   * ```
+   * import { Runner } from '@pixi/runner';
+   *
+   * const myObject = {
+   *     loaded: new Runner('loaded')
+   * }
+   *
+   * const listener = {
+   *     loaded: function(){
+   *         // thin
+   *     }
+   * }
+   *
+   * myObject.loaded.add(listener);
+   *
+   * myObject.loaded.emit();
+   * ```
+   *
+   * Or for handling calling the same function on many items
+   * ```
+   * import { Runner } from '@pixi/runner';
+   *
+   * const myGame = {
+   *     update: new Runner('update')
+   * }
+   *
+   * const gameObject = {
+   *     update: function(time){
+   *         // update my gamey state
+   *     }
+   * }
+   *
+   * myGame.update.add(gameObject);
+   *
+   * myGame.update.emit(time);
+   * ```
+   * @memberof PIXI
+   */
+  var Runner = /** @class */ (function () {
+      /**
+       * @param name - The function name that will be executed on the listeners added to this Runner.
+       */
+      function Runner(name) {
+          this.items = [];
+          this._name = name;
+          this._aliasCount = 0;
+      }
+      /* eslint-disable jsdoc/require-param, jsdoc/check-param-names */
+      /**
+       * Dispatch/Broadcast Runner to all listeners added to the queue.
+       * @param {...any} params - (optional) parameters to pass to each listener
+       */
+      /*  eslint-enable jsdoc/require-param, jsdoc/check-param-names */
+      Runner.prototype.emit = function (a0, a1, a2, a3, a4, a5, a6, a7) {
+          if (arguments.length > 8) {
+              throw new Error('max arguments reached');
+          }
+          var _a = this, name = _a.name, items = _a.items;
+          this._aliasCount++;
+          for (var i = 0, len = items.length; i < len; i++) {
+              items[i][name](a0, a1, a2, a3, a4, a5, a6, a7);
+          }
+          if (items === this.items) {
+              this._aliasCount--;
+          }
+          return this;
+      };
+      Runner.prototype.ensureNonAliasedItems = function () {
+          if (this._aliasCount > 0 && this.items.length > 1) {
+              this._aliasCount = 0;
+              this.items = this.items.slice(0);
+          }
+      };
+      /**
+       * Add a listener to the Runner
+       *
+       * Runners do not need to have scope or functions passed to them.
+       * All that is required is to pass the listening object and ensure that it has contains a function that has the same name
+       * as the name provided to the Runner when it was created.
+       *
+       * Eg A listener passed to this Runner will require a 'complete' function.
+       *
+       * ```
+       * import { Runner } from '@pixi/runner';
+       *
+       * const complete = new Runner('complete');
+       * ```
+       *
+       * The scope used will be the object itself.
+       * @param {any} item - The object that will be listening.
+       */
+      Runner.prototype.add = function (item) {
+          if (item[this._name]) {
+              this.ensureNonAliasedItems();
+              this.remove(item);
+              this.items.push(item);
+          }
+          return this;
+      };
+      /**
+       * Remove a single listener from the dispatch queue.
+       * @param {any} item - The listener that you would like to remove.
+       */
+      Runner.prototype.remove = function (item) {
+          var index = this.items.indexOf(item);
+          if (index !== -1) {
+              this.ensureNonAliasedItems();
+              this.items.splice(index, 1);
+          }
+          return this;
+      };
+      /**
+       * Check to see if the listener is already in the Runner
+       * @param {any} item - The listener that you would like to check.
+       */
+      Runner.prototype.contains = function (item) {
+          return this.items.indexOf(item) !== -1;
+      };
+      /** Remove all listeners from the Runner */
+      Runner.prototype.removeAll = function () {
+          this.ensureNonAliasedItems();
+          this.items.length = 0;
+          return this;
+      };
+      /** Remove all references, don't use after this. */
+      Runner.prototype.destroy = function () {
+          this.removeAll();
+          this.items = null;
+          this._name = null;
+      };
+      Object.defineProperty(Runner.prototype, "empty", {
+          /**
+           * `true` if there are no this Runner contains no listeners
+           * @readonly
+           */
+          get: function () {
+              return this.items.length === 0;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Runner.prototype, "name", {
+          /**
+           * The name of the runner.
+           * @readonly
+           */
+          get: function () {
+              return this._name;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return Runner;
+  }());
+  Object.defineProperties(Runner.prototype, {
+      /**
+       * Alias for `emit`
+       * @memberof PIXI.Runner#
+       * @method dispatch
+       * @see PIXI.Runner#emit
+       */
+      dispatch: { value: Runner.prototype.emit },
+      /**
+       * Alias for `emit`
+       * @memberof PIXI.Runner#
+       * @method run
+       * @see PIXI.Runner#emit
+       */
+      run: { value: Runner.prototype.emit },
+  });
 
-            offset += stride * 4;
-        }
-    };
+  /*!
+   * @pixi/ticker - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/ticker is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-    /**
-     *
-     * @param {PIXI.DisplayObject[]} children - the array of display objects to render
-     * @param {number} startIndex - the index to start from in the children array
-     * @param {number} amount - the amount of children that will have their rotation uploaded
-     * @param {number[]} array - The vertices to upload.
-     * @param {number} stride - Stride to use for iteration.
-     * @param {number} offset - Offset to start at.
-     */
+  /**
+   * Target frames per millisecond.
+   * @static
+   * @name TARGET_FPMS
+   * @memberof PIXI.settings
+   * @type {number}
+   * @default 0.06
+   */
+  settings.TARGET_FPMS = 0.06;
 
+  /**
+   * Represents the update priorities used by internal PIXI classes when registered with
+   * the {@link PIXI.Ticker} object. Higher priority items are updated first and lower
+   * priority items, such as render, should go later.
+   * @static
+   * @constant
+   * @name UPDATE_PRIORITY
+   * @memberof PIXI
+   * @enum {number}
+   * @property {number} [INTERACTION=50] Highest priority, used for {@link PIXI.InteractionManager}
+   * @property {number} [HIGH=25] High priority updating, {@link PIXI.VideoBaseTexture} and {@link PIXI.AnimatedSprite}
+   * @property {number} [NORMAL=0] Default priority for ticker events, see {@link PIXI.Ticker#add}.
+   * @property {number} [LOW=-25] Low priority used for {@link PIXI.Application} rendering.
+   * @property {number} [UTILITY=-50] Lowest priority used for {@link PIXI.BasePrepare} utility.
+   */
+  exports.UPDATE_PRIORITY = void 0;
+  (function (UPDATE_PRIORITY) {
+      UPDATE_PRIORITY[UPDATE_PRIORITY["INTERACTION"] = 50] = "INTERACTION";
+      UPDATE_PRIORITY[UPDATE_PRIORITY["HIGH"] = 25] = "HIGH";
+      UPDATE_PRIORITY[UPDATE_PRIORITY["NORMAL"] = 0] = "NORMAL";
+      UPDATE_PRIORITY[UPDATE_PRIORITY["LOW"] = -25] = "LOW";
+      UPDATE_PRIORITY[UPDATE_PRIORITY["UTILITY"] = -50] = "UTILITY";
+  })(exports.UPDATE_PRIORITY || (exports.UPDATE_PRIORITY = {}));
 
-    ParticleRenderer.prototype.uploadRotation = function uploadRotation(children, startIndex, amount, array, stride, offset) {
-        for (var i = 0; i < amount; i++) {
-            var spriteRotation = children[startIndex + i].rotation;
+  /**
+   * Internal class for handling the priority sorting of ticker handlers.
+   * @private
+   * @class
+   * @memberof PIXI
+   */
+  var TickerListener = /** @class */ (function () {
+      /**
+       * Constructor
+       * @private
+       * @param fn - The listener function to be added for one update
+       * @param context - The listener context
+       * @param priority - The priority for emitting
+       * @param once - If the handler should fire once
+       */
+      function TickerListener(fn, context, priority, once) {
+          if (context === void 0) { context = null; }
+          if (priority === void 0) { priority = 0; }
+          if (once === void 0) { once = false; }
+          /** The next item in chain. */
+          this.next = null;
+          /** The previous item in chain. */
+          this.previous = null;
+          /** `true` if this listener has been destroyed already. */
+          this._destroyed = false;
+          this.fn = fn;
+          this.context = context;
+          this.priority = priority;
+          this.once = once;
+      }
+      /**
+       * Simple compare function to figure out if a function and context match.
+       * @private
+       * @param fn - The listener function to be added for one update
+       * @param context - The listener context
+       * @returns `true` if the listener match the arguments
+       */
+      TickerListener.prototype.match = function (fn, context) {
+          if (context === void 0) { context = null; }
+          return this.fn === fn && this.context === context;
+      };
+      /**
+       * Emit by calling the current function.
+       * @private
+       * @param deltaTime - time since the last emit.
+       * @returns Next ticker
+       */
+      TickerListener.prototype.emit = function (deltaTime) {
+          if (this.fn) {
+              if (this.context) {
+                  this.fn.call(this.context, deltaTime);
+              }
+              else {
+                  this.fn(deltaTime);
+              }
+          }
+          var redirect = this.next;
+          if (this.once) {
+              this.destroy(true);
+          }
+          // Soft-destroying should remove
+          // the next reference
+          if (this._destroyed) {
+              this.next = null;
+          }
+          return redirect;
+      };
+      /**
+       * Connect to the list.
+       * @private
+       * @param previous - Input node, previous listener
+       */
+      TickerListener.prototype.connect = function (previous) {
+          this.previous = previous;
+          if (previous.next) {
+              previous.next.previous = this;
+          }
+          this.next = previous.next;
+          previous.next = this;
+      };
+      /**
+       * Destroy and don't use after this.
+       * @private
+       * @param hard - `true` to remove the `next` reference, this
+       *        is considered a hard destroy. Soft destroy maintains the next reference.
+       * @returns The listener to redirect while emitting or removing.
+       */
+      TickerListener.prototype.destroy = function (hard) {
+          if (hard === void 0) { hard = false; }
+          this._destroyed = true;
+          this.fn = null;
+          this.context = null;
+          // Disconnect, hook up next and previous
+          if (this.previous) {
+              this.previous.next = this.next;
+          }
+          if (this.next) {
+              this.next.previous = this.previous;
+          }
+          // Redirect to the next item
+          var redirect = this.next;
+          // Remove references
+          this.next = hard ? null : redirect;
+          this.previous = null;
+          return redirect;
+      };
+      return TickerListener;
+  }());
 
-            array[offset] = spriteRotation;
-            array[offset + stride] = spriteRotation;
-            array[offset + stride * 2] = spriteRotation;
-            array[offset + stride * 3] = spriteRotation;
+  /**
+   * A Ticker class that runs an update loop that other objects listen to.
+   *
+   * This class is composed around listeners meant for execution on the next requested animation frame.
+   * Animation frames are requested only when necessary, e.g. When the ticker is started and the emitter has listeners.
+   * @class
+   * @memberof PIXI
+   */
+  var Ticker = /** @class */ (function () {
+      function Ticker() {
+          var _this = this;
+          /**
+           * Whether or not this ticker should invoke the method
+           * {@link PIXI.Ticker#start} automatically
+           * when a listener is added.
+           */
+          this.autoStart = false;
+          /**
+           * Scalar time value from last frame to this frame.
+           * This value is capped by setting {@link PIXI.Ticker#minFPS}
+           * and is scaled with {@link PIXI.Ticker#speed}.
+           * **Note:** The cap may be exceeded by scaling.
+           */
+          this.deltaTime = 1;
+          /**
+           * The last time {@link PIXI.Ticker#update} was invoked.
+           * This value is also reset internally outside of invoking
+           * update, but only when a new animation frame is requested.
+           * If the platform supports DOMHighResTimeStamp,
+           * this value will have a precision of 1 µs.
+           */
+          this.lastTime = -1;
+          /**
+           * Factor of current {@link PIXI.Ticker#deltaTime}.
+           * @example
+           * // Scales ticker.deltaTime to what would be
+           * // the equivalent of approximately 120 FPS
+           * ticker.speed = 2;
+           */
+          this.speed = 1;
+          /**
+           * Whether or not this ticker has been started.
+           * `true` if {@link PIXI.Ticker#start} has been called.
+           * `false` if {@link PIXI.Ticker#stop} has been called.
+           * While `false`, this value may change to `true` in the
+           * event of {@link PIXI.Ticker#autoStart} being `true`
+           * and a listener is added.
+           */
+          this.started = false;
+          /** Internal current frame request ID */
+          this._requestId = null;
+          /**
+           * Internal value managed by minFPS property setter and getter.
+           * This is the maximum allowed milliseconds between updates.
+           */
+          this._maxElapsedMS = 100;
+          /**
+           * Internal value managed by minFPS property setter and getter.
+           * This is the minimum allowed milliseconds between updates.
+           */
+          this._minElapsedMS = 0;
+          /** If enabled, deleting is disabled.*/
+          this._protected = false;
+          /** The last time keyframe was executed. Maintains a relatively fixed interval with the previous value. */
+          this._lastFrame = -1;
+          this._head = new TickerListener(null, null, Infinity);
+          this.deltaMS = 1 / settings.TARGET_FPMS;
+          this.elapsedMS = 1 / settings.TARGET_FPMS;
+          this._tick = function (time) {
+              _this._requestId = null;
+              if (_this.started) {
+                  // Invoke listeners now
+                  _this.update(time);
+                  // Listener side effects may have modified ticker state.
+                  if (_this.started && _this._requestId === null && _this._head.next) {
+                      _this._requestId = requestAnimationFrame(_this._tick);
+                  }
+              }
+          };
+      }
+      /**
+       * Conditionally requests a new animation frame.
+       * If a frame has not already been requested, and if the internal
+       * emitter has listeners, a new frame is requested.
+       * @private
+       */
+      Ticker.prototype._requestIfNeeded = function () {
+          if (this._requestId === null && this._head.next) {
+              // ensure callbacks get correct delta
+              this.lastTime = performance.now();
+              this._lastFrame = this.lastTime;
+              this._requestId = requestAnimationFrame(this._tick);
+          }
+      };
+      /**
+       * Conditionally cancels a pending animation frame.
+       * @private
+       */
+      Ticker.prototype._cancelIfNeeded = function () {
+          if (this._requestId !== null) {
+              cancelAnimationFrame(this._requestId);
+              this._requestId = null;
+          }
+      };
+      /**
+       * Conditionally requests a new animation frame.
+       * If the ticker has been started it checks if a frame has not already
+       * been requested, and if the internal emitter has listeners. If these
+       * conditions are met, a new frame is requested. If the ticker has not
+       * been started, but autoStart is `true`, then the ticker starts now,
+       * and continues with the previous conditions to request a new frame.
+       * @private
+       */
+      Ticker.prototype._startIfPossible = function () {
+          if (this.started) {
+              this._requestIfNeeded();
+          }
+          else if (this.autoStart) {
+              this.start();
+          }
+      };
+      /**
+       * Register a handler for tick events. Calls continuously unless
+       * it is removed or the ticker is stopped.
+       * @param fn - The listener function to be added for updates
+       * @param context - The listener context
+       * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
+       * @returns This instance of a ticker
+       */
+      Ticker.prototype.add = function (fn, context, priority) {
+          if (priority === void 0) { priority = exports.UPDATE_PRIORITY.NORMAL; }
+          return this._addListener(new TickerListener(fn, context, priority));
+      };
+      /**
+       * Add a handler for the tick event which is only execute once.
+       * @param fn - The listener function to be added for one update
+       * @param context - The listener context
+       * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
+       * @returns This instance of a ticker
+       */
+      Ticker.prototype.addOnce = function (fn, context, priority) {
+          if (priority === void 0) { priority = exports.UPDATE_PRIORITY.NORMAL; }
+          return this._addListener(new TickerListener(fn, context, priority, true));
+      };
+      /**
+       * Internally adds the event handler so that it can be sorted by priority.
+       * Priority allows certain handler (user, AnimatedSprite, Interaction) to be run
+       * before the rendering.
+       * @private
+       * @param listener - Current listener being added.
+       * @returns This instance of a ticker
+       */
+      Ticker.prototype._addListener = function (listener) {
+          // For attaching to head
+          var current = this._head.next;
+          var previous = this._head;
+          // Add the first item
+          if (!current) {
+              listener.connect(previous);
+          }
+          else {
+              // Go from highest to lowest priority
+              while (current) {
+                  if (listener.priority > current.priority) {
+                      listener.connect(previous);
+                      break;
+                  }
+                  previous = current;
+                  current = current.next;
+              }
+              // Not yet connected
+              if (!listener.previous) {
+                  listener.connect(previous);
+              }
+          }
+          this._startIfPossible();
+          return this;
+      };
+      /**
+       * Removes any handlers matching the function and context parameters.
+       * If no handlers are left after removing, then it cancels the animation frame.
+       * @param fn - The listener function to be removed
+       * @param context - The listener context to be removed
+       * @returns This instance of a ticker
+       */
+      Ticker.prototype.remove = function (fn, context) {
+          var listener = this._head.next;
+          while (listener) {
+              // We found a match, lets remove it
+              // no break to delete all possible matches
+              // incase a listener was added 2+ times
+              if (listener.match(fn, context)) {
+                  listener = listener.destroy();
+              }
+              else {
+                  listener = listener.next;
+              }
+          }
+          if (!this._head.next) {
+              this._cancelIfNeeded();
+          }
+          return this;
+      };
+      Object.defineProperty(Ticker.prototype, "count", {
+          /**
+           * The number of listeners on this ticker, calculated by walking through linked list
+           * @readonly
+           * @member {number}
+           */
+          get: function () {
+              if (!this._head) {
+                  return 0;
+              }
+              var count = 0;
+              var current = this._head;
+              while ((current = current.next)) {
+                  count++;
+              }
+              return count;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Starts the ticker. If the ticker has listeners a new animation frame is requested at this point. */
+      Ticker.prototype.start = function () {
+          if (!this.started) {
+              this.started = true;
+              this._requestIfNeeded();
+          }
+      };
+      /** Stops the ticker. If the ticker has requested an animation frame it is canceled at this point. */
+      Ticker.prototype.stop = function () {
+          if (this.started) {
+              this.started = false;
+              this._cancelIfNeeded();
+          }
+      };
+      /** Destroy the ticker and don't use after this. Calling this method removes all references to internal events. */
+      Ticker.prototype.destroy = function () {
+          if (!this._protected) {
+              this.stop();
+              var listener = this._head.next;
+              while (listener) {
+                  listener = listener.destroy(true);
+              }
+              this._head.destroy();
+              this._head = null;
+          }
+      };
+      /**
+       * Triggers an update. An update entails setting the
+       * current {@link PIXI.Ticker#elapsedMS},
+       * the current {@link PIXI.Ticker#deltaTime},
+       * invoking all listeners with current deltaTime,
+       * and then finally setting {@link PIXI.Ticker#lastTime}
+       * with the value of currentTime that was provided.
+       * This method will be called automatically by animation
+       * frame callbacks if the ticker instance has been started
+       * and listeners are added.
+       * @param {number} [currentTime=performance.now()] - the current time of execution
+       */
+      Ticker.prototype.update = function (currentTime) {
+          if (currentTime === void 0) { currentTime = performance.now(); }
+          var elapsedMS;
+          // If the difference in time is zero or negative, we ignore most of the work done here.
+          // If there is no valid difference, then should be no reason to let anyone know about it.
+          // A zero delta, is exactly that, nothing should update.
+          //
+          // The difference in time can be negative, and no this does not mean time traveling.
+          // This can be the result of a race condition between when an animation frame is requested
+          // on the current JavaScript engine event loop, and when the ticker's start method is invoked
+          // (which invokes the internal _requestIfNeeded method). If a frame is requested before
+          // _requestIfNeeded is invoked, then the callback for the animation frame the ticker requests,
+          // can receive a time argument that can be less than the lastTime value that was set within
+          // _requestIfNeeded. This difference is in microseconds, but this is enough to cause problems.
+          //
+          // This check covers this browser engine timing issue, as well as if consumers pass an invalid
+          // currentTime value. This may happen if consumers opt-out of the autoStart, and update themselves.
+          if (currentTime > this.lastTime) {
+              // Save uncapped elapsedMS for measurement
+              elapsedMS = this.elapsedMS = currentTime - this.lastTime;
+              // cap the milliseconds elapsed used for deltaTime
+              if (elapsedMS > this._maxElapsedMS) {
+                  elapsedMS = this._maxElapsedMS;
+              }
+              elapsedMS *= this.speed;
+              // If not enough time has passed, exit the function.
+              // Get ready for next frame by setting _lastFrame, but based on _minElapsedMS
+              // adjustment to ensure a relatively stable interval.
+              if (this._minElapsedMS) {
+                  var delta = currentTime - this._lastFrame | 0;
+                  if (delta < this._minElapsedMS) {
+                      return;
+                  }
+                  this._lastFrame = currentTime - (delta % this._minElapsedMS);
+              }
+              this.deltaMS = elapsedMS;
+              this.deltaTime = this.deltaMS * settings.TARGET_FPMS;
+              // Cache a local reference, in-case ticker is destroyed
+              // during the emit, we can still check for head.next
+              var head = this._head;
+              // Invoke listeners added to internal emitter
+              var listener = head.next;
+              while (listener) {
+                  listener = listener.emit(this.deltaTime);
+              }
+              if (!head.next) {
+                  this._cancelIfNeeded();
+              }
+          }
+          else {
+              this.deltaTime = this.deltaMS = this.elapsedMS = 0;
+          }
+          this.lastTime = currentTime;
+      };
+      Object.defineProperty(Ticker.prototype, "FPS", {
+          /**
+           * The frames per second at which this ticker is running.
+           * The default is approximately 60 in most modern browsers.
+           * **Note:** This does not factor in the value of
+           * {@link PIXI.Ticker#speed}, which is specific
+           * to scaling {@link PIXI.Ticker#deltaTime}.
+           * @member {number}
+           * @readonly
+           */
+          get: function () {
+              return 1000 / this.elapsedMS;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Ticker.prototype, "minFPS", {
+          /**
+           * Manages the maximum amount of milliseconds allowed to
+           * elapse between invoking {@link PIXI.Ticker#update}.
+           * This value is used to cap {@link PIXI.Ticker#deltaTime},
+           * but does not effect the measured value of {@link PIXI.Ticker#FPS}.
+           * When setting this property it is clamped to a value between
+           * `0` and `PIXI.settings.TARGET_FPMS * 1000`.
+           * @member {number}
+           * @default 10
+           */
+          get: function () {
+              return 1000 / this._maxElapsedMS;
+          },
+          set: function (fps) {
+              // Minimum must be below the maxFPS
+              var minFPS = Math.min(this.maxFPS, fps);
+              // Must be at least 0, but below 1 / settings.TARGET_FPMS
+              var minFPMS = Math.min(Math.max(0, minFPS) / 1000, settings.TARGET_FPMS);
+              this._maxElapsedMS = 1 / minFPMS;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Ticker.prototype, "maxFPS", {
+          /**
+           * Manages the minimum amount of milliseconds required to
+           * elapse between invoking {@link PIXI.Ticker#update}.
+           * This will effect the measured value of {@link PIXI.Ticker#FPS}.
+           * If it is set to `0`, then there is no limit; PixiJS will render as many frames as it can.
+           * Otherwise it will be at least `minFPS`
+           * @member {number}
+           * @default 0
+           */
+          get: function () {
+              if (this._minElapsedMS) {
+                  return Math.round(1000 / this._minElapsedMS);
+              }
+              return 0;
+          },
+          set: function (fps) {
+              if (fps === 0) {
+                  this._minElapsedMS = 0;
+              }
+              else {
+                  // Max must be at least the minFPS
+                  var maxFPS = Math.max(this.minFPS, fps);
+                  this._minElapsedMS = 1 / (maxFPS / 1000);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Ticker, "shared", {
+          /**
+           * The shared ticker instance used by {@link PIXI.AnimatedSprite} and by
+           * {@link PIXI.VideoResource} to update animation frames / video textures.
+           *
+           * It may also be used by {@link PIXI.Application} if created with the `sharedTicker` option property set to true.
+           *
+           * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
+           * Please follow the examples for usage, including how to opt-out of auto-starting the shared ticker.
+           * @example
+           * let ticker = PIXI.Ticker.shared;
+           * // Set this to prevent starting this ticker when listeners are added.
+           * // By default this is true only for the PIXI.Ticker.shared instance.
+           * ticker.autoStart = false;
+           * // FYI, call this to ensure the ticker is stopped. It should be stopped
+           * // if you have not attempted to render anything yet.
+           * ticker.stop();
+           * // Call this when you are ready for a running shared ticker.
+           * ticker.start();
+           * @example
+           * // You may use the shared ticker to render...
+           * let renderer = PIXI.autoDetectRenderer();
+           * let stage = new PIXI.Container();
+           * document.body.appendChild(renderer.view);
+           * ticker.add(function (time) {
+           *     renderer.render(stage);
+           * });
+           * @example
+           * // Or you can just update it manually.
+           * ticker.autoStart = false;
+           * ticker.stop();
+           * function animate(time) {
+           *     ticker.update(time);
+           *     renderer.render(stage);
+           *     requestAnimationFrame(animate);
+           * }
+           * animate(performance.now());
+           * @member {PIXI.Ticker}
+           * @static
+           */
+          get: function () {
+              if (!Ticker._shared) {
+                  var shared = Ticker._shared = new Ticker();
+                  shared.autoStart = true;
+                  shared._protected = true;
+              }
+              return Ticker._shared;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Ticker, "system", {
+          /**
+           * The system ticker instance used by {@link PIXI.InteractionManager} and by
+           * {@link PIXI.BasePrepare} for core timing functionality that shouldn't usually need to be paused,
+           * unlike the `shared` ticker which drives visual animations and rendering which may want to be paused.
+           *
+           * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
+           * @member {PIXI.Ticker}
+           * @static
+           */
+          get: function () {
+              if (!Ticker._system) {
+                  var system = Ticker._system = new Ticker();
+                  system.autoStart = true;
+                  system._protected = true;
+              }
+              return Ticker._system;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return Ticker;
+  }());
 
-            offset += stride * 4;
-        }
-    };
+  /**
+   * Middleware for for Application Ticker.
+   * @example
+   * import {TickerPlugin} from '@pixi/ticker';
+   * import {Application} from '@pixi/app';
+   * import {extensions} from '@pixi/extensions';
+   * extensions.add(TickerPlugin);
+   * @class
+   * @memberof PIXI
+   */
+  var TickerPlugin = /** @class */ (function () {
+      function TickerPlugin() {
+      }
+      /**
+       * Initialize the plugin with scope of application instance
+       * @static
+       * @private
+       * @param {object} [options] - See application options
+       */
+      TickerPlugin.init = function (options) {
+          var _this = this;
+          // Set default
+          options = Object.assign({
+              autoStart: true,
+              sharedTicker: false,
+          }, options);
+          // Create ticker setter
+          Object.defineProperty(this, 'ticker', {
+              set: function (ticker) {
+                  if (this._ticker) {
+                      this._ticker.remove(this.render, this);
+                  }
+                  this._ticker = ticker;
+                  if (ticker) {
+                      ticker.add(this.render, this, exports.UPDATE_PRIORITY.LOW);
+                  }
+              },
+              get: function () {
+                  return this._ticker;
+              },
+          });
+          /**
+           * Convenience method for stopping the render.
+           * @method
+           * @memberof PIXI.Application
+           * @instance
+           */
+          this.stop = function () {
+              _this._ticker.stop();
+          };
+          /**
+           * Convenience method for starting the render.
+           * @method
+           * @memberof PIXI.Application
+           * @instance
+           */
+          this.start = function () {
+              _this._ticker.start();
+          };
+          /**
+           * Internal reference to the ticker.
+           * @type {PIXI.Ticker}
+           * @name _ticker
+           * @memberof PIXI.Application#
+           * @private
+           */
+          this._ticker = null;
+          /**
+           * Ticker for doing render updates.
+           * @type {PIXI.Ticker}
+           * @name ticker
+           * @memberof PIXI.Application#
+           * @default PIXI.Ticker.shared
+           */
+          this.ticker = options.sharedTicker ? Ticker.shared : new Ticker();
+          // Start the rendering
+          if (options.autoStart) {
+              this.start();
+          }
+      };
+      /**
+       * Clean up the ticker, scoped to application.
+       * @static
+       * @private
+       */
+      TickerPlugin.destroy = function () {
+          if (this._ticker) {
+              var oldTicker = this._ticker;
+              this.ticker = null;
+              oldTicker.destroy();
+          }
+      };
+      /** @ignore */
+      TickerPlugin.extension = exports.ExtensionType.Application;
+      return TickerPlugin;
+  }());
+
+  /*!
+   * @pixi/core - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/core is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-    /**
-     *
-     * @param {PIXI.DisplayObject[]} children - the array of display objects to render
-     * @param {number} startIndex - the index to start from in the children array
-     * @param {number} amount - the amount of children that will have their rotation uploaded
-     * @param {number[]} array - The vertices to upload.
-     * @param {number} stride - Stride to use for iteration.
-     * @param {number} offset - Offset to start at.
-     */
+  /**
+   * The maximum support for using WebGL. If a device does not
+   * support WebGL version, for instance WebGL 2, it will still
+   * attempt to fallback support to WebGL 1. If you want to
+   * explicitly remove feature support to target a more stable
+   * baseline, prefer a lower environment.
+   *
+   * Due to {@link https://bugs.chromium.org/p/chromium/issues/detail?id=934823|bug in chromium}
+   * we disable webgl2 by default for all non-apple mobile devices.
+   * @static
+   * @name PREFER_ENV
+   * @memberof PIXI.settings
+   * @type {number}
+   * @default PIXI.ENV.WEBGL2
+   */
+  settings.PREFER_ENV = isMobile.any ? exports.ENV.WEBGL : exports.ENV.WEBGL2;
+  /**
+   * If set to `true`, *only* Textures and BaseTexture objects stored
+   * in the caches ({@link PIXI.utils.TextureCache TextureCache} and
+   * {@link PIXI.utils.BaseTextureCache BaseTextureCache}) can be
+   * used when calling {@link PIXI.Texture.from Texture.from} or
+   * {@link PIXI.BaseTexture.from BaseTexture.from}.
+   * Otherwise, these `from` calls throw an exception. Using this property
+   * can be useful if you want to enforce preloading all assets with
+   * {@link PIXI.Loader Loader}.
+   * @static
+   * @name STRICT_TEXTURE_CACHE
+   * @memberof PIXI.settings
+   * @type {boolean}
+   * @default false
+   */
+  settings.STRICT_TEXTURE_CACHE = false;
 
+  /**
+   * Collection of installed resource types, class must extend {@link PIXI.Resource}.
+   * @example
+   * class CustomResource extends PIXI.Resource {
+   *   // MUST have source, options constructor signature
+   *   // for auto-detected resources to be created.
+   *   constructor(source, options) {
+   *     super();
+   *   }
+   *   upload(renderer, baseTexture, glTexture) {
+   *     // upload with GL
+   *     return true;
+   *   }
+   *   // used to auto-detect resource
+   *   static test(source, extension) {
+   *     return extension === 'xyz'|| source instanceof SomeClass;
+   *   }
+   * }
+   * // Install the new resource type
+   * PIXI.INSTALLED.push(CustomResource);
+   * @memberof PIXI
+   * @type {Array<PIXI.IResourcePlugin>}
+   * @static
+   * @readonly
+   */
+  var INSTALLED = [];
+  /**
+   * Create a resource element from a single source element. This
+   * auto-detects which type of resource to create. All resources that
+   * are auto-detectable must have a static `test` method and a constructor
+   * with the arguments `(source, options?)`. Currently, the supported
+   * resources for auto-detection include:
+   *  - {@link PIXI.ImageResource}
+   *  - {@link PIXI.CanvasResource}
+   *  - {@link PIXI.VideoResource}
+   *  - {@link PIXI.SVGResource}
+   *  - {@link PIXI.BufferResource}
+   * @static
+   * @memberof PIXI
+   * @function autoDetectResource
+   * @param {string|*} source - Resource source, this can be the URL to the resource,
+   *        a typed-array (for BufferResource), HTMLVideoElement, SVG data-uri
+   *        or any other resource that can be auto-detected. If not resource is
+   *        detected, it's assumed to be an ImageResource.
+   * @param {object} [options] - Pass-through options to use for Resource
+   * @param {number} [options.width] - Width of BufferResource or SVG rasterization
+   * @param {number} [options.height] - Height of BufferResource or SVG rasterization
+   * @param {boolean} [options.autoLoad=true] - Image, SVG and Video flag to start loading
+   * @param {number} [options.scale=1] - SVG source scale. Overridden by width, height
+   * @param {boolean} [options.createBitmap=PIXI.settings.CREATE_IMAGE_BITMAP] - Image option to create Bitmap object
+   * @param {boolean} [options.crossorigin=true] - Image and Video option to set crossOrigin
+   * @param {boolean} [options.autoPlay=true] - Video option to start playing video immediately
+   * @param {number} [options.updateFPS=0] - Video option to update how many times a second the
+   *        texture should be updated from the video. Leave at 0 to update at every render
+   * @returns {PIXI.Resource} The created resource.
+   */
+  function autoDetectResource(source, options) {
+      if (!source) {
+          return null;
+      }
+      var extension = '';
+      if (typeof source === 'string') {
+          // search for file extension: period, 3-4 chars, then ?, # or EOL
+          var result = (/\.(\w{3,4})(?:$|\?|#)/i).exec(source);
+          if (result) {
+              extension = result[1].toLowerCase();
+          }
+      }
+      for (var i = INSTALLED.length - 1; i >= 0; --i) {
+          var ResourcePlugin = INSTALLED[i];
+          if (ResourcePlugin.test && ResourcePlugin.test(source, extension)) {
+              return new ResourcePlugin(source, options);
+          }
+      }
+      throw new Error('Unrecognized source type to auto-detect Resource');
+  }
 
-    ParticleRenderer.prototype.uploadUvs = function uploadUvs(children, startIndex, amount, array, stride, offset) {
-        for (var i = 0; i < amount; ++i) {
-            var textureUvs = children[startIndex + i]._texture._uvs;
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$i = function(d, b) {
+      extendStatics$i = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$i(d, b);
+  };
 
-            if (textureUvs) {
-                array[offset] = textureUvs.x0;
-                array[offset + 1] = textureUvs.y0;
+  function __extends$i(d, b) {
+      extendStatics$i(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-                array[offset + stride] = textureUvs.x1;
-                array[offset + stride + 1] = textureUvs.y1;
+  var __assign = function() {
+      __assign = Object.assign || function __assign(t) {
+          var arguments$1 = arguments;
 
-                array[offset + stride * 2] = textureUvs.x2;
-                array[offset + stride * 2 + 1] = textureUvs.y2;
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+              s = arguments$1[i];
+              for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p)) { t[p] = s[p]; } }
+          }
+          return t;
+      };
+      return __assign.apply(this, arguments);
+  };
 
-                array[offset + stride * 3] = textureUvs.x3;
-                array[offset + stride * 3 + 1] = textureUvs.y3;
+  function __rest(s, e) {
+      var t = {};
+      for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+          { t[p] = s[p]; } }
+      if (s != null && typeof Object.getOwnPropertySymbols === "function")
+          { for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                  { t[p[i]] = s[p[i]]; }
+          } }
+      return t;
+  }
 
-                offset += stride * 4;
-            } else {
-                // TODO you know this can be easier!
-                array[offset] = 0;
-                array[offset + 1] = 0;
+  /**
+   * Base resource class for textures that manages validation and uploading, depending on its type.
+   *
+   * Uploading of a base texture to the GPU is required.
+   * @memberof PIXI
+   */
+  var Resource = /** @class */ (function () {
+      /**
+       * @param width - Width of the resource
+       * @param height - Height of the resource
+       */
+      function Resource(width, height) {
+          if (width === void 0) { width = 0; }
+          if (height === void 0) { height = 0; }
+          this._width = width;
+          this._height = height;
+          this.destroyed = false;
+          this.internal = false;
+          this.onResize = new Runner('setRealSize');
+          this.onUpdate = new Runner('update');
+          this.onError = new Runner('onError');
+      }
+      /**
+       * Bind to a parent BaseTexture
+       * @param baseTexture - Parent texture
+       */
+      Resource.prototype.bind = function (baseTexture) {
+          this.onResize.add(baseTexture);
+          this.onUpdate.add(baseTexture);
+          this.onError.add(baseTexture);
+          // Call a resize immediate if we already
+          // have the width and height of the resource
+          if (this._width || this._height) {
+              this.onResize.emit(this._width, this._height);
+          }
+      };
+      /**
+       * Unbind to a parent BaseTexture
+       * @param baseTexture - Parent texture
+       */
+      Resource.prototype.unbind = function (baseTexture) {
+          this.onResize.remove(baseTexture);
+          this.onUpdate.remove(baseTexture);
+          this.onError.remove(baseTexture);
+      };
+      /**
+       * Trigger a resize event
+       * @param width - X dimension
+       * @param height - Y dimension
+       */
+      Resource.prototype.resize = function (width, height) {
+          if (width !== this._width || height !== this._height) {
+              this._width = width;
+              this._height = height;
+              this.onResize.emit(width, height);
+          }
+      };
+      Object.defineProperty(Resource.prototype, "valid", {
+          /**
+           * Has been validated
+           * @readonly
+           */
+          get: function () {
+              return !!this._width && !!this._height;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Has been updated trigger event. */
+      Resource.prototype.update = function () {
+          if (!this.destroyed) {
+              this.onUpdate.emit();
+          }
+      };
+      /**
+       * This can be overridden to start preloading a resource
+       * or do any other prepare step.
+       * @protected
+       * @returns Handle the validate event
+       */
+      Resource.prototype.load = function () {
+          return Promise.resolve(this);
+      };
+      Object.defineProperty(Resource.prototype, "width", {
+          /**
+           * The width of the resource.
+           * @readonly
+           */
+          get: function () {
+              return this._width;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Resource.prototype, "height", {
+          /**
+           * The height of the resource.
+           * @readonly
+           */
+          get: function () {
+              return this._height;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Set the style, optional to override
+       * @param _renderer - yeah, renderer!
+       * @param _baseTexture - the texture
+       * @param _glTexture - texture instance for this webgl context
+       * @returns - `true` is success
+       */
+      Resource.prototype.style = function (_renderer, _baseTexture, _glTexture) {
+          return false;
+      };
+      /** Clean up anything, this happens when destroying is ready. */
+      Resource.prototype.dispose = function () {
+          // override
+      };
+      /**
+       * Call when destroying resource, unbind any BaseTexture object
+       * before calling this method, as reference counts are maintained
+       * internally.
+       */
+      Resource.prototype.destroy = function () {
+          if (!this.destroyed) {
+              this.destroyed = true;
+              this.dispose();
+              this.onError.removeAll();
+              this.onError = null;
+              this.onResize.removeAll();
+              this.onResize = null;
+              this.onUpdate.removeAll();
+              this.onUpdate = null;
+          }
+      };
+      /**
+       * Abstract, used to auto-detect resource type.
+       * @param {*} _source - The source object
+       * @param {string} _extension - The extension of source, if set
+       */
+      Resource.test = function (_source, _extension) {
+          return false;
+      };
+      return Resource;
+  }());
 
-                array[offset + stride] = 0;
-                array[offset + stride + 1] = 0;
+  /**
+   * @interface SharedArrayBuffer
+   */
+  /**
+   * Buffer resource with data of typed array.
+   * @memberof PIXI
+   */
+  var BufferResource = /** @class */ (function (_super) {
+      __extends$i(BufferResource, _super);
+      /**
+       * @param source - Source buffer
+       * @param options - Options
+       * @param {number} options.width - Width of the texture
+       * @param {number} options.height - Height of the texture
+       */
+      function BufferResource(source, options) {
+          var _this = this;
+          var _a = options || {}, width = _a.width, height = _a.height;
+          if (!width || !height) {
+              throw new Error('BufferResource width or height invalid');
+          }
+          _this = _super.call(this, width, height) || this;
+          _this.data = source;
+          return _this;
+      }
+      /**
+       * Upload the texture to the GPU.
+       * @param renderer - Upload to the renderer
+       * @param baseTexture - Reference to parent texture
+       * @param glTexture - glTexture
+       * @returns - true is success
+       */
+      BufferResource.prototype.upload = function (renderer, baseTexture, glTexture) {
+          var gl = renderer.gl;
+          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === exports.ALPHA_MODES.UNPACK);
+          var width = baseTexture.realWidth;
+          var height = baseTexture.realHeight;
+          if (glTexture.width === width && glTexture.height === height) {
+              gl.texSubImage2D(baseTexture.target, 0, 0, 0, width, height, baseTexture.format, glTexture.type, this.data);
+          }
+          else {
+              glTexture.width = width;
+              glTexture.height = height;
+              gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, width, height, 0, baseTexture.format, glTexture.type, this.data);
+          }
+          return true;
+      };
+      /** Destroy and don't use after this. */
+      BufferResource.prototype.dispose = function () {
+          this.data = null;
+      };
+      /**
+       * Used to auto-detect the type of resource.
+       * @param {*} source - The source object
+       * @returns {boolean} `true` if <canvas>
+       */
+      BufferResource.test = function (source) {
+          return source instanceof Float32Array
+              || source instanceof Uint8Array
+              || source instanceof Uint32Array;
+      };
+      return BufferResource;
+  }(Resource));
+
+  var defaultBufferOptions = {
+      scaleMode: exports.SCALE_MODES.NEAREST,
+      format: exports.FORMATS.RGBA,
+      alphaMode: exports.ALPHA_MODES.NPM,
+  };
+  /**
+   * A Texture stores the information that represents an image.
+   * All textures have a base texture, which contains information about the source.
+   * Therefore you can have many textures all using a single BaseTexture
+   * @memberof PIXI
+   * @typeParam R - The BaseTexture's Resource type.
+   * @typeParam RO - The options for constructing resource.
+   */
+  var BaseTexture = /** @class */ (function (_super) {
+      __extends$i(BaseTexture, _super);
+      /**
+       * @param {PIXI.Resource|string|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} [resource=null] -
+       *        The current resource to use, for things that aren't Resource objects, will be converted
+       *        into a Resource.
+       * @param options - Collection of options
+       * @param {PIXI.MIPMAP_MODES} [options.mipmap=PIXI.settings.MIPMAP_TEXTURES] - If mipmapping is enabled for texture
+       * @param {number} [options.anisotropicLevel=PIXI.settings.ANISOTROPIC_LEVEL] - Anisotropic filtering level of texture
+       * @param {PIXI.WRAP_MODES} [options.wrapMode=PIXI.settings.WRAP_MODE] - Wrap mode for textures
+       * @param {PIXI.SCALE_MODES} [options.scaleMode=PIXI.settings.SCALE_MODE] - Default scale mode, linear, nearest
+       * @param {PIXI.FORMATS} [options.format=PIXI.FORMATS.RGBA] - GL format type
+       * @param {PIXI.TYPES} [options.type=PIXI.TYPES.UNSIGNED_BYTE] - GL data type
+       * @param {PIXI.TARGETS} [options.target=PIXI.TARGETS.TEXTURE_2D] - GL texture target
+       * @param {PIXI.ALPHA_MODES} [options.alphaMode=PIXI.ALPHA_MODES.UNPACK] - Pre multiply the image alpha
+       * @param {number} [options.width=0] - Width of the texture
+       * @param {number} [options.height=0] - Height of the texture
+       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] - Resolution of the base texture
+       * @param {object} [options.resourceOptions] - Optional resource options,
+       *        see {@link PIXI.autoDetectResource autoDetectResource}
+       */
+      function BaseTexture(resource, options) {
+          if (resource === void 0) { resource = null; }
+          if (options === void 0) { options = null; }
+          var _this = _super.call(this) || this;
+          options = options || {};
+          var alphaMode = options.alphaMode, mipmap = options.mipmap, anisotropicLevel = options.anisotropicLevel, scaleMode = options.scaleMode, width = options.width, height = options.height, wrapMode = options.wrapMode, format = options.format, type = options.type, target = options.target, resolution = options.resolution, resourceOptions = options.resourceOptions;
+          // Convert the resource to a Resource object
+          if (resource && !(resource instanceof Resource)) {
+              resource = autoDetectResource(resource, resourceOptions);
+              resource.internal = true;
+          }
+          _this.resolution = resolution || settings.RESOLUTION;
+          _this.width = Math.round((width || 0) * _this.resolution) / _this.resolution;
+          _this.height = Math.round((height || 0) * _this.resolution) / _this.resolution;
+          _this._mipmap = mipmap !== undefined ? mipmap : settings.MIPMAP_TEXTURES;
+          _this.anisotropicLevel = anisotropicLevel !== undefined ? anisotropicLevel : settings.ANISOTROPIC_LEVEL;
+          _this._wrapMode = wrapMode || settings.WRAP_MODE;
+          _this._scaleMode = scaleMode !== undefined ? scaleMode : settings.SCALE_MODE;
+          _this.format = format || exports.FORMATS.RGBA;
+          _this.type = type || exports.TYPES.UNSIGNED_BYTE;
+          _this.target = target || exports.TARGETS.TEXTURE_2D;
+          _this.alphaMode = alphaMode !== undefined ? alphaMode : exports.ALPHA_MODES.UNPACK;
+          _this.uid = uid();
+          _this.touched = 0;
+          _this.isPowerOfTwo = false;
+          _this._refreshPOT();
+          _this._glTextures = {};
+          _this.dirtyId = 0;
+          _this.dirtyStyleId = 0;
+          _this.cacheId = null;
+          _this.valid = width > 0 && height > 0;
+          _this.textureCacheIds = [];
+          _this.destroyed = false;
+          _this.resource = null;
+          _this._batchEnabled = 0;
+          _this._batchLocation = 0;
+          _this.parentTextureArray = null;
+          /**
+           * Fired when a not-immediately-available source finishes loading.
+           * @protected
+           * @event PIXI.BaseTexture#loaded
+           * @param {PIXI.BaseTexture} baseTexture - Resource loaded.
+           */
+          /**
+           * Fired when a not-immediately-available source fails to load.
+           * @protected
+           * @event PIXI.BaseTexture#error
+           * @param {PIXI.BaseTexture} baseTexture - Resource errored.
+           * @param {ErrorEvent} event - Load error event.
+           */
+          /**
+           * Fired when BaseTexture is updated.
+           * @protected
+           * @event PIXI.BaseTexture#loaded
+           * @param {PIXI.BaseTexture} baseTexture - Resource loaded.
+           */
+          /**
+           * Fired when BaseTexture is updated.
+           * @protected
+           * @event PIXI.BaseTexture#update
+           * @param {PIXI.BaseTexture} baseTexture - Instance of texture being updated.
+           */
+          /**
+           * Fired when BaseTexture is destroyed.
+           * @protected
+           * @event PIXI.BaseTexture#dispose
+           * @param {PIXI.BaseTexture} baseTexture - Instance of texture being destroyed.
+           */
+          // Set the resource
+          _this.setResource(resource);
+          return _this;
+      }
+      Object.defineProperty(BaseTexture.prototype, "realWidth", {
+          /**
+           * Pixel width of the source of this texture
+           * @readonly
+           */
+          get: function () {
+              return Math.round(this.width * this.resolution);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BaseTexture.prototype, "realHeight", {
+          /**
+           * Pixel height of the source of this texture
+           * @readonly
+           */
+          get: function () {
+              return Math.round(this.height * this.resolution);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BaseTexture.prototype, "mipmap", {
+          /**
+           * Mipmap mode of the texture, affects downscaled images
+           * @default PIXI.settings.MIPMAP_TEXTURES
+           */
+          get: function () {
+              return this._mipmap;
+          },
+          set: function (value) {
+              if (this._mipmap !== value) {
+                  this._mipmap = value;
+                  this.dirtyStyleId++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BaseTexture.prototype, "scaleMode", {
+          /**
+           * The scale mode to apply when scaling this texture
+           * @default PIXI.settings.SCALE_MODE
+           */
+          get: function () {
+              return this._scaleMode;
+          },
+          set: function (value) {
+              if (this._scaleMode !== value) {
+                  this._scaleMode = value;
+                  this.dirtyStyleId++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BaseTexture.prototype, "wrapMode", {
+          /**
+           * How the texture wraps
+           * @default PIXI.settings.WRAP_MODE
+           */
+          get: function () {
+              return this._wrapMode;
+          },
+          set: function (value) {
+              if (this._wrapMode !== value) {
+                  this._wrapMode = value;
+                  this.dirtyStyleId++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Changes style options of BaseTexture
+       * @param scaleMode - Pixi scalemode
+       * @param mipmap - enable mipmaps
+       * @returns - this
+       */
+      BaseTexture.prototype.setStyle = function (scaleMode, mipmap) {
+          var dirty;
+          if (scaleMode !== undefined && scaleMode !== this.scaleMode) {
+              this.scaleMode = scaleMode;
+              dirty = true;
+          }
+          if (mipmap !== undefined && mipmap !== this.mipmap) {
+              this.mipmap = mipmap;
+              dirty = true;
+          }
+          if (dirty) {
+              this.dirtyStyleId++;
+          }
+          return this;
+      };
+      /**
+       * Changes w/h/resolution. Texture becomes valid if width and height are greater than zero.
+       * @param desiredWidth - Desired visual width
+       * @param desiredHeight - Desired visual height
+       * @param resolution - Optionally set resolution
+       * @returns - this
+       */
+      BaseTexture.prototype.setSize = function (desiredWidth, desiredHeight, resolution) {
+          resolution = resolution || this.resolution;
+          return this.setRealSize(desiredWidth * resolution, desiredHeight * resolution, resolution);
+      };
+      /**
+       * Sets real size of baseTexture, preserves current resolution.
+       * @param realWidth - Full rendered width
+       * @param realHeight - Full rendered height
+       * @param resolution - Optionally set resolution
+       * @returns - this
+       */
+      BaseTexture.prototype.setRealSize = function (realWidth, realHeight, resolution) {
+          this.resolution = resolution || this.resolution;
+          this.width = Math.round(realWidth) / this.resolution;
+          this.height = Math.round(realHeight) / this.resolution;
+          this._refreshPOT();
+          this.update();
+          return this;
+      };
+      /**
+       * Refresh check for isPowerOfTwo texture based on size
+       * @private
+       */
+      BaseTexture.prototype._refreshPOT = function () {
+          this.isPowerOfTwo = isPow2(this.realWidth) && isPow2(this.realHeight);
+      };
+      /**
+       * Changes resolution
+       * @param resolution - res
+       * @returns - this
+       */
+      BaseTexture.prototype.setResolution = function (resolution) {
+          var oldResolution = this.resolution;
+          if (oldResolution === resolution) {
+              return this;
+          }
+          this.resolution = resolution;
+          if (this.valid) {
+              this.width = Math.round(this.width * oldResolution) / resolution;
+              this.height = Math.round(this.height * oldResolution) / resolution;
+              this.emit('update', this);
+          }
+          this._refreshPOT();
+          return this;
+      };
+      /**
+       * Sets the resource if it wasn't set. Throws error if resource already present
+       * @param resource - that is managing this BaseTexture
+       * @returns - this
+       */
+      BaseTexture.prototype.setResource = function (resource) {
+          if (this.resource === resource) {
+              return this;
+          }
+          if (this.resource) {
+              throw new Error('Resource can be set only once');
+          }
+          resource.bind(this);
+          this.resource = resource;
+          return this;
+      };
+      /** Invalidates the object. Texture becomes valid if width and height are greater than zero. */
+      BaseTexture.prototype.update = function () {
+          if (!this.valid) {
+              if (this.width > 0 && this.height > 0) {
+                  this.valid = true;
+                  this.emit('loaded', this);
+                  this.emit('update', this);
+              }
+          }
+          else {
+              this.dirtyId++;
+              this.dirtyStyleId++;
+              this.emit('update', this);
+          }
+      };
+      /**
+       * Handle errors with resources.
+       * @private
+       * @param event - Error event emitted.
+       */
+      BaseTexture.prototype.onError = function (event) {
+          this.emit('error', this, event);
+      };
+      /**
+       * Destroys this base texture.
+       * The method stops if resource doesn't want this texture to be destroyed.
+       * Removes texture from all caches.
+       */
+      BaseTexture.prototype.destroy = function () {
+          // remove and destroy the resource
+          if (this.resource) {
+              this.resource.unbind(this);
+              // only destroy resourced created internally
+              if (this.resource.internal) {
+                  this.resource.destroy();
+              }
+              this.resource = null;
+          }
+          if (this.cacheId) {
+              delete BaseTextureCache[this.cacheId];
+              delete TextureCache[this.cacheId];
+              this.cacheId = null;
+          }
+          // finally let the WebGL renderer know..
+          this.dispose();
+          BaseTexture.removeFromCache(this);
+          this.textureCacheIds = null;
+          this.destroyed = true;
+      };
+      /**
+       * Frees the texture from WebGL memory without destroying this texture object.
+       * This means you can still use the texture later which will upload it to GPU
+       * memory again.
+       * @fires PIXI.BaseTexture#dispose
+       */
+      BaseTexture.prototype.dispose = function () {
+          this.emit('dispose', this);
+      };
+      /** Utility function for BaseTexture|Texture cast. */
+      BaseTexture.prototype.castToBaseTexture = function () {
+          return this;
+      };
+      /**
+       * Helper function that creates a base texture based on the source you provide.
+       * The source can be - image url, image element, canvas element. If the
+       * source is an image url or an image element and not in the base texture
+       * cache, it will be created and loaded.
+       * @static
+       * @param {string|string[]|HTMLImageElement|HTMLCanvasElement|SVGElement|HTMLVideoElement} source - The
+       *        source to create base texture from.
+       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
+       * @param {string} [options.pixiIdPrefix=pixiid] - If a source has no id, this is the prefix of the generated id
+       * @param {boolean} [strict] - Enforce strict-mode, see {@link PIXI.settings.STRICT_TEXTURE_CACHE}.
+       * @returns {PIXI.BaseTexture} The new base texture.
+       */
+      BaseTexture.from = function (source, options, strict) {
+          if (strict === void 0) { strict = settings.STRICT_TEXTURE_CACHE; }
+          var isFrame = typeof source === 'string';
+          var cacheId = null;
+          if (isFrame) {
+              cacheId = source;
+          }
+          else {
+              if (!source._pixiId) {
+                  var prefix = (options && options.pixiIdPrefix) || 'pixiid';
+                  source._pixiId = prefix + "_" + uid();
+              }
+              cacheId = source._pixiId;
+          }
+          var baseTexture = BaseTextureCache[cacheId];
+          // Strict-mode rejects invalid cacheIds
+          if (isFrame && strict && !baseTexture) {
+              throw new Error("The cacheId \"" + cacheId + "\" does not exist in BaseTextureCache.");
+          }
+          if (!baseTexture) {
+              baseTexture = new BaseTexture(source, options);
+              baseTexture.cacheId = cacheId;
+              BaseTexture.addToCache(baseTexture, cacheId);
+          }
+          return baseTexture;
+      };
+      /**
+       * Create a new BaseTexture with a BufferResource from a Float32Array.
+       * RGBA values are floats from 0 to 1.
+       * @param {Float32Array|Uint8Array} buffer - The optional array to use, if no data
+       *        is provided, a new Float32Array is created.
+       * @param width - Width of the resource
+       * @param height - Height of the resource
+       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
+       *        Default properties are different from the constructor's defaults.
+       * @param {PIXI.FORMATS} [options.format=PIXI.FORMATS.RGBA] - GL format type
+       * @param {PIXI.ALPHA_MODES} [options.alphaMode=PIXI.ALPHA_MODES.NPM] - Image alpha, not premultiplied by default
+       * @param {PIXI.SCALE_MODES} [options.scaleMode=PIXI.SCALE_MODES.NEAREST] - Scale mode, pixelating by default
+       * @returns - The resulting new BaseTexture
+       */
+      BaseTexture.fromBuffer = function (buffer, width, height, options) {
+          buffer = buffer || new Float32Array(width * height * 4);
+          var resource = new BufferResource(buffer, { width: width, height: height });
+          var type = buffer instanceof Float32Array ? exports.TYPES.FLOAT : exports.TYPES.UNSIGNED_BYTE;
+          return new BaseTexture(resource, Object.assign({}, defaultBufferOptions, options || { width: width, height: height, type: type }));
+      };
+      /**
+       * Adds a BaseTexture to the global BaseTextureCache. This cache is shared across the whole PIXI object.
+       * @param {PIXI.BaseTexture} baseTexture - The BaseTexture to add to the cache.
+       * @param {string} id - The id that the BaseTexture will be stored against.
+       */
+      BaseTexture.addToCache = function (baseTexture, id) {
+          if (id) {
+              if (baseTexture.textureCacheIds.indexOf(id) === -1) {
+                  baseTexture.textureCacheIds.push(id);
+              }
+              if (BaseTextureCache[id]) {
+                  // eslint-disable-next-line no-console
+                  console.warn("BaseTexture added to the cache with an id [" + id + "] that already had an entry");
+              }
+              BaseTextureCache[id] = baseTexture;
+          }
+      };
+      /**
+       * Remove a BaseTexture from the global BaseTextureCache.
+       * @param {string|PIXI.BaseTexture} baseTexture - id of a BaseTexture to be removed, or a BaseTexture instance itself.
+       * @returns {PIXI.BaseTexture|null} The BaseTexture that was removed.
+       */
+      BaseTexture.removeFromCache = function (baseTexture) {
+          if (typeof baseTexture === 'string') {
+              var baseTextureFromCache = BaseTextureCache[baseTexture];
+              if (baseTextureFromCache) {
+                  var index = baseTextureFromCache.textureCacheIds.indexOf(baseTexture);
+                  if (index > -1) {
+                      baseTextureFromCache.textureCacheIds.splice(index, 1);
+                  }
+                  delete BaseTextureCache[baseTexture];
+                  return baseTextureFromCache;
+              }
+          }
+          else if (baseTexture && baseTexture.textureCacheIds) {
+              for (var i = 0; i < baseTexture.textureCacheIds.length; ++i) {
+                  delete BaseTextureCache[baseTexture.textureCacheIds[i]];
+              }
+              baseTexture.textureCacheIds.length = 0;
+              return baseTexture;
+          }
+          return null;
+      };
+      /** Global number of the texture batch, used by multi-texture renderers. */
+      BaseTexture._globalBatch = 0;
+      return BaseTexture;
+  }(eventemitter3));
 
-                array[offset + stride * 2] = 0;
-                array[offset + stride * 2 + 1] = 0;
+  /**
+   * Resource that can manage several resource (items) inside.
+   * All resources need to have the same pixel size.
+   * Parent class for CubeResource and ArrayResource
+   * @memberof PIXI
+   */
+  var AbstractMultiResource = /** @class */ (function (_super) {
+      __extends$i(AbstractMultiResource, _super);
+      /**
+       * @param length
+       * @param options - Options to for Resource constructor
+       * @param {number} [options.width] - Width of the resource
+       * @param {number} [options.height] - Height of the resource
+       */
+      function AbstractMultiResource(length, options) {
+          var _this = this;
+          var _a = options || {}, width = _a.width, height = _a.height;
+          _this = _super.call(this, width, height) || this;
+          _this.items = [];
+          _this.itemDirtyIds = [];
+          for (var i = 0; i < length; i++) {
+              var partTexture = new BaseTexture();
+              _this.items.push(partTexture);
+              // -2 - first run of texture array upload
+              // -1 - texture item was allocated
+              // >=0 - texture item uploaded , in sync with items[i].dirtyId
+              _this.itemDirtyIds.push(-2);
+          }
+          _this.length = length;
+          _this._load = null;
+          _this.baseTexture = null;
+          return _this;
+      }
+      /**
+       * Used from ArrayResource and CubeResource constructors.
+       * @param resources - Can be resources, image elements, canvas, etc. ,
+       *  length should be same as constructor length
+       * @param options - Detect options for resources
+       */
+      AbstractMultiResource.prototype.initFromArray = function (resources, options) {
+          for (var i = 0; i < this.length; i++) {
+              if (!resources[i]) {
+                  continue;
+              }
+              if (resources[i].castToBaseTexture) {
+                  this.addBaseTextureAt(resources[i].castToBaseTexture(), i);
+              }
+              else if (resources[i] instanceof Resource) {
+                  this.addResourceAt(resources[i], i);
+              }
+              else {
+                  this.addResourceAt(autoDetectResource(resources[i], options), i);
+              }
+          }
+      };
+      /** Destroy this BaseImageResource. */
+      AbstractMultiResource.prototype.dispose = function () {
+          for (var i = 0, len = this.length; i < len; i++) {
+              this.items[i].destroy();
+          }
+          this.items = null;
+          this.itemDirtyIds = null;
+          this._load = null;
+      };
+      /**
+       * Set a resource by ID
+       * @param resource
+       * @param index - Zero-based index of resource to set
+       * @returns - Instance for chaining
+       */
+      AbstractMultiResource.prototype.addResourceAt = function (resource, index) {
+          if (!this.items[index]) {
+              throw new Error("Index " + index + " is out of bounds");
+          }
+          // Inherit the first resource dimensions
+          if (resource.valid && !this.valid) {
+              this.resize(resource.width, resource.height);
+          }
+          this.items[index].setResource(resource);
+          return this;
+      };
+      /**
+       * Set the parent base texture.
+       * @param baseTexture
+       */
+      AbstractMultiResource.prototype.bind = function (baseTexture) {
+          if (this.baseTexture !== null) {
+              throw new Error('Only one base texture per TextureArray is allowed');
+          }
+          _super.prototype.bind.call(this, baseTexture);
+          for (var i = 0; i < this.length; i++) {
+              this.items[i].parentTextureArray = baseTexture;
+              this.items[i].on('update', baseTexture.update, baseTexture);
+          }
+      };
+      /**
+       * Unset the parent base texture.
+       * @param baseTexture
+       */
+      AbstractMultiResource.prototype.unbind = function (baseTexture) {
+          _super.prototype.unbind.call(this, baseTexture);
+          for (var i = 0; i < this.length; i++) {
+              this.items[i].parentTextureArray = null;
+              this.items[i].off('update', baseTexture.update, baseTexture);
+          }
+      };
+      /**
+       * Load all the resources simultaneously
+       * @returns - When load is resolved
+       */
+      AbstractMultiResource.prototype.load = function () {
+          var _this = this;
+          if (this._load) {
+              return this._load;
+          }
+          var resources = this.items.map(function (item) { return item.resource; }).filter(function (item) { return item; });
+          // TODO: also implement load part-by-part strategy
+          var promises = resources.map(function (item) { return item.load(); });
+          this._load = Promise.all(promises)
+              .then(function () {
+              var _a = _this.items[0], realWidth = _a.realWidth, realHeight = _a.realHeight;
+              _this.resize(realWidth, realHeight);
+              return Promise.resolve(_this);
+          });
+          return this._load;
+      };
+      return AbstractMultiResource;
+  }(Resource));
 
-                array[offset + stride * 3] = 0;
-                array[offset + stride * 3 + 1] = 0;
+  /**
+   * A resource that contains a number of sources.
+   * @memberof PIXI
+   */
+  var ArrayResource = /** @class */ (function (_super) {
+      __extends$i(ArrayResource, _super);
+      /**
+       * @param source - Number of items in array or the collection
+       *        of image URLs to use. Can also be resources, image elements, canvas, etc.
+       * @param options - Options to apply to {@link PIXI.autoDetectResource}
+       * @param {number} [options.width] - Width of the resource
+       * @param {number} [options.height] - Height of the resource
+       */
+      function ArrayResource(source, options) {
+          var _this = this;
+          var _a = options || {}, width = _a.width, height = _a.height;
+          var urls;
+          var length;
+          if (Array.isArray(source)) {
+              urls = source;
+              length = source.length;
+          }
+          else {
+              length = source;
+          }
+          _this = _super.call(this, length, { width: width, height: height }) || this;
+          if (urls) {
+              _this.initFromArray(urls, options);
+          }
+          return _this;
+      }
+      /**
+       * Set a baseTexture by ID,
+       * ArrayResource just takes resource from it, nothing more
+       * @param baseTexture
+       * @param index - Zero-based index of resource to set
+       * @returns - Instance for chaining
+       */
+      ArrayResource.prototype.addBaseTextureAt = function (baseTexture, index) {
+          if (baseTexture.resource) {
+              this.addResourceAt(baseTexture.resource, index);
+          }
+          else {
+              throw new Error('ArrayResource does not support RenderTexture');
+          }
+          return this;
+      };
+      /**
+       * Add binding
+       * @param baseTexture
+       */
+      ArrayResource.prototype.bind = function (baseTexture) {
+          _super.prototype.bind.call(this, baseTexture);
+          baseTexture.target = exports.TARGETS.TEXTURE_2D_ARRAY;
+      };
+      /**
+       * Upload the resources to the GPU.
+       * @param renderer
+       * @param texture
+       * @param glTexture
+       * @returns - whether texture was uploaded
+       */
+      ArrayResource.prototype.upload = function (renderer, texture, glTexture) {
+          var _a = this, length = _a.length, itemDirtyIds = _a.itemDirtyIds, items = _a.items;
+          var gl = renderer.gl;
+          if (glTexture.dirtyId < 0) {
+              gl.texImage3D(gl.TEXTURE_2D_ARRAY, 0, glTexture.internalFormat, this._width, this._height, length, 0, texture.format, glTexture.type, null);
+          }
+          for (var i = 0; i < length; i++) {
+              var item = items[i];
+              if (itemDirtyIds[i] < item.dirtyId) {
+                  itemDirtyIds[i] = item.dirtyId;
+                  if (item.valid) {
+                      gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, 0, 0, // xoffset
+                      0, // yoffset
+                      i, // zoffset
+                      item.resource.width, item.resource.height, 1, texture.format, glTexture.type, item.resource.source);
+                  }
+              }
+          }
+          return true;
+      };
+      return ArrayResource;
+  }(AbstractMultiResource));
 
-                offset += stride * 4;
-            }
-        }
-    };
+  /**
+   * Base for all the image/canvas resources.
+   * @memberof PIXI
+   */
+  var BaseImageResource = /** @class */ (function (_super) {
+      __extends$i(BaseImageResource, _super);
+      /**
+       * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|SVGElement} source
+       */
+      function BaseImageResource(source) {
+          var _this = this;
+          var sourceAny = source;
+          var width = sourceAny.naturalWidth || sourceAny.videoWidth || sourceAny.width;
+          var height = sourceAny.naturalHeight || sourceAny.videoHeight || sourceAny.height;
+          _this = _super.call(this, width, height) || this;
+          _this.source = source;
+          _this.noSubImage = false;
+          return _this;
+      }
+      /**
+       * Set cross origin based detecting the url and the crossorigin
+       * @param element - Element to apply crossOrigin
+       * @param url - URL to check
+       * @param crossorigin - Cross origin value to use
+       */
+      BaseImageResource.crossOrigin = function (element, url, crossorigin) {
+          if (crossorigin === undefined && url.indexOf('data:') !== 0) {
+              element.crossOrigin = determineCrossOrigin(url);
+          }
+          else if (crossorigin !== false) {
+              element.crossOrigin = typeof crossorigin === 'string' ? crossorigin : 'anonymous';
+          }
+      };
+      /**
+       * Upload the texture to the GPU.
+       * @param renderer - Upload to the renderer
+       * @param baseTexture - Reference to parent texture
+       * @param glTexture
+       * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|SVGElement} [source] - (optional)
+       * @returns - true is success
+       */
+      BaseImageResource.prototype.upload = function (renderer, baseTexture, glTexture, source) {
+          var gl = renderer.gl;
+          var width = baseTexture.realWidth;
+          var height = baseTexture.realHeight;
+          source = source || this.source;
+          if (source instanceof HTMLImageElement) {
+              if (!source.complete || source.naturalWidth === 0) {
+                  return false;
+              }
+          }
+          else if (source instanceof HTMLVideoElement) {
+              if (source.readyState <= 1) {
+                  return false;
+              }
+          }
+          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === exports.ALPHA_MODES.UNPACK);
+          if (!this.noSubImage
+              && baseTexture.target === gl.TEXTURE_2D
+              && glTexture.width === width
+              && glTexture.height === height) {
+              gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, baseTexture.format, glTexture.type, source);
+          }
+          else {
+              glTexture.width = width;
+              glTexture.height = height;
+              gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, baseTexture.format, glTexture.type, source);
+          }
+          return true;
+      };
+      /**
+       * Checks if source width/height was changed, resize can cause extra baseTexture update.
+       * Triggers one update in any case.
+       */
+      BaseImageResource.prototype.update = function () {
+          if (this.destroyed) {
+              return;
+          }
+          var source = this.source;
+          var width = source.naturalWidth || source.videoWidth || source.width;
+          var height = source.naturalHeight || source.videoHeight || source.height;
+          this.resize(width, height);
+          _super.prototype.update.call(this);
+      };
+      /** Destroy this {@link BaseImageResource} */
+      BaseImageResource.prototype.dispose = function () {
+          this.source = null;
+      };
+      return BaseImageResource;
+  }(Resource));
 
-    /**
-     *
-     * @param {PIXI.DisplayObject[]} children - the array of display objects to render
-     * @param {number} startIndex - the index to start from in the children array
-     * @param {number} amount - the amount of children that will have their rotation uploaded
-     * @param {number[]} array - The vertices to upload.
-     * @param {number} stride - Stride to use for iteration.
-     * @param {number} offset - Offset to start at.
-     */
+  /**
+   * @interface OffscreenCanvas
+   */
+  /**
+   * Resource type for HTMLCanvasElement.
+   * @memberof PIXI
+   */
+  var CanvasResource = /** @class */ (function (_super) {
+      __extends$i(CanvasResource, _super);
+      /**
+       * @param source - Canvas element to use
+       */
+      // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+      function CanvasResource(source) {
+          return _super.call(this, source) || this;
+      }
+      /**
+       * Used to auto-detect the type of resource.
+       * @param {*} source - The source object
+       * @returns {boolean} `true` if source is HTMLCanvasElement or OffscreenCanvas
+       */
+      CanvasResource.test = function (source) {
+          var OffscreenCanvas = globalThis.OffscreenCanvas;
+          // Check for browsers that don't yet support OffscreenCanvas
+          if (OffscreenCanvas && source instanceof OffscreenCanvas) {
+              return true;
+          }
+          return globalThis.HTMLCanvasElement && source instanceof HTMLCanvasElement;
+      };
+      return CanvasResource;
+  }(BaseImageResource));
 
+  /**
+   * Resource for a CubeTexture which contains six resources.
+   * @memberof PIXI
+   */
+  var CubeResource = /** @class */ (function (_super) {
+      __extends$i(CubeResource, _super);
+      /**
+       * @param {Array<string|PIXI.Resource>} [source] - Collection of URLs or resources
+       *        to use as the sides of the cube.
+       * @param options - ImageResource options
+       * @param {number} [options.width] - Width of resource
+       * @param {number} [options.height] - Height of resource
+       * @param {number} [options.autoLoad=true] - Whether to auto-load resources
+       * @param {number} [options.linkBaseTexture=true] - In case BaseTextures are supplied,
+       *   whether to copy them or use
+       */
+      function CubeResource(source, options) {
+          var _this = this;
+          var _a = options || {}, width = _a.width, height = _a.height, autoLoad = _a.autoLoad, linkBaseTexture = _a.linkBaseTexture;
+          if (source && source.length !== CubeResource.SIDES) {
+              throw new Error("Invalid length. Got " + source.length + ", expected 6");
+          }
+          _this = _super.call(this, 6, { width: width, height: height }) || this;
+          for (var i = 0; i < CubeResource.SIDES; i++) {
+              _this.items[i].target = exports.TARGETS.TEXTURE_CUBE_MAP_POSITIVE_X + i;
+          }
+          _this.linkBaseTexture = linkBaseTexture !== false;
+          if (source) {
+              _this.initFromArray(source, options);
+          }
+          if (autoLoad !== false) {
+              _this.load();
+          }
+          return _this;
+      }
+      /**
+       * Add binding.
+       * @param baseTexture - parent base texture
+       */
+      CubeResource.prototype.bind = function (baseTexture) {
+          _super.prototype.bind.call(this, baseTexture);
+          baseTexture.target = exports.TARGETS.TEXTURE_CUBE_MAP;
+      };
+      CubeResource.prototype.addBaseTextureAt = function (baseTexture, index, linkBaseTexture) {
+          if (!this.items[index]) {
+              throw new Error("Index " + index + " is out of bounds");
+          }
+          if (!this.linkBaseTexture
+              || baseTexture.parentTextureArray
+              || Object.keys(baseTexture._glTextures).length > 0) {
+              // copy mode
+              if (baseTexture.resource) {
+                  this.addResourceAt(baseTexture.resource, index);
+              }
+              else {
+                  throw new Error("CubeResource does not support copying of renderTexture.");
+              }
+          }
+          else {
+              // link mode, the difficult one!
+              baseTexture.target = exports.TARGETS.TEXTURE_CUBE_MAP_POSITIVE_X + index;
+              baseTexture.parentTextureArray = this.baseTexture;
+              this.items[index] = baseTexture;
+          }
+          if (baseTexture.valid && !this.valid) {
+              this.resize(baseTexture.realWidth, baseTexture.realHeight);
+          }
+          this.items[index] = baseTexture;
+          return this;
+      };
+      /**
+       * Upload the resource
+       * @param renderer
+       * @param _baseTexture
+       * @param glTexture
+       * @returns {boolean} true is success
+       */
+      CubeResource.prototype.upload = function (renderer, _baseTexture, glTexture) {
+          var dirty = this.itemDirtyIds;
+          for (var i = 0; i < CubeResource.SIDES; i++) {
+              var side = this.items[i];
+              if (dirty[i] < side.dirtyId || glTexture.dirtyId < _baseTexture.dirtyId) {
+                  if (side.valid && side.resource) {
+                      side.resource.upload(renderer, side, glTexture);
+                      dirty[i] = side.dirtyId;
+                  }
+                  else if (dirty[i] < -1) {
+                      // either item is not valid yet, either its a renderTexture
+                      // allocate the memory
+                      renderer.gl.texImage2D(side.target, 0, glTexture.internalFormat, _baseTexture.realWidth, _baseTexture.realHeight, 0, _baseTexture.format, glTexture.type, null);
+                      dirty[i] = -1;
+                  }
+              }
+          }
+          return true;
+      };
+      /**
+       * Used to auto-detect the type of resource.
+       * @param {*} source - The source object
+       * @returns {boolean} `true` if source is an array of 6 elements
+       */
+      CubeResource.test = function (source) {
+          return Array.isArray(source) && source.length === CubeResource.SIDES;
+      };
+      /** Number of texture sides to store for CubeResources. */
+      CubeResource.SIDES = 6;
+      return CubeResource;
+  }(AbstractMultiResource));
 
-    ParticleRenderer.prototype.uploadAlpha = function uploadAlpha(children, startIndex, amount, array, stride, offset) {
-        for (var i = 0; i < amount; i++) {
-            var spriteAlpha = children[startIndex + i].alpha;
+  /**
+   * Resource type for HTMLImageElement.
+   * @memberof PIXI
+   */
+  var ImageResource = /** @class */ (function (_super) {
+      __extends$i(ImageResource, _super);
+      /**
+       * @param source - image source or URL
+       * @param options
+       * @param {boolean} [options.autoLoad=true] - start loading process
+       * @param {boolean} [options.createBitmap=PIXI.settings.CREATE_IMAGE_BITMAP] - whether its required to create
+       *        a bitmap before upload
+       * @param {boolean} [options.crossorigin=true] - Load image using cross origin
+       * @param {PIXI.ALPHA_MODES} [options.alphaMode=PIXI.ALPHA_MODES.UNPACK] - Premultiply image alpha in bitmap
+       */
+      function ImageResource(source, options) {
+          var _this = this;
+          options = options || {};
+          if (!(source instanceof HTMLImageElement)) {
+              var imageElement = new Image();
+              BaseImageResource.crossOrigin(imageElement, source, options.crossorigin);
+              imageElement.src = source;
+              source = imageElement;
+          }
+          _this = _super.call(this, source) || this;
+          // FireFox 68, and possibly other versions, seems like setting the HTMLImageElement#width and #height
+          // to non-zero values before its loading completes if images are in a cache.
+          // Because of this, need to set the `_width` and the `_height` to zero to avoid uploading incomplete images.
+          // Please refer to the issue #5968 (https://github.com/pixijs/pixi.js/issues/5968).
+          if (!source.complete && !!_this._width && !!_this._height) {
+              _this._width = 0;
+              _this._height = 0;
+          }
+          _this.url = source.src;
+          _this._process = null;
+          _this.preserveBitmap = false;
+          _this.createBitmap = (options.createBitmap !== undefined
+              ? options.createBitmap : settings.CREATE_IMAGE_BITMAP) && !!globalThis.createImageBitmap;
+          _this.alphaMode = typeof options.alphaMode === 'number' ? options.alphaMode : null;
+          _this.bitmap = null;
+          _this._load = null;
+          if (options.autoLoad !== false) {
+              _this.load();
+          }
+          return _this;
+      }
+      /**
+       * Returns a promise when image will be loaded and processed.
+       * @param createBitmap - whether process image into bitmap
+       */
+      ImageResource.prototype.load = function (createBitmap) {
+          var _this = this;
+          if (this._load) {
+              return this._load;
+          }
+          if (createBitmap !== undefined) {
+              this.createBitmap = createBitmap;
+          }
+          this._load = new Promise(function (resolve, reject) {
+              var source = _this.source;
+              _this.url = source.src;
+              var completed = function () {
+                  if (_this.destroyed) {
+                      return;
+                  }
+                  source.onload = null;
+                  source.onerror = null;
+                  _this.resize(source.width, source.height);
+                  _this._load = null;
+                  if (_this.createBitmap) {
+                      resolve(_this.process());
+                  }
+                  else {
+                      resolve(_this);
+                  }
+              };
+              if (source.complete && source.src) {
+                  completed();
+              }
+              else {
+                  source.onload = completed;
+                  source.onerror = function (event) {
+                      // Avoids Promise freezing when resource broken
+                      reject(event);
+                      _this.onError.emit(event);
+                  };
+              }
+          });
+          return this._load;
+      };
+      /**
+       * Called when we need to convert image into BitmapImage.
+       * Can be called multiple times, real promise is cached inside.
+       * @returns - Cached promise to fill that bitmap
+       */
+      ImageResource.prototype.process = function () {
+          var _this = this;
+          var source = this.source;
+          if (this._process !== null) {
+              return this._process;
+          }
+          if (this.bitmap !== null || !globalThis.createImageBitmap) {
+              return Promise.resolve(this);
+          }
+          var createImageBitmap = globalThis.createImageBitmap;
+          var cors = !source.crossOrigin || source.crossOrigin === 'anonymous';
+          this._process = fetch(source.src, {
+              mode: cors ? 'cors' : 'no-cors'
+          })
+              .then(function (r) { return r.blob(); })
+              .then(function (blob) { return createImageBitmap(blob, 0, 0, source.width, source.height, {
+              premultiplyAlpha: _this.alphaMode === null || _this.alphaMode === exports.ALPHA_MODES.UNPACK
+                  ? 'premultiply' : 'none',
+          }); })
+              .then(function (bitmap) {
+              if (_this.destroyed) {
+                  return Promise.reject();
+              }
+              _this.bitmap = bitmap;
+              _this.update();
+              _this._process = null;
+              return Promise.resolve(_this);
+          });
+          return this._process;
+      };
+      /**
+       * Upload the image resource to GPU.
+       * @param renderer - Renderer to upload to
+       * @param baseTexture - BaseTexture for this resource
+       * @param glTexture - GLTexture to use
+       * @returns {boolean} true is success
+       */
+      ImageResource.prototype.upload = function (renderer, baseTexture, glTexture) {
+          if (typeof this.alphaMode === 'number') {
+              // bitmap stores unpack premultiply flag, we dont have to notify texImage2D about it
+              baseTexture.alphaMode = this.alphaMode;
+          }
+          if (!this.createBitmap) {
+              return _super.prototype.upload.call(this, renderer, baseTexture, glTexture);
+          }
+          if (!this.bitmap) {
+              // yeah, ignore the output
+              this.process();
+              if (!this.bitmap) {
+                  return false;
+              }
+          }
+          _super.prototype.upload.call(this, renderer, baseTexture, glTexture, this.bitmap);
+          if (!this.preserveBitmap) {
+              // checks if there are other renderers that possibly need this bitmap
+              var flag = true;
+              var glTextures = baseTexture._glTextures;
+              for (var key in glTextures) {
+                  var otherTex = glTextures[key];
+                  if (otherTex !== glTexture && otherTex.dirtyId !== baseTexture.dirtyId) {
+                      flag = false;
+                      break;
+                  }
+              }
+              if (flag) {
+                  if (this.bitmap.close) {
+                      this.bitmap.close();
+                  }
+                  this.bitmap = null;
+              }
+          }
+          return true;
+      };
+      /** Destroys this resource. */
+      ImageResource.prototype.dispose = function () {
+          this.source.onload = null;
+          this.source.onerror = null;
+          _super.prototype.dispose.call(this);
+          if (this.bitmap) {
+              this.bitmap.close();
+              this.bitmap = null;
+          }
+          this._process = null;
+          this._load = null;
+      };
+      /**
+       * Used to auto-detect the type of resource.
+       * @param {*} source - The source object
+       * @returns {boolean} `true` if source is string or HTMLImageElement
+       */
+      ImageResource.test = function (source) {
+          return typeof source === 'string' || source instanceof HTMLImageElement;
+      };
+      return ImageResource;
+  }(BaseImageResource));
 
-            array[offset] = spriteAlpha;
-            array[offset + stride] = spriteAlpha;
-            array[offset + stride * 2] = spriteAlpha;
-            array[offset + stride * 3] = spriteAlpha;
+  /**
+   * Resource type for SVG elements and graphics.
+   * @memberof PIXI
+   */
+  var SVGResource = /** @class */ (function (_super) {
+      __extends$i(SVGResource, _super);
+      /**
+       * @param sourceBase64 - Base64 encoded SVG element or URL for SVG file.
+       * @param {object} [options] - Options to use
+       * @param {number} [options.scale=1] - Scale to apply to SVG. Overridden by...
+       * @param {number} [options.width] - Rasterize SVG this wide. Aspect ratio preserved if height not specified.
+       * @param {number} [options.height] - Rasterize SVG this high. Aspect ratio preserved if width not specified.
+       * @param {boolean} [options.autoLoad=true] - Start loading right away.
+       */
+      function SVGResource(sourceBase64, options) {
+          var _this = this;
+          options = options || {};
+          _this = _super.call(this, settings.ADAPTER.createCanvas()) || this;
+          _this._width = 0;
+          _this._height = 0;
+          _this.svg = sourceBase64;
+          _this.scale = options.scale || 1;
+          _this._overrideWidth = options.width;
+          _this._overrideHeight = options.height;
+          _this._resolve = null;
+          _this._crossorigin = options.crossorigin;
+          _this._load = null;
+          if (options.autoLoad !== false) {
+              _this.load();
+          }
+          return _this;
+      }
+      SVGResource.prototype.load = function () {
+          var _this = this;
+          if (this._load) {
+              return this._load;
+          }
+          this._load = new Promise(function (resolve) {
+              // Save this until after load is finished
+              _this._resolve = function () {
+                  _this.resize(_this.source.width, _this.source.height);
+                  resolve(_this);
+              };
+              // Convert SVG inline string to data-uri
+              if (SVGResource.SVG_XML.test(_this.svg.trim())) {
+                  if (!btoa) {
+                      throw new Error('Your browser doesn\'t support base64 conversions.');
+                  }
+                  _this.svg = "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(_this.svg)));
+              }
+              _this._loadSvg();
+          });
+          return this._load;
+      };
+      /** Loads an SVG image from `imageUrl` or `data URL`. */
+      SVGResource.prototype._loadSvg = function () {
+          var _this = this;
+          var tempImage = new Image();
+          BaseImageResource.crossOrigin(tempImage, this.svg, this._crossorigin);
+          tempImage.src = this.svg;
+          tempImage.onerror = function (event) {
+              if (!_this._resolve) {
+                  return;
+              }
+              tempImage.onerror = null;
+              _this.onError.emit(event);
+          };
+          tempImage.onload = function () {
+              if (!_this._resolve) {
+                  return;
+              }
+              var svgWidth = tempImage.width;
+              var svgHeight = tempImage.height;
+              if (!svgWidth || !svgHeight) {
+                  throw new Error('The SVG image must have width and height defined (in pixels), canvas API needs them.');
+              }
+              // Set render size
+              var width = svgWidth * _this.scale;
+              var height = svgHeight * _this.scale;
+              if (_this._overrideWidth || _this._overrideHeight) {
+                  width = _this._overrideWidth || _this._overrideHeight / svgHeight * svgWidth;
+                  height = _this._overrideHeight || _this._overrideWidth / svgWidth * svgHeight;
+              }
+              width = Math.round(width);
+              height = Math.round(height);
+              // Create a canvas element
+              var canvas = _this.source;
+              canvas.width = width;
+              canvas.height = height;
+              canvas._pixiId = "canvas_" + uid();
+              // Draw the Svg to the canvas
+              canvas
+                  .getContext('2d')
+                  .drawImage(tempImage, 0, 0, svgWidth, svgHeight, 0, 0, width, height);
+              _this._resolve();
+              _this._resolve = null;
+          };
+      };
+      /**
+       * Get size from an svg string using a regular expression.
+       * @param svgString - a serialized svg element
+       * @returns - image extension
+       */
+      SVGResource.getSize = function (svgString) {
+          var sizeMatch = SVGResource.SVG_SIZE.exec(svgString);
+          var size = {};
+          if (sizeMatch) {
+              size[sizeMatch[1]] = Math.round(parseFloat(sizeMatch[3]));
+              size[sizeMatch[5]] = Math.round(parseFloat(sizeMatch[7]));
+          }
+          return size;
+      };
+      /** Destroys this texture. */
+      SVGResource.prototype.dispose = function () {
+          _super.prototype.dispose.call(this);
+          this._resolve = null;
+          this._crossorigin = null;
+      };
+      /**
+       * Used to auto-detect the type of resource.
+       * @param {*} source - The source object
+       * @param {string} extension - The extension of source, if set
+       * @returns {boolean} - If the source is a SVG source or data file
+       */
+      SVGResource.test = function (source, extension) {
+          // url file extension is SVG
+          return extension === 'svg'
+              // source is SVG data-uri
+              || (typeof source === 'string' && source.startsWith('data:image/svg+xml'))
+              // source is SVG inline
+              || (typeof source === 'string' && SVGResource.SVG_XML.test(source));
+      };
+      /**
+       * Regular expression for SVG XML document.
+       * @example &lt;?xml version="1.0" encoding="utf-8" ?&gt;&lt;!-- image/svg --&gt;&lt;svg
+       * @readonly
+       */
+      SVGResource.SVG_XML = /^(<\?xml[^?]+\?>)?\s*(<!--[^(-->)]*-->)?\s*\<svg/m;
+      /**
+       * Regular expression for SVG size.
+       * @example &lt;svg width="100" height="100"&gt;&lt;/svg&gt;
+       * @readonly
+       */
+      SVGResource.SVG_SIZE = /<svg[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*>/i; // eslint-disable-line max-len
+      return SVGResource;
+  }(BaseImageResource));
 
-            offset += stride * 4;
-        }
-    };
+  /**
+   * Resource type for {@code HTMLVideoElement}.
+   * @memberof PIXI
+   */
+  var VideoResource = /** @class */ (function (_super) {
+      __extends$i(VideoResource, _super);
+      /**
+       * @param {HTMLVideoElement|object|string|Array<string|object>} source - Video element to use.
+       * @param {object} [options] - Options to use
+       * @param {boolean} [options.autoLoad=true] - Start loading the video immediately
+       * @param {boolean} [options.autoPlay=true] - Start playing video immediately
+       * @param {number} [options.updateFPS=0] - How many times a second to update the texture from the video.
+       * Leave at 0 to update at every render.
+       * @param {boolean} [options.crossorigin=true] - Load image using cross origin
+       */
+      function VideoResource(source, options) {
+          var _this = this;
+          options = options || {};
+          if (!(source instanceof HTMLVideoElement)) {
+              var videoElement = document.createElement('video');
+              // workaround for https://github.com/pixijs/pixi.js/issues/5996
+              videoElement.setAttribute('preload', 'auto');
+              videoElement.setAttribute('webkit-playsinline', '');
+              videoElement.setAttribute('playsinline', '');
+              if (typeof source === 'string') {
+                  source = [source];
+              }
+              var firstSrc = source[0].src || source[0];
+              BaseImageResource.crossOrigin(videoElement, firstSrc, options.crossorigin);
+              // array of objects or strings
+              for (var i = 0; i < source.length; ++i) {
+                  var sourceElement = document.createElement('source');
+                  var _a = source[i], src = _a.src, mime = _a.mime;
+                  src = src || source[i];
+                  var baseSrc = src.split('?').shift().toLowerCase();
+                  var ext = baseSrc.slice(baseSrc.lastIndexOf('.') + 1);
+                  mime = mime || VideoResource.MIME_TYPES[ext] || "video/" + ext;
+                  sourceElement.src = src;
+                  sourceElement.type = mime;
+                  videoElement.appendChild(sourceElement);
+              }
+              // Override the source
+              source = videoElement;
+          }
+          _this = _super.call(this, source) || this;
+          _this.noSubImage = true;
+          _this._autoUpdate = true;
+          _this._isConnectedToTicker = false;
+          _this._updateFPS = options.updateFPS || 0;
+          _this._msToNextUpdate = 0;
+          _this.autoPlay = options.autoPlay !== false;
+          _this._load = null;
+          _this._resolve = null;
+          // Bind for listeners
+          _this._onCanPlay = _this._onCanPlay.bind(_this);
+          _this._onError = _this._onError.bind(_this);
+          if (options.autoLoad !== false) {
+              _this.load();
+          }
+          return _this;
+      }
+      /**
+       * Trigger updating of the texture.
+       * @param _deltaTime - time delta since last tick
+       */
+      VideoResource.prototype.update = function (_deltaTime) {
+          if (!this.destroyed) {
+              // account for if video has had its playbackRate changed
+              var elapsedMS = Ticker.shared.elapsedMS * this.source.playbackRate;
+              this._msToNextUpdate = Math.floor(this._msToNextUpdate - elapsedMS);
+              if (!this._updateFPS || this._msToNextUpdate <= 0) {
+                  _super.prototype.update.call(this);
+                  this._msToNextUpdate = this._updateFPS ? Math.floor(1000 / this._updateFPS) : 0;
+              }
+          }
+      };
+      /**
+       * Start preloading the video resource.
+       * @returns {Promise<void>} Handle the validate event
+       */
+      VideoResource.prototype.load = function () {
+          var _this = this;
+          if (this._load) {
+              return this._load;
+          }
+          var source = this.source;
+          if ((source.readyState === source.HAVE_ENOUGH_DATA || source.readyState === source.HAVE_FUTURE_DATA)
+              && source.width && source.height) {
+              source.complete = true;
+          }
+          source.addEventListener('play', this._onPlayStart.bind(this));
+          source.addEventListener('pause', this._onPlayStop.bind(this));
+          if (!this._isSourceReady()) {
+              source.addEventListener('canplay', this._onCanPlay);
+              source.addEventListener('canplaythrough', this._onCanPlay);
+              source.addEventListener('error', this._onError, true);
+          }
+          else {
+              this._onCanPlay();
+          }
+          this._load = new Promise(function (resolve) {
+              if (_this.valid) {
+                  resolve(_this);
+              }
+              else {
+                  _this._resolve = resolve;
+                  source.load();
+              }
+          });
+          return this._load;
+      };
+      /**
+       * Handle video error events.
+       * @param event
+       */
+      VideoResource.prototype._onError = function (event) {
+          this.source.removeEventListener('error', this._onError, true);
+          this.onError.emit(event);
+      };
+      /**
+       * Returns true if the underlying source is playing.
+       * @returns - True if playing.
+       */
+      VideoResource.prototype._isSourcePlaying = function () {
+          var source = this.source;
+          return (!source.paused && !source.ended && this._isSourceReady());
+      };
+      /**
+       * Returns true if the underlying source is ready for playing.
+       * @returns - True if ready.
+       */
+      VideoResource.prototype._isSourceReady = function () {
+          var source = this.source;
+          return source.readyState > 2;
+      };
+      /** Runs the update loop when the video is ready to play. */
+      VideoResource.prototype._onPlayStart = function () {
+          // Just in case the video has not received its can play even yet..
+          if (!this.valid) {
+              this._onCanPlay();
+          }
+          if (this.autoUpdate && !this._isConnectedToTicker) {
+              Ticker.shared.add(this.update, this);
+              this._isConnectedToTicker = true;
+          }
+      };
+      /** Fired when a pause event is triggered, stops the update loop. */
+      VideoResource.prototype._onPlayStop = function () {
+          if (this._isConnectedToTicker) {
+              Ticker.shared.remove(this.update, this);
+              this._isConnectedToTicker = false;
+          }
+      };
+      /** Fired when the video is loaded and ready to play. */
+      VideoResource.prototype._onCanPlay = function () {
+          var source = this.source;
+          source.removeEventListener('canplay', this._onCanPlay);
+          source.removeEventListener('canplaythrough', this._onCanPlay);
+          var valid = this.valid;
+          this.resize(source.videoWidth, source.videoHeight);
+          // prevent multiple loaded dispatches..
+          if (!valid && this._resolve) {
+              this._resolve(this);
+              this._resolve = null;
+          }
+          if (this._isSourcePlaying()) {
+              this._onPlayStart();
+          }
+          else if (this.autoPlay) {
+              source.play();
+          }
+      };
+      /** Destroys this texture. */
+      VideoResource.prototype.dispose = function () {
+          if (this._isConnectedToTicker) {
+              Ticker.shared.remove(this.update, this);
+              this._isConnectedToTicker = false;
+          }
+          var source = this.source;
+          if (source) {
+              source.removeEventListener('error', this._onError, true);
+              source.pause();
+              source.src = '';
+              source.load();
+          }
+          _super.prototype.dispose.call(this);
+      };
+      Object.defineProperty(VideoResource.prototype, "autoUpdate", {
+          /** Should the base texture automatically update itself, set to true by default. */
+          get: function () {
+              return this._autoUpdate;
+          },
+          set: function (value) {
+              if (value !== this._autoUpdate) {
+                  this._autoUpdate = value;
+                  if (!this._autoUpdate && this._isConnectedToTicker) {
+                      Ticker.shared.remove(this.update, this);
+                      this._isConnectedToTicker = false;
+                  }
+                  else if (this._autoUpdate && !this._isConnectedToTicker && this._isSourcePlaying()) {
+                      Ticker.shared.add(this.update, this);
+                      this._isConnectedToTicker = true;
+                  }
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(VideoResource.prototype, "updateFPS", {
+          /**
+           * How many times a second to update the texture from the video. Leave at 0 to update at every render.
+           * A lower fps can help performance, as updating the texture at 60fps on a 30ps video may not be efficient.
+           */
+          get: function () {
+              return this._updateFPS;
+          },
+          set: function (value) {
+              if (value !== this._updateFPS) {
+                  this._updateFPS = value;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Used to auto-detect the type of resource.
+       * @param {*} source - The source object
+       * @param {string} extension - The extension of source, if set
+       * @returns {boolean} `true` if video source
+       */
+      VideoResource.test = function (source, extension) {
+          return (globalThis.HTMLVideoElement && source instanceof HTMLVideoElement)
+              || VideoResource.TYPES.indexOf(extension) > -1;
+      };
+      /**
+       * List of common video file extensions supported by VideoResource.
+       * @readonly
+       */
+      VideoResource.TYPES = ['mp4', 'm4v', 'webm', 'ogg', 'ogv', 'h264', 'avi', 'mov'];
+      /**
+       * Map of video MIME types that can't be directly derived from file extensions.
+       * @readonly
+       */
+      VideoResource.MIME_TYPES = {
+          ogv: 'video/ogg',
+          mov: 'video/quicktime',
+          m4v: 'video/mp4',
+      };
+      return VideoResource;
+  }(BaseImageResource));
 
-    /**
-     * Destroys the ParticleRenderer.
-     *
-     */
+  /**
+   * Resource type for ImageBitmap.
+   * @memberof PIXI
+   */
+  var ImageBitmapResource = /** @class */ (function (_super) {
+      __extends$i(ImageBitmapResource, _super);
+      /**
+       * @param source - Image element to use
+       */
+      // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+      function ImageBitmapResource(source) {
+          return _super.call(this, source) || this;
+      }
+      /**
+       * Used to auto-detect the type of resource.
+       * @param {*} source - The source object
+       * @returns {boolean} `true` if source is an ImageBitmap
+       */
+      ImageBitmapResource.test = function (source) {
+          return !!globalThis.createImageBitmap && typeof ImageBitmap !== 'undefined' && source instanceof ImageBitmap;
+      };
+      return ImageBitmapResource;
+  }(BaseImageResource));
+
+  INSTALLED.push(ImageResource, ImageBitmapResource, CanvasResource, VideoResource, SVGResource, BufferResource, CubeResource, ArrayResource);
+
+  var _resources = {
+      __proto__: null,
+      Resource: Resource,
+      BaseImageResource: BaseImageResource,
+      INSTALLED: INSTALLED,
+      autoDetectResource: autoDetectResource,
+      AbstractMultiResource: AbstractMultiResource,
+      ArrayResource: ArrayResource,
+      BufferResource: BufferResource,
+      CanvasResource: CanvasResource,
+      CubeResource: CubeResource,
+      ImageResource: ImageResource,
+      SVGResource: SVGResource,
+      VideoResource: VideoResource,
+      ImageBitmapResource: ImageBitmapResource
+  };
 
+  /**
+   * Resource type for DepthTexture.
+   * @memberof PIXI
+   */
+  var DepthResource = /** @class */ (function (_super) {
+      __extends$i(DepthResource, _super);
+      function DepthResource() {
+          return _super !== null && _super.apply(this, arguments) || this;
+      }
+      /**
+       * Upload the texture to the GPU.
+       * @param renderer - Upload to the renderer
+       * @param baseTexture - Reference to parent texture
+       * @param glTexture - glTexture
+       * @returns - true is success
+       */
+      DepthResource.prototype.upload = function (renderer, baseTexture, glTexture) {
+          var gl = renderer.gl;
+          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === exports.ALPHA_MODES.UNPACK);
+          var width = baseTexture.realWidth;
+          var height = baseTexture.realHeight;
+          if (glTexture.width === width && glTexture.height === height) {
+              gl.texSubImage2D(baseTexture.target, 0, 0, 0, width, height, baseTexture.format, glTexture.type, this.data);
+          }
+          else {
+              glTexture.width = width;
+              glTexture.height = height;
+              gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, width, height, 0, baseTexture.format, glTexture.type, this.data);
+          }
+          return true;
+      };
+      return DepthResource;
+  }(BufferResource));
 
-    ParticleRenderer.prototype.destroy = function destroy() {
-        if (this.renderer.gl) {
-            this.renderer.gl.deleteBuffer(this.indexBuffer);
-        }
+  /**
+   * A framebuffer can be used to render contents off of the screen. {@link PIXI.BaseRenderTexture} uses
+   * one internally to render into itself. You can attach a depth or stencil buffer to a framebuffer.
+   *
+   * On WebGL 2 machines, shaders can output to multiple textures simultaneously with GLSL 300 ES.
+   * @memberof PIXI
+   */
+  var Framebuffer = /** @class */ (function () {
+      /**
+       * @param width - Width of the frame buffer
+       * @param height - Height of the frame buffer
+       */
+      function Framebuffer(width, height) {
+          this.width = Math.round(width || 100);
+          this.height = Math.round(height || 100);
+          this.stencil = false;
+          this.depth = false;
+          this.dirtyId = 0;
+          this.dirtyFormat = 0;
+          this.dirtySize = 0;
+          this.depthTexture = null;
+          this.colorTextures = [];
+          this.glFramebuffers = {};
+          this.disposeRunner = new Runner('disposeFramebuffer');
+          this.multisample = exports.MSAA_QUALITY.NONE;
+      }
+      Object.defineProperty(Framebuffer.prototype, "colorTexture", {
+          /**
+           * Reference to the colorTexture.
+           * @readonly
+           */
+          get: function () {
+              return this.colorTextures[0];
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Add texture to the colorTexture array.
+       * @param index - Index of the array to add the texture to
+       * @param texture - Texture to add to the array
+       */
+      Framebuffer.prototype.addColorTexture = function (index, texture) {
+          if (index === void 0) { index = 0; }
+          // TODO add some validation to the texture - same width / height etc?
+          this.colorTextures[index] = texture || new BaseTexture(null, {
+              scaleMode: exports.SCALE_MODES.NEAREST,
+              resolution: 1,
+              mipmap: exports.MIPMAP_MODES.OFF,
+              width: this.width,
+              height: this.height,
+          });
+          this.dirtyId++;
+          this.dirtyFormat++;
+          return this;
+      };
+      /**
+       * Add a depth texture to the frame buffer.
+       * @param texture - Texture to add.
+       */
+      Framebuffer.prototype.addDepthTexture = function (texture) {
+          /* eslint-disable max-len */
+          this.depthTexture = texture || new BaseTexture(new DepthResource(null, { width: this.width, height: this.height }), {
+              scaleMode: exports.SCALE_MODES.NEAREST,
+              resolution: 1,
+              width: this.width,
+              height: this.height,
+              mipmap: exports.MIPMAP_MODES.OFF,
+              format: exports.FORMATS.DEPTH_COMPONENT,
+              type: exports.TYPES.UNSIGNED_SHORT,
+          });
+          this.dirtyId++;
+          this.dirtyFormat++;
+          return this;
+      };
+      /** Enable depth on the frame buffer. */
+      Framebuffer.prototype.enableDepth = function () {
+          this.depth = true;
+          this.dirtyId++;
+          this.dirtyFormat++;
+          return this;
+      };
+      /** Enable stencil on the frame buffer. */
+      Framebuffer.prototype.enableStencil = function () {
+          this.stencil = true;
+          this.dirtyId++;
+          this.dirtyFormat++;
+          return this;
+      };
+      /**
+       * Resize the frame buffer
+       * @param width - Width of the frame buffer to resize to
+       * @param height - Height of the frame buffer to resize to
+       */
+      Framebuffer.prototype.resize = function (width, height) {
+          width = Math.round(width);
+          height = Math.round(height);
+          if (width === this.width && height === this.height)
+              { return; }
+          this.width = width;
+          this.height = height;
+          this.dirtyId++;
+          this.dirtySize++;
+          for (var i = 0; i < this.colorTextures.length; i++) {
+              var texture = this.colorTextures[i];
+              var resolution = texture.resolution;
+              // take into account the fact the texture may have a different resolution..
+              texture.setSize(width / resolution, height / resolution);
+          }
+          if (this.depthTexture) {
+              var resolution = this.depthTexture.resolution;
+              this.depthTexture.setSize(width / resolution, height / resolution);
+          }
+      };
+      /** Disposes WebGL resources that are connected to this geometry. */
+      Framebuffer.prototype.dispose = function () {
+          this.disposeRunner.emit(this, false);
+      };
+      /** Destroys and removes the depth texture added to this framebuffer. */
+      Framebuffer.prototype.destroyDepthTexture = function () {
+          if (this.depthTexture) {
+              this.depthTexture.destroy();
+              this.depthTexture = null;
+              ++this.dirtyId;
+              ++this.dirtyFormat;
+          }
+      };
+      return Framebuffer;
+  }());
 
-        _core$ObjectRenderer.prototype.destroy.call(this);
+  /**
+   * A BaseRenderTexture is a special texture that allows any PixiJS display object to be rendered to it.
+   *
+   * __Hint__: All DisplayObjects (i.e. Sprites) that render to a BaseRenderTexture should be preloaded
+   * otherwise black rectangles will be drawn instead.
+   *
+   * A BaseRenderTexture takes a snapshot of any Display Object given to its render method. The position
+   * and rotation of the given Display Objects is ignored. For example:
+   *
+   * ```js
+   * let renderer = PIXI.autoDetectRenderer();
+   * let baseRenderTexture = new PIXI.BaseRenderTexture({ width: 800, height: 600 });
+   * let renderTexture = new PIXI.RenderTexture(baseRenderTexture);
+   * let sprite = PIXI.Sprite.from("spinObj_01.png");
+   *
+   * sprite.position.x = 800/2;
+   * sprite.position.y = 600/2;
+   * sprite.anchor.x = 0.5;
+   * sprite.anchor.y = 0.5;
+   *
+   * renderer.render(sprite, {renderTexture});
+   * ```
+   *
+   * The Sprite in this case will be rendered using its local transform. To render this sprite at 0,0
+   * you can clear the transform
+   *
+   * ```js
+   *
+   * sprite.setTransform()
+   *
+   * let baseRenderTexture = new PIXI.BaseRenderTexture({ width: 100, height: 100 });
+   * let renderTexture = new PIXI.RenderTexture(baseRenderTexture);
+   *
+   * renderer.render(sprite, {renderTexture});  // Renders to center of RenderTexture
+   * ```
+   * @memberof PIXI
+   */
+  var BaseRenderTexture = /** @class */ (function (_super) {
+      __extends$i(BaseRenderTexture, _super);
+      /**
+       * @param options
+       * @param {number} [options.width=100] - The width of the base render texture.
+       * @param {number} [options.height=100] - The height of the base render texture.
+       * @param {PIXI.SCALE_MODES} [options.scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES}
+       *   for possible values.
+       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] - The resolution / device pixel ratio
+       *   of the texture being generated.
+       * @param {PIXI.MSAA_QUALITY} [options.multisample=PIXI.MSAA_QUALITY.NONE] - The number of samples of the frame buffer.
+       */
+      function BaseRenderTexture(options) {
+          if (options === void 0) { options = {}; }
+          var _this = this;
+          if (typeof options === 'number') {
+              /* eslint-disable prefer-rest-params */
+              // Backward compatibility of signature
+              var width = arguments[0];
+              var height = arguments[1];
+              var scaleMode = arguments[2];
+              var resolution = arguments[3];
+              options = { width: width, height: height, scaleMode: scaleMode, resolution: resolution };
+              /* eslint-enable prefer-rest-params */
+          }
+          options.width = options.width || 100;
+          options.height = options.height || 100;
+          options.multisample = options.multisample !== undefined ? options.multisample : exports.MSAA_QUALITY.NONE;
+          _this = _super.call(this, null, options) || this;
+          // Set defaults
+          _this.mipmap = exports.MIPMAP_MODES.OFF;
+          _this.valid = true;
+          _this.clearColor = [0, 0, 0, 0];
+          _this.framebuffer = new Framebuffer(_this.realWidth, _this.realHeight)
+              .addColorTexture(0, _this);
+          _this.framebuffer.multisample = options.multisample;
+          // TODO - could this be added the systems?
+          _this.maskStack = [];
+          _this.filterStack = [{}];
+          return _this;
+      }
+      /**
+       * Resizes the BaseRenderTexture.
+       * @param desiredWidth - The desired width to resize to.
+       * @param desiredHeight - The desired height to resize to.
+       */
+      BaseRenderTexture.prototype.resize = function (desiredWidth, desiredHeight) {
+          this.framebuffer.resize(desiredWidth * this.resolution, desiredHeight * this.resolution);
+          this.setRealSize(this.framebuffer.width, this.framebuffer.height);
+      };
+      /**
+       * Frees the texture and framebuffer from WebGL memory without destroying this texture object.
+       * This means you can still use the texture later which will upload it to GPU
+       * memory again.
+       * @fires PIXI.BaseTexture#dispose
+       */
+      BaseRenderTexture.prototype.dispose = function () {
+          this.framebuffer.dispose();
+          _super.prototype.dispose.call(this);
+      };
+      /** Destroys this texture. */
+      BaseRenderTexture.prototype.destroy = function () {
+          _super.prototype.destroy.call(this);
+          this.framebuffer.destroyDepthTexture();
+          this.framebuffer = null;
+      };
+      return BaseRenderTexture;
+  }(BaseTexture));
 
-        this.shader.destroy();
+  /**
+   * Stores a texture's frame in UV coordinates, in
+   * which everything lies in the rectangle `[(0,0), (1,0),
+   * (1,1), (0,1)]`.
+   *
+   * | Corner       | Coordinates |
+   * |--------------|-------------|
+   * | Top-Left     | `(x0,y0)`   |
+   * | Top-Right    | `(x1,y1)`   |
+   * | Bottom-Right | `(x2,y2)`   |
+   * | Bottom-Left  | `(x3,y3)`   |
+   * @protected
+   * @memberof PIXI
+   */
+  var TextureUvs = /** @class */ (function () {
+      function TextureUvs() {
+          this.x0 = 0;
+          this.y0 = 0;
+          this.x1 = 1;
+          this.y1 = 0;
+          this.x2 = 1;
+          this.y2 = 1;
+          this.x3 = 0;
+          this.y3 = 1;
+          this.uvsFloat32 = new Float32Array(8);
+      }
+      /**
+       * Sets the texture Uvs based on the given frame information.
+       * @protected
+       * @param frame - The frame of the texture
+       * @param baseFrame - The base frame of the texture
+       * @param rotate - Rotation of frame, see {@link PIXI.groupD8}
+       */
+      TextureUvs.prototype.set = function (frame, baseFrame, rotate) {
+          var tw = baseFrame.width;
+          var th = baseFrame.height;
+          if (rotate) {
+              // width and height div 2 div baseFrame size
+              var w2 = frame.width / 2 / tw;
+              var h2 = frame.height / 2 / th;
+              // coordinates of center
+              var cX = (frame.x / tw) + w2;
+              var cY = (frame.y / th) + h2;
+              rotate = groupD8.add(rotate, groupD8.NW); // NW is top-left corner
+              this.x0 = cX + (w2 * groupD8.uX(rotate));
+              this.y0 = cY + (h2 * groupD8.uY(rotate));
+              rotate = groupD8.add(rotate, 2); // rotate 90 degrees clockwise
+              this.x1 = cX + (w2 * groupD8.uX(rotate));
+              this.y1 = cY + (h2 * groupD8.uY(rotate));
+              rotate = groupD8.add(rotate, 2);
+              this.x2 = cX + (w2 * groupD8.uX(rotate));
+              this.y2 = cY + (h2 * groupD8.uY(rotate));
+              rotate = groupD8.add(rotate, 2);
+              this.x3 = cX + (w2 * groupD8.uX(rotate));
+              this.y3 = cY + (h2 * groupD8.uY(rotate));
+          }
+          else {
+              this.x0 = frame.x / tw;
+              this.y0 = frame.y / th;
+              this.x1 = (frame.x + frame.width) / tw;
+              this.y1 = frame.y / th;
+              this.x2 = (frame.x + frame.width) / tw;
+              this.y2 = (frame.y + frame.height) / th;
+              this.x3 = frame.x / tw;
+              this.y3 = (frame.y + frame.height) / th;
+          }
+          this.uvsFloat32[0] = this.x0;
+          this.uvsFloat32[1] = this.y0;
+          this.uvsFloat32[2] = this.x1;
+          this.uvsFloat32[3] = this.y1;
+          this.uvsFloat32[4] = this.x2;
+          this.uvsFloat32[5] = this.y2;
+          this.uvsFloat32[6] = this.x3;
+          this.uvsFloat32[7] = this.y3;
+      };
+      TextureUvs.prototype.toString = function () {
+          return "[@pixi/core:TextureUvs "
+              + ("x0=" + this.x0 + " y0=" + this.y0 + " ")
+              + ("x1=" + this.x1 + " y1=" + this.y1 + " x2=" + this.x2 + " ")
+              + ("y2=" + this.y2 + " x3=" + this.x3 + " y3=" + this.y3)
+              + "]";
+      };
+      return TextureUvs;
+  }());
+
+  var DEFAULT_UVS = new TextureUvs();
+  /**
+   * Used to remove listeners from WHITE and EMPTY Textures
+   * @ignore
+   */
+  function removeAllHandlers(tex) {
+      tex.destroy = function _emptyDestroy() { };
+      tex.on = function _emptyOn() { };
+      tex.once = function _emptyOnce() { };
+      tex.emit = function _emptyEmit() { };
+  }
+  /**
+   * A texture stores the information that represents an image or part of an image.
+   *
+   * It cannot be added to the display list directly; instead use it as the texture for a Sprite.
+   * If no frame is provided for a texture, then the whole image is used.
+   *
+   * You can directly create a texture from an image and then reuse it multiple times like this :
+   *
+   * ```js
+   * let texture = PIXI.Texture.from('assets/image.png');
+   * let sprite1 = new PIXI.Sprite(texture);
+   * let sprite2 = new PIXI.Sprite(texture);
+   * ```
+   *
+   * If you didnt pass the texture frame to constructor, it enables `noFrame` mode:
+   * it subscribes on baseTexture events, it automatically resizes at the same time as baseTexture.
+   *
+   * Textures made from SVGs, loaded or not, cannot be used before the file finishes processing.
+   * You can check for this by checking the sprite's _textureID property.
+   * ```js
+   * var texture = PIXI.Texture.from('assets/image.svg');
+   * var sprite1 = new PIXI.Sprite(texture);
+   * //sprite1._textureID should not be undefined if the texture has finished processing the SVG file
+   * ```
+   * You can use a ticker or rAF to ensure your sprites load the finished textures after processing. See issue #3068.
+   * @memberof PIXI
+   * @typeParam R - The BaseTexture's Resource type.
+   */
+  var Texture = /** @class */ (function (_super) {
+      __extends$i(Texture, _super);
+      /**
+       * @param baseTexture - The base texture source to create the texture from
+       * @param frame - The rectangle frame of the texture to show
+       * @param orig - The area of original texture
+       * @param trim - Trimmed rectangle of original texture
+       * @param rotate - indicates how the texture was rotated by texture packer. See {@link PIXI.groupD8}
+       * @param anchor - Default anchor point used for sprite placement / rotation
+       */
+      function Texture(baseTexture, frame, orig, trim, rotate, anchor) {
+          var _this = _super.call(this) || this;
+          _this.noFrame = false;
+          if (!frame) {
+              _this.noFrame = true;
+              frame = new Rectangle(0, 0, 1, 1);
+          }
+          if (baseTexture instanceof Texture) {
+              baseTexture = baseTexture.baseTexture;
+          }
+          _this.baseTexture = baseTexture;
+          _this._frame = frame;
+          _this.trim = trim;
+          _this.valid = false;
+          _this._uvs = DEFAULT_UVS;
+          _this.uvMatrix = null;
+          _this.orig = orig || frame; // new Rectangle(0, 0, 1, 1);
+          _this._rotate = Number(rotate || 0);
+          if (rotate === true) {
+              // this is old texturepacker legacy, some games/libraries are passing "true" for rotated textures
+              _this._rotate = 2;
+          }
+          else if (_this._rotate % 2 !== 0) {
+              throw new Error('attempt to use diamond-shaped UVs. If you are sure, set rotation manually');
+          }
+          _this.defaultAnchor = anchor ? new Point(anchor.x, anchor.y) : new Point(0, 0);
+          _this._updateID = 0;
+          _this.textureCacheIds = [];
+          if (!baseTexture.valid) {
+              baseTexture.once('loaded', _this.onBaseTextureUpdated, _this);
+          }
+          else if (_this.noFrame) {
+              // if there is no frame we should monitor for any base texture changes..
+              if (baseTexture.valid) {
+                  _this.onBaseTextureUpdated(baseTexture);
+              }
+          }
+          else {
+              _this.frame = frame;
+          }
+          if (_this.noFrame) {
+              baseTexture.on('update', _this.onBaseTextureUpdated, _this);
+          }
+          return _this;
+      }
+      /**
+       * Updates this texture on the gpu.
+       *
+       * Calls the TextureResource update.
+       *
+       * If you adjusted `frame` manually, please call `updateUvs()` instead.
+       */
+      Texture.prototype.update = function () {
+          if (this.baseTexture.resource) {
+              this.baseTexture.resource.update();
+          }
+      };
+      /**
+       * Called when the base texture is updated
+       * @protected
+       * @param baseTexture - The base texture.
+       */
+      Texture.prototype.onBaseTextureUpdated = function (baseTexture) {
+          if (this.noFrame) {
+              if (!this.baseTexture.valid) {
+                  return;
+              }
+              this._frame.width = baseTexture.width;
+              this._frame.height = baseTexture.height;
+              this.valid = true;
+              this.updateUvs();
+          }
+          else {
+              // TODO this code looks confusing.. boo to abusing getters and setters!
+              // if user gave us frame that has bigger size than resized texture it can be a problem
+              this.frame = this._frame;
+          }
+          this.emit('update', this);
+      };
+      /**
+       * Destroys this texture
+       * @param [destroyBase=false] - Whether to destroy the base texture as well
+       */
+      Texture.prototype.destroy = function (destroyBase) {
+          if (this.baseTexture) {
+              if (destroyBase) {
+                  var resource = this.baseTexture.resource;
+                  // delete the texture if it exists in the texture cache..
+                  // this only needs to be removed if the base texture is actually destroyed too..
+                  if (resource && resource.url && TextureCache[resource.url]) {
+                      Texture.removeFromCache(resource.url);
+                  }
+                  this.baseTexture.destroy();
+              }
+              this.baseTexture.off('loaded', this.onBaseTextureUpdated, this);
+              this.baseTexture.off('update', this.onBaseTextureUpdated, this);
+              this.baseTexture = null;
+          }
+          this._frame = null;
+          this._uvs = null;
+          this.trim = null;
+          this.orig = null;
+          this.valid = false;
+          Texture.removeFromCache(this);
+          this.textureCacheIds = null;
+      };
+      /**
+       * Creates a new texture object that acts the same as this one.
+       * @returns - The new texture
+       */
+      Texture.prototype.clone = function () {
+          var clonedFrame = this._frame.clone();
+          var clonedOrig = this._frame === this.orig ? clonedFrame : this.orig.clone();
+          var clonedTexture = new Texture(this.baseTexture, !this.noFrame && clonedFrame, clonedOrig, this.trim && this.trim.clone(), this.rotate, this.defaultAnchor);
+          if (this.noFrame) {
+              clonedTexture._frame = clonedFrame;
+          }
+          return clonedTexture;
+      };
+      /**
+       * Updates the internal WebGL UV cache. Use it after you change `frame` or `trim` of the texture.
+       * Call it after changing the frame
+       */
+      Texture.prototype.updateUvs = function () {
+          if (this._uvs === DEFAULT_UVS) {
+              this._uvs = new TextureUvs();
+          }
+          this._uvs.set(this._frame, this.baseTexture, this.rotate);
+          this._updateID++;
+      };
+      /**
+       * Helper function that creates a new Texture based on the source you provide.
+       * The source can be - frame id, image url, video url, canvas element, video element, base texture
+       * @param {string|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|PIXI.BaseTexture} source -
+       *        Source or array of sources to create texture from
+       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
+       * @param {string} [options.pixiIdPrefix=pixiid] - If a source has no id, this is the prefix of the generated id
+       * @param {boolean} [strict] - Enforce strict-mode, see {@link PIXI.settings.STRICT_TEXTURE_CACHE}.
+       * @returns {PIXI.Texture} The newly created texture
+       */
+      Texture.from = function (source, options, strict) {
+          if (options === void 0) { options = {}; }
+          if (strict === void 0) { strict = settings.STRICT_TEXTURE_CACHE; }
+          var isFrame = typeof source === 'string';
+          var cacheId = null;
+          if (isFrame) {
+              cacheId = source;
+          }
+          else if (source instanceof BaseTexture) {
+              if (!source.cacheId) {
+                  var prefix = (options && options.pixiIdPrefix) || 'pixiid';
+                  source.cacheId = prefix + "-" + uid();
+                  BaseTexture.addToCache(source, source.cacheId);
+              }
+              cacheId = source.cacheId;
+          }
+          else {
+              if (!source._pixiId) {
+                  var prefix = (options && options.pixiIdPrefix) || 'pixiid';
+                  source._pixiId = prefix + "_" + uid();
+              }
+              cacheId = source._pixiId;
+          }
+          var texture = TextureCache[cacheId];
+          // Strict-mode rejects invalid cacheIds
+          if (isFrame && strict && !texture) {
+              throw new Error("The cacheId \"" + cacheId + "\" does not exist in TextureCache.");
+          }
+          if (!texture && !(source instanceof BaseTexture)) {
+              if (!options.resolution) {
+                  options.resolution = getResolutionOfUrl(source);
+              }
+              texture = new Texture(new BaseTexture(source, options));
+              texture.baseTexture.cacheId = cacheId;
+              BaseTexture.addToCache(texture.baseTexture, cacheId);
+              Texture.addToCache(texture, cacheId);
+          }
+          else if (!texture && (source instanceof BaseTexture)) {
+              texture = new Texture(source);
+              Texture.addToCache(texture, cacheId);
+          }
+          // lets assume its a base texture!
+          return texture;
+      };
+      /**
+       * Useful for loading textures via URLs. Use instead of `Texture.from` because
+       * it does a better job of handling failed URLs more effectively. This also ignores
+       * `PIXI.settings.STRICT_TEXTURE_CACHE`. Works for Videos, SVGs, Images.
+       * @param url - The remote URL or array of URLs to load.
+       * @param options - Optional options to include
+       * @returns - A Promise that resolves to a Texture.
+       */
+      Texture.fromURL = function (url, options) {
+          var resourceOptions = Object.assign({ autoLoad: false }, options === null || options === void 0 ? void 0 : options.resourceOptions);
+          var texture = Texture.from(url, Object.assign({ resourceOptions: resourceOptions }, options), false);
+          var resource = texture.baseTexture.resource;
+          // The texture was already loaded
+          if (texture.baseTexture.valid) {
+              return Promise.resolve(texture);
+          }
+          // Manually load the texture, this should allow users to handle load errors
+          return resource.load().then(function () { return Promise.resolve(texture); });
+      };
+      /**
+       * Create a new Texture with a BufferResource from a Float32Array.
+       * RGBA values are floats from 0 to 1.
+       * @param {Float32Array|Uint8Array} buffer - The optional array to use, if no data
+       *        is provided, a new Float32Array is created.
+       * @param width - Width of the resource
+       * @param height - Height of the resource
+       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
+       * @returns - The resulting new BaseTexture
+       */
+      Texture.fromBuffer = function (buffer, width, height, options) {
+          return new Texture(BaseTexture.fromBuffer(buffer, width, height, options));
+      };
+      /**
+       * Create a texture from a source and add to the cache.
+       * @param {HTMLImageElement|HTMLCanvasElement|string} source - The input source.
+       * @param imageUrl - File name of texture, for cache and resolving resolution.
+       * @param name - Human readable name for the texture cache. If no name is
+       *        specified, only `imageUrl` will be used as the cache ID.
+       * @param options
+       * @returns - Output texture
+       */
+      Texture.fromLoader = function (source, imageUrl, name, options) {
+          var baseTexture = new BaseTexture(source, Object.assign({
+              scaleMode: settings.SCALE_MODE,
+              resolution: getResolutionOfUrl(imageUrl),
+          }, options));
+          var resource = baseTexture.resource;
+          if (resource instanceof ImageResource) {
+              resource.url = imageUrl;
+          }
+          var texture = new Texture(baseTexture);
+          // No name, use imageUrl instead
+          if (!name) {
+              name = imageUrl;
+          }
+          // lets also add the frame to pixi's global cache for 'fromLoader' function
+          BaseTexture.addToCache(texture.baseTexture, name);
+          Texture.addToCache(texture, name);
+          // also add references by url if they are different.
+          if (name !== imageUrl) {
+              BaseTexture.addToCache(texture.baseTexture, imageUrl);
+              Texture.addToCache(texture, imageUrl);
+          }
+          // Generally images are valid right away
+          if (texture.baseTexture.valid) {
+              return Promise.resolve(texture);
+          }
+          // SVG assets need to be parsed async, let's wait
+          return new Promise(function (resolve) {
+              texture.baseTexture.once('loaded', function () { return resolve(texture); });
+          });
+      };
+      /**
+       * Adds a Texture to the global TextureCache. This cache is shared across the whole PIXI object.
+       * @param texture - The Texture to add to the cache.
+       * @param id - The id that the Texture will be stored against.
+       */
+      Texture.addToCache = function (texture, id) {
+          if (id) {
+              if (texture.textureCacheIds.indexOf(id) === -1) {
+                  texture.textureCacheIds.push(id);
+              }
+              if (TextureCache[id]) {
+                  // eslint-disable-next-line no-console
+                  console.warn("Texture added to the cache with an id [" + id + "] that already had an entry");
+              }
+              TextureCache[id] = texture;
+          }
+      };
+      /**
+       * Remove a Texture from the global TextureCache.
+       * @param texture - id of a Texture to be removed, or a Texture instance itself
+       * @returns - The Texture that was removed
+       */
+      Texture.removeFromCache = function (texture) {
+          if (typeof texture === 'string') {
+              var textureFromCache = TextureCache[texture];
+              if (textureFromCache) {
+                  var index = textureFromCache.textureCacheIds.indexOf(texture);
+                  if (index > -1) {
+                      textureFromCache.textureCacheIds.splice(index, 1);
+                  }
+                  delete TextureCache[texture];
+                  return textureFromCache;
+              }
+          }
+          else if (texture && texture.textureCacheIds) {
+              for (var i = 0; i < texture.textureCacheIds.length; ++i) {
+                  // Check that texture matches the one being passed in before deleting it from the cache.
+                  if (TextureCache[texture.textureCacheIds[i]] === texture) {
+                      delete TextureCache[texture.textureCacheIds[i]];
+                  }
+              }
+              texture.textureCacheIds.length = 0;
+              return texture;
+          }
+          return null;
+      };
+      Object.defineProperty(Texture.prototype, "resolution", {
+          /**
+           * Returns resolution of baseTexture
+           * @readonly
+           */
+          get: function () {
+              return this.baseTexture.resolution;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Texture.prototype, "frame", {
+          /**
+           * The frame specifies the region of the base texture that this texture uses.
+           * Please call `updateUvs()` after you change coordinates of `frame` manually.
+           */
+          get: function () {
+              return this._frame;
+          },
+          set: function (frame) {
+              this._frame = frame;
+              this.noFrame = false;
+              var x = frame.x, y = frame.y, width = frame.width, height = frame.height;
+              var xNotFit = x + width > this.baseTexture.width;
+              var yNotFit = y + height > this.baseTexture.height;
+              if (xNotFit || yNotFit) {
+                  var relationship = xNotFit && yNotFit ? 'and' : 'or';
+                  var errorX = "X: " + x + " + " + width + " = " + (x + width) + " > " + this.baseTexture.width;
+                  var errorY = "Y: " + y + " + " + height + " = " + (y + height) + " > " + this.baseTexture.height;
+                  throw new Error('Texture Error: frame does not fit inside the base Texture dimensions: '
+                      + (errorX + " " + relationship + " " + errorY));
+              }
+              this.valid = width && height && this.baseTexture.valid;
+              if (!this.trim && !this.rotate) {
+                  this.orig = frame;
+              }
+              if (this.valid) {
+                  this.updateUvs();
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Texture.prototype, "rotate", {
+          /**
+           * Indicates whether the texture is rotated inside the atlas
+           * set to 2 to compensate for texture packer rotation
+           * set to 6 to compensate for spine packer rotation
+           * can be used to rotate or mirror sprites
+           * See {@link PIXI.groupD8} for explanation
+           */
+          get: function () {
+              return this._rotate;
+          },
+          set: function (rotate) {
+              this._rotate = rotate;
+              if (this.valid) {
+                  this.updateUvs();
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Texture.prototype, "width", {
+          /** The width of the Texture in pixels. */
+          get: function () {
+              return this.orig.width;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Texture.prototype, "height", {
+          /** The height of the Texture in pixels. */
+          get: function () {
+              return this.orig.height;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Utility function for BaseTexture|Texture cast. */
+      Texture.prototype.castToBaseTexture = function () {
+          return this.baseTexture;
+      };
+      Object.defineProperty(Texture, "EMPTY", {
+          /** An empty texture, used often to not have to create multiple empty textures. Can not be destroyed. */
+          get: function () {
+              if (!Texture._EMPTY) {
+                  Texture._EMPTY = new Texture(new BaseTexture());
+                  removeAllHandlers(Texture._EMPTY);
+                  removeAllHandlers(Texture._EMPTY.baseTexture);
+              }
+              return Texture._EMPTY;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Texture, "WHITE", {
+          /** A white texture of 16x16 size, used for graphics and other things Can not be destroyed. */
+          get: function () {
+              if (!Texture._WHITE) {
+                  var canvas = settings.ADAPTER.createCanvas(16, 16);
+                  var context = canvas.getContext('2d');
+                  canvas.width = 16;
+                  canvas.height = 16;
+                  context.fillStyle = 'white';
+                  context.fillRect(0, 0, 16, 16);
+                  Texture._WHITE = new Texture(BaseTexture.from(canvas));
+                  removeAllHandlers(Texture._WHITE);
+                  removeAllHandlers(Texture._WHITE.baseTexture);
+              }
+              return Texture._WHITE;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return Texture;
+  }(eventemitter3));
 
-        this.indices = null;
-        this.tempMatrix = null;
-    };
+  /**
+   * A RenderTexture is a special texture that allows any PixiJS display object to be rendered to it.
+   *
+   * __Hint__: All DisplayObjects (i.e. Sprites) that render to a RenderTexture should be preloaded
+   * otherwise black rectangles will be drawn instead.
+   *
+   * __Hint-2__: The actual memory allocation will happen on first render.
+   * You shouldn't create renderTextures each frame just to delete them after, try to reuse them.
+   *
+   * A RenderTexture takes a snapshot of any Display Object given to its render method. For example:
+   *
+   * ```js
+   * let renderer = PIXI.autoDetectRenderer();
+   * let renderTexture = PIXI.RenderTexture.create({ width: 800, height: 600 });
+   * let sprite = PIXI.Sprite.from("spinObj_01.png");
+   *
+   * sprite.position.x = 800/2;
+   * sprite.position.y = 600/2;
+   * sprite.anchor.x = 0.5;
+   * sprite.anchor.y = 0.5;
+   *
+   * renderer.render(sprite, {renderTexture});
+   * ```
+   * Note that you should not create a new renderer, but reuse the same one as the rest of the application.
+   *
+   * The Sprite in this case will be rendered using its local transform. To render this sprite at 0,0
+   * you can clear the transform
+   *
+   * ```js
+   *
+   * sprite.setTransform()
+   *
+   * let renderTexture = new PIXI.RenderTexture.create({ width: 100, height: 100 });
+   *
+   * renderer.render(sprite, {renderTexture});  // Renders to center of RenderTexture
+   * ```
+   * @memberof PIXI
+   */
+  var RenderTexture = /** @class */ (function (_super) {
+      __extends$i(RenderTexture, _super);
+      /**
+       * @param baseRenderTexture - The base texture object that this texture uses.
+       * @param frame - The rectangle frame of the texture to show.
+       */
+      function RenderTexture(baseRenderTexture, frame) {
+          var _this = _super.call(this, baseRenderTexture, frame) || this;
+          _this.valid = true;
+          _this.filterFrame = null;
+          _this.filterPoolKey = null;
+          _this.updateUvs();
+          return _this;
+      }
+      Object.defineProperty(RenderTexture.prototype, "framebuffer", {
+          /**
+           * Shortcut to `this.baseTexture.framebuffer`, saves baseTexture cast.
+           * @readonly
+           */
+          get: function () {
+              return this.baseTexture.framebuffer;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(RenderTexture.prototype, "multisample", {
+          /**
+           * Shortcut to `this.framebuffer.multisample`.
+           * @default PIXI.MSAA_QUALITY.NONE
+           */
+          get: function () {
+              return this.framebuffer.multisample;
+          },
+          set: function (value) {
+              this.framebuffer.multisample = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Resizes the RenderTexture.
+       * @param desiredWidth - The desired width to resize to.
+       * @param desiredHeight - The desired height to resize to.
+       * @param resizeBaseTexture - Should the baseTexture.width and height values be resized as well?
+       */
+      RenderTexture.prototype.resize = function (desiredWidth, desiredHeight, resizeBaseTexture) {
+          if (resizeBaseTexture === void 0) { resizeBaseTexture = true; }
+          var resolution = this.baseTexture.resolution;
+          var width = Math.round(desiredWidth * resolution) / resolution;
+          var height = Math.round(desiredHeight * resolution) / resolution;
+          // TODO - could be not required..
+          this.valid = (width > 0 && height > 0);
+          this._frame.width = this.orig.width = width;
+          this._frame.height = this.orig.height = height;
+          if (resizeBaseTexture) {
+              this.baseTexture.resize(width, height);
+          }
+          this.updateUvs();
+      };
+      /**
+       * Changes the resolution of baseTexture, but does not change framebuffer size.
+       * @param resolution - The new resolution to apply to RenderTexture
+       */
+      RenderTexture.prototype.setResolution = function (resolution) {
+          var baseTexture = this.baseTexture;
+          if (baseTexture.resolution === resolution) {
+              return;
+          }
+          baseTexture.setResolution(resolution);
+          this.resize(baseTexture.width, baseTexture.height, false);
+      };
+      RenderTexture.create = function (options) {
+          var arguments$1 = arguments;
+
+          var rest = [];
+          for (var _i = 1; _i < arguments.length; _i++) {
+              rest[_i - 1] = arguments$1[_i];
+          }
+          // @deprecated fallback, old-style: create(width, height, scaleMode, resolution)
+          if (typeof options === 'number') {
+              deprecation('6.0.0', 'Arguments (width, height, scaleMode, resolution) have been deprecated.');
+              /* eslint-disable prefer-rest-params */
+              options = {
+                  width: options,
+                  height: rest[0],
+                  scaleMode: rest[1],
+                  resolution: rest[2],
+              };
+              /* eslint-enable prefer-rest-params */
+          }
+          return new RenderTexture(new BaseRenderTexture(options));
+      };
+      return RenderTexture;
+  }(Texture));
 
-    return ParticleRenderer;
-}(core.ObjectRenderer);
+  /**
+   * Texture pool, used by FilterSystem and plugins.
+   *
+   * Stores collection of temporary pow2 or screen-sized renderTextures
+   *
+   * If you use custom RenderTexturePool for your filters, you can use methods
+   * `getFilterTexture` and `returnFilterTexture` same as in
+   * @memberof PIXI
+   */
+  var RenderTexturePool = /** @class */ (function () {
+      /**
+       * @param textureOptions - options that will be passed to BaseRenderTexture constructor
+       * @param {PIXI.SCALE_MODES} [textureOptions.scaleMode] - See {@link PIXI.SCALE_MODES} for possible values.
+       */
+      function RenderTexturePool(textureOptions) {
+          this.texturePool = {};
+          this.textureOptions = textureOptions || {};
+          this.enableFullScreen = false;
+          this._pixelsWidth = 0;
+          this._pixelsHeight = 0;
+      }
+      /**
+       * Creates texture with params that were specified in pool constructor.
+       * @param realWidth - Width of texture in pixels.
+       * @param realHeight - Height of texture in pixels.
+       * @param multisample - Number of samples of the framebuffer.
+       */
+      RenderTexturePool.prototype.createTexture = function (realWidth, realHeight, multisample) {
+          if (multisample === void 0) { multisample = exports.MSAA_QUALITY.NONE; }
+          var baseRenderTexture = new BaseRenderTexture(Object.assign({
+              width: realWidth,
+              height: realHeight,
+              resolution: 1,
+              multisample: multisample,
+          }, this.textureOptions));
+          return new RenderTexture(baseRenderTexture);
+      };
+      /**
+       * Gets a Power-of-Two render texture or fullScreen texture
+       * @param minWidth - The minimum width of the render texture.
+       * @param minHeight - The minimum height of the render texture.
+       * @param resolution - The resolution of the render texture.
+       * @param multisample - Number of samples of the render texture.
+       * @returns The new render texture.
+       */
+      RenderTexturePool.prototype.getOptimalTexture = function (minWidth, minHeight, resolution, multisample) {
+          if (resolution === void 0) { resolution = 1; }
+          if (multisample === void 0) { multisample = exports.MSAA_QUALITY.NONE; }
+          var key;
+          minWidth = Math.ceil((minWidth * resolution) - 1e-6);
+          minHeight = Math.ceil((minHeight * resolution) - 1e-6);
+          if (!this.enableFullScreen || minWidth !== this._pixelsWidth || minHeight !== this._pixelsHeight) {
+              minWidth = nextPow2(minWidth);
+              minHeight = nextPow2(minHeight);
+              key = (((minWidth & 0xFFFF) << 16) | (minHeight & 0xFFFF)) >>> 0;
+              if (multisample > 1) {
+                  key += multisample * 0x100000000;
+              }
+          }
+          else {
+              key = multisample > 1 ? -multisample : -1;
+          }
+          if (!this.texturePool[key]) {
+              this.texturePool[key] = [];
+          }
+          var renderTexture = this.texturePool[key].pop();
+          if (!renderTexture) {
+              renderTexture = this.createTexture(minWidth, minHeight, multisample);
+          }
+          renderTexture.filterPoolKey = key;
+          renderTexture.setResolution(resolution);
+          return renderTexture;
+      };
+      /**
+       * Gets extra texture of the same size as input renderTexture
+       *
+       * `getFilterTexture(input, 0.5)` or `getFilterTexture(0.5, input)`
+       * @param input - renderTexture from which size and resolution will be copied
+       * @param resolution - override resolution of the renderTexture
+       *  It overrides, it does not multiply
+       * @param multisample - number of samples of the renderTexture
+       */
+      RenderTexturePool.prototype.getFilterTexture = function (input, resolution, multisample) {
+          var filterTexture = this.getOptimalTexture(input.width, input.height, resolution || input.resolution, multisample || exports.MSAA_QUALITY.NONE);
+          filterTexture.filterFrame = input.filterFrame;
+          return filterTexture;
+      };
+      /**
+       * Place a render texture back into the pool.
+       * @param renderTexture - The renderTexture to free
+       */
+      RenderTexturePool.prototype.returnTexture = function (renderTexture) {
+          var key = renderTexture.filterPoolKey;
+          renderTexture.filterFrame = null;
+          this.texturePool[key].push(renderTexture);
+      };
+      /**
+       * Alias for returnTexture, to be compliant with FilterSystem interface.
+       * @param renderTexture - The renderTexture to free
+       */
+      RenderTexturePool.prototype.returnFilterTexture = function (renderTexture) {
+          this.returnTexture(renderTexture);
+      };
+      /**
+       * Clears the pool.
+       * @param destroyTextures - Destroy all stored textures.
+       */
+      RenderTexturePool.prototype.clear = function (destroyTextures) {
+          destroyTextures = destroyTextures !== false;
+          if (destroyTextures) {
+              for (var i in this.texturePool) {
+                  var textures = this.texturePool[i];
+                  if (textures) {
+                      for (var j = 0; j < textures.length; j++) {
+                          textures[j].destroy(true);
+                      }
+                  }
+              }
+          }
+          this.texturePool = {};
+      };
+      /**
+       * If screen size was changed, drops all screen-sized textures,
+       * sets new screen size, sets `enableFullScreen` to true
+       *
+       * Size is measured in pixels, `renderer.view` can be passed here, not `renderer.screen`
+       * @param size - Initial size of screen.
+       */
+      RenderTexturePool.prototype.setScreenSize = function (size) {
+          if (size.width === this._pixelsWidth
+              && size.height === this._pixelsHeight) {
+              return;
+          }
+          this.enableFullScreen = size.width > 0 && size.height > 0;
+          for (var i in this.texturePool) {
+              if (!(Number(i) < 0)) {
+                  continue;
+              }
+              var textures = this.texturePool[i];
+              if (textures) {
+                  for (var j = 0; j < textures.length; j++) {
+                      textures[j].destroy(true);
+                  }
+              }
+              this.texturePool[i] = [];
+          }
+          this._pixelsWidth = size.width;
+          this._pixelsHeight = size.height;
+      };
+      /**
+       * Key that is used to store fullscreen renderTextures in a pool
+       * @constant
+       */
+      RenderTexturePool.SCREEN_KEY = -1;
+      return RenderTexturePool;
+  }());
 
-exports.default = ParticleRenderer;
+  /* eslint-disable max-len */
+  /**
+   * Holds the information for a single attribute structure required to render geometry.
+   *
+   * This does not contain the actual data, but instead has a buffer id that maps to a {@link PIXI.Buffer}
+   * This can include anything from positions, uvs, normals, colors etc.
+   * @memberof PIXI
+   */
+  var Attribute = /** @class */ (function () {
+      /**
+       * @param buffer - the id of the buffer that this attribute will look for
+       * @param size - the size of the attribute. If you have 2 floats per vertex (eg position x and y) this would be 2.
+       * @param normalized - should the data be normalized.
+       * @param {PIXI.TYPES} [type=PIXI.TYPES.FLOAT] - what type of number is the attribute. Check {@link PIXI.TYPES} to see the ones available
+       * @param [stride=0] - How far apart, in bytes, the start of each value is. (used for interleaving data)
+       * @param [start=0] - How far into the array to start reading values (used for interleaving data)
+       * @param [instance=false] - Whether the geometry is instanced.
+       */
+      function Attribute(buffer, size, normalized, type, stride, start, instance) {
+          if (size === void 0) { size = 0; }
+          if (normalized === void 0) { normalized = false; }
+          if (type === void 0) { type = exports.TYPES.FLOAT; }
+          this.buffer = buffer;
+          this.size = size;
+          this.normalized = normalized;
+          this.type = type;
+          this.stride = stride;
+          this.start = start;
+          this.instance = instance;
+      }
+      /** Destroys the Attribute. */
+      Attribute.prototype.destroy = function () {
+          this.buffer = null;
+      };
+      /**
+       * Helper function that creates an Attribute based on the information provided
+       * @param buffer - the id of the buffer that this attribute will look for
+       * @param [size=0] - the size of the attribute. If you have 2 floats per vertex (eg position x and y) this would be 2
+       * @param [normalized=false] - should the data be normalized.
+       * @param [type=PIXI.TYPES.FLOAT] - what type of number is the attribute. Check {@link PIXI.TYPES} to see the ones available
+       * @param [stride=0] - How far apart, in bytes, the start of each value is. (used for interleaving data)
+       * @returns - A new {@link PIXI.Attribute} based on the information provided
+       */
+      Attribute.from = function (buffer, size, normalized, type, stride) {
+          return new Attribute(buffer, size, normalized, type, stride);
+      };
+      return Attribute;
+  }());
 
+  var UID$4 = 0;
+  /**
+   * A wrapper for data so that it can be used and uploaded by WebGL
+   * @memberof PIXI
+   */
+  var Buffer = /** @class */ (function () {
+      /**
+       * @param {PIXI.IArrayBuffer} data - the data to store in the buffer.
+       * @param _static - `true` for static buffer
+       * @param index - `true` for index buffer
+       */
+      function Buffer(data, _static, index) {
+          if (_static === void 0) { _static = true; }
+          if (index === void 0) { index = false; }
+          this.data = (data || new Float32Array(1));
+          this._glBuffers = {};
+          this._updateID = 0;
+          this.index = index;
+          this.static = _static;
+          this.id = UID$4++;
+          this.disposeRunner = new Runner('disposeBuffer');
+      }
+      // TODO could explore flagging only a partial upload?
+      /**
+       * Flags this buffer as requiring an upload to the GPU.
+       * @param {PIXI.IArrayBuffer|number[]} [data] - the data to update in the buffer.
+       */
+      Buffer.prototype.update = function (data) {
+          if (data instanceof Array) {
+              data = new Float32Array(data);
+          }
+          this.data = data || this.data;
+          this._updateID++;
+      };
+      /** Disposes WebGL resources that are connected to this geometry. */
+      Buffer.prototype.dispose = function () {
+          this.disposeRunner.emit(this, false);
+      };
+      /** Destroys the buffer. */
+      Buffer.prototype.destroy = function () {
+          this.dispose();
+          this.data = null;
+      };
+      Object.defineProperty(Buffer.prototype, "index", {
+          get: function () {
+              return this.type === exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+          },
+          /**
+           * Flags whether this is an index buffer.
+           *
+           * Index buffers are of type `ELEMENT_ARRAY_BUFFER`. Note that setting this property to false will make
+           * the buffer of type `ARRAY_BUFFER`.
+           *
+           * For backwards compatibility.
+           */
+          set: function (value) {
+              this.type = value ? exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER : exports.BUFFER_TYPE.ARRAY_BUFFER;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Helper function that creates a buffer based on an array or TypedArray
+       * @param {ArrayBufferView | number[]} data - the TypedArray that the buffer will store. If this is a regular Array it will be converted to a Float32Array.
+       * @returns - A new Buffer based on the data provided.
+       */
+      Buffer.from = function (data) {
+          if (data instanceof Array) {
+              data = new Float32Array(data);
+          }
+          return new Buffer(data);
+      };
+      return Buffer;
+  }());
+
+  /* eslint-disable object-shorthand */
+  var map$1 = {
+      Float32Array: Float32Array,
+      Uint32Array: Uint32Array,
+      Int32Array: Int32Array,
+      Uint8Array: Uint8Array,
+  };
+  function interleaveTypedArrays(arrays, sizes) {
+      var outSize = 0;
+      var stride = 0;
+      var views = {};
+      for (var i = 0; i < arrays.length; i++) {
+          stride += sizes[i];
+          outSize += arrays[i].length;
+      }
+      var buffer = new ArrayBuffer(outSize * 4);
+      var out = null;
+      var littleOffset = 0;
+      for (var i = 0; i < arrays.length; i++) {
+          var size = sizes[i];
+          var array = arrays[i];
+          var type = getBufferType(array);
+          if (!views[type]) {
+              views[type] = new map$1[type](buffer);
+          }
+          out = views[type];
+          for (var j = 0; j < array.length; j++) {
+              var indexStart = ((j / size | 0) * stride) + littleOffset;
+              var index = j % size;
+              out[indexStart + index] = array[j];
+          }
+          littleOffset += size;
+      }
+      return new Float32Array(buffer);
+  }
 
-core.WebGLRenderer.registerPlugin('particle', ParticleRenderer);
+  var byteSizeMap$1 = { 5126: 4, 5123: 2, 5121: 1 };
+  var UID$3 = 0;
+  /* eslint-disable object-shorthand */
+  var map = {
+      Float32Array: Float32Array,
+      Uint32Array: Uint32Array,
+      Int32Array: Int32Array,
+      Uint8Array: Uint8Array,
+      Uint16Array: Uint16Array,
+  };
+  /* eslint-disable max-len */
+  /**
+   * The Geometry represents a model. It consists of two components:
+   * - GeometryStyle - The structure of the model such as the attributes layout
+   * - GeometryData - the data of the model - this consists of buffers.
+   * This can include anything from positions, uvs, normals, colors etc.
+   *
+   * Geometry can be defined without passing in a style or data if required (thats how I prefer!)
+   *
+   * ```js
+   * let geometry = new PIXI.Geometry();
+   *
+   * geometry.addAttribute('positions', [0, 0, 100, 0, 100, 100, 0, 100], 2);
+   * geometry.addAttribute('uvs', [0,0,1,0,1,1,0,1],2)
+   * geometry.addIndex([0,1,2,1,3,2])
+   * ```
+   * @memberof PIXI
+   */
+  var Geometry = /** @class */ (function () {
+      /**
+       * @param buffers - An array of buffers. optional.
+       * @param attributes - Of the geometry, optional structure of the attributes layout
+       */
+      function Geometry(buffers, attributes) {
+          if (buffers === void 0) { buffers = []; }
+          if (attributes === void 0) { attributes = {}; }
+          this.buffers = buffers;
+          this.indexBuffer = null;
+          this.attributes = attributes;
+          this.glVertexArrayObjects = {};
+          this.id = UID$3++;
+          this.instanced = false;
+          this.instanceCount = 1;
+          this.disposeRunner = new Runner('disposeGeometry');
+          this.refCount = 0;
+      }
+      /**
+       *
+       * Adds an attribute to the geometry
+       * Note: `stride` and `start` should be `undefined` if you dont know them, not 0!
+       * @param id - the name of the attribute (matching up to a shader)
+       * @param {PIXI.Buffer|number[]} buffer - the buffer that holds the data of the attribute . You can also provide an Array and a buffer will be created from it.
+       * @param size - the size of the attribute. If you have 2 floats per vertex (eg position x and y) this would be 2
+       * @param normalized - should the data be normalized.
+       * @param [type=PIXI.TYPES.FLOAT] - what type of number is the attribute. Check {PIXI.TYPES} to see the ones available
+       * @param [stride=0] - How far apart, in bytes, the start of each value is. (used for interleaving data)
+       * @param [start=0] - How far into the array to start reading values (used for interleaving data)
+       * @param instance - Instancing flag
+       * @returns - Returns self, useful for chaining.
+       */
+      Geometry.prototype.addAttribute = function (id, buffer, size, normalized, type, stride, start, instance) {
+          if (size === void 0) { size = 0; }
+          if (normalized === void 0) { normalized = false; }
+          if (instance === void 0) { instance = false; }
+          if (!buffer) {
+              throw new Error('You must pass a buffer when creating an attribute');
+          }
+          // check if this is a buffer!
+          if (!(buffer instanceof Buffer)) {
+              // its an array!
+              if (buffer instanceof Array) {
+                  buffer = new Float32Array(buffer);
+              }
+              buffer = new Buffer(buffer);
+          }
+          var ids = id.split('|');
+          if (ids.length > 1) {
+              for (var i = 0; i < ids.length; i++) {
+                  this.addAttribute(ids[i], buffer, size, normalized, type);
+              }
+              return this;
+          }
+          var bufferIndex = this.buffers.indexOf(buffer);
+          if (bufferIndex === -1) {
+              this.buffers.push(buffer);
+              bufferIndex = this.buffers.length - 1;
+          }
+          this.attributes[id] = new Attribute(bufferIndex, size, normalized, type, stride, start, instance);
+          // assuming that if there is instanced data then this will be drawn with instancing!
+          this.instanced = this.instanced || instance;
+          return this;
+      };
+      /**
+       * Returns the requested attribute.
+       * @param id - The name of the attribute required
+       * @returns - The attribute requested.
+       */
+      Geometry.prototype.getAttribute = function (id) {
+          return this.attributes[id];
+      };
+      /**
+       * Returns the requested buffer.
+       * @param id - The name of the buffer required.
+       * @returns - The buffer requested.
+       */
+      Geometry.prototype.getBuffer = function (id) {
+          return this.buffers[this.getAttribute(id).buffer];
+      };
+      /**
+       *
+       * Adds an index buffer to the geometry
+       * The index buffer contains integers, three for each triangle in the geometry, which reference the various attribute buffers (position, colour, UV coordinates, other UV coordinates, normal, …). There is only ONE index buffer.
+       * @param {PIXI.Buffer|number[]} [buffer] - The buffer that holds the data of the index buffer. You can also provide an Array and a buffer will be created from it.
+       * @returns - Returns self, useful for chaining.
+       */
+      Geometry.prototype.addIndex = function (buffer) {
+          if (!(buffer instanceof Buffer)) {
+              // its an array!
+              if (buffer instanceof Array) {
+                  buffer = new Uint16Array(buffer);
+              }
+              buffer = new Buffer(buffer);
+          }
+          buffer.type = exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+          this.indexBuffer = buffer;
+          if (this.buffers.indexOf(buffer) === -1) {
+              this.buffers.push(buffer);
+          }
+          return this;
+      };
+      /**
+       * Returns the index buffer
+       * @returns - The index buffer.
+       */
+      Geometry.prototype.getIndex = function () {
+          return this.indexBuffer;
+      };
+      /**
+       * This function modifies the structure so that all current attributes become interleaved into a single buffer
+       * This can be useful if your model remains static as it offers a little performance boost
+       * @returns - Returns self, useful for chaining.
+       */
+      Geometry.prototype.interleave = function () {
+          // a simple check to see if buffers are already interleaved..
+          if (this.buffers.length === 1 || (this.buffers.length === 2 && this.indexBuffer))
+              { return this; }
+          // assume already that no buffers are interleaved
+          var arrays = [];
+          var sizes = [];
+          var interleavedBuffer = new Buffer();
+          var i;
+          for (i in this.attributes) {
+              var attribute = this.attributes[i];
+              var buffer = this.buffers[attribute.buffer];
+              arrays.push(buffer.data);
+              sizes.push((attribute.size * byteSizeMap$1[attribute.type]) / 4);
+              attribute.buffer = 0;
+          }
+          interleavedBuffer.data = interleaveTypedArrays(arrays, sizes);
+          for (i = 0; i < this.buffers.length; i++) {
+              if (this.buffers[i] !== this.indexBuffer) {
+                  this.buffers[i].destroy();
+              }
+          }
+          this.buffers = [interleavedBuffer];
+          if (this.indexBuffer) {
+              this.buffers.push(this.indexBuffer);
+          }
+          return this;
+      };
+      /** Get the size of the geometries, in vertices. */
+      Geometry.prototype.getSize = function () {
+          for (var i in this.attributes) {
+              var attribute = this.attributes[i];
+              var buffer = this.buffers[attribute.buffer];
+              return buffer.data.length / ((attribute.stride / 4) || attribute.size);
+          }
+          return 0;
+      };
+      /** Disposes WebGL resources that are connected to this geometry. */
+      Geometry.prototype.dispose = function () {
+          this.disposeRunner.emit(this, false);
+      };
+      /** Destroys the geometry. */
+      Geometry.prototype.destroy = function () {
+          this.dispose();
+          this.buffers = null;
+          this.indexBuffer = null;
+          this.attributes = null;
+      };
+      /**
+       * Returns a clone of the geometry.
+       * @returns - A new clone of this geometry.
+       */
+      Geometry.prototype.clone = function () {
+          var geometry = new Geometry();
+          for (var i = 0; i < this.buffers.length; i++) {
+              geometry.buffers[i] = new Buffer(this.buffers[i].data.slice(0));
+          }
+          for (var i in this.attributes) {
+              var attrib = this.attributes[i];
+              geometry.attributes[i] = new Attribute(attrib.buffer, attrib.size, attrib.normalized, attrib.type, attrib.stride, attrib.start, attrib.instance);
+          }
+          if (this.indexBuffer) {
+              geometry.indexBuffer = geometry.buffers[this.buffers.indexOf(this.indexBuffer)];
+              geometry.indexBuffer.type = exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+          }
+          return geometry;
+      };
+      /**
+       * Merges an array of geometries into a new single one.
+       *
+       * Geometry attribute styles must match for this operation to work.
+       * @param geometries - array of geometries to merge
+       * @returns - Shiny new geometry!
+       */
+      Geometry.merge = function (geometries) {
+          // todo add a geometry check!
+          // also a size check.. cant be too big!]
+          var geometryOut = new Geometry();
+          var arrays = [];
+          var sizes = [];
+          var offsets = [];
+          var geometry;
+          // pass one.. get sizes..
+          for (var i = 0; i < geometries.length; i++) {
+              geometry = geometries[i];
+              for (var j = 0; j < geometry.buffers.length; j++) {
+                  sizes[j] = sizes[j] || 0;
+                  sizes[j] += geometry.buffers[j].data.length;
+                  offsets[j] = 0;
+              }
+          }
+          // build the correct size arrays..
+          for (var i = 0; i < geometry.buffers.length; i++) {
+              // TODO types!
+              arrays[i] = new map[getBufferType(geometry.buffers[i].data)](sizes[i]);
+              geometryOut.buffers[i] = new Buffer(arrays[i]);
+          }
+          // pass to set data..
+          for (var i = 0; i < geometries.length; i++) {
+              geometry = geometries[i];
+              for (var j = 0; j < geometry.buffers.length; j++) {
+                  arrays[j].set(geometry.buffers[j].data, offsets[j]);
+                  offsets[j] += geometry.buffers[j].data.length;
+              }
+          }
+          geometryOut.attributes = geometry.attributes;
+          if (geometry.indexBuffer) {
+              geometryOut.indexBuffer = geometryOut.buffers[geometry.buffers.indexOf(geometry.indexBuffer)];
+              geometryOut.indexBuffer.type = exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+              var offset = 0;
+              var stride = 0;
+              var offset2 = 0;
+              var bufferIndexToCount = 0;
+              // get a buffer
+              for (var i = 0; i < geometry.buffers.length; i++) {
+                  if (geometry.buffers[i] !== geometry.indexBuffer) {
+                      bufferIndexToCount = i;
+                      break;
+                  }
+              }
+              // figure out the stride of one buffer..
+              for (var i in geometry.attributes) {
+                  var attribute = geometry.attributes[i];
+                  if ((attribute.buffer | 0) === bufferIndexToCount) {
+                      stride += ((attribute.size * byteSizeMap$1[attribute.type]) / 4);
+                  }
+              }
+              // time to off set all indexes..
+              for (var i = 0; i < geometries.length; i++) {
+                  var indexBufferData = geometries[i].indexBuffer.data;
+                  for (var j = 0; j < indexBufferData.length; j++) {
+                      geometryOut.indexBuffer.data[j + offset2] += offset;
+                  }
+                  offset += geometries[i].buffers[bufferIndexToCount].data.length / (stride);
+                  offset2 += indexBufferData.length;
+              }
+          }
+          return geometryOut;
+      };
+      return Geometry;
+  }());
 
-},{"../../core":65,"./ParticleBuffer":175,"./ParticleShader":177}],177:[function(require,module,exports){
-'use strict';
+  /**
+   * Helper class to create a quad
+   * @memberof PIXI
+   */
+  var Quad = /** @class */ (function (_super) {
+      __extends$i(Quad, _super);
+      function Quad() {
+          var _this = _super.call(this) || this;
+          _this.addAttribute('aVertexPosition', new Float32Array([
+              0, 0,
+              1, 0,
+              1, 1,
+              0, 1 ]))
+              .addIndex([0, 1, 3, 2]);
+          return _this;
+      }
+      return Quad;
+  }(Geometry));
 
-exports.__esModule = true;
+  /**
+   * Helper class to create a quad with uvs like in v4
+   * @memberof PIXI
+   */
+  var QuadUv = /** @class */ (function (_super) {
+      __extends$i(QuadUv, _super);
+      function QuadUv() {
+          var _this = _super.call(this) || this;
+          _this.vertices = new Float32Array([
+              -1, -1,
+              1, -1,
+              1, 1,
+              -1, 1 ]);
+          _this.uvs = new Float32Array([
+              0, 0,
+              1, 0,
+              1, 1,
+              0, 1 ]);
+          _this.vertexBuffer = new Buffer(_this.vertices);
+          _this.uvBuffer = new Buffer(_this.uvs);
+          _this.addAttribute('aVertexPosition', _this.vertexBuffer)
+              .addAttribute('aTextureCoord', _this.uvBuffer)
+              .addIndex([0, 1, 2, 0, 2, 3]);
+          return _this;
+      }
+      /**
+       * Maps two Rectangle to the quad.
+       * @param targetTextureFrame - The first rectangle
+       * @param destinationFrame - The second rectangle
+       * @returns - Returns itself.
+       */
+      QuadUv.prototype.map = function (targetTextureFrame, destinationFrame) {
+          var x = 0; // destinationFrame.x / targetTextureFrame.width;
+          var y = 0; // destinationFrame.y / targetTextureFrame.height;
+          this.uvs[0] = x;
+          this.uvs[1] = y;
+          this.uvs[2] = x + (destinationFrame.width / targetTextureFrame.width);
+          this.uvs[3] = y;
+          this.uvs[4] = x + (destinationFrame.width / targetTextureFrame.width);
+          this.uvs[5] = y + (destinationFrame.height / targetTextureFrame.height);
+          this.uvs[6] = x;
+          this.uvs[7] = y + (destinationFrame.height / targetTextureFrame.height);
+          x = destinationFrame.x;
+          y = destinationFrame.y;
+          this.vertices[0] = x;
+          this.vertices[1] = y;
+          this.vertices[2] = x + destinationFrame.width;
+          this.vertices[3] = y;
+          this.vertices[4] = x + destinationFrame.width;
+          this.vertices[5] = y + destinationFrame.height;
+          this.vertices[6] = x;
+          this.vertices[7] = y + destinationFrame.height;
+          this.invalidate();
+          return this;
+      };
+      /**
+       * Legacy upload method, just marks buffers dirty.
+       * @returns - Returns itself.
+       */
+      QuadUv.prototype.invalidate = function () {
+          this.vertexBuffer._updateID++;
+          this.uvBuffer._updateID++;
+          return this;
+      };
+      return QuadUv;
+  }(Geometry));
+
+  var UID$2 = 0;
+  /**
+   * Uniform group holds uniform map and some ID's for work
+   *
+   * `UniformGroup` has two modes:
+   *
+   * 1: Normal mode
+   * Normal mode will upload the uniforms with individual function calls as required
+   *
+   * 2: Uniform buffer mode
+   * This mode will treat the uniforms as a uniform buffer. You can pass in either a buffer that you manually handle, or
+   * or a generic object that PixiJS will automatically map to a buffer for you.
+   * For maximum benefits, make Ubo UniformGroups static, and only update them each frame.
+   *
+   * Rules of UBOs:
+   * - UBOs only work with WebGL2, so make sure you have a fallback!
+   * - Only floats are supported (including vec[2,3,4], mat[2,3,4])
+   * - Samplers cannot be used in ubo's (a GPU limitation)
+   * - You must ensure that the object you pass in exactly matches in the shader ubo structure.
+   * Otherwise, weirdness will ensue!
+   * - The name of the ubo object added to the group must match exactly the name of the ubo in the shader.
+   *
+   * ```
+   * // ubo in shader:
+   * uniform myCoolData { // declaring a ubo..
+   * mat4 uCoolMatrix;
+   * float uFloatyMcFloatFace
+   *
+   *
+   * // a new uniform buffer object..
+   * const myCoolData = new UniformBufferGroup({
+   *   uCoolMatrix: new Matrix(),
+   *   uFloatyMcFloatFace: 23,
+   * }}
+   *
+   * // build a shader...
+   * const shader = Shader.from(srcVert, srcFrag, {
+   *   myCoolData // name matches the ubo name in the shader. will be processed accordingly.
+   * })
+   *
+   *  ```
+   * @memberof PIXI
+   */
+  var UniformGroup = /** @class */ (function () {
+      /**
+       * @param {object | Buffer} [uniforms] - Custom uniforms to use to augment the built-in ones. Or a pixi buffer.
+       * @param isStatic - Uniforms wont be changed after creation.
+       * @param isUbo - If true, will treat this uniform group as a uniform buffer object.
+       */
+      function UniformGroup(uniforms, isStatic, isUbo) {
+          this.group = true;
+          // lets generate this when the shader ?
+          this.syncUniforms = {};
+          this.dirtyId = 0;
+          this.id = UID$2++;
+          this.static = !!isStatic;
+          this.ubo = !!isUbo;
+          if (uniforms instanceof Buffer) {
+              this.buffer = uniforms;
+              this.buffer.type = exports.BUFFER_TYPE.UNIFORM_BUFFER;
+              this.autoManage = false;
+              this.ubo = true;
+          }
+          else {
+              this.uniforms = uniforms;
+              if (this.ubo) {
+                  this.buffer = new Buffer(new Float32Array(1));
+                  this.buffer.type = exports.BUFFER_TYPE.UNIFORM_BUFFER;
+                  this.autoManage = true;
+              }
+          }
+      }
+      UniformGroup.prototype.update = function () {
+          this.dirtyId++;
+          if (!this.autoManage && this.buffer) {
+              this.buffer.update();
+          }
+      };
+      UniformGroup.prototype.add = function (name, uniforms, _static) {
+          if (!this.ubo) {
+              this.uniforms[name] = new UniformGroup(uniforms, _static);
+          }
+          else {
+              // eslint-disable-next-line max-len
+              throw new Error('[UniformGroup] uniform groups in ubo mode cannot be modified, or have uniform groups nested in them');
+          }
+      };
+      UniformGroup.from = function (uniforms, _static, _ubo) {
+          return new UniformGroup(uniforms, _static, _ubo);
+      };
+      /**
+       * A short hand function for creating a static UBO UniformGroup.
+       * @param uniforms - the ubo item
+       * @param _static - should this be updated each time it is used? defaults to true here!
+       */
+      UniformGroup.uboFrom = function (uniforms, _static) {
+          return new UniformGroup(uniforms, _static !== null && _static !== void 0 ? _static : true, true);
+      };
+      return UniformGroup;
+  }());
 
-var _Shader2 = require('../../core/Shader');
+  /**
+   * System plugin to the renderer to manage filter states.
+   * @ignore
+   */
+  var FilterState = /** @class */ (function () {
+      function FilterState() {
+          this.renderTexture = null;
+          this.target = null;
+          this.legacy = false;
+          this.resolution = 1;
+          this.multisample = exports.MSAA_QUALITY.NONE;
+          // next three fields are created only for root
+          // re-assigned for everything else
+          this.sourceFrame = new Rectangle();
+          this.destinationFrame = new Rectangle();
+          this.bindingSourceFrame = new Rectangle();
+          this.bindingDestinationFrame = new Rectangle();
+          this.filters = [];
+          this.transform = null;
+      }
+      /** Clears the state */
+      FilterState.prototype.clear = function () {
+          this.target = null;
+          this.filters = null;
+          this.renderTexture = null;
+      };
+      return FilterState;
+  }());
+
+  var tempPoints = [new Point(), new Point(), new Point(), new Point()];
+  var tempMatrix$2 = new Matrix();
+  /**
+   * System plugin to the renderer to manage filters.
+   *
+   * ## Pipeline
+   *
+   * The FilterSystem executes the filtering pipeline by rendering the display-object into a texture, applying its
+   * [filters]{@link PIXI.Filter} in series, and the last filter outputs into the final render-target.
+   *
+   * The filter-frame is the rectangle in world space being filtered, and those contents are mapped into
+   * `(0, 0, filterFrame.width, filterFrame.height)` into the filter render-texture. The filter-frame is also called
+   * the source-frame, as it is used to bind the filter render-textures. The last filter outputs to the `filterFrame`
+   * in the final render-target.
+   *
+   * ## Usage
+   *
+   * {@link PIXI.Container#renderAdvanced} is an example of how to use the filter system. It is a 3 step process:
+   *
+   * **push**: Use {@link PIXI.FilterSystem#push} to push the set of filters to be applied on a filter-target.
+   * **render**: Render the contents to be filtered using the renderer. The filter-system will only capture the contents
+   *      inside the bounds of the filter-target. NOTE: Using {@link PIXI.Renderer#render} is
+   *      illegal during an existing render cycle, and it may reset the filter system.
+   * **pop**: Use {@link PIXI.FilterSystem#pop} to pop & execute the filters you initially pushed. It will apply them
+   *      serially and output to the bounds of the filter-target.
+   * @memberof PIXI
+   */
+  var FilterSystem = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this System works for.
+       */
+      function FilterSystem(renderer) {
+          this.renderer = renderer;
+          this.defaultFilterStack = [{}];
+          this.texturePool = new RenderTexturePool();
+          this.texturePool.setScreenSize(renderer.view);
+          this.statePool = [];
+          this.quad = new Quad();
+          this.quadUv = new QuadUv();
+          this.tempRect = new Rectangle();
+          this.activeState = {};
+          this.globalUniforms = new UniformGroup({
+              outputFrame: new Rectangle(),
+              inputSize: new Float32Array(4),
+              inputPixel: new Float32Array(4),
+              inputClamp: new Float32Array(4),
+              resolution: 1,
+              // legacy variables
+              filterArea: new Float32Array(4),
+              filterClamp: new Float32Array(4),
+          }, true);
+          this.forceClear = false;
+          this.useMaxPadding = false;
+      }
+      /**
+       * Pushes a set of filters to be applied later to the system. This will redirect further rendering into an
+       * input render-texture for the rest of the filtering pipeline.
+       * @param {PIXI.DisplayObject} target - The target of the filter to render.
+       * @param filters - The filters to apply.
+       */
+      FilterSystem.prototype.push = function (target, filters) {
+          var _a, _b;
+          var renderer = this.renderer;
+          var filterStack = this.defaultFilterStack;
+          var state = this.statePool.pop() || new FilterState();
+          var renderTextureSystem = this.renderer.renderTexture;
+          var resolution = filters[0].resolution;
+          var multisample = filters[0].multisample;
+          var padding = filters[0].padding;
+          var autoFit = filters[0].autoFit;
+          // We don't know whether it's a legacy filter until it was bound for the first time,
+          // therefore we have to assume that it is if legacy is undefined.
+          var legacy = (_a = filters[0].legacy) !== null && _a !== void 0 ? _a : true;
+          for (var i = 1; i < filters.length; i++) {
+              var filter = filters[i];
+              // let's use the lowest resolution
+              resolution = Math.min(resolution, filter.resolution);
+              // let's use the lowest number of samples
+              multisample = Math.min(multisample, filter.multisample);
+              // figure out the padding required for filters
+              padding = this.useMaxPadding
+                  // old behavior: use largest amount of padding!
+                  ? Math.max(padding, filter.padding)
+                  // new behavior: sum the padding
+                  : padding + filter.padding;
+              // only auto fit if all filters are autofit
+              autoFit = autoFit && filter.autoFit;
+              legacy = legacy || ((_b = filter.legacy) !== null && _b !== void 0 ? _b : true);
+          }
+          if (filterStack.length === 1) {
+              this.defaultFilterStack[0].renderTexture = renderTextureSystem.current;
+          }
+          filterStack.push(state);
+          state.resolution = resolution;
+          state.multisample = multisample;
+          state.legacy = legacy;
+          state.target = target;
+          state.sourceFrame.copyFrom(target.filterArea || target.getBounds(true));
+          state.sourceFrame.pad(padding);
+          var sourceFrameProjected = this.tempRect.copyFrom(renderTextureSystem.sourceFrame);
+          // Project source frame into world space (if projection is applied)
+          if (renderer.projection.transform) {
+              this.transformAABB(tempMatrix$2.copyFrom(renderer.projection.transform).invert(), sourceFrameProjected);
+          }
+          if (autoFit) {
+              state.sourceFrame.fit(sourceFrameProjected);
+              if (state.sourceFrame.width <= 0 || state.sourceFrame.height <= 0) {
+                  state.sourceFrame.width = 0;
+                  state.sourceFrame.height = 0;
+              }
+          }
+          else if (!state.sourceFrame.intersects(sourceFrameProjected)) {
+              state.sourceFrame.width = 0;
+              state.sourceFrame.height = 0;
+          }
+          // Round sourceFrame in screen space based on render-texture.
+          this.roundFrame(state.sourceFrame, renderTextureSystem.current ? renderTextureSystem.current.resolution : renderer.resolution, renderTextureSystem.sourceFrame, renderTextureSystem.destinationFrame, renderer.projection.transform);
+          state.renderTexture = this.getOptimalFilterTexture(state.sourceFrame.width, state.sourceFrame.height, resolution, multisample);
+          state.filters = filters;
+          state.destinationFrame.width = state.renderTexture.width;
+          state.destinationFrame.height = state.renderTexture.height;
+          var destinationFrame = this.tempRect;
+          destinationFrame.x = 0;
+          destinationFrame.y = 0;
+          destinationFrame.width = state.sourceFrame.width;
+          destinationFrame.height = state.sourceFrame.height;
+          state.renderTexture.filterFrame = state.sourceFrame;
+          state.bindingSourceFrame.copyFrom(renderTextureSystem.sourceFrame);
+          state.bindingDestinationFrame.copyFrom(renderTextureSystem.destinationFrame);
+          state.transform = renderer.projection.transform;
+          renderer.projection.transform = null;
+          renderTextureSystem.bind(state.renderTexture, state.sourceFrame, destinationFrame);
+          renderer.framebuffer.clear(0, 0, 0, 0);
+      };
+      /** Pops off the filter and applies it. */
+      FilterSystem.prototype.pop = function () {
+          var filterStack = this.defaultFilterStack;
+          var state = filterStack.pop();
+          var filters = state.filters;
+          this.activeState = state;
+          var globalUniforms = this.globalUniforms.uniforms;
+          globalUniforms.outputFrame = state.sourceFrame;
+          globalUniforms.resolution = state.resolution;
+          var inputSize = globalUniforms.inputSize;
+          var inputPixel = globalUniforms.inputPixel;
+          var inputClamp = globalUniforms.inputClamp;
+          inputSize[0] = state.destinationFrame.width;
+          inputSize[1] = state.destinationFrame.height;
+          inputSize[2] = 1.0 / inputSize[0];
+          inputSize[3] = 1.0 / inputSize[1];
+          inputPixel[0] = Math.round(inputSize[0] * state.resolution);
+          inputPixel[1] = Math.round(inputSize[1] * state.resolution);
+          inputPixel[2] = 1.0 / inputPixel[0];
+          inputPixel[3] = 1.0 / inputPixel[1];
+          inputClamp[0] = 0.5 * inputPixel[2];
+          inputClamp[1] = 0.5 * inputPixel[3];
+          inputClamp[2] = (state.sourceFrame.width * inputSize[2]) - (0.5 * inputPixel[2]);
+          inputClamp[3] = (state.sourceFrame.height * inputSize[3]) - (0.5 * inputPixel[3]);
+          // only update the rect if its legacy..
+          if (state.legacy) {
+              var filterArea = globalUniforms.filterArea;
+              filterArea[0] = state.destinationFrame.width;
+              filterArea[1] = state.destinationFrame.height;
+              filterArea[2] = state.sourceFrame.x;
+              filterArea[3] = state.sourceFrame.y;
+              globalUniforms.filterClamp = globalUniforms.inputClamp;
+          }
+          this.globalUniforms.update();
+          var lastState = filterStack[filterStack.length - 1];
+          this.renderer.framebuffer.blit();
+          if (filters.length === 1) {
+              filters[0].apply(this, state.renderTexture, lastState.renderTexture, exports.CLEAR_MODES.BLEND, state);
+              this.returnFilterTexture(state.renderTexture);
+          }
+          else {
+              var flip = state.renderTexture;
+              var flop = this.getOptimalFilterTexture(flip.width, flip.height, state.resolution);
+              flop.filterFrame = flip.filterFrame;
+              var i = 0;
+              for (i = 0; i < filters.length - 1; ++i) {
+                  if (i === 1 && state.multisample > 1) {
+                      flop = this.getOptimalFilterTexture(flip.width, flip.height, state.resolution);
+                      flop.filterFrame = flip.filterFrame;
+                  }
+                  filters[i].apply(this, flip, flop, exports.CLEAR_MODES.CLEAR, state);
+                  var t = flip;
+                  flip = flop;
+                  flop = t;
+              }
+              filters[i].apply(this, flip, lastState.renderTexture, exports.CLEAR_MODES.BLEND, state);
+              if (i > 1 && state.multisample > 1) {
+                  this.returnFilterTexture(state.renderTexture);
+              }
+              this.returnFilterTexture(flip);
+              this.returnFilterTexture(flop);
+          }
+          // lastState.renderTexture is blitted when lastState is popped
+          state.clear();
+          this.statePool.push(state);
+      };
+      /**
+       * Binds a renderTexture with corresponding `filterFrame`, clears it if mode corresponds.
+       * @param filterTexture - renderTexture to bind, should belong to filter pool or filter stack
+       * @param clearMode - clearMode, by default its CLEAR/YES. See {@link PIXI.CLEAR_MODES}
+       */
+      FilterSystem.prototype.bindAndClear = function (filterTexture, clearMode) {
+          if (clearMode === void 0) { clearMode = exports.CLEAR_MODES.CLEAR; }
+          var _a = this.renderer, renderTextureSystem = _a.renderTexture, stateSystem = _a.state;
+          if (filterTexture === this.defaultFilterStack[this.defaultFilterStack.length - 1].renderTexture) {
+              // Restore projection transform if rendering into the output render-target.
+              this.renderer.projection.transform = this.activeState.transform;
+          }
+          else {
+              // Prevent projection within filtering pipeline.
+              this.renderer.projection.transform = null;
+          }
+          if (filterTexture && filterTexture.filterFrame) {
+              var destinationFrame = this.tempRect;
+              destinationFrame.x = 0;
+              destinationFrame.y = 0;
+              destinationFrame.width = filterTexture.filterFrame.width;
+              destinationFrame.height = filterTexture.filterFrame.height;
+              renderTextureSystem.bind(filterTexture, filterTexture.filterFrame, destinationFrame);
+          }
+          else if (filterTexture !== this.defaultFilterStack[this.defaultFilterStack.length - 1].renderTexture) {
+              renderTextureSystem.bind(filterTexture);
+          }
+          else {
+              // Restore binding for output render-target.
+              this.renderer.renderTexture.bind(filterTexture, this.activeState.bindingSourceFrame, this.activeState.bindingDestinationFrame);
+          }
+          // Clear the texture in BLIT mode if blending is disabled or the forceClear flag is set. The blending
+          // is stored in the 0th bit of the state.
+          var autoClear = (stateSystem.stateId & 1) || this.forceClear;
+          if (clearMode === exports.CLEAR_MODES.CLEAR
+              || (clearMode === exports.CLEAR_MODES.BLIT && autoClear)) {
+              // Use framebuffer.clear because we want to clear the whole filter texture, not just the filtering
+              // area over which the shaders are run. This is because filters may sampling outside of it (e.g. blur)
+              // instead of clamping their arithmetic.
+              this.renderer.framebuffer.clear(0, 0, 0, 0);
+          }
+      };
+      /**
+       * Draws a filter using the default rendering process.
+       *
+       * This should be called only by {@link Filter#apply}.
+       * @param filter - The filter to draw.
+       * @param input - The input render target.
+       * @param output - The target to output to.
+       * @param clearMode - Should the output be cleared before rendering to it
+       */
+      FilterSystem.prototype.applyFilter = function (filter, input, output, clearMode) {
+          var renderer = this.renderer;
+          // Set state before binding, so bindAndClear gets the blend mode.
+          renderer.state.set(filter.state);
+          this.bindAndClear(output, clearMode);
+          // set the uniforms..
+          filter.uniforms.uSampler = input;
+          filter.uniforms.filterGlobals = this.globalUniforms;
+          // TODO make it so that the order of this does not matter..
+          // because it does at the moment cos of global uniforms.
+          // they need to get resynced
+          renderer.shader.bind(filter);
+          // check to see if the filter is a legacy one..
+          filter.legacy = !!filter.program.attributeData.aTextureCoord;
+          if (filter.legacy) {
+              this.quadUv.map(input._frame, input.filterFrame);
+              renderer.geometry.bind(this.quadUv);
+              renderer.geometry.draw(exports.DRAW_MODES.TRIANGLES);
+          }
+          else {
+              renderer.geometry.bind(this.quad);
+              renderer.geometry.draw(exports.DRAW_MODES.TRIANGLE_STRIP);
+          }
+      };
+      /**
+       * Multiply _input normalized coordinates_ to this matrix to get _sprite texture normalized coordinates_.
+       *
+       * Use `outputMatrix * vTextureCoord` in the shader.
+       * @param outputMatrix - The matrix to output to.
+       * @param {PIXI.Sprite} sprite - The sprite to map to.
+       * @returns The mapped matrix.
+       */
+      FilterSystem.prototype.calculateSpriteMatrix = function (outputMatrix, sprite) {
+          var _a = this.activeState, sourceFrame = _a.sourceFrame, destinationFrame = _a.destinationFrame;
+          var orig = sprite._texture.orig;
+          var mappedMatrix = outputMatrix.set(destinationFrame.width, 0, 0, destinationFrame.height, sourceFrame.x, sourceFrame.y);
+          var worldTransform = sprite.worldTransform.copyTo(Matrix.TEMP_MATRIX);
+          worldTransform.invert();
+          mappedMatrix.prepend(worldTransform);
+          mappedMatrix.scale(1.0 / orig.width, 1.0 / orig.height);
+          mappedMatrix.translate(sprite.anchor.x, sprite.anchor.y);
+          return mappedMatrix;
+      };
+      /** Destroys this Filter System. */
+      FilterSystem.prototype.destroy = function () {
+          this.renderer = null;
+          // Those textures has to be destroyed by RenderTextureSystem or FramebufferSystem
+          this.texturePool.clear(false);
+      };
+      /**
+       * Gets a Power-of-Two render texture or fullScreen texture
+       * @param minWidth - The minimum width of the render texture in real pixels.
+       * @param minHeight - The minimum height of the render texture in real pixels.
+       * @param resolution - The resolution of the render texture.
+       * @param multisample - Number of samples of the render texture.
+       * @returns - The new render texture.
+       */
+      FilterSystem.prototype.getOptimalFilterTexture = function (minWidth, minHeight, resolution, multisample) {
+          if (resolution === void 0) { resolution = 1; }
+          if (multisample === void 0) { multisample = exports.MSAA_QUALITY.NONE; }
+          return this.texturePool.getOptimalTexture(minWidth, minHeight, resolution, multisample);
+      };
+      /**
+       * Gets extra render texture to use inside current filter
+       * To be compliant with older filters, you can use params in any order
+       * @param input - renderTexture from which size and resolution will be copied
+       * @param resolution - override resolution of the renderTexture
+       * @param multisample - number of samples of the renderTexture
+       */
+      FilterSystem.prototype.getFilterTexture = function (input, resolution, multisample) {
+          if (typeof input === 'number') {
+              var swap = input;
+              input = resolution;
+              resolution = swap;
+          }
+          input = input || this.activeState.renderTexture;
+          var filterTexture = this.texturePool.getOptimalTexture(input.width, input.height, resolution || input.resolution, multisample || exports.MSAA_QUALITY.NONE);
+          filterTexture.filterFrame = input.filterFrame;
+          return filterTexture;
+      };
+      /**
+       * Frees a render texture back into the pool.
+       * @param renderTexture - The renderTarget to free
+       */
+      FilterSystem.prototype.returnFilterTexture = function (renderTexture) {
+          this.texturePool.returnTexture(renderTexture);
+      };
+      /** Empties the texture pool. */
+      FilterSystem.prototype.emptyPool = function () {
+          this.texturePool.clear(true);
+      };
+      /** Calls `texturePool.resize()`, affects fullScreen renderTextures. */
+      FilterSystem.prototype.resize = function () {
+          this.texturePool.setScreenSize(this.renderer.view);
+      };
+      /**
+       * @param matrix - first param
+       * @param rect - second param
+       */
+      FilterSystem.prototype.transformAABB = function (matrix, rect) {
+          var lt = tempPoints[0];
+          var lb = tempPoints[1];
+          var rt = tempPoints[2];
+          var rb = tempPoints[3];
+          lt.set(rect.left, rect.top);
+          lb.set(rect.left, rect.bottom);
+          rt.set(rect.right, rect.top);
+          rb.set(rect.right, rect.bottom);
+          matrix.apply(lt, lt);
+          matrix.apply(lb, lb);
+          matrix.apply(rt, rt);
+          matrix.apply(rb, rb);
+          var x0 = Math.min(lt.x, lb.x, rt.x, rb.x);
+          var y0 = Math.min(lt.y, lb.y, rt.y, rb.y);
+          var x1 = Math.max(lt.x, lb.x, rt.x, rb.x);
+          var y1 = Math.max(lt.y, lb.y, rt.y, rb.y);
+          rect.x = x0;
+          rect.y = y0;
+          rect.width = x1 - x0;
+          rect.height = y1 - y0;
+      };
+      FilterSystem.prototype.roundFrame = function (frame, resolution, bindingSourceFrame, bindingDestinationFrame, transform) {
+          if (frame.width <= 0 || frame.height <= 0 || bindingSourceFrame.width <= 0 || bindingSourceFrame.height <= 0) {
+              return;
+          }
+          if (transform) {
+              var a = transform.a, b = transform.b, c = transform.c, d = transform.d;
+              // Skip if skew/rotation present in matrix, except for multiple of 90° rotation. If rotation
+              // is a multiple of 90°, then either pair of (b,c) or (a,d) will be (0,0).
+              if ((Math.abs(b) > 1e-4 || Math.abs(c) > 1e-4)
+                  && (Math.abs(a) > 1e-4 || Math.abs(d) > 1e-4)) {
+                  return;
+              }
+          }
+          transform = transform ? tempMatrix$2.copyFrom(transform) : tempMatrix$2.identity();
+          // Get forward transform from world space to screen space
+          transform
+              .translate(-bindingSourceFrame.x, -bindingSourceFrame.y)
+              .scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height)
+              .translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
+          // Convert frame to screen space
+          this.transformAABB(transform, frame);
+          // Round frame in screen space
+          frame.ceil(resolution);
+          // Project back into world space.
+          this.transformAABB(transform.invert(), frame);
+      };
+      return FilterSystem;
+  }());
 
-var _Shader3 = _interopRequireDefault(_Shader2);
+  /**
+   * Base for a common object renderer that can be used as a
+   * system renderer plugin.
+   * @memberof PIXI
+   */
+  var ObjectRenderer = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this manager works for.
+       */
+      function ObjectRenderer(renderer) {
+          this.renderer = renderer;
+      }
+      /** Stub method that should be used to empty the current batch by rendering objects now. */
+      ObjectRenderer.prototype.flush = function () {
+          // flush!
+      };
+      /** Generic destruction method that frees all resources. This should be called by subclasses. */
+      ObjectRenderer.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      /**
+       * Stub method that initializes any state required before
+       * rendering starts. It is different from the `prerender`
+       * signal, which occurs every frame, in that it is called
+       * whenever an object requests _this_ renderer specifically.
+       */
+      ObjectRenderer.prototype.start = function () {
+          // set the shader..
+      };
+      /** Stops the renderer. It should free up any state and become dormant. */
+      ObjectRenderer.prototype.stop = function () {
+          this.flush();
+      };
+      /**
+       * Keeps the object to render. It doesn't have to be
+       * rendered immediately.
+       * @param {PIXI.DisplayObject} _object - The object to render.
+       */
+      ObjectRenderer.prototype.render = function (_object) {
+          // render the object
+      };
+      return ObjectRenderer;
+  }());
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  /**
+   * System plugin to the renderer to manage batching.
+   * @memberof PIXI
+   */
+  var BatchSystem = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this System works for.
+       */
+      function BatchSystem(renderer) {
+          this.renderer = renderer;
+          this.emptyRenderer = new ObjectRenderer(renderer);
+          this.currentRenderer = this.emptyRenderer;
+      }
+      /**
+       * Changes the current renderer to the one given in parameter
+       * @param objectRenderer - The object renderer to use.
+       */
+      BatchSystem.prototype.setObjectRenderer = function (objectRenderer) {
+          if (this.currentRenderer === objectRenderer) {
+              return;
+          }
+          this.currentRenderer.stop();
+          this.currentRenderer = objectRenderer;
+          this.currentRenderer.start();
+      };
+      /**
+       * This should be called if you wish to do some custom rendering
+       * It will basically render anything that may be batched up such as sprites
+       */
+      BatchSystem.prototype.flush = function () {
+          this.setObjectRenderer(this.emptyRenderer);
+      };
+      /** Reset the system to an empty renderer */
+      BatchSystem.prototype.reset = function () {
+          this.setObjectRenderer(this.emptyRenderer);
+      };
+      /**
+       * Handy function for batch renderers: copies bound textures in first maxTextures locations to array
+       * sets actual _batchLocation for them
+       * @param arr - arr copy destination
+       * @param maxTextures - number of copied elements
+       */
+      BatchSystem.prototype.copyBoundTextures = function (arr, maxTextures) {
+          var boundTextures = this.renderer.texture.boundTextures;
+          for (var i = maxTextures - 1; i >= 0; --i) {
+              arr[i] = boundTextures[i] || null;
+              if (arr[i]) {
+                  arr[i]._batchLocation = i;
+              }
+          }
+      };
+      /**
+       * Assigns batch locations to textures in array based on boundTextures state.
+       * All textures in texArray should have `_batchEnabled = _batchId`,
+       * and their count should be less than `maxTextures`.
+       * @param texArray - textures to bound
+       * @param boundTextures - current state of bound textures
+       * @param batchId - marker for _batchEnabled param of textures in texArray
+       * @param maxTextures - number of texture locations to manipulate
+       */
+      BatchSystem.prototype.boundArray = function (texArray, boundTextures, batchId, maxTextures) {
+          var elements = texArray.elements, ids = texArray.ids, count = texArray.count;
+          var j = 0;
+          for (var i = 0; i < count; i++) {
+              var tex = elements[i];
+              var loc = tex._batchLocation;
+              if (loc >= 0 && loc < maxTextures
+                  && boundTextures[loc] === tex) {
+                  ids[i] = loc;
+                  continue;
+              }
+              while (j < maxTextures) {
+                  var bound = boundTextures[j];
+                  if (bound && bound._batchEnabled === batchId
+                      && bound._batchLocation === j) {
+                      j++;
+                      continue;
+                  }
+                  ids[i] = j;
+                  tex._batchLocation = j;
+                  boundTextures[j] = tex;
+                  break;
+              }
+          }
+      };
+      /**
+       * @ignore
+       */
+      BatchSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return BatchSystem;
+  }());
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  var CONTEXT_UID_COUNTER = 0;
+  /**
+   * System plugin to the renderer to manage the context.
+   * @memberof PIXI
+   */
+  var ContextSystem = /** @class */ (function () {
+      /** @param renderer - The renderer this System works for. */
+      function ContextSystem(renderer) {
+          this.renderer = renderer;
+          this.webGLVersion = 1;
+          this.extensions = {};
+          this.supports = {
+              uint32Indices: false,
+          };
+          // Bind functions
+          this.handleContextLost = this.handleContextLost.bind(this);
+          this.handleContextRestored = this.handleContextRestored.bind(this);
+          renderer.view.addEventListener('webglcontextlost', this.handleContextLost, false);
+          renderer.view.addEventListener('webglcontextrestored', this.handleContextRestored, false);
+      }
+      Object.defineProperty(ContextSystem.prototype, "isLost", {
+          /**
+           * `true` if the context is lost
+           * @readonly
+           */
+          get: function () {
+              return (!this.gl || this.gl.isContextLost());
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Handles the context change event.
+       * @param {WebGLRenderingContext} gl - New WebGL context.
+       */
+      ContextSystem.prototype.contextChange = function (gl) {
+          this.gl = gl;
+          this.renderer.gl = gl;
+          this.renderer.CONTEXT_UID = CONTEXT_UID_COUNTER++;
+      };
+      /**
+       * Initializes the context.
+       * @protected
+       * @param {WebGLRenderingContext} gl - WebGL context
+       */
+      ContextSystem.prototype.initFromContext = function (gl) {
+          this.gl = gl;
+          this.validateContext(gl);
+          this.renderer.gl = gl;
+          this.renderer.CONTEXT_UID = CONTEXT_UID_COUNTER++;
+          this.renderer.runners.contextChange.emit(gl);
+      };
+      /**
+       * Initialize from context options
+       * @protected
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/getContext
+       * @param {object} options - context attributes
+       */
+      ContextSystem.prototype.initFromOptions = function (options) {
+          var gl = this.createContext(this.renderer.view, options);
+          this.initFromContext(gl);
+      };
+      /**
+       * Helper class to create a WebGL Context
+       * @param canvas - the canvas element that we will get the context from
+       * @param options - An options object that gets passed in to the canvas element containing the
+       *    context attributes
+       * @see https://developer.mozilla.org/en/docs/Web/API/HTMLCanvasElement/getContext
+       * @returns {WebGLRenderingContext} the WebGL context
+       */
+      ContextSystem.prototype.createContext = function (canvas, options) {
+          var gl;
+          if (settings.PREFER_ENV >= exports.ENV.WEBGL2) {
+              gl = canvas.getContext('webgl2', options);
+          }
+          if (gl) {
+              this.webGLVersion = 2;
+          }
+          else {
+              this.webGLVersion = 1;
+              gl = canvas.getContext('webgl', options) || canvas.getContext('experimental-webgl', options);
+              if (!gl) {
+                  // fail, not able to get a context
+                  throw new Error('This browser does not support WebGL. Try using the canvas renderer');
+              }
+          }
+          this.gl = gl;
+          this.getExtensions();
+          return this.gl;
+      };
+      /** Auto-populate the {@link PIXI.ContextSystem.extensions extensions}. */
+      ContextSystem.prototype.getExtensions = function () {
+          // time to set up default extensions that Pixi uses.
+          var gl = this.gl;
+          var common = {
+              loseContext: gl.getExtension('WEBGL_lose_context'),
+              anisotropicFiltering: gl.getExtension('EXT_texture_filter_anisotropic'),
+              floatTextureLinear: gl.getExtension('OES_texture_float_linear'),
+              s3tc: gl.getExtension('WEBGL_compressed_texture_s3tc'),
+              s3tc_sRGB: gl.getExtension('WEBGL_compressed_texture_s3tc_srgb'),
+              etc: gl.getExtension('WEBGL_compressed_texture_etc'),
+              etc1: gl.getExtension('WEBGL_compressed_texture_etc1'),
+              pvrtc: gl.getExtension('WEBGL_compressed_texture_pvrtc')
+                  || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+              atc: gl.getExtension('WEBGL_compressed_texture_atc'),
+              astc: gl.getExtension('WEBGL_compressed_texture_astc')
+          };
+          if (this.webGLVersion === 1) {
+              Object.assign(this.extensions, common, {
+                  drawBuffers: gl.getExtension('WEBGL_draw_buffers'),
+                  depthTexture: gl.getExtension('WEBGL_depth_texture'),
+                  vertexArrayObject: gl.getExtension('OES_vertex_array_object')
+                      || gl.getExtension('MOZ_OES_vertex_array_object')
+                      || gl.getExtension('WEBKIT_OES_vertex_array_object'),
+                  uint32ElementIndex: gl.getExtension('OES_element_index_uint'),
+                  // Floats and half-floats
+                  floatTexture: gl.getExtension('OES_texture_float'),
+                  floatTextureLinear: gl.getExtension('OES_texture_float_linear'),
+                  textureHalfFloat: gl.getExtension('OES_texture_half_float'),
+                  textureHalfFloatLinear: gl.getExtension('OES_texture_half_float_linear'),
+              });
+          }
+          else if (this.webGLVersion === 2) {
+              Object.assign(this.extensions, common, {
+                  // Floats and half-floats
+                  colorBufferFloat: gl.getExtension('EXT_color_buffer_float')
+              });
+          }
+      };
+      /**
+       * Handles a lost webgl context
+       * @param {WebGLContextEvent} event - The context lost event.
+       */
+      ContextSystem.prototype.handleContextLost = function (event) {
+          var _this = this;
+          // Prevent default to be able to restore the context
+          event.preventDefault();
+          // Restore the context after this event has exited
+          setTimeout(function () {
+              if (_this.gl.isContextLost() && _this.extensions.loseContext) {
+                  _this.extensions.loseContext.restoreContext();
+              }
+          }, 0);
+      };
+      /** Handles a restored webgl context. */
+      ContextSystem.prototype.handleContextRestored = function () {
+          this.renderer.runners.contextChange.emit(this.gl);
+      };
+      ContextSystem.prototype.destroy = function () {
+          var view = this.renderer.view;
+          this.renderer = null;
+          // remove listeners
+          view.removeEventListener('webglcontextlost', this.handleContextLost);
+          view.removeEventListener('webglcontextrestored', this.handleContextRestored);
+          this.gl.useProgram(null);
+          if (this.extensions.loseContext) {
+              this.extensions.loseContext.loseContext();
+          }
+      };
+      /** Handle the post-render runner event. */
+      ContextSystem.prototype.postrender = function () {
+          if (this.renderer.renderingToScreen) {
+              this.gl.flush();
+          }
+      };
+      /**
+       * Validate context.
+       * @param {WebGLRenderingContext} gl - Render context.
+       */
+      ContextSystem.prototype.validateContext = function (gl) {
+          var attributes = gl.getContextAttributes();
+          var isWebGl2 = 'WebGL2RenderingContext' in globalThis && gl instanceof globalThis.WebGL2RenderingContext;
+          if (isWebGl2) {
+              this.webGLVersion = 2;
+          }
+          // this is going to be fairly simple for now.. but at least we have room to grow!
+          if (attributes && !attributes.stencil) {
+              /* eslint-disable max-len, no-console */
+              console.warn('Provided WebGL context does not have a stencil buffer, masks may not render correctly');
+              /* eslint-enable max-len, no-console */
+          }
+          var hasuint32 = isWebGl2 || !!gl.getExtension('OES_element_index_uint');
+          this.supports.uint32Indices = hasuint32;
+          if (!hasuint32) {
+              /* eslint-disable max-len, no-console */
+              console.warn('Provided WebGL context does not support 32 index buffer, complex graphics may not render correctly');
+              /* eslint-enable max-len, no-console */
+          }
+      };
+      return ContextSystem;
+  }());
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+  /**
+   * Internal framebuffer for WebGL context.
+   * @memberof PIXI
+   */
+  var GLFramebuffer = /** @class */ (function () {
+      function GLFramebuffer(framebuffer) {
+          this.framebuffer = framebuffer;
+          this.stencil = null;
+          this.dirtyId = -1;
+          this.dirtyFormat = -1;
+          this.dirtySize = -1;
+          this.multisample = exports.MSAA_QUALITY.NONE;
+          this.msaaBuffer = null;
+          this.blitFramebuffer = null;
+          this.mipLevel = 0;
+      }
+      return GLFramebuffer;
+  }());
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  var tempRectangle = new Rectangle();
+  /**
+   * System plugin to the renderer to manage framebuffers.
+   * @memberof PIXI
+   */
+  var FramebufferSystem = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this System works for.
+       */
+      function FramebufferSystem(renderer) {
+          this.renderer = renderer;
+          this.managedFramebuffers = [];
+          this.unknownFramebuffer = new Framebuffer(10, 10);
+          this.msaaSamples = null;
+      }
+      /** Sets up the renderer context and necessary buffers. */
+      FramebufferSystem.prototype.contextChange = function () {
+          this.disposeAll(true);
+          var gl = this.gl = this.renderer.gl;
+          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+          this.current = this.unknownFramebuffer;
+          this.viewport = new Rectangle();
+          this.hasMRT = true;
+          this.writeDepthTexture = true;
+          // webgl2
+          if (this.renderer.context.webGLVersion === 1) {
+              // webgl 1!
+              var nativeDrawBuffersExtension_1 = this.renderer.context.extensions.drawBuffers;
+              var nativeDepthTextureExtension = this.renderer.context.extensions.depthTexture;
+              if (settings.PREFER_ENV === exports.ENV.WEBGL_LEGACY) {
+                  nativeDrawBuffersExtension_1 = null;
+                  nativeDepthTextureExtension = null;
+              }
+              if (nativeDrawBuffersExtension_1) {
+                  gl.drawBuffers = function (activeTextures) {
+                      return nativeDrawBuffersExtension_1.drawBuffersWEBGL(activeTextures);
+                  };
+              }
+              else {
+                  this.hasMRT = false;
+                  gl.drawBuffers = function () {
+                      // empty
+                  };
+              }
+              if (!nativeDepthTextureExtension) {
+                  this.writeDepthTexture = false;
+              }
+          }
+          else {
+              // WebGL2
+              // cache possible MSAA samples
+              this.msaaSamples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA8, gl.SAMPLES);
+          }
+      };
+      /**
+       * Bind a framebuffer.
+       * @param framebuffer
+       * @param frame - frame, default is framebuffer size
+       * @param mipLevel - optional mip level to set on the framebuffer - defaults to 0
+       */
+      FramebufferSystem.prototype.bind = function (framebuffer, frame, mipLevel) {
+          if (mipLevel === void 0) { mipLevel = 0; }
+          var gl = this.gl;
+          if (framebuffer) {
+              // TODO caching layer!
+              var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID] || this.initFramebuffer(framebuffer);
+              if (this.current !== framebuffer) {
+                  this.current = framebuffer;
+                  gl.bindFramebuffer(gl.FRAMEBUFFER, fbo.framebuffer);
+              }
+              // make sure all textures are unbound..
+              if (fbo.mipLevel !== mipLevel) {
+                  framebuffer.dirtyId++;
+                  framebuffer.dirtyFormat++;
+                  fbo.mipLevel = mipLevel;
+              }
+              // now check for updates...
+              if (fbo.dirtyId !== framebuffer.dirtyId) {
+                  fbo.dirtyId = framebuffer.dirtyId;
+                  if (fbo.dirtyFormat !== framebuffer.dirtyFormat) {
+                      fbo.dirtyFormat = framebuffer.dirtyFormat;
+                      fbo.dirtySize = framebuffer.dirtySize;
+                      this.updateFramebuffer(framebuffer, mipLevel);
+                  }
+                  else if (fbo.dirtySize !== framebuffer.dirtySize) {
+                      fbo.dirtySize = framebuffer.dirtySize;
+                      this.resizeFramebuffer(framebuffer);
+                  }
+              }
+              for (var i = 0; i < framebuffer.colorTextures.length; i++) {
+                  var tex = framebuffer.colorTextures[i];
+                  this.renderer.texture.unbind(tex.parentTextureArray || tex);
+              }
+              if (framebuffer.depthTexture) {
+                  this.renderer.texture.unbind(framebuffer.depthTexture);
+              }
+              if (frame) {
+                  var mipWidth = (frame.width >> mipLevel);
+                  var mipHeight = (frame.height >> mipLevel);
+                  var scale = mipWidth / frame.width;
+                  this.setViewport(frame.x * scale, frame.y * scale, mipWidth, mipHeight);
+              }
+              else {
+                  var mipWidth = (framebuffer.width >> mipLevel);
+                  var mipHeight = (framebuffer.height >> mipLevel);
+                  this.setViewport(0, 0, mipWidth, mipHeight);
+              }
+          }
+          else {
+              if (this.current) {
+                  this.current = null;
+                  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+              }
+              if (frame) {
+                  this.setViewport(frame.x, frame.y, frame.width, frame.height);
+              }
+              else {
+                  this.setViewport(0, 0, this.renderer.width, this.renderer.height);
+              }
+          }
+      };
+      /**
+       * Set the WebGLRenderingContext's viewport.
+       * @param x - X position of viewport
+       * @param y - Y position of viewport
+       * @param width - Width of viewport
+       * @param height - Height of viewport
+       */
+      FramebufferSystem.prototype.setViewport = function (x, y, width, height) {
+          var v = this.viewport;
+          x = Math.round(x);
+          y = Math.round(y);
+          width = Math.round(width);
+          height = Math.round(height);
+          if (v.width !== width || v.height !== height || v.x !== x || v.y !== y) {
+              v.x = x;
+              v.y = y;
+              v.width = width;
+              v.height = height;
+              this.gl.viewport(x, y, width, height);
+          }
+      };
+      Object.defineProperty(FramebufferSystem.prototype, "size", {
+          /**
+           * Get the size of the current width and height. Returns object with `width` and `height` values.
+           * @readonly
+           */
+          get: function () {
+              if (this.current) {
+                  // TODO store temp
+                  return { x: 0, y: 0, width: this.current.width, height: this.current.height };
+              }
+              return { x: 0, y: 0, width: this.renderer.width, height: this.renderer.height };
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Clear the color of the context
+       * @param r - Red value from 0 to 1
+       * @param g - Green value from 0 to 1
+       * @param b - Blue value from 0 to 1
+       * @param a - Alpha value from 0 to 1
+       * @param {PIXI.BUFFER_BITS} [mask=BUFFER_BITS.COLOR | BUFFER_BITS.DEPTH] - Bitwise OR of masks
+       *  that indicate the buffers to be cleared, by default COLOR and DEPTH buffers.
+       */
+      FramebufferSystem.prototype.clear = function (r, g, b, a, mask) {
+          if (mask === void 0) { mask = exports.BUFFER_BITS.COLOR | exports.BUFFER_BITS.DEPTH; }
+          var gl = this.gl;
+          // TODO clear color can be set only one right?
+          gl.clearColor(r, g, b, a);
+          gl.clear(mask);
+      };
+      /**
+       * Initialize framebuffer for this context
+       * @protected
+       * @param framebuffer
+       * @returns - created GLFramebuffer
+       */
+      FramebufferSystem.prototype.initFramebuffer = function (framebuffer) {
+          var gl = this.gl;
+          var fbo = new GLFramebuffer(gl.createFramebuffer());
+          fbo.multisample = this.detectSamples(framebuffer.multisample);
+          framebuffer.glFramebuffers[this.CONTEXT_UID] = fbo;
+          this.managedFramebuffers.push(framebuffer);
+          framebuffer.disposeRunner.add(this);
+          return fbo;
+      };
+      /**
+       * Resize the framebuffer
+       * @param framebuffer
+       * @protected
+       */
+      FramebufferSystem.prototype.resizeFramebuffer = function (framebuffer) {
+          var gl = this.gl;
+          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+          if (fbo.msaaBuffer) {
+              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.msaaBuffer);
+              gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.RGBA8, framebuffer.width, framebuffer.height);
+          }
+          if (fbo.stencil) {
+              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.stencil);
+              if (fbo.msaaBuffer) {
+                  gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, framebuffer.width, framebuffer.height);
+              }
+              else {
+                  gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, framebuffer.width, framebuffer.height);
+              }
+          }
+          var colorTextures = framebuffer.colorTextures;
+          var count = colorTextures.length;
+          if (!gl.drawBuffers) {
+              count = Math.min(count, 1);
+          }
+          for (var i = 0; i < count; i++) {
+              var texture = colorTextures[i];
+              var parentTexture = texture.parentTextureArray || texture;
+              this.renderer.texture.bind(parentTexture, 0);
+          }
+          if (framebuffer.depthTexture && this.writeDepthTexture) {
+              this.renderer.texture.bind(framebuffer.depthTexture, 0);
+          }
+      };
+      /**
+       * Update the framebuffer
+       * @param framebuffer
+       * @param mipLevel
+       * @protected
+       */
+      FramebufferSystem.prototype.updateFramebuffer = function (framebuffer, mipLevel) {
+          var gl = this.gl;
+          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+          // bind the color texture
+          var colorTextures = framebuffer.colorTextures;
+          var count = colorTextures.length;
+          if (!gl.drawBuffers) {
+              count = Math.min(count, 1);
+          }
+          if (fbo.multisample > 1 && this.canMultisampleFramebuffer(framebuffer)) {
+              fbo.msaaBuffer = fbo.msaaBuffer || gl.createRenderbuffer();
+              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.msaaBuffer);
+              gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.RGBA8, framebuffer.width, framebuffer.height);
+              gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, fbo.msaaBuffer);
+          }
+          else if (fbo.msaaBuffer) {
+              gl.deleteRenderbuffer(fbo.msaaBuffer);
+              fbo.msaaBuffer = null;
+              if (fbo.blitFramebuffer) {
+                  fbo.blitFramebuffer.dispose();
+                  fbo.blitFramebuffer = null;
+              }
+          }
+          var activeTextures = [];
+          for (var i = 0; i < count; i++) {
+              var texture = colorTextures[i];
+              var parentTexture = texture.parentTextureArray || texture;
+              this.renderer.texture.bind(parentTexture, 0);
+              if (i === 0 && fbo.msaaBuffer) {
+                  continue;
+              }
+              gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, texture.target, parentTexture._glTextures[this.CONTEXT_UID].texture, mipLevel);
+              activeTextures.push(gl.COLOR_ATTACHMENT0 + i);
+          }
+          if (activeTextures.length > 1) {
+              gl.drawBuffers(activeTextures);
+          }
+          if (framebuffer.depthTexture) {
+              var writeDepthTexture = this.writeDepthTexture;
+              if (writeDepthTexture) {
+                  var depthTexture = framebuffer.depthTexture;
+                  this.renderer.texture.bind(depthTexture, 0);
+                  gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, depthTexture._glTextures[this.CONTEXT_UID].texture, mipLevel);
+              }
+          }
+          if ((framebuffer.stencil || framebuffer.depth) && !(framebuffer.depthTexture && this.writeDepthTexture)) {
+              fbo.stencil = fbo.stencil || gl.createRenderbuffer();
+              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.stencil);
+              if (fbo.msaaBuffer) {
+                  gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, framebuffer.width, framebuffer.height);
+              }
+              else {
+                  gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, framebuffer.width, framebuffer.height);
+              }
+              gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, fbo.stencil);
+          }
+          else if (fbo.stencil) {
+              gl.deleteRenderbuffer(fbo.stencil);
+              fbo.stencil = null;
+          }
+      };
+      /**
+       * Returns true if the frame buffer can be multisampled.
+       * @param framebuffer
+       */
+      FramebufferSystem.prototype.canMultisampleFramebuffer = function (framebuffer) {
+          return this.renderer.context.webGLVersion !== 1
+              && framebuffer.colorTextures.length <= 1 && !framebuffer.depthTexture;
+      };
+      /**
+       * Detects number of samples that is not more than a param but as close to it as possible
+       * @param samples - number of samples
+       * @returns - recommended number of samples
+       */
+      FramebufferSystem.prototype.detectSamples = function (samples) {
+          var msaaSamples = this.msaaSamples;
+          var res = exports.MSAA_QUALITY.NONE;
+          if (samples <= 1 || msaaSamples === null) {
+              return res;
+          }
+          for (var i = 0; i < msaaSamples.length; i++) {
+              if (msaaSamples[i] <= samples) {
+                  res = msaaSamples[i];
+                  break;
+              }
+          }
+          if (res === 1) {
+              res = exports.MSAA_QUALITY.NONE;
+          }
+          return res;
+      };
+      /**
+       * Only works with WebGL2
+       *
+       * blits framebuffer to another of the same or bigger size
+       * after that target framebuffer is bound
+       *
+       * Fails with WebGL warning if blits multisample framebuffer to different size
+       * @param framebuffer - by default it blits "into itself", from renderBuffer to texture.
+       * @param sourcePixels - source rectangle in pixels
+       * @param destPixels - dest rectangle in pixels, assumed to be the same as sourcePixels
+       */
+      FramebufferSystem.prototype.blit = function (framebuffer, sourcePixels, destPixels) {
+          var _a = this, current = _a.current, renderer = _a.renderer, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
+          if (renderer.context.webGLVersion !== 2) {
+              return;
+          }
+          if (!current) {
+              return;
+          }
+          var fbo = current.glFramebuffers[CONTEXT_UID];
+          if (!fbo) {
+              return;
+          }
+          if (!framebuffer) {
+              if (!fbo.msaaBuffer) {
+                  return;
+              }
+              var colorTexture = current.colorTextures[0];
+              if (!colorTexture) {
+                  return;
+              }
+              if (!fbo.blitFramebuffer) {
+                  fbo.blitFramebuffer = new Framebuffer(current.width, current.height);
+                  fbo.blitFramebuffer.addColorTexture(0, colorTexture);
+              }
+              framebuffer = fbo.blitFramebuffer;
+              if (framebuffer.colorTextures[0] !== colorTexture) {
+                  framebuffer.colorTextures[0] = colorTexture;
+                  framebuffer.dirtyId++;
+                  framebuffer.dirtyFormat++;
+              }
+              if (framebuffer.width !== current.width || framebuffer.height !== current.height) {
+                  framebuffer.width = current.width;
+                  framebuffer.height = current.height;
+                  framebuffer.dirtyId++;
+                  framebuffer.dirtySize++;
+              }
+          }
+          if (!sourcePixels) {
+              sourcePixels = tempRectangle;
+              sourcePixels.width = current.width;
+              sourcePixels.height = current.height;
+          }
+          if (!destPixels) {
+              destPixels = sourcePixels;
+          }
+          var sameSize = sourcePixels.width === destPixels.width && sourcePixels.height === destPixels.height;
+          this.bind(framebuffer);
+          gl.bindFramebuffer(gl.READ_FRAMEBUFFER, fbo.framebuffer);
+          gl.blitFramebuffer(sourcePixels.left, sourcePixels.top, sourcePixels.right, sourcePixels.bottom, destPixels.left, destPixels.top, destPixels.right, destPixels.bottom, gl.COLOR_BUFFER_BIT, sameSize ? gl.NEAREST : gl.LINEAR);
+      };
+      /**
+       * Disposes framebuffer.
+       * @param framebuffer - framebuffer that has to be disposed of
+       * @param contextLost - If context was lost, we suppress all delete function calls
+       */
+      FramebufferSystem.prototype.disposeFramebuffer = function (framebuffer, contextLost) {
+          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+          var gl = this.gl;
+          if (!fbo) {
+              return;
+          }
+          delete framebuffer.glFramebuffers[this.CONTEXT_UID];
+          var index = this.managedFramebuffers.indexOf(framebuffer);
+          if (index >= 0) {
+              this.managedFramebuffers.splice(index, 1);
+          }
+          framebuffer.disposeRunner.remove(this);
+          if (!contextLost) {
+              gl.deleteFramebuffer(fbo.framebuffer);
+              if (fbo.msaaBuffer) {
+                  gl.deleteRenderbuffer(fbo.msaaBuffer);
+              }
+              if (fbo.stencil) {
+                  gl.deleteRenderbuffer(fbo.stencil);
+              }
+          }
+          if (fbo.blitFramebuffer) {
+              fbo.blitFramebuffer.dispose();
+          }
+      };
+      /**
+       * Disposes all framebuffers, but not textures bound to them.
+       * @param [contextLost=false] - If context was lost, we suppress all delete function calls
+       */
+      FramebufferSystem.prototype.disposeAll = function (contextLost) {
+          var list = this.managedFramebuffers;
+          this.managedFramebuffers = [];
+          for (var i = 0; i < list.length; i++) {
+              this.disposeFramebuffer(list[i], contextLost);
+          }
+      };
+      /**
+       * Forcing creation of stencil buffer for current framebuffer, if it wasn't done before.
+       * Used by MaskSystem, when its time to use stencil mask for Graphics element.
+       *
+       * Its an alternative for public lazy `framebuffer.enableStencil`, in case we need stencil without rebind.
+       * @private
+       */
+      FramebufferSystem.prototype.forceStencil = function () {
+          var framebuffer = this.current;
+          if (!framebuffer) {
+              return;
+          }
+          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+          if (!fbo || fbo.stencil) {
+              return;
+          }
+          framebuffer.stencil = true;
+          var w = framebuffer.width;
+          var h = framebuffer.height;
+          var gl = this.gl;
+          var stencil = gl.createRenderbuffer();
+          gl.bindRenderbuffer(gl.RENDERBUFFER, stencil);
+          if (fbo.msaaBuffer) {
+              gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, w, h);
+          }
+          else {
+              gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, w, h);
+          }
+          fbo.stencil = stencil;
+          gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, stencil);
+      };
+      /** Resets framebuffer stored state, binds screen framebuffer. Should be called before renderTexture reset(). */
+      FramebufferSystem.prototype.reset = function () {
+          this.current = this.unknownFramebuffer;
+          this.viewport = new Rectangle();
+      };
+      FramebufferSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return FramebufferSystem;
+  }());
+
+  var byteSizeMap = { 5126: 4, 5123: 2, 5121: 1 };
+  /**
+   * System plugin to the renderer to manage geometry.
+   * @memberof PIXI
+   */
+  var GeometrySystem = /** @class */ (function () {
+      /** @param renderer - The renderer this System works for. */
+      function GeometrySystem(renderer) {
+          this.renderer = renderer;
+          this._activeGeometry = null;
+          this._activeVao = null;
+          this.hasVao = true;
+          this.hasInstance = true;
+          this.canUseUInt32ElementIndex = false;
+          this.managedGeometries = {};
+      }
+      /** Sets up the renderer context and necessary buffers. */
+      GeometrySystem.prototype.contextChange = function () {
+          this.disposeAll(true);
+          var gl = this.gl = this.renderer.gl;
+          var context = this.renderer.context;
+          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+          // webgl2
+          if (context.webGLVersion !== 2) {
+              // webgl 1!
+              var nativeVaoExtension_1 = this.renderer.context.extensions.vertexArrayObject;
+              if (settings.PREFER_ENV === exports.ENV.WEBGL_LEGACY) {
+                  nativeVaoExtension_1 = null;
+              }
+              if (nativeVaoExtension_1) {
+                  gl.createVertexArray = function () {
+                      return nativeVaoExtension_1.createVertexArrayOES();
+                  };
+                  gl.bindVertexArray = function (vao) {
+                      return nativeVaoExtension_1.bindVertexArrayOES(vao);
+                  };
+                  gl.deleteVertexArray = function (vao) {
+                      return nativeVaoExtension_1.deleteVertexArrayOES(vao);
+                  };
+              }
+              else {
+                  this.hasVao = false;
+                  gl.createVertexArray = function () {
+                      return null;
+                  };
+                  gl.bindVertexArray = function () {
+                      return null;
+                  };
+                  gl.deleteVertexArray = function () {
+                      return null;
+                  };
+              }
+          }
+          if (context.webGLVersion !== 2) {
+              var instanceExt_1 = gl.getExtension('ANGLE_instanced_arrays');
+              if (instanceExt_1) {
+                  gl.vertexAttribDivisor = function (a, b) {
+                      return instanceExt_1.vertexAttribDivisorANGLE(a, b);
+                  };
+                  gl.drawElementsInstanced = function (a, b, c, d, e) {
+                      return instanceExt_1.drawElementsInstancedANGLE(a, b, c, d, e);
+                  };
+                  gl.drawArraysInstanced = function (a, b, c, d) {
+                      return instanceExt_1.drawArraysInstancedANGLE(a, b, c, d);
+                  };
+              }
+              else {
+                  this.hasInstance = false;
+              }
+          }
+          this.canUseUInt32ElementIndex = context.webGLVersion === 2 || !!context.extensions.uint32ElementIndex;
+      };
+      /**
+       * Binds geometry so that is can be drawn. Creating a Vao if required
+       * @param geometry - Instance of geometry to bind.
+       * @param shader - Instance of shader to use vao for.
+       */
+      GeometrySystem.prototype.bind = function (geometry, shader) {
+          shader = shader || this.renderer.shader.shader;
+          var gl = this.gl;
+          // not sure the best way to address this..
+          // currently different shaders require different VAOs for the same geometry
+          // Still mulling over the best way to solve this one..
+          // will likely need to modify the shader attribute locations at run time!
+          var vaos = geometry.glVertexArrayObjects[this.CONTEXT_UID];
+          var incRefCount = false;
+          if (!vaos) {
+              this.managedGeometries[geometry.id] = geometry;
+              geometry.disposeRunner.add(this);
+              geometry.glVertexArrayObjects[this.CONTEXT_UID] = vaos = {};
+              incRefCount = true;
+          }
+          var vao = vaos[shader.program.id] || this.initGeometryVao(geometry, shader, incRefCount);
+          this._activeGeometry = geometry;
+          if (this._activeVao !== vao) {
+              this._activeVao = vao;
+              if (this.hasVao) {
+                  gl.bindVertexArray(vao);
+              }
+              else {
+                  this.activateVao(geometry, shader.program);
+              }
+          }
+          // TODO - optimise later!
+          // don't need to loop through if nothing changed!
+          // maybe look to add an 'autoupdate' to geometry?
+          this.updateBuffers();
+      };
+      /** Reset and unbind any active VAO and geometry. */
+      GeometrySystem.prototype.reset = function () {
+          this.unbind();
+      };
+      /** Update buffers of the currently bound geometry. */
+      GeometrySystem.prototype.updateBuffers = function () {
+          var geometry = this._activeGeometry;
+          var bufferSystem = this.renderer.buffer;
+          for (var i = 0; i < geometry.buffers.length; i++) {
+              var buffer = geometry.buffers[i];
+              bufferSystem.update(buffer);
+          }
+      };
+      /**
+       * Check compatibility between a geometry and a program
+       * @param geometry - Geometry instance.
+       * @param program - Program instance.
+       */
+      GeometrySystem.prototype.checkCompatibility = function (geometry, program) {
+          // geometry must have at least all the attributes that the shader requires.
+          var geometryAttributes = geometry.attributes;
+          var shaderAttributes = program.attributeData;
+          for (var j in shaderAttributes) {
+              if (!geometryAttributes[j]) {
+                  throw new Error("shader and geometry incompatible, geometry missing the \"" + j + "\" attribute");
+              }
+          }
+      };
+      /**
+       * Takes a geometry and program and generates a unique signature for them.
+       * @param geometry - To get signature from.
+       * @param program - To test geometry against.
+       * @returns - Unique signature of the geometry and program
+       */
+      GeometrySystem.prototype.getSignature = function (geometry, program) {
+          var attribs = geometry.attributes;
+          var shaderAttributes = program.attributeData;
+          var strings = ['g', geometry.id];
+          for (var i in attribs) {
+              if (shaderAttributes[i]) {
+                  strings.push(i, shaderAttributes[i].location);
+              }
+          }
+          return strings.join('-');
+      };
+      /**
+       * Creates or gets Vao with the same structure as the geometry and stores it on the geometry.
+       * If vao is created, it is bound automatically. We use a shader to infer what and how to set up the
+       * attribute locations.
+       * @param geometry - Instance of geometry to to generate Vao for.
+       * @param shader - Instance of the shader.
+       * @param incRefCount - Increment refCount of all geometry buffers.
+       */
+      GeometrySystem.prototype.initGeometryVao = function (geometry, shader, incRefCount) {
+          if (incRefCount === void 0) { incRefCount = true; }
+          var gl = this.gl;
+          var CONTEXT_UID = this.CONTEXT_UID;
+          var bufferSystem = this.renderer.buffer;
+          var program = shader.program;
+          if (!program.glPrograms[CONTEXT_UID]) {
+              this.renderer.shader.generateProgram(shader);
+          }
+          this.checkCompatibility(geometry, program);
+          var signature = this.getSignature(geometry, program);
+          var vaoObjectHash = geometry.glVertexArrayObjects[this.CONTEXT_UID];
+          var vao = vaoObjectHash[signature];
+          if (vao) {
+              // this will give us easy access to the vao
+              vaoObjectHash[program.id] = vao;
+              return vao;
+          }
+          var buffers = geometry.buffers;
+          var attributes = geometry.attributes;
+          var tempStride = {};
+          var tempStart = {};
+          for (var j in buffers) {
+              tempStride[j] = 0;
+              tempStart[j] = 0;
+          }
+          for (var j in attributes) {
+              if (!attributes[j].size && program.attributeData[j]) {
+                  attributes[j].size = program.attributeData[j].size;
+              }
+              else if (!attributes[j].size) {
+                  console.warn("PIXI Geometry attribute '" + j + "' size cannot be determined (likely the bound shader does not have the attribute)"); // eslint-disable-line
+              }
+              tempStride[attributes[j].buffer] += attributes[j].size * byteSizeMap[attributes[j].type];
+          }
+          for (var j in attributes) {
+              var attribute = attributes[j];
+              var attribSize = attribute.size;
+              if (attribute.stride === undefined) {
+                  if (tempStride[attribute.buffer] === attribSize * byteSizeMap[attribute.type]) {
+                      attribute.stride = 0;
+                  }
+                  else {
+                      attribute.stride = tempStride[attribute.buffer];
+                  }
+              }
+              if (attribute.start === undefined) {
+                  attribute.start = tempStart[attribute.buffer];
+                  tempStart[attribute.buffer] += attribSize * byteSizeMap[attribute.type];
+              }
+          }
+          vao = gl.createVertexArray();
+          gl.bindVertexArray(vao);
+          // first update - and create the buffers!
+          // only create a gl buffer if it actually gets
+          for (var i = 0; i < buffers.length; i++) {
+              var buffer = buffers[i];
+              bufferSystem.bind(buffer);
+              if (incRefCount) {
+                  buffer._glBuffers[CONTEXT_UID].refCount++;
+              }
+          }
+          // TODO - maybe make this a data object?
+          // lets wait to see if we need to first!
+          this.activateVao(geometry, program);
+          this._activeVao = vao;
+          // add it to the cache!
+          vaoObjectHash[program.id] = vao;
+          vaoObjectHash[signature] = vao;
+          return vao;
+      };
+      /**
+       * Disposes geometry.
+       * @param geometry - Geometry with buffers. Only VAO will be disposed
+       * @param [contextLost=false] - If context was lost, we suppress deleteVertexArray
+       */
+      GeometrySystem.prototype.disposeGeometry = function (geometry, contextLost) {
+          var _a;
+          if (!this.managedGeometries[geometry.id]) {
+              return;
+          }
+          delete this.managedGeometries[geometry.id];
+          var vaos = geometry.glVertexArrayObjects[this.CONTEXT_UID];
+          var gl = this.gl;
+          var buffers = geometry.buffers;
+          var bufferSystem = (_a = this.renderer) === null || _a === void 0 ? void 0 : _a.buffer;
+          geometry.disposeRunner.remove(this);
+          if (!vaos) {
+              return;
+          }
+          // bufferSystem may have already been destroyed..
+          // if this is the case, there is no need to destroy the geometry buffers...
+          // they already have been!
+          if (bufferSystem) {
+              for (var i = 0; i < buffers.length; i++) {
+                  var buf = buffers[i]._glBuffers[this.CONTEXT_UID];
+                  // my be null as context may have changed right before the dispose is called
+                  if (buf) {
+                      buf.refCount--;
+                      if (buf.refCount === 0 && !contextLost) {
+                          bufferSystem.dispose(buffers[i], contextLost);
+                      }
+                  }
+              }
+          }
+          if (!contextLost) {
+              for (var vaoId in vaos) {
+                  // delete only signatures, everything else are copies
+                  if (vaoId[0] === 'g') {
+                      var vao = vaos[vaoId];
+                      if (this._activeVao === vao) {
+                          this.unbind();
+                      }
+                      gl.deleteVertexArray(vao);
+                  }
+              }
+          }
+          delete geometry.glVertexArrayObjects[this.CONTEXT_UID];
+      };
+      /**
+       * Dispose all WebGL resources of all managed geometries.
+       * @param [contextLost=false] - If context was lost, we suppress `gl.delete` calls
+       */
+      GeometrySystem.prototype.disposeAll = function (contextLost) {
+          var all = Object.keys(this.managedGeometries);
+          for (var i = 0; i < all.length; i++) {
+              this.disposeGeometry(this.managedGeometries[all[i]], contextLost);
+          }
+      };
+      /**
+       * Activate vertex array object.
+       * @param geometry - Geometry instance.
+       * @param program - Shader program instance.
+       */
+      GeometrySystem.prototype.activateVao = function (geometry, program) {
+          var gl = this.gl;
+          var CONTEXT_UID = this.CONTEXT_UID;
+          var bufferSystem = this.renderer.buffer;
+          var buffers = geometry.buffers;
+          var attributes = geometry.attributes;
+          if (geometry.indexBuffer) {
+              // first update the index buffer if we have one..
+              bufferSystem.bind(geometry.indexBuffer);
+          }
+          var lastBuffer = null;
+          // add a new one!
+          for (var j in attributes) {
+              var attribute = attributes[j];
+              var buffer = buffers[attribute.buffer];
+              var glBuffer = buffer._glBuffers[CONTEXT_UID];
+              if (program.attributeData[j]) {
+                  if (lastBuffer !== glBuffer) {
+                      bufferSystem.bind(buffer);
+                      lastBuffer = glBuffer;
+                  }
+                  var location = program.attributeData[j].location;
+                  // TODO introduce state again
+                  // we can optimise this for older devices that have no VAOs
+                  gl.enableVertexAttribArray(location);
+                  gl.vertexAttribPointer(location, attribute.size, attribute.type || gl.FLOAT, attribute.normalized, attribute.stride, attribute.start);
+                  if (attribute.instance) {
+                      // TODO calculate instance count based of this...
+                      if (this.hasInstance) {
+                          gl.vertexAttribDivisor(location, 1);
+                      }
+                      else {
+                          throw new Error('geometry error, GPU Instancing is not supported on this device');
+                      }
+                  }
+              }
+          }
+      };
+      /**
+       * Draws the currently bound geometry.
+       * @param type - The type primitive to render.
+       * @param size - The number of elements to be rendered. If not specified, all vertices after the
+       *  starting vertex will be drawn.
+       * @param start - The starting vertex in the geometry to start drawing from. If not specified,
+       *  drawing will start from the first vertex.
+       * @param instanceCount - The number of instances of the set of elements to execute. If not specified,
+       *  all instances will be drawn.
+       */
+      GeometrySystem.prototype.draw = function (type, size, start, instanceCount) {
+          var gl = this.gl;
+          var geometry = this._activeGeometry;
+          // TODO.. this should not change so maybe cache the function?
+          if (geometry.indexBuffer) {
+              var byteSize = geometry.indexBuffer.data.BYTES_PER_ELEMENT;
+              var glType = byteSize === 2 ? gl.UNSIGNED_SHORT : gl.UNSIGNED_INT;
+              if (byteSize === 2 || (byteSize === 4 && this.canUseUInt32ElementIndex)) {
+                  if (geometry.instanced) {
+                      /* eslint-disable max-len */
+                      gl.drawElementsInstanced(type, size || geometry.indexBuffer.data.length, glType, (start || 0) * byteSize, instanceCount || 1);
+                      /* eslint-enable max-len */
+                  }
+                  else {
+                      /* eslint-disable max-len */
+                      gl.drawElements(type, size || geometry.indexBuffer.data.length, glType, (start || 0) * byteSize);
+                      /* eslint-enable max-len */
+                  }
+              }
+              else {
+                  console.warn('unsupported index buffer type: uint32');
+              }
+          }
+          else if (geometry.instanced) {
+              // TODO need a better way to calculate size..
+              gl.drawArraysInstanced(type, start, size || geometry.getSize(), instanceCount || 1);
+          }
+          else {
+              gl.drawArrays(type, start, size || geometry.getSize());
+          }
+          return this;
+      };
+      /** Unbind/reset everything. */
+      GeometrySystem.prototype.unbind = function () {
+          this.gl.bindVertexArray(null);
+          this._activeVao = null;
+          this._activeGeometry = null;
+      };
+      GeometrySystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return GeometrySystem;
+  }());
 
-/**
- * @class
- * @extends PIXI.Shader
- * @memberof PIXI
- */
-var ParticleShader = function (_Shader) {
-    _inherits(ParticleShader, _Shader);
-
-    /**
-     * @param {PIXI.Shader} gl - The webgl shader manager this shader works for.
-     */
-    function ParticleShader(gl) {
-        _classCallCheck(this, ParticleShader);
-
-        return _possibleConstructorReturn(this, _Shader.call(this, gl,
-        // vertex shader
-        ['attribute vec2 aVertexPosition;', 'attribute vec2 aTextureCoord;', 'attribute float aColor;', 'attribute vec2 aPositionCoord;', 'attribute vec2 aScale;', 'attribute float aRotation;', 'uniform mat3 projectionMatrix;', 'varying vec2 vTextureCoord;', 'varying float vColor;', 'void main(void){', '   vec2 v = aVertexPosition;', '   v.x = (aVertexPosition.x) * cos(aRotation) - (aVertexPosition.y) * sin(aRotation);', '   v.y = (aVertexPosition.x) * sin(aRotation) + (aVertexPosition.y) * cos(aRotation);', '   v = v + aPositionCoord;', '   gl_Position = vec4((projectionMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);', '   vTextureCoord = aTextureCoord;', '   vColor = aColor;', '}'].join('\n'),
-        // hello
-        ['varying vec2 vTextureCoord;', 'varying float vColor;', 'uniform sampler2D uSampler;', 'uniform vec4 uColor;', 'void main(void){', '  vec4 color = texture2D(uSampler, vTextureCoord) * vColor * uColor;', '  if (color.a == 0.0) discard;', '  gl_FragColor = color;', '}'].join('\n')));
-    }
+  /**
+   * Component for masked elements.
+   *
+   * Holds mask mode and temporary data about current mask.
+   * @memberof PIXI
+   */
+  var MaskData = /** @class */ (function () {
+      /**
+       * Create MaskData
+       * @param {PIXI.DisplayObject} [maskObject=null] - object that describes the mask
+       */
+      function MaskData(maskObject) {
+          if (maskObject === void 0) { maskObject = null; }
+          this.type = exports.MASK_TYPES.NONE;
+          this.autoDetect = true;
+          this.maskObject = maskObject || null;
+          this.pooled = false;
+          this.isMaskData = true;
+          this.resolution = null;
+          this.multisample = settings.FILTER_MULTISAMPLE;
+          this.enabled = true;
+          this.colorMask = 0xf;
+          this._filters = null;
+          this._stencilCounter = 0;
+          this._scissorCounter = 0;
+          this._scissorRect = null;
+          this._scissorRectLocal = null;
+          this._colorMask = 0xf;
+          this._target = null;
+      }
+      Object.defineProperty(MaskData.prototype, "filter", {
+          /**
+           * The sprite mask filter.
+           * If set to `null`, the default sprite mask filter is used.
+           * @default null
+           */
+          get: function () {
+              return this._filters ? this._filters[0] : null;
+          },
+          set: function (value) {
+              if (value) {
+                  if (this._filters) {
+                      this._filters[0] = value;
+                  }
+                  else {
+                      this._filters = [value];
+                  }
+              }
+              else {
+                  this._filters = null;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Resets the mask data after popMask(). */
+      MaskData.prototype.reset = function () {
+          if (this.pooled) {
+              this.maskObject = null;
+              this.type = exports.MASK_TYPES.NONE;
+              this.autoDetect = true;
+          }
+          this._target = null;
+          this._scissorRectLocal = null;
+      };
+      /**
+       * Copies counters from maskData above, called from pushMask().
+       * @param maskAbove
+       */
+      MaskData.prototype.copyCountersOrReset = function (maskAbove) {
+          if (maskAbove) {
+              this._stencilCounter = maskAbove._stencilCounter;
+              this._scissorCounter = maskAbove._scissorCounter;
+              this._scissorRect = maskAbove._scissorRect;
+          }
+          else {
+              this._stencilCounter = 0;
+              this._scissorCounter = 0;
+              this._scissorRect = null;
+          }
+      };
+      return MaskData;
+  }());
 
-    return ParticleShader;
-}(_Shader3.default);
+  /**
+   * @private
+   * @param {WebGLRenderingContext} gl - The current WebGL context {WebGLProgram}
+   * @param {number} type - the type, can be either VERTEX_SHADER or FRAGMENT_SHADER
+   * @param {string} src - The vertex shader source as an array of strings.
+   * @returns {WebGLShader} the shader
+   */
+  function compileShader(gl, type, src) {
+      var shader = gl.createShader(type);
+      gl.shaderSource(shader, src);
+      gl.compileShader(shader);
+      return shader;
+  }
 
-exports.default = ParticleShader;
+  /**
+   * will log a shader error highlighting the lines with the error
+   * also will add numbers along the side.
+   * @param gl - the WebGLContext
+   * @param shader - the shader to log errors for
+   */
+  function logPrettyShaderError(gl, shader) {
+      var shaderSrc = gl.getShaderSource(shader)
+          .split('\n')
+          .map(function (line, index) { return index + ": " + line; });
+      var shaderLog = gl.getShaderInfoLog(shader);
+      var splitShader = shaderLog.split('\n');
+      var dedupe = {};
+      var lineNumbers = splitShader.map(function (line) { return parseFloat(line.replace(/^ERROR\: 0\:([\d]+)\:.*$/, '$1')); })
+          .filter(function (n) {
+          if (n && !dedupe[n]) {
+              dedupe[n] = true;
+              return true;
+          }
+          return false;
+      });
+      var logArgs = [''];
+      lineNumbers.forEach(function (number) {
+          shaderSrc[number - 1] = "%c" + shaderSrc[number - 1] + "%c";
+          logArgs.push('background: #FF0000; color:#FFFFFF; font-size: 10px', 'font-size: 10px');
+      });
+      var fragmentSourceToLog = shaderSrc
+          .join('\n');
+      logArgs[0] = fragmentSourceToLog;
+      console.error(shaderLog);
+      // eslint-disable-next-line no-console
+      console.groupCollapsed('click to view full shader code');
+      console.warn.apply(console, logArgs);
+      // eslint-disable-next-line no-console
+      console.groupEnd();
+  }
+  /**
+   *
+   * logs out any program errors
+   * @param gl - The current WebGL context
+   * @param program - the WebGL program to display errors for
+   * @param vertexShader  - the fragment WebGL shader program
+   * @param fragmentShader - the vertex WebGL shader program
+   */
+  function logProgramError(gl, program, vertexShader, fragmentShader) {
+      // if linking fails, then log and cleanup
+      if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+          if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+              logPrettyShaderError(gl, vertexShader);
+          }
+          if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+              logPrettyShaderError(gl, fragmentShader);
+          }
+          console.error('PixiJS Error: Could not initialize shader.');
+          // if there is a program info log, log it
+          if (gl.getProgramInfoLog(program) !== '') {
+              console.warn('PixiJS Warning: gl.getProgramInfoLog()', gl.getProgramInfoLog(program));
+          }
+      }
+  }
 
-},{"../../core/Shader":44}],178:[function(require,module,exports){
-"use strict";
+  function booleanArray(size) {
+      var array = new Array(size);
+      for (var i = 0; i < array.length; i++) {
+          array[i] = false;
+      }
+      return array;
+  }
+  /**
+   * @method defaultValue
+   * @memberof PIXI.glCore.shader
+   * @param {string} type - Type of value
+   * @param {number} size
+   * @private
+   */
+  function defaultValue(type, size) {
+      switch (type) {
+          case 'float':
+              return 0;
+          case 'vec2':
+              return new Float32Array(2 * size);
+          case 'vec3':
+              return new Float32Array(3 * size);
+          case 'vec4':
+              return new Float32Array(4 * size);
+          case 'int':
+          case 'uint':
+          case 'sampler2D':
+          case 'sampler2DArray':
+              return 0;
+          case 'ivec2':
+              return new Int32Array(2 * size);
+          case 'ivec3':
+              return new Int32Array(3 * size);
+          case 'ivec4':
+              return new Int32Array(4 * size);
+          case 'uvec2':
+              return new Uint32Array(2 * size);
+          case 'uvec3':
+              return new Uint32Array(3 * size);
+          case 'uvec4':
+              return new Uint32Array(4 * size);
+          case 'bool':
+              return false;
+          case 'bvec2':
+              return booleanArray(2 * size);
+          case 'bvec3':
+              return booleanArray(3 * size);
+          case 'bvec4':
+              return booleanArray(4 * size);
+          case 'mat2':
+              return new Float32Array([1, 0,
+                  0, 1]);
+          case 'mat3':
+              return new Float32Array([1, 0, 0,
+                  0, 1, 0,
+                  0, 0, 1]);
+          case 'mat4':
+              return new Float32Array([1, 0, 0, 0,
+                  0, 1, 0, 0,
+                  0, 0, 1, 0,
+                  0, 0, 0, 1]);
+      }
+      return null;
+  }
 
-// References:
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
+  var unknownContext = {};
+  var context = unknownContext;
+  /**
+   * returns a little WebGL context to use for program inspection.
+   * @static
+   * @private
+   * @returns {WebGLRenderingContext} a gl context to test with
+   */
+  function getTestContext() {
+      if (context === unknownContext || (context && context.isContextLost())) {
+          var canvas = settings.ADAPTER.createCanvas();
+          var gl = void 0;
+          if (settings.PREFER_ENV >= exports.ENV.WEBGL2) {
+              gl = canvas.getContext('webgl2', {});
+          }
+          if (!gl) {
+              gl = (canvas.getContext('webgl', {})
+                  || canvas.getContext('experimental-webgl', {}));
+              if (!gl) {
+                  // fail, not able to get a context
+                  gl = null;
+              }
+              else {
+                  // for shader testing..
+                  gl.getExtension('WEBGL_draw_buffers');
+              }
+          }
+          context = gl;
+      }
+      return context;
+  }
 
-if (!Math.sign) {
-    Math.sign = function mathSign(x) {
-        x = Number(x);
+  var maxFragmentPrecision;
+  function getMaxFragmentPrecision() {
+      if (!maxFragmentPrecision) {
+          maxFragmentPrecision = exports.PRECISION.MEDIUM;
+          var gl = getTestContext();
+          if (gl) {
+              if (gl.getShaderPrecisionFormat) {
+                  var shaderFragment = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT);
+                  maxFragmentPrecision = shaderFragment.precision ? exports.PRECISION.HIGH : exports.PRECISION.MEDIUM;
+              }
+          }
+      }
+      return maxFragmentPrecision;
+  }
 
-        if (x === 0 || isNaN(x)) {
-            return x;
-        }
+  /**
+   * Sets the float precision on the shader, ensuring the device supports the request precision.
+   * If the precision is already present, it just ensures that the device is able to handle it.
+   * @private
+   * @param {string} src - The shader source
+   * @param {PIXI.PRECISION} requestedPrecision - The request float precision of the shader.
+   * @param {PIXI.PRECISION} maxSupportedPrecision - The maximum precision the shader supports.
+   * @returns {string} modified shader source
+   */
+  function setPrecision(src, requestedPrecision, maxSupportedPrecision) {
+      if (src.substring(0, 9) !== 'precision') {
+          // no precision supplied, so PixiJS will add the requested level.
+          var precision = requestedPrecision;
+          // If highp is requested but not supported, downgrade precision to a level all devices support.
+          if (requestedPrecision === exports.PRECISION.HIGH && maxSupportedPrecision !== exports.PRECISION.HIGH) {
+              precision = exports.PRECISION.MEDIUM;
+          }
+          return "precision " + precision + " float;\n" + src;
+      }
+      else if (maxSupportedPrecision !== exports.PRECISION.HIGH && src.substring(0, 15) === 'precision highp') {
+          // precision was supplied, but at a level this device does not support, so downgrading to mediump.
+          return src.replace('precision highp', 'precision mediump');
+      }
+      return src;
+  }
 
-        return x > 0 ? 1 : -1;
-    };
-}
+  var GLSL_TO_SIZE = {
+      float: 1,
+      vec2: 2,
+      vec3: 3,
+      vec4: 4,
+      int: 1,
+      ivec2: 2,
+      ivec3: 3,
+      ivec4: 4,
+      uint: 1,
+      uvec2: 2,
+      uvec3: 3,
+      uvec4: 4,
+      bool: 1,
+      bvec2: 2,
+      bvec3: 3,
+      bvec4: 4,
+      mat2: 4,
+      mat3: 9,
+      mat4: 16,
+      sampler2D: 1,
+  };
+  /**
+   * @private
+   * @method mapSize
+   * @memberof PIXI.glCore.shader
+   * @param {string} type
+   */
+  function mapSize(type) {
+      return GLSL_TO_SIZE[type];
+  }
 
-},{}],179:[function(require,module,exports){
-'use strict';
+  var GL_TABLE = null;
+  var GL_TO_GLSL_TYPES = {
+      FLOAT: 'float',
+      FLOAT_VEC2: 'vec2',
+      FLOAT_VEC3: 'vec3',
+      FLOAT_VEC4: 'vec4',
+      INT: 'int',
+      INT_VEC2: 'ivec2',
+      INT_VEC3: 'ivec3',
+      INT_VEC4: 'ivec4',
+      UNSIGNED_INT: 'uint',
+      UNSIGNED_INT_VEC2: 'uvec2',
+      UNSIGNED_INT_VEC3: 'uvec3',
+      UNSIGNED_INT_VEC4: 'uvec4',
+      BOOL: 'bool',
+      BOOL_VEC2: 'bvec2',
+      BOOL_VEC3: 'bvec3',
+      BOOL_VEC4: 'bvec4',
+      FLOAT_MAT2: 'mat2',
+      FLOAT_MAT3: 'mat3',
+      FLOAT_MAT4: 'mat4',
+      SAMPLER_2D: 'sampler2D',
+      INT_SAMPLER_2D: 'sampler2D',
+      UNSIGNED_INT_SAMPLER_2D: 'sampler2D',
+      SAMPLER_CUBE: 'samplerCube',
+      INT_SAMPLER_CUBE: 'samplerCube',
+      UNSIGNED_INT_SAMPLER_CUBE: 'samplerCube',
+      SAMPLER_2D_ARRAY: 'sampler2DArray',
+      INT_SAMPLER_2D_ARRAY: 'sampler2DArray',
+      UNSIGNED_INT_SAMPLER_2D_ARRAY: 'sampler2DArray',
+  };
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  function mapType(gl, type) {
+      if (!GL_TABLE) {
+          var typeNames = Object.keys(GL_TO_GLSL_TYPES);
+          GL_TABLE = {};
+          for (var i = 0; i < typeNames.length; ++i) {
+              var tn = typeNames[i];
+              GL_TABLE[gl[tn]] = GL_TO_GLSL_TYPES[tn];
+          }
+      }
+      return GL_TABLE[type];
+  }
 
-var _objectAssign = require('object-assign');
+  /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+  // Parsers, each one of these will take a look at the type of shader property and uniform.
+  // if they pass the test function then the code function is called that returns a the shader upload code for that uniform.
+  // Shader upload code is automagically generated with these parsers.
+  // If no parser is valid then the default upload functions are used.
+  // exposing Parsers means that custom upload logic can be added to pixi's shaders.
+  // A good example would be a pixi rectangle can be directly set on a uniform.
+  // If the shader sees it it knows how to upload the rectangle structure as a vec4
+  // format is as follows:
+  //
+  // {
+  //     test: (data, uniform) => {} <--- test is this code should be used for this uniform
+  //     code: (name, uniform) => {} <--- returns the string of the piece of code that uploads the uniform
+  //     codeUbo: (name, uniform) => {} <--- returns the string of the piece of code that uploads the
+  //                                         uniform to a uniform buffer
+  // }
+  var uniformParsers = [
+      // a float cache layer
+      {
+          test: function (data) {
+              return data.type === 'float' && data.size === 1 && !data.isArray;
+          },
+          code: function (name) {
+              return "\n            if(uv[\"" + name + "\"] !== ud[\"" + name + "\"].value)\n            {\n                ud[\"" + name + "\"].value = uv[\"" + name + "\"]\n                gl.uniform1f(ud[\"" + name + "\"].location, uv[\"" + name + "\"])\n            }\n            ";
+          },
+      },
+      // handling samplers
+      {
+          test: function (data, uniform) {
+              // eslint-disable-next-line max-len,no-eq-null,eqeqeq
+              return (data.type === 'sampler2D' || data.type === 'samplerCube' || data.type === 'sampler2DArray') && data.size === 1 && !data.isArray && (uniform == null || uniform.castToBaseTexture !== undefined);
+          },
+          code: function (name) { return "t = syncData.textureCount++;\n\n            renderer.texture.bind(uv[\"" + name + "\"], t);\n\n            if(ud[\"" + name + "\"].value !== t)\n            {\n                ud[\"" + name + "\"].value = t;\n                gl.uniform1i(ud[\"" + name + "\"].location, t);\n; // eslint-disable-line max-len\n            }"; },
+      },
+      // uploading pixi matrix object to mat3
+      {
+          test: function (data, uniform) {
+              return data.type === 'mat3' && data.size === 1 && !data.isArray && uniform.a !== undefined;
+          },
+          code: function (name) {
+              // TODO and some smart caching dirty ids here!
+              return "\n            gl.uniformMatrix3fv(ud[\"" + name + "\"].location, false, uv[\"" + name + "\"].toArray(true));\n            ";
+          },
+          codeUbo: function (name) {
+              return "\n                var " + name + "_matrix = uv." + name + ".toArray(true);\n\n                data[offset] = " + name + "_matrix[0];\n                data[offset+1] = " + name + "_matrix[1];\n                data[offset+2] = " + name + "_matrix[2];\n        \n                data[offset + 4] = " + name + "_matrix[3];\n                data[offset + 5] = " + name + "_matrix[4];\n                data[offset + 6] = " + name + "_matrix[5];\n        \n                data[offset + 8] = " + name + "_matrix[6];\n                data[offset + 9] = " + name + "_matrix[7];\n                data[offset + 10] = " + name + "_matrix[8];\n            ";
+          },
+      },
+      // uploading a pixi point as a vec2 with caching layer
+      {
+          test: function (data, uniform) {
+              return data.type === 'vec2' && data.size === 1 && !data.isArray && uniform.x !== undefined;
+          },
+          code: function (name) {
+              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v.x || cv[1] !== v.y)\n                {\n                    cv[0] = v.x;\n                    cv[1] = v.y;\n                    gl.uniform2f(ud[\"" + name + "\"].location, v.x, v.y);\n                }";
+          },
+          codeUbo: function (name) {
+              return "\n                v = uv." + name + ";\n\n                data[offset] = v.x;\n                data[offset+1] = v.y;\n            ";
+          }
+      },
+      // caching layer for a vec2
+      {
+          test: function (data) {
+              return data.type === 'vec2' && data.size === 1 && !data.isArray;
+          },
+          code: function (name) {
+              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v[0] || cv[1] !== v[1])\n                {\n                    cv[0] = v[0];\n                    cv[1] = v[1];\n                    gl.uniform2f(ud[\"" + name + "\"].location, v[0], v[1]);\n                }\n            ";
+          },
+      },
+      // upload a pixi rectangle as a vec4 with caching layer
+      {
+          test: function (data, uniform) {
+              return data.type === 'vec4' && data.size === 1 && !data.isArray && uniform.width !== undefined;
+          },
+          code: function (name) {
+              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v.x || cv[1] !== v.y || cv[2] !== v.width || cv[3] !== v.height)\n                {\n                    cv[0] = v.x;\n                    cv[1] = v.y;\n                    cv[2] = v.width;\n                    cv[3] = v.height;\n                    gl.uniform4f(ud[\"" + name + "\"].location, v.x, v.y, v.width, v.height)\n                }";
+          },
+          codeUbo: function (name) {
+              return "\n                    v = uv." + name + ";\n\n                    data[offset] = v.x;\n                    data[offset+1] = v.y;\n                    data[offset+2] = v.width;\n                    data[offset+3] = v.height;\n                ";
+          }
+      },
+      // a caching layer for vec4 uploading
+      {
+          test: function (data) {
+              return data.type === 'vec4' && data.size === 1 && !data.isArray;
+          },
+          code: function (name) {
+              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n                {\n                    cv[0] = v[0];\n                    cv[1] = v[1];\n                    cv[2] = v[2];\n                    cv[3] = v[3];\n\n                    gl.uniform4f(ud[\"" + name + "\"].location, v[0], v[1], v[2], v[3])\n                }";
+          },
+      } ];
+
+  // cu = Cached value's uniform data field
+  // cv = Cached value
+  // v = value to upload
+  // ud = uniformData
+  // uv = uniformValue
+  // l = location
+  var GLSL_TO_SINGLE_SETTERS_CACHED = {
+      float: "\n    if (cv !== v)\n    {\n        cu.value = v;\n        gl.uniform1f(location, v);\n    }",
+      vec2: "\n    if (cv[0] !== v[0] || cv[1] !== v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2f(location, v[0], v[1])\n    }",
+      vec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3f(location, v[0], v[1], v[2])\n    }",
+      vec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4f(location, v[0], v[1], v[2], v[3]);\n    }",
+      int: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
+      ivec2: "\n    if (cv[0] !== v[0] || cv[1] !== v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2i(location, v[0], v[1]);\n    }",
+      ivec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3i(location, v[0], v[1], v[2]);\n    }",
+      ivec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4i(location, v[0], v[1], v[2], v[3]);\n    }",
+      uint: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1ui(location, v);\n    }",
+      uvec2: "\n    if (cv[0] !== v[0] || cv[1] !== v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2ui(location, v[0], v[1]);\n    }",
+      uvec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3ui(location, v[0], v[1], v[2]);\n    }",
+      uvec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4ui(location, v[0], v[1], v[2], v[3]);\n    }",
+      bool: "\n    if (cv !== v)\n    {\n        cu.value = v;\n        gl.uniform1i(location, v);\n    }",
+      bvec2: "\n    if (cv[0] != v[0] || cv[1] != v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2i(location, v[0], v[1]);\n    }",
+      bvec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3i(location, v[0], v[1], v[2]);\n    }",
+      bvec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4i(location, v[0], v[1], v[2], v[3]);\n    }",
+      mat2: 'gl.uniformMatrix2fv(location, false, v)',
+      mat3: 'gl.uniformMatrix3fv(location, false, v)',
+      mat4: 'gl.uniformMatrix4fv(location, false, v)',
+      sampler2D: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
+      samplerCube: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
+      sampler2DArray: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
+  };
+  var GLSL_TO_ARRAY_SETTERS = {
+      float: "gl.uniform1fv(location, v)",
+      vec2: "gl.uniform2fv(location, v)",
+      vec3: "gl.uniform3fv(location, v)",
+      vec4: 'gl.uniform4fv(location, v)',
+      mat4: 'gl.uniformMatrix4fv(location, false, v)',
+      mat3: 'gl.uniformMatrix3fv(location, false, v)',
+      mat2: 'gl.uniformMatrix2fv(location, false, v)',
+      int: 'gl.uniform1iv(location, v)',
+      ivec2: 'gl.uniform2iv(location, v)',
+      ivec3: 'gl.uniform3iv(location, v)',
+      ivec4: 'gl.uniform4iv(location, v)',
+      uint: 'gl.uniform1uiv(location, v)',
+      uvec2: 'gl.uniform2uiv(location, v)',
+      uvec3: 'gl.uniform3uiv(location, v)',
+      uvec4: 'gl.uniform4uiv(location, v)',
+      bool: 'gl.uniform1iv(location, v)',
+      bvec2: 'gl.uniform2iv(location, v)',
+      bvec3: 'gl.uniform3iv(location, v)',
+      bvec4: 'gl.uniform4iv(location, v)',
+      sampler2D: 'gl.uniform1iv(location, v)',
+      samplerCube: 'gl.uniform1iv(location, v)',
+      sampler2DArray: 'gl.uniform1iv(location, v)',
+  };
+  function generateUniformsSync(group, uniformData) {
+      var _a;
+      var funcFragments = ["\n        var v = null;\n        var cv = null;\n        var cu = null;\n        var t = 0;\n        var gl = renderer.gl;\n    "];
+      for (var i in group.uniforms) {
+          var data = uniformData[i];
+          if (!data) {
+              if ((_a = group.uniforms[i]) === null || _a === void 0 ? void 0 : _a.group) {
+                  if (group.uniforms[i].ubo) {
+                      funcFragments.push("\n                        renderer.shader.syncUniformBufferGroup(uv." + i + ", '" + i + "');\n                    ");
+                  }
+                  else {
+                      funcFragments.push("\n                        renderer.shader.syncUniformGroup(uv." + i + ", syncData);\n                    ");
+                  }
+              }
+              continue;
+          }
+          var uniform = group.uniforms[i];
+          var parsed = false;
+          for (var j = 0; j < uniformParsers.length; j++) {
+              if (uniformParsers[j].test(data, uniform)) {
+                  funcFragments.push(uniformParsers[j].code(i, uniform));
+                  parsed = true;
+                  break;
+              }
+          }
+          if (!parsed) {
+              var templateType = data.size === 1 && !data.isArray ? GLSL_TO_SINGLE_SETTERS_CACHED : GLSL_TO_ARRAY_SETTERS;
+              var template = templateType[data.type].replace('location', "ud[\"" + i + "\"].location");
+              funcFragments.push("\n            cu = ud[\"" + i + "\"];\n            cv = cu.value;\n            v = uv[\"" + i + "\"];\n            " + template + ";");
+          }
+      }
+      /*
+       * the introduction of syncData is to solve an issue where textures in uniform groups are not set correctly
+       * the texture count was always starting from 0 in each group. This needs to increment each time a texture is used
+       * no matter which group is being used
+       *
+       */
+      // eslint-disable-next-line no-new-func
+      return new Function('ud', 'uv', 'renderer', 'syncData', funcFragments.join('\n'));
+  }
 
-var _objectAssign2 = _interopRequireDefault(_objectAssign);
+  var fragTemplate$1 = [
+      'precision mediump float;',
+      'void main(void){',
+      'float test = 0.1;',
+      '%forloop%',
+      'gl_FragColor = vec4(0.0);',
+      '}' ].join('\n');
+  function generateIfTestSrc(maxIfs) {
+      var src = '';
+      for (var i = 0; i < maxIfs; ++i) {
+          if (i > 0) {
+              src += '\nelse ';
+          }
+          if (i < maxIfs - 1) {
+              src += "if(test == " + i + ".0){}";
+          }
+      }
+      return src;
+  }
+  function checkMaxIfStatementsInShader(maxIfs, gl) {
+      if (maxIfs === 0) {
+          throw new Error('Invalid value of `0` passed to `checkMaxIfStatementsInShader`');
+      }
+      var shader = gl.createShader(gl.FRAGMENT_SHADER);
+      while (true) // eslint-disable-line no-constant-condition
+       {
+          var fragmentSrc = fragTemplate$1.replace(/%forloop%/gi, generateIfTestSrc(maxIfs));
+          gl.shaderSource(shader, fragmentSrc);
+          gl.compileShader(shader);
+          if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+              maxIfs = (maxIfs / 2) | 0;
+          }
+          else {
+              // valid!
+              break;
+          }
+      }
+      return maxIfs;
+  }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  // Cache the result to prevent running this over and over
+  var unsafeEval;
+  /**
+   * Not all platforms allow to generate function code (e.g., `new Function`).
+   * this provides the platform-level detection.
+   * @private
+   * @returns {boolean} `true` if `new Function` is supported.
+   */
+  function unsafeEvalSupported() {
+      if (typeof unsafeEval === 'boolean') {
+          return unsafeEval;
+      }
+      try {
+          /* eslint-disable no-new-func */
+          var func = new Function('param1', 'param2', 'param3', 'return param1[param2] === param3;');
+          /* eslint-enable no-new-func */
+          unsafeEval = func({ a: 'b' }, 'a', 'b') === true;
+      }
+      catch (e) {
+          unsafeEval = false;
+      }
+      return unsafeEval;
+  }
 
-if (!Object.assign) {
-    Object.assign = _objectAssign2.default;
-} // References:
-// https://github.com/sindresorhus/object-assign
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+  var defaultFragment$2 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n   gl_FragColor *= texture2D(uSampler, vTextureCoord);\n}";
 
-},{"object-assign":5}],180:[function(require,module,exports){
-'use strict';
+  var defaultVertex$3 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void){\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}\n";
 
-require('./Object.assign');
+  var UID$1 = 0;
+  var nameCache = {};
+  /**
+   * Helper class to create a shader program.
+   * @memberof PIXI
+   */
+  var Program = /** @class */ (function () {
+      /**
+       * @param vertexSrc - The source of the vertex shader.
+       * @param fragmentSrc - The source of the fragment shader.
+       * @param name - Name for shader
+       */
+      function Program(vertexSrc, fragmentSrc, name) {
+          if (name === void 0) { name = 'pixi-shader'; }
+          this.id = UID$1++;
+          this.vertexSrc = vertexSrc || Program.defaultVertexSrc;
+          this.fragmentSrc = fragmentSrc || Program.defaultFragmentSrc;
+          this.vertexSrc = this.vertexSrc.trim();
+          this.fragmentSrc = this.fragmentSrc.trim();
+          if (this.vertexSrc.substring(0, 8) !== '#version') {
+              name = name.replace(/\s+/g, '-');
+              if (nameCache[name]) {
+                  nameCache[name]++;
+                  name += "-" + nameCache[name];
+              }
+              else {
+                  nameCache[name] = 1;
+              }
+              this.vertexSrc = "#define SHADER_NAME " + name + "\n" + this.vertexSrc;
+              this.fragmentSrc = "#define SHADER_NAME " + name + "\n" + this.fragmentSrc;
+              this.vertexSrc = setPrecision(this.vertexSrc, settings.PRECISION_VERTEX, exports.PRECISION.HIGH);
+              this.fragmentSrc = setPrecision(this.fragmentSrc, settings.PRECISION_FRAGMENT, getMaxFragmentPrecision());
+          }
+          // currently this does not extract structs only default types
+          // this is where we store shader references..
+          this.glPrograms = {};
+          this.syncUniforms = null;
+      }
+      Object.defineProperty(Program, "defaultVertexSrc", {
+          /**
+           * The default vertex shader source.
+           * @constant
+           */
+          get: function () {
+              return defaultVertex$3;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Program, "defaultFragmentSrc", {
+          /**
+           * The default fragment shader source.
+           * @constant
+           */
+          get: function () {
+              return defaultFragment$2;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * A short hand function to create a program based of a vertex and fragment shader.
+       *
+       * This method will also check to see if there is a cached program.
+       * @param vertexSrc - The source of the vertex shader.
+       * @param fragmentSrc - The source of the fragment shader.
+       * @param name - Name for shader
+       * @returns A shiny new PixiJS shader program!
+       */
+      Program.from = function (vertexSrc, fragmentSrc, name) {
+          var key = vertexSrc + fragmentSrc;
+          var program = ProgramCache[key];
+          if (!program) {
+              ProgramCache[key] = program = new Program(vertexSrc, fragmentSrc, name);
+          }
+          return program;
+      };
+      return Program;
+  }());
 
-require('./requestAnimationFrame');
+  /**
+   * A helper class for shaders.
+   * @memberof PIXI
+   */
+  var Shader = /** @class */ (function () {
+      /**
+       * @param program - The program the shader will use.
+       * @param uniforms - Custom uniforms to use to augment the built-in ones.
+       */
+      function Shader(program, uniforms) {
+          /**
+           * Used internally to bind uniform buffer objects.
+           * @ignore
+           */
+          this.uniformBindCount = 0;
+          this.program = program;
+          // lets see whats been passed in
+          // uniforms should be converted to a uniform group
+          if (uniforms) {
+              if (uniforms instanceof UniformGroup) {
+                  this.uniformGroup = uniforms;
+              }
+              else {
+                  this.uniformGroup = new UniformGroup(uniforms);
+              }
+          }
+          else {
+              this.uniformGroup = new UniformGroup({});
+          }
+          this.disposeRunner = new Runner('disposeShader');
+      }
+      // TODO move to shader system..
+      Shader.prototype.checkUniformExists = function (name, group) {
+          if (group.uniforms[name]) {
+              return true;
+          }
+          for (var i in group.uniforms) {
+              var uniform = group.uniforms[i];
+              if (uniform.group) {
+                  if (this.checkUniformExists(name, uniform)) {
+                      return true;
+                  }
+              }
+          }
+          return false;
+      };
+      Shader.prototype.destroy = function () {
+          // usage count on programs?
+          // remove if not used!
+          this.uniformGroup = null;
+          this.disposeRunner.emit(this);
+          this.disposeRunner.destroy();
+      };
+      Object.defineProperty(Shader.prototype, "uniforms", {
+          /**
+           * Shader uniform values, shortcut for `uniformGroup.uniforms`.
+           * @readonly
+           */
+          get: function () {
+              return this.uniformGroup.uniforms;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * A short hand function to create a shader based of a vertex and fragment shader.
+       * @param vertexSrc - The source of the vertex shader.
+       * @param fragmentSrc - The source of the fragment shader.
+       * @param uniforms - Custom uniforms to use to augment the built-in ones.
+       * @returns A shiny new PixiJS shader!
+       */
+      Shader.from = function (vertexSrc, fragmentSrc, uniforms) {
+          var program = Program.from(vertexSrc, fragmentSrc);
+          return new Shader(program, uniforms);
+      };
+      return Shader;
+  }());
+
+  /* eslint-disable max-len */
+  var BLEND$1 = 0;
+  var OFFSET$1 = 1;
+  var CULLING$1 = 2;
+  var DEPTH_TEST$1 = 3;
+  var WINDING$1 = 4;
+  var DEPTH_MASK$1 = 5;
+  /**
+   * This is a WebGL state, and is is passed to {@link PIXI.StateSystem}.
+   *
+   * Each mesh rendered may require WebGL to be in a different state.
+   * For example you may want different blend mode or to enable polygon offsets
+   * @memberof PIXI
+   */
+  var State = /** @class */ (function () {
+      function State() {
+          this.data = 0;
+          this.blendMode = exports.BLEND_MODES.NORMAL;
+          this.polygonOffset = 0;
+          this.blend = true;
+          this.depthMask = true;
+          //  this.depthTest = true;
+      }
+      Object.defineProperty(State.prototype, "blend", {
+          /**
+           * Activates blending of the computed fragment color values.
+           * @default true
+           */
+          get: function () {
+              return !!(this.data & (1 << BLEND$1));
+          },
+          set: function (value) {
+              if (!!(this.data & (1 << BLEND$1)) !== value) {
+                  this.data ^= (1 << BLEND$1);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(State.prototype, "offsets", {
+          /**
+           * Activates adding an offset to depth values of polygon's fragments
+           * @default false
+           */
+          get: function () {
+              return !!(this.data & (1 << OFFSET$1));
+          },
+          set: function (value) {
+              if (!!(this.data & (1 << OFFSET$1)) !== value) {
+                  this.data ^= (1 << OFFSET$1);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(State.prototype, "culling", {
+          /**
+           * Activates culling of polygons.
+           * @default false
+           */
+          get: function () {
+              return !!(this.data & (1 << CULLING$1));
+          },
+          set: function (value) {
+              if (!!(this.data & (1 << CULLING$1)) !== value) {
+                  this.data ^= (1 << CULLING$1);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(State.prototype, "depthTest", {
+          /**
+           * Activates depth comparisons and updates to the depth buffer.
+           * @default false
+           */
+          get: function () {
+              return !!(this.data & (1 << DEPTH_TEST$1));
+          },
+          set: function (value) {
+              if (!!(this.data & (1 << DEPTH_TEST$1)) !== value) {
+                  this.data ^= (1 << DEPTH_TEST$1);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(State.prototype, "depthMask", {
+          /**
+           * Enables or disables writing to the depth buffer.
+           * @default true
+           */
+          get: function () {
+              return !!(this.data & (1 << DEPTH_MASK$1));
+          },
+          set: function (value) {
+              if (!!(this.data & (1 << DEPTH_MASK$1)) !== value) {
+                  this.data ^= (1 << DEPTH_MASK$1);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(State.prototype, "clockwiseFrontFace", {
+          /**
+           * Specifies whether or not front or back-facing polygons can be culled.
+           * @default false
+           */
+          get: function () {
+              return !!(this.data & (1 << WINDING$1));
+          },
+          set: function (value) {
+              if (!!(this.data & (1 << WINDING$1)) !== value) {
+                  this.data ^= (1 << WINDING$1);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(State.prototype, "blendMode", {
+          /**
+           * The blend mode to be applied when this state is set. Apply a value of `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.
+           * Setting this mode to anything other than NO_BLEND will automatically switch blending on.
+           * @default PIXI.BLEND_MODES.NORMAL
+           */
+          get: function () {
+              return this._blendMode;
+          },
+          set: function (value) {
+              this.blend = (value !== exports.BLEND_MODES.NONE);
+              this._blendMode = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(State.prototype, "polygonOffset", {
+          /**
+           * The polygon offset. Setting this property to anything other than 0 will automatically enable polygon offset fill.
+           * @default 0
+           */
+          get: function () {
+              return this._polygonOffset;
+          },
+          set: function (value) {
+              this.offsets = !!value;
+              this._polygonOffset = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      State.prototype.toString = function () {
+          return "[@pixi/core:State "
+              + ("blendMode=" + this.blendMode + " ")
+              + ("clockwiseFrontFace=" + this.clockwiseFrontFace + " ")
+              + ("culling=" + this.culling + " ")
+              + ("depthMask=" + this.depthMask + " ")
+              + ("polygonOffset=" + this.polygonOffset)
+              + "]";
+      };
+      State.for2d = function () {
+          var state = new State();
+          state.depthTest = false;
+          state.blend = true;
+          return state;
+      };
+      return State;
+  }());
+
+  var defaultFragment$1 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n   gl_FragColor = texture2D(uSampler, vTextureCoord);\n}\n";
+
+  var defaultVertex$2 = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";
 
-require('./Math.sign');
+  /**
+   * A filter is a special shader that applies post-processing effects to an input texture and writes into an output
+   * render-target.
+   *
+   * {@link http://pixijs.io/examples/#/filters/blur-filter.js Example} of the
+   * {@link PIXI.filters.BlurFilter BlurFilter}.
+   *
+   * ### Usage
+   * Filters can be applied to any DisplayObject or Container.
+   * PixiJS' `FilterSystem` renders the container into temporary Framebuffer,
+   * then filter renders it to the screen.
+   * Multiple filters can be added to the `filters` array property and stacked on each other.
+   *
+   * ```
+   * const filter = new PIXI.Filter(myShaderVert, myShaderFrag, { myUniform: 0.5 });
+   * const container = new PIXI.Container();
+   * container.filters = [filter];
+   * ```
+   *
+   * ### Previous Version Differences
+   *
+   * In PixiJS **v3**, a filter was always applied to _whole screen_.
+   *
+   * In PixiJS **v4**, a filter can be applied _only part of the screen_.
+   * Developers had to create a set of uniforms to deal with coordinates.
+   *
+   * In PixiJS **v5** combines _both approaches_.
+   * Developers can use normal coordinates of v3 and then allow filter to use partial Framebuffers,
+   * bringing those extra uniforms into account.
+   *
+   * Also be aware that we have changed default vertex shader, please consult
+   * {@link https://github.com/pixijs/pixi.js/wiki/v5-Creating-filters Wiki}.
+   *
+   * ### Frames
+   *
+   * The following table summarizes the coordinate spaces used in the filtering pipeline:
+   *
+   * <table>
+   * <thead>
+   *   <tr>
+   *     <th>Coordinate Space</th>
+   *     <th>Description</th>
+   *   </tr>
+   * </thead>
+   * <tbody>
+   *   <tr>
+   *     <td>Texture Coordinates</td>
+   *     <td>
+   *         The texture (or UV) coordinates in the input base-texture's space. These are normalized into the (0,1) range along
+   *         both axes.
+   *     </td>
+   *   </tr>
+   *   <tr>
+   *     <td>World Space</td>
+   *     <td>
+   *         A point in the same space as the world bounds of any display-object (i.e. in the scene graph's space).
+   *     </td>
+   *   </tr>
+   *   <tr>
+   *     <td>Physical Pixels</td>
+   *     <td>
+   *         This is base-texture's space with the origin on the top-left. You can calculate these by multiplying the texture
+   *         coordinates by the dimensions of the texture.
+   *     </td>
+   *   </tr>
+   * </tbody>
+   * </table>
+   *
+   * ### Built-in Uniforms
+   *
+   * PixiJS viewport uses screen (CSS) coordinates, `(0, 0, renderer.screen.width, renderer.screen.height)`,
+   * and `projectionMatrix` uniform maps it to the gl viewport.
+   *
+   * **uSampler**
+   *
+   * The most important uniform is the input texture that container was rendered into.
+   * _Important note: as with all Framebuffers in PixiJS, both input and output are
+   * premultiplied by alpha._
+   *
+   * By default, input normalized coordinates are passed to fragment shader with `vTextureCoord`.
+   * Use it to sample the input.
+   *
+   * ```
+   * const fragment = `
+   * varying vec2 vTextureCoord;
+   * uniform sampler2D uSampler;
+   * void main(void)
+   * {
+   *    gl_FragColor = texture2D(uSampler, vTextureCoord);
+   * }
+   * `;
+   *
+   * const myFilter = new PIXI.Filter(null, fragment);
+   * ```
+   *
+   * This filter is just one uniform less than {@link PIXI.filters.AlphaFilter AlphaFilter}.
+   *
+   * **outputFrame**
+   *
+   * The `outputFrame` holds the rectangle where filter is applied in screen (CSS) coordinates.
+   * It's the same as `renderer.screen` for a fullscreen filter.
+   * Only a part of  `outputFrame.zw` size of temporary Framebuffer is used,
+   * `(0, 0, outputFrame.width, outputFrame.height)`,
+   *
+   * Filters uses this quad to normalized (0-1) space, its passed into `aVertexPosition` attribute.
+   * To calculate vertex position in screen space using normalized (0-1) space:
+   *
+   * ```
+   * vec4 filterVertexPosition( void )
+   * {
+   *     vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;
+   *     return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);
+   * }
+   * ```
+   *
+   * **inputSize**
+   *
+   * Temporary framebuffer is different, it can be either the size of screen, either power-of-two.
+   * The `inputSize.xy` are size of temporary framebuffer that holds input.
+   * The `inputSize.zw` is inverted, it's a shortcut to evade division inside the shader.
+   *
+   * Set `inputSize.xy = outputFrame.zw` for a fullscreen filter.
+   *
+   * To calculate input normalized coordinate, you have to map it to filter normalized space.
+   * Multiply by `outputFrame.zw` to get input coordinate.
+   * Divide by `inputSize.xy` to get input normalized coordinate.
+   *
+   * ```
+   * vec2 filterTextureCoord( void )
+   * {
+   *     return aVertexPosition * (outputFrame.zw * inputSize.zw); // same as /inputSize.xy
+   * }
+   * ```
+   * **resolution**
+   *
+   * The `resolution` is the ratio of screen (CSS) pixels to real pixels.
+   *
+   * **inputPixel**
+   *
+   * `inputPixel.xy` is the size of framebuffer in real pixels, same as `inputSize.xy * resolution`
+   * `inputPixel.zw` is inverted `inputPixel.xy`.
+   *
+   * It's handy for filters that use neighbour pixels, like {@link PIXI.filters.FXAAFilter FXAAFilter}.
+   *
+   * **inputClamp**
+   *
+   * If you try to get info from outside of used part of Framebuffer - you'll get undefined behaviour.
+   * For displacements, coordinates has to be clamped.
+   *
+   * The `inputClamp.xy` is left-top pixel center, you may ignore it, because we use left-top part of Framebuffer
+   * `inputClamp.zw` is bottom-right pixel center.
+   *
+   * ```
+   * vec4 color = texture2D(uSampler, clamp(modifiedTextureCoord, inputClamp.xy, inputClamp.zw))
+   * ```
+   * OR
+   * ```
+   * vec4 color = texture2D(uSampler, min(modifigedTextureCoord, inputClamp.zw))
+   * ```
+   *
+   * ### Additional Information
+   *
+   * Complete documentation on Filter usage is located in the
+   * {@link https://github.com/pixijs/pixi.js/wiki/v5-Creating-filters Wiki}.
+   *
+   * Since PixiJS only had a handful of built-in filters, additional filters can be downloaded
+   * {@link https://github.com/pixijs/pixi-filters here} from the PixiJS Filters repository.
+   * @memberof PIXI
+   */
+  var Filter = /** @class */ (function (_super) {
+      __extends$i(Filter, _super);
+      /**
+       * @param vertexSrc - The source of the vertex shader.
+       * @param fragmentSrc - The source of the fragment shader.
+       * @param uniforms - Custom uniforms to use to augment the built-in ones.
+       */
+      function Filter(vertexSrc, fragmentSrc, uniforms) {
+          var _this = this;
+          var program = Program.from(vertexSrc || Filter.defaultVertexSrc, fragmentSrc || Filter.defaultFragmentSrc);
+          _this = _super.call(this, program, uniforms) || this;
+          _this.padding = 0;
+          _this.resolution = settings.FILTER_RESOLUTION;
+          _this.multisample = settings.FILTER_MULTISAMPLE;
+          _this.enabled = true;
+          _this.autoFit = true;
+          _this.state = new State();
+          return _this;
+      }
+      /**
+       * Applies the filter
+       * @param {PIXI.FilterSystem} filterManager - The renderer to retrieve the filter from
+       * @param {PIXI.RenderTexture} input - The input render target.
+       * @param {PIXI.RenderTexture} output - The target to output to.
+       * @param {PIXI.CLEAR_MODES} [clearMode] - Should the output be cleared before rendering to it.
+       * @param {object} [_currentState] - It's current state of filter.
+       *        There are some useful properties in the currentState :
+       *        target, filters, sourceFrame, destinationFrame, renderTarget, resolution
+       */
+      Filter.prototype.apply = function (filterManager, input, output, clearMode, _currentState) {
+          // do as you please!
+          filterManager.applyFilter(this, input, output, clearMode);
+          // or just do a regular render..
+      };
+      Object.defineProperty(Filter.prototype, "blendMode", {
+          /**
+           * Sets the blend mode of the filter.
+           * @default PIXI.BLEND_MODES.NORMAL
+           */
+          get: function () {
+              return this.state.blendMode;
+          },
+          set: function (value) {
+              this.state.blendMode = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Filter.prototype, "resolution", {
+          /**
+           * The resolution of the filter. Setting this to be lower will lower the quality but
+           * increase the performance of the filter.
+           */
+          get: function () {
+              return this._resolution;
+          },
+          set: function (value) {
+              this._resolution = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Filter, "defaultVertexSrc", {
+          /**
+           * The default vertex shader source
+           * @constant
+           */
+          get: function () {
+              return defaultVertex$2;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Filter, "defaultFragmentSrc", {
+          /**
+           * The default fragment shader source
+           * @constant
+           */
+          get: function () {
+              return defaultFragment$1;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return Filter;
+  }(Shader));
+
+  var vertex$4 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 otherMatrix;\n\nvarying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;\n}\n";
+
+  var fragment$7 = "varying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform sampler2D mask;\nuniform float alpha;\nuniform float npmAlpha;\nuniform vec4 maskClamp;\n\nvoid main(void)\n{\n    float clip = step(3.5,\n        step(maskClamp.x, vMaskCoord.x) +\n        step(maskClamp.y, vMaskCoord.y) +\n        step(vMaskCoord.x, maskClamp.z) +\n        step(vMaskCoord.y, maskClamp.w));\n\n    vec4 original = texture2D(uSampler, vTextureCoord);\n    vec4 masky = texture2D(mask, vMaskCoord);\n    float alphaMul = 1.0 - npmAlpha * (1.0 - masky.a);\n\n    original *= (alphaMul * masky.r * alpha * clip);\n\n    gl_FragColor = original;\n}\n";
+
+  var tempMat$1 = new Matrix();
+  /**
+   * Class controls uv mapping from Texture normal space to BaseTexture normal space.
+   *
+   * Takes `trim` and `rotate` into account. May contain clamp settings for Meshes and TilingSprite.
+   *
+   * Can be used in Texture `uvMatrix` field, or separately, you can use different clamp settings on the same texture.
+   * If you want to add support for texture region of certain feature or filter, that's what you're looking for.
+   *
+   * Takes track of Texture changes through `_lastTextureID` private field.
+   * Use `update()` method call to track it from outside.
+   * @see PIXI.Texture
+   * @see PIXI.Mesh
+   * @see PIXI.TilingSprite
+   * @memberof PIXI
+   */
+  var TextureMatrix = /** @class */ (function () {
+      /**
+       * @param texture - observed texture
+       * @param clampMargin - Changes frame clamping, 0.5 by default. Use -0.5 for extra border.
+       */
+      function TextureMatrix(texture, clampMargin) {
+          this._texture = texture;
+          this.mapCoord = new Matrix();
+          this.uClampFrame = new Float32Array(4);
+          this.uClampOffset = new Float32Array(2);
+          this._textureID = -1;
+          this._updateID = 0;
+          this.clampOffset = 0;
+          this.clampMargin = (typeof clampMargin === 'undefined') ? 0.5 : clampMargin;
+          this.isSimple = false;
+      }
+      Object.defineProperty(TextureMatrix.prototype, "texture", {
+          /** Texture property. */
+          get: function () {
+              return this._texture;
+          },
+          set: function (value) {
+              this._texture = value;
+              this._textureID = -1;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Multiplies uvs array to transform
+       * @param uvs - mesh uvs
+       * @param [out=uvs] - output
+       * @returns - output
+       */
+      TextureMatrix.prototype.multiplyUvs = function (uvs, out) {
+          if (out === undefined) {
+              out = uvs;
+          }
+          var mat = this.mapCoord;
+          for (var i = 0; i < uvs.length; i += 2) {
+              var x = uvs[i];
+              var y = uvs[i + 1];
+              out[i] = (x * mat.a) + (y * mat.c) + mat.tx;
+              out[i + 1] = (x * mat.b) + (y * mat.d) + mat.ty;
+          }
+          return out;
+      };
+      /**
+       * Updates matrices if texture was changed.
+       * @param [forceUpdate=false] - if true, matrices will be updated any case
+       * @returns - Whether or not it was updated
+       */
+      TextureMatrix.prototype.update = function (forceUpdate) {
+          var tex = this._texture;
+          if (!tex || !tex.valid) {
+              return false;
+          }
+          if (!forceUpdate
+              && this._textureID === tex._updateID) {
+              return false;
+          }
+          this._textureID = tex._updateID;
+          this._updateID++;
+          var uvs = tex._uvs;
+          this.mapCoord.set(uvs.x1 - uvs.x0, uvs.y1 - uvs.y0, uvs.x3 - uvs.x0, uvs.y3 - uvs.y0, uvs.x0, uvs.y0);
+          var orig = tex.orig;
+          var trim = tex.trim;
+          if (trim) {
+              tempMat$1.set(orig.width / trim.width, 0, 0, orig.height / trim.height, -trim.x / trim.width, -trim.y / trim.height);
+              this.mapCoord.append(tempMat$1);
+          }
+          var texBase = tex.baseTexture;
+          var frame = this.uClampFrame;
+          var margin = this.clampMargin / texBase.resolution;
+          var offset = this.clampOffset;
+          frame[0] = (tex._frame.x + margin + offset) / texBase.width;
+          frame[1] = (tex._frame.y + margin + offset) / texBase.height;
+          frame[2] = (tex._frame.x + tex._frame.width - margin + offset) / texBase.width;
+          frame[3] = (tex._frame.y + tex._frame.height - margin + offset) / texBase.height;
+          this.uClampOffset[0] = offset / texBase.realWidth;
+          this.uClampOffset[1] = offset / texBase.realHeight;
+          this.isSimple = tex._frame.width === texBase.width
+              && tex._frame.height === texBase.height
+              && tex.rotate === 0;
+          return true;
+      };
+      return TextureMatrix;
+  }());
 
-if (!window.ArrayBuffer) {
-    window.ArrayBuffer = Array;
-}
+  /**
+   * This handles a Sprite acting as a mask, as opposed to a Graphic.
+   *
+   * WebGL only.
+   * @memberof PIXI
+   */
+  var SpriteMaskFilter = /** @class */ (function (_super) {
+      __extends$i(SpriteMaskFilter, _super);
+      /** @ignore */
+      function SpriteMaskFilter(vertexSrc, fragmentSrc, uniforms) {
+          var _this = this;
+          var sprite = null;
+          if (typeof vertexSrc !== 'string' && fragmentSrc === undefined && uniforms === undefined) {
+              sprite = vertexSrc;
+              vertexSrc = undefined;
+              fragmentSrc = undefined;
+              uniforms = undefined;
+          }
+          _this = _super.call(this, vertexSrc || vertex$4, fragmentSrc || fragment$7, uniforms) || this;
+          _this.maskSprite = sprite;
+          _this.maskMatrix = new Matrix();
+          return _this;
+      }
+      Object.defineProperty(SpriteMaskFilter.prototype, "maskSprite", {
+          /**
+           * Sprite mask
+           * @type {PIXI.DisplayObject}
+           */
+          get: function () {
+              return this._maskSprite;
+          },
+          set: function (value) {
+              this._maskSprite = value;
+              if (this._maskSprite) {
+                  this._maskSprite.renderable = false;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Applies the filter
+       * @param filterManager - The renderer to retrieve the filter from
+       * @param input - The input render target.
+       * @param output - The target to output to.
+       * @param clearMode - Should the output be cleared before rendering to it.
+       */
+      SpriteMaskFilter.prototype.apply = function (filterManager, input, output, clearMode) {
+          var maskSprite = this._maskSprite;
+          var tex = maskSprite._texture;
+          if (!tex.valid) {
+              return;
+          }
+          if (!tex.uvMatrix) {
+              // margin = 0.0, let it bleed a bit, shader code becomes easier
+              // assuming that atlas textures were made with 1-pixel padding
+              tex.uvMatrix = new TextureMatrix(tex, 0.0);
+          }
+          tex.uvMatrix.update();
+          this.uniforms.npmAlpha = tex.baseTexture.alphaMode ? 0.0 : 1.0;
+          this.uniforms.mask = tex;
+          // get _normalized sprite texture coords_ and convert them to _normalized atlas texture coords_ with `prepend`
+          this.uniforms.otherMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, maskSprite)
+              .prepend(tex.uvMatrix.mapCoord);
+          this.uniforms.alpha = maskSprite.worldAlpha;
+          this.uniforms.maskClamp = tex.uvMatrix.uClampFrame;
+          filterManager.applyFilter(this, input, output, clearMode);
+      };
+      return SpriteMaskFilter;
+  }(Filter));
 
-if (!window.Float32Array) {
-    window.Float32Array = Array;
-}
+  /**
+   * System plugin to the renderer to manage masks.
+   *
+   * There are three built-in types of masking:
+   * **Scissor Masking**: Scissor masking discards pixels that are outside of a rectangle called the scissor box. It is
+   *  the most performant as the scissor test is inexpensive. However, it can only be used when the mask is rectangular.
+   * **Stencil Masking**: Stencil masking discards pixels that don't overlap with the pixels rendered into the stencil
+   *  buffer. It is the next fastest option as it does not require rendering into a separate framebuffer. However, it does
+   *  cause the mask to be rendered **twice** for each masking operation; hence, minimize the rendering cost of your masks.
+   * **Sprite Mask Filtering**: Sprite mask filtering discards pixels based on the red channel of the sprite-mask's
+   *  texture. (Generally, the masking texture is grayscale). Using advanced techniques, you might be able to embed this
+   *  type of masking in a custom shader - and hence, bypassing the masking system fully for performance wins.
+   *
+   * The best type of masking is auto-detected when you `push` one. To use scissor masking, you must pass in a `Graphics`
+   * object with just a rectangle drawn.
+   *
+   * ## Mask Stacks
+   *
+   * In the scene graph, masks can be applied recursively, i.e. a mask can be applied during a masking operation. The mask
+   * stack stores the currently applied masks in order. Each {@link PIXI.BaseRenderTexture} holds its own mask stack, i.e.
+   * when you switch render-textures, the old masks only applied when you switch back to rendering to the old render-target.
+   * @memberof PIXI
+   */
+  var MaskSystem = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this System works for.
+       */
+      function MaskSystem(renderer) {
+          this.renderer = renderer;
+          this.enableScissor = true;
+          this.alphaMaskPool = [];
+          this.maskDataPool = [];
+          this.maskStack = [];
+          this.alphaMaskIndex = 0;
+      }
+      /**
+       * Changes the mask stack that is used by this System.
+       * @param maskStack - The mask stack
+       */
+      MaskSystem.prototype.setMaskStack = function (maskStack) {
+          this.maskStack = maskStack;
+          this.renderer.scissor.setMaskStack(maskStack);
+          this.renderer.stencil.setMaskStack(maskStack);
+      };
+      /**
+       * Enables the mask and appends it to the current mask stack.
+       *
+       * NOTE: The batch renderer should be flushed beforehand to prevent pending renders from being masked.
+       * @param {PIXI.DisplayObject} target - Display Object to push the mask to
+       * @param {PIXI.MaskData|PIXI.Sprite|PIXI.Graphics|PIXI.DisplayObject} maskDataOrTarget - The masking data.
+       */
+      MaskSystem.prototype.push = function (target, maskDataOrTarget) {
+          var maskData = maskDataOrTarget;
+          if (!maskData.isMaskData) {
+              var d = this.maskDataPool.pop() || new MaskData();
+              d.pooled = true;
+              d.maskObject = maskDataOrTarget;
+              maskData = d;
+          }
+          var maskAbove = this.maskStack.length !== 0 ? this.maskStack[this.maskStack.length - 1] : null;
+          maskData.copyCountersOrReset(maskAbove);
+          maskData._colorMask = maskAbove ? maskAbove._colorMask : 0xf;
+          if (maskData.autoDetect) {
+              this.detect(maskData);
+          }
+          maskData._target = target;
+          if (maskData.type !== exports.MASK_TYPES.SPRITE) {
+              this.maskStack.push(maskData);
+          }
+          if (maskData.enabled) {
+              switch (maskData.type) {
+                  case exports.MASK_TYPES.SCISSOR:
+                      this.renderer.scissor.push(maskData);
+                      break;
+                  case exports.MASK_TYPES.STENCIL:
+                      this.renderer.stencil.push(maskData);
+                      break;
+                  case exports.MASK_TYPES.SPRITE:
+                      maskData.copyCountersOrReset(null);
+                      this.pushSpriteMask(maskData);
+                      break;
+                  case exports.MASK_TYPES.COLOR:
+                      this.pushColorMask(maskData);
+                      break;
+              }
+          }
+          if (maskData.type === exports.MASK_TYPES.SPRITE) {
+              this.maskStack.push(maskData);
+          }
+      };
+      /**
+       * Removes the last mask from the mask stack and doesn't return it.
+       *
+       * NOTE: The batch renderer should be flushed beforehand to render the masked contents before the mask is removed.
+       * @param {PIXI.IMaskTarget} target - Display Object to pop the mask from
+       */
+      MaskSystem.prototype.pop = function (target) {
+          var maskData = this.maskStack.pop();
+          if (!maskData || maskData._target !== target) {
+              // TODO: add an assert when we have it
+              return;
+          }
+          if (maskData.enabled) {
+              switch (maskData.type) {
+                  case exports.MASK_TYPES.SCISSOR:
+                      this.renderer.scissor.pop(maskData);
+                      break;
+                  case exports.MASK_TYPES.STENCIL:
+                      this.renderer.stencil.pop(maskData.maskObject);
+                      break;
+                  case exports.MASK_TYPES.SPRITE:
+                      this.popSpriteMask(maskData);
+                      break;
+                  case exports.MASK_TYPES.COLOR:
+                      this.popColorMask(maskData);
+                      break;
+              }
+          }
+          maskData.reset();
+          if (maskData.pooled) {
+              this.maskDataPool.push(maskData);
+          }
+          if (this.maskStack.length !== 0) {
+              var maskCurrent = this.maskStack[this.maskStack.length - 1];
+              if (maskCurrent.type === exports.MASK_TYPES.SPRITE && maskCurrent._filters) {
+                  maskCurrent._filters[0].maskSprite = maskCurrent.maskObject;
+              }
+          }
+      };
+      /**
+       * Sets type of MaskData based on its maskObject.
+       * @param maskData
+       */
+      MaskSystem.prototype.detect = function (maskData) {
+          var maskObject = maskData.maskObject;
+          if (!maskObject) {
+              maskData.type = exports.MASK_TYPES.COLOR;
+          }
+          else if (maskObject.isSprite) {
+              maskData.type = exports.MASK_TYPES.SPRITE;
+          }
+          else if (this.enableScissor && this.renderer.scissor.testScissor(maskData)) {
+              maskData.type = exports.MASK_TYPES.SCISSOR;
+          }
+          else {
+              maskData.type = exports.MASK_TYPES.STENCIL;
+          }
+      };
+      /**
+       * Applies the Mask and adds it to the current filter stack.
+       * @param maskData - Sprite to be used as the mask.
+       */
+      MaskSystem.prototype.pushSpriteMask = function (maskData) {
+          var _a, _b;
+          var maskObject = maskData.maskObject;
+          var target = maskData._target;
+          var alphaMaskFilter = maskData._filters;
+          if (!alphaMaskFilter) {
+              alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex];
+              if (!alphaMaskFilter) {
+                  alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex] = [new SpriteMaskFilter()];
+              }
+          }
+          var renderer = this.renderer;
+          var renderTextureSystem = renderer.renderTexture;
+          var resolution;
+          var multisample;
+          if (renderTextureSystem.current) {
+              var renderTexture = renderTextureSystem.current;
+              resolution = maskData.resolution || renderTexture.resolution;
+              multisample = (_a = maskData.multisample) !== null && _a !== void 0 ? _a : renderTexture.multisample;
+          }
+          else {
+              resolution = maskData.resolution || renderer.resolution;
+              multisample = (_b = maskData.multisample) !== null && _b !== void 0 ? _b : renderer.multisample;
+          }
+          alphaMaskFilter[0].resolution = resolution;
+          alphaMaskFilter[0].multisample = multisample;
+          alphaMaskFilter[0].maskSprite = maskObject;
+          var stashFilterArea = target.filterArea;
+          target.filterArea = maskObject.getBounds(true);
+          renderer.filter.push(target, alphaMaskFilter);
+          target.filterArea = stashFilterArea;
+          if (!maskData._filters) {
+              this.alphaMaskIndex++;
+          }
+      };
+      /**
+       * Removes the last filter from the filter stack and doesn't return it.
+       * @param maskData - Sprite to be used as the mask.
+       */
+      MaskSystem.prototype.popSpriteMask = function (maskData) {
+          this.renderer.filter.pop();
+          if (maskData._filters) {
+              maskData._filters[0].maskSprite = null;
+          }
+          else {
+              this.alphaMaskIndex--;
+              this.alphaMaskPool[this.alphaMaskIndex][0].maskSprite = null;
+          }
+      };
+      /**
+       * Pushes the color mask.
+       * @param maskData - The mask data
+       */
+      MaskSystem.prototype.pushColorMask = function (maskData) {
+          var currColorMask = maskData._colorMask;
+          var nextColorMask = maskData._colorMask = currColorMask & maskData.colorMask;
+          if (nextColorMask !== currColorMask) {
+              this.renderer.gl.colorMask((nextColorMask & 0x1) !== 0, (nextColorMask & 0x2) !== 0, (nextColorMask & 0x4) !== 0, (nextColorMask & 0x8) !== 0);
+          }
+      };
+      /**
+       * Pops the color mask.
+       * @param maskData - The mask data
+       */
+      MaskSystem.prototype.popColorMask = function (maskData) {
+          var currColorMask = maskData._colorMask;
+          var nextColorMask = this.maskStack.length > 0
+              ? this.maskStack[this.maskStack.length - 1]._colorMask : 0xf;
+          if (nextColorMask !== currColorMask) {
+              this.renderer.gl.colorMask((nextColorMask & 0x1) !== 0, (nextColorMask & 0x2) !== 0, (nextColorMask & 0x4) !== 0, (nextColorMask & 0x8) !== 0);
+          }
+      };
+      MaskSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return MaskSystem;
+  }());
 
-if (!window.Uint32Array) {
-    window.Uint32Array = Array;
-}
+  /**
+   * System plugin to the renderer to manage specific types of masking operations.
+   * @memberof PIXI
+   */
+  var AbstractMaskSystem = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this System works for.
+       */
+      function AbstractMaskSystem(renderer) {
+          this.renderer = renderer;
+          this.maskStack = [];
+          this.glConst = 0;
+      }
+      /** Gets count of masks of certain type. */
+      AbstractMaskSystem.prototype.getStackLength = function () {
+          return this.maskStack.length;
+      };
+      /**
+       * Changes the mask stack that is used by this System.
+       * @param {PIXI.MaskData[]} maskStack - The mask stack
+       */
+      AbstractMaskSystem.prototype.setMaskStack = function (maskStack) {
+          var gl = this.renderer.gl;
+          var curStackLen = this.getStackLength();
+          this.maskStack = maskStack;
+          var newStackLen = this.getStackLength();
+          if (newStackLen !== curStackLen) {
+              if (newStackLen === 0) {
+                  gl.disable(this.glConst);
+              }
+              else {
+                  gl.enable(this.glConst);
+                  this._useCurrent();
+              }
+          }
+      };
+      /**
+       * Setup renderer to use the current mask data.
+       * @private
+       */
+      AbstractMaskSystem.prototype._useCurrent = function () {
+          // OVERWRITE;
+      };
+      /** Destroys the mask stack. */
+      AbstractMaskSystem.prototype.destroy = function () {
+          this.renderer = null;
+          this.maskStack = null;
+      };
+      return AbstractMaskSystem;
+  }());
+
+  var tempMatrix$1 = new Matrix();
+  var rectPool = [];
+  /**
+   * System plugin to the renderer to manage scissor masking.
+   *
+   * Scissor masking discards pixels outside of a rectangle called the scissor box. The scissor box is in the framebuffer
+   * viewport's space; however, the mask's rectangle is projected from world-space to viewport space automatically
+   * by this system.
+   * @memberof PIXI
+   */
+  var ScissorSystem = /** @class */ (function (_super) {
+      __extends$i(ScissorSystem, _super);
+      /**
+       * @param {PIXI.Renderer} renderer - The renderer this System works for.
+       */
+      function ScissorSystem(renderer) {
+          var _this = _super.call(this, renderer) || this;
+          _this.glConst = settings.ADAPTER.getWebGLRenderingContext().SCISSOR_TEST;
+          return _this;
+      }
+      ScissorSystem.prototype.getStackLength = function () {
+          var maskData = this.maskStack[this.maskStack.length - 1];
+          if (maskData) {
+              return maskData._scissorCounter;
+          }
+          return 0;
+      };
+      /**
+       * evaluates _boundsTransformed, _scissorRect for MaskData
+       * @param maskData
+       */
+      ScissorSystem.prototype.calcScissorRect = function (maskData) {
+          var _a;
+          if (maskData._scissorRectLocal) {
+              return;
+          }
+          var prevData = maskData._scissorRect;
+          var maskObject = maskData.maskObject;
+          var renderer = this.renderer;
+          var renderTextureSystem = renderer.renderTexture;
+          var rect = maskObject.getBounds(true, (_a = rectPool.pop()) !== null && _a !== void 0 ? _a : new Rectangle());
+          this.roundFrameToPixels(rect, renderTextureSystem.current ? renderTextureSystem.current.resolution : renderer.resolution, renderTextureSystem.sourceFrame, renderTextureSystem.destinationFrame, renderer.projection.transform);
+          if (prevData) {
+              rect.fit(prevData);
+          }
+          maskData._scissorRectLocal = rect;
+      };
+      ScissorSystem.isMatrixRotated = function (matrix) {
+          if (!matrix) {
+              return false;
+          }
+          var a = matrix.a, b = matrix.b, c = matrix.c, d = matrix.d;
+          // Skip if skew/rotation present in matrix, except for multiple of 90° rotation. If rotation
+          // is a multiple of 90°, then either pair of (b,c) or (a,d) will be (0,0).
+          return ((Math.abs(b) > 1e-4 || Math.abs(c) > 1e-4)
+              && (Math.abs(a) > 1e-4 || Math.abs(d) > 1e-4));
+      };
+      /**
+       * Test, whether the object can be scissor mask with current renderer projection.
+       * Calls "calcScissorRect()" if its true.
+       * @param maskData - mask data
+       * @returns whether Whether the object can be scissor mask
+       */
+      ScissorSystem.prototype.testScissor = function (maskData) {
+          var maskObject = maskData.maskObject;
+          if (!maskObject.isFastRect || !maskObject.isFastRect()) {
+              return false;
+          }
+          if (ScissorSystem.isMatrixRotated(maskObject.worldTransform)) {
+              return false;
+          }
+          if (ScissorSystem.isMatrixRotated(this.renderer.projection.transform)) {
+              return false;
+          }
+          this.calcScissorRect(maskData);
+          var rect = maskData._scissorRectLocal;
+          return rect.width > 0 && rect.height > 0;
+      };
+      ScissorSystem.prototype.roundFrameToPixels = function (frame, resolution, bindingSourceFrame, bindingDestinationFrame, transform) {
+          if (ScissorSystem.isMatrixRotated(transform)) {
+              return;
+          }
+          transform = transform ? tempMatrix$1.copyFrom(transform) : tempMatrix$1.identity();
+          // Get forward transform from world space to screen space
+          transform
+              .translate(-bindingSourceFrame.x, -bindingSourceFrame.y)
+              .scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height)
+              .translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
+          // Convert frame to screen space
+          this.renderer.filter.transformAABB(transform, frame);
+          frame.fit(bindingDestinationFrame);
+          frame.x = Math.round(frame.x * resolution);
+          frame.y = Math.round(frame.y * resolution);
+          frame.width = Math.round(frame.width * resolution);
+          frame.height = Math.round(frame.height * resolution);
+      };
+      /**
+       * Applies the Mask and adds it to the current stencil stack.
+       * @author alvin
+       * @param maskData - The mask data.
+       */
+      ScissorSystem.prototype.push = function (maskData) {
+          if (!maskData._scissorRectLocal) {
+              this.calcScissorRect(maskData);
+          }
+          var gl = this.renderer.gl;
+          if (!maskData._scissorRect) {
+              gl.enable(gl.SCISSOR_TEST);
+          }
+          maskData._scissorCounter++;
+          maskData._scissorRect = maskData._scissorRectLocal;
+          this._useCurrent();
+      };
+      /**
+       * This should be called after a mask is popped off the mask stack. It will rebind the scissor box to be latest with the
+       * last mask in the stack.
+       *
+       * This can also be called when you directly modify the scissor box and want to restore PixiJS state.
+       * @param maskData - The mask data.
+       */
+      ScissorSystem.prototype.pop = function (maskData) {
+          var gl = this.renderer.gl;
+          if (maskData) {
+              rectPool.push(maskData._scissorRectLocal);
+          }
+          if (this.getStackLength() > 0) {
+              this._useCurrent();
+          }
+          else {
+              gl.disable(gl.SCISSOR_TEST);
+          }
+      };
+      /**
+       * Setup renderer to use the current scissor data.
+       * @private
+       */
+      ScissorSystem.prototype._useCurrent = function () {
+          var rect = this.maskStack[this.maskStack.length - 1]._scissorRect;
+          var y;
+          if (this.renderer.renderTexture.current) {
+              y = rect.y;
+          }
+          else {
+              // flipY. In future we'll have it over renderTextures as an option
+              y = this.renderer.height - rect.height - rect.y;
+          }
+          this.renderer.gl.scissor(rect.x, y, rect.width, rect.height);
+      };
+      return ScissorSystem;
+  }(AbstractMaskSystem));
 
-if (!window.Uint16Array) {
-    window.Uint16Array = Array;
-}
+  /**
+   * System plugin to the renderer to manage stencils (used for masks).
+   * @memberof PIXI
+   */
+  var StencilSystem = /** @class */ (function (_super) {
+      __extends$i(StencilSystem, _super);
+      /**
+       * @param renderer - The renderer this System works for.
+       */
+      function StencilSystem(renderer) {
+          var _this = _super.call(this, renderer) || this;
+          _this.glConst = settings.ADAPTER.getWebGLRenderingContext().STENCIL_TEST;
+          return _this;
+      }
+      StencilSystem.prototype.getStackLength = function () {
+          var maskData = this.maskStack[this.maskStack.length - 1];
+          if (maskData) {
+              return maskData._stencilCounter;
+          }
+          return 0;
+      };
+      /**
+       * Applies the Mask and adds it to the current stencil stack.
+       * @param maskData - The mask data
+       */
+      StencilSystem.prototype.push = function (maskData) {
+          var maskObject = maskData.maskObject;
+          var gl = this.renderer.gl;
+          var prevMaskCount = maskData._stencilCounter;
+          if (prevMaskCount === 0) {
+              // force use stencil texture in current framebuffer
+              this.renderer.framebuffer.forceStencil();
+              gl.clearStencil(0);
+              gl.clear(gl.STENCIL_BUFFER_BIT);
+              gl.enable(gl.STENCIL_TEST);
+          }
+          maskData._stencilCounter++;
+          var colorMask = maskData._colorMask;
+          if (colorMask !== 0) {
+              maskData._colorMask = 0;
+              gl.colorMask(false, false, false, false);
+          }
+          // Increment the reference stencil value where the new mask overlaps with the old ones.
+          gl.stencilFunc(gl.EQUAL, prevMaskCount, 0xFFFFFFFF);
+          gl.stencilOp(gl.KEEP, gl.KEEP, gl.INCR);
+          maskObject.renderable = true;
+          maskObject.render(this.renderer);
+          this.renderer.batch.flush();
+          maskObject.renderable = false;
+          if (colorMask !== 0) {
+              maskData._colorMask = colorMask;
+              gl.colorMask((colorMask & 1) !== 0, (colorMask & 2) !== 0, (colorMask & 4) !== 0, (colorMask & 8) !== 0);
+          }
+          this._useCurrent();
+      };
+      /**
+       * Pops stencil mask. MaskData is already removed from stack
+       * @param {PIXI.DisplayObject} maskObject - object of popped mask data
+       */
+      StencilSystem.prototype.pop = function (maskObject) {
+          var gl = this.renderer.gl;
+          if (this.getStackLength() === 0) {
+              // the stack is empty!
+              gl.disable(gl.STENCIL_TEST);
+          }
+          else {
+              var maskData = this.maskStack.length !== 0 ? this.maskStack[this.maskStack.length - 1] : null;
+              var colorMask = maskData ? maskData._colorMask : 0xf;
+              if (colorMask !== 0) {
+                  maskData._colorMask = 0;
+                  gl.colorMask(false, false, false, false);
+              }
+              // Decrement the reference stencil value where the popped mask overlaps with the other ones
+              gl.stencilOp(gl.KEEP, gl.KEEP, gl.DECR);
+              maskObject.renderable = true;
+              maskObject.render(this.renderer);
+              this.renderer.batch.flush();
+              maskObject.renderable = false;
+              if (colorMask !== 0) {
+                  maskData._colorMask = colorMask;
+                  gl.colorMask((colorMask & 0x1) !== 0, (colorMask & 0x2) !== 0, (colorMask & 0x4) !== 0, (colorMask & 0x8) !== 0);
+              }
+              this._useCurrent();
+          }
+      };
+      /**
+       * Setup renderer to use the current stencil data.
+       * @private
+       */
+      StencilSystem.prototype._useCurrent = function () {
+          var gl = this.renderer.gl;
+          gl.stencilFunc(gl.EQUAL, this.getStackLength(), 0xFFFFFFFF);
+          gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+      };
+      return StencilSystem;
+  }(AbstractMaskSystem));
 
-},{"./Math.sign":178,"./Object.assign":179,"./requestAnimationFrame":181}],181:[function(require,module,exports){
-(function (global){
-'use strict';
+  /**
+   * System plugin to the renderer to manage the projection matrix.
+   *
+   * The `projectionMatrix` is a global uniform provided to all shaders. It is used to transform points in world space to
+   * normalized device coordinates.
+   * @memberof PIXI
+   */
+  var ProjectionSystem = /** @class */ (function () {
+      /** @param renderer - The renderer this System works for. */
+      function ProjectionSystem(renderer) {
+          this.renderer = renderer;
+          this.destinationFrame = null;
+          this.sourceFrame = null;
+          this.defaultFrame = null;
+          this.projectionMatrix = new Matrix();
+          this.transform = null;
+      }
+      /**
+       * Updates the projection-matrix based on the sourceFrame → destinationFrame mapping provided.
+       *
+       * NOTE: It is expected you call `renderer.framebuffer.setViewport(destinationFrame)` after this. This is because
+       * the framebuffer viewport converts shader vertex output in normalized device coordinates to window coordinates.
+       *
+       * NOTE-2: {@link RenderTextureSystem#bind} updates the projection-matrix when you bind a render-texture. It is expected
+       * that you dirty the current bindings when calling this manually.
+       * @param destinationFrame - The rectangle in the render-target to render the contents into. If rendering to the canvas,
+       *  the origin is on the top-left; if rendering to a render-texture, the origin is on the bottom-left.
+       * @param sourceFrame - The rectangle in world space that contains the contents being rendered.
+       * @param resolution - The resolution of the render-target, which is the ratio of
+       *  world-space (or CSS) pixels to physical pixels.
+       * @param root - Whether the render-target is the screen. This is required because rendering to textures
+       *  is y-flipped (i.e. upside down relative to the screen).
+       */
+      ProjectionSystem.prototype.update = function (destinationFrame, sourceFrame, resolution, root) {
+          this.destinationFrame = destinationFrame || this.destinationFrame || this.defaultFrame;
+          this.sourceFrame = sourceFrame || this.sourceFrame || destinationFrame;
+          // Calculate object-space to clip-space projection
+          this.calculateProjection(this.destinationFrame, this.sourceFrame, resolution, root);
+          if (this.transform) {
+              this.projectionMatrix.append(this.transform);
+          }
+          var renderer = this.renderer;
+          renderer.globalUniforms.uniforms.projectionMatrix = this.projectionMatrix;
+          renderer.globalUniforms.update();
+          // this will work for now
+          // but would be sweet to stick and even on the global uniforms..
+          if (renderer.shader.shader) {
+              renderer.shader.syncUniformGroup(renderer.shader.shader.uniforms.globals);
+          }
+      };
+      /**
+       * Calculates the `projectionMatrix` to map points inside `sourceFrame` to inside `destinationFrame`.
+       * @param _destinationFrame - The destination frame in the render-target.
+       * @param sourceFrame - The source frame in world space.
+       * @param _resolution - The render-target's resolution, i.e. ratio of CSS to physical pixels.
+       * @param root - Whether rendering into the screen. Otherwise, if rendering to a framebuffer, the projection
+       *  is y-flipped.
+       */
+      ProjectionSystem.prototype.calculateProjection = function (_destinationFrame, sourceFrame, _resolution, root) {
+          var pm = this.projectionMatrix;
+          var sign = !root ? 1 : -1;
+          pm.identity();
+          pm.a = (1 / sourceFrame.width * 2);
+          pm.d = sign * (1 / sourceFrame.height * 2);
+          pm.tx = -1 - (sourceFrame.x * pm.a);
+          pm.ty = -sign - (sourceFrame.y * pm.d);
+      };
+      /**
+       * Sets the transform of the active render target to the given matrix.
+       * @param _matrix - The transformation matrix
+       */
+      ProjectionSystem.prototype.setTransform = function (_matrix) {
+          // this._activeRenderTarget.transform = matrix;
+      };
+      ProjectionSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return ProjectionSystem;
+  }());
+
+  // Temporary rectangle for assigned sourceFrame or destinationFrame
+  var tempRect = new Rectangle();
+  // Temporary rectangle for renderTexture destinationFrame
+  var tempRect2 = new Rectangle();
+  /* eslint-disable max-len */
+  /**
+   * System plugin to the renderer to manage render textures.
+   *
+   * Should be added after FramebufferSystem
+   *
+   * ### Frames
+   *
+   * The `RenderTextureSystem` holds a sourceFrame → destinationFrame projection. The following table explains the different
+   * coordinate spaces used:
+   *
+   * | Frame                  | Description                                                      | Coordinate System                                       |
+   * | ---------------------- | ---------------------------------------------------------------- | ------------------------------------------------------- |
+   * | sourceFrame            | The rectangle inside of which display-objects are being rendered | **World Space**: The origin on the top-left             |
+   * | destinationFrame       | The rectangle in the render-target (canvas or texture) into which contents should be rendered | If rendering to the canvas, this is in screen space and the origin is on the top-left. If rendering to a render-texture, this is in its base-texture's space with the origin on the bottom-left.  |
+   * | viewportFrame          | The framebuffer viewport corresponding to the destination-frame  | **Window Coordinates**: The origin is always on the bottom-left. |
+   * @memberof PIXI
+   */
+  var RenderTextureSystem = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this System works for.
+       */
+      function RenderTextureSystem(renderer) {
+          this.renderer = renderer;
+          this.clearColor = renderer._backgroundColorRgba;
+          this.defaultMaskStack = [];
+          this.current = null;
+          this.sourceFrame = new Rectangle();
+          this.destinationFrame = new Rectangle();
+          this.viewportFrame = new Rectangle();
+      }
+      /**
+       * Bind the current render texture.
+       * @param renderTexture - RenderTexture to bind, by default its `null` - the screen.
+       * @param sourceFrame - Part of world that is mapped to the renderTexture.
+       * @param destinationFrame - Part of renderTexture, by default it has the same size as sourceFrame.
+       */
+      RenderTextureSystem.prototype.bind = function (renderTexture, sourceFrame, destinationFrame) {
+          if (renderTexture === void 0) { renderTexture = null; }
+          var renderer = this.renderer;
+          this.current = renderTexture;
+          var baseTexture;
+          var framebuffer;
+          var resolution;
+          if (renderTexture) {
+              baseTexture = renderTexture.baseTexture;
+              resolution = baseTexture.resolution;
+              if (!sourceFrame) {
+                  tempRect.width = renderTexture.frame.width;
+                  tempRect.height = renderTexture.frame.height;
+                  sourceFrame = tempRect;
+              }
+              if (!destinationFrame) {
+                  tempRect2.x = renderTexture.frame.x;
+                  tempRect2.y = renderTexture.frame.y;
+                  tempRect2.width = sourceFrame.width;
+                  tempRect2.height = sourceFrame.height;
+                  destinationFrame = tempRect2;
+              }
+              framebuffer = baseTexture.framebuffer;
+          }
+          else {
+              resolution = renderer.resolution;
+              if (!sourceFrame) {
+                  tempRect.width = renderer.screen.width;
+                  tempRect.height = renderer.screen.height;
+                  sourceFrame = tempRect;
+              }
+              if (!destinationFrame) {
+                  destinationFrame = tempRect;
+                  destinationFrame.width = sourceFrame.width;
+                  destinationFrame.height = sourceFrame.height;
+              }
+          }
+          var viewportFrame = this.viewportFrame;
+          viewportFrame.x = destinationFrame.x * resolution;
+          viewportFrame.y = destinationFrame.y * resolution;
+          viewportFrame.width = destinationFrame.width * resolution;
+          viewportFrame.height = destinationFrame.height * resolution;
+          if (!renderTexture) {
+              viewportFrame.y = renderer.view.height - (viewportFrame.y + viewportFrame.height);
+          }
+          viewportFrame.ceil();
+          this.renderer.framebuffer.bind(framebuffer, viewportFrame);
+          this.renderer.projection.update(destinationFrame, sourceFrame, resolution, !framebuffer);
+          if (renderTexture) {
+              this.renderer.mask.setMaskStack(baseTexture.maskStack);
+          }
+          else {
+              this.renderer.mask.setMaskStack(this.defaultMaskStack);
+          }
+          this.sourceFrame.copyFrom(sourceFrame);
+          this.destinationFrame.copyFrom(destinationFrame);
+      };
+      /**
+       * Erases the render texture and fills the drawing area with a colour.
+       * @param clearColor - The color as rgba, default to use the renderer backgroundColor
+       * @param [mask=BUFFER_BITS.COLOR | BUFFER_BITS.DEPTH] - Bitwise OR of masks
+       *  that indicate the buffers to be cleared, by default COLOR and DEPTH buffers.
+       */
+      RenderTextureSystem.prototype.clear = function (clearColor, mask) {
+          if (this.current) {
+              clearColor = clearColor || this.current.baseTexture.clearColor;
+          }
+          else {
+              clearColor = clearColor || this.clearColor;
+          }
+          var destinationFrame = this.destinationFrame;
+          var baseFrame = this.current ? this.current.baseTexture : this.renderer.screen;
+          var clearMask = destinationFrame.width !== baseFrame.width || destinationFrame.height !== baseFrame.height;
+          if (clearMask) {
+              var _a = this.viewportFrame, x = _a.x, y = _a.y, width = _a.width, height = _a.height;
+              x = Math.round(x);
+              y = Math.round(y);
+              width = Math.round(width);
+              height = Math.round(height);
+              // TODO: ScissorSystem should cache whether the scissor test is enabled or not.
+              this.renderer.gl.enable(this.renderer.gl.SCISSOR_TEST);
+              this.renderer.gl.scissor(x, y, width, height);
+          }
+          this.renderer.framebuffer.clear(clearColor[0], clearColor[1], clearColor[2], clearColor[3], mask);
+          if (clearMask) {
+              // Restore the scissor box
+              this.renderer.scissor.pop();
+          }
+      };
+      RenderTextureSystem.prototype.resize = function () {
+          // resize the root only!
+          this.bind(null);
+      };
+      /** Resets render-texture state. */
+      RenderTextureSystem.prototype.reset = function () {
+          this.bind(null);
+      };
+      RenderTextureSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return RenderTextureSystem;
+  }());
+
+  function uboUpdate(_ud, _uv, _renderer, _syncData, buffer) {
+      _renderer.buffer.update(buffer);
+  }
+  // cv = CachedValue
+  // v = value
+  // ud = uniformData
+  // uv = uniformValue
+  // l = location
+  var UBO_TO_SINGLE_SETTERS = {
+      float: "\n        data[offset] = v;\n    ",
+      vec2: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n    ",
+      vec3: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n        data[offset+2] = v[2];\n\n    ",
+      vec4: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n        data[offset+2] = v[2];\n        data[offset+3] = v[3];\n    ",
+      mat2: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n\n        data[offset+4] = v[2];\n        data[offset+5] = v[3];\n    ",
+      mat3: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n        data[offset+2] = v[2];\n\n        data[offset + 4] = v[3];\n        data[offset + 5] = v[4];\n        data[offset + 6] = v[5];\n\n        data[offset + 8] = v[6];\n        data[offset + 9] = v[7];\n        data[offset + 10] = v[8];\n    ",
+      mat4: "\n        for(var i = 0; i < 16; i++)\n        {\n            data[offset + i] = v[i];\n        }\n    "
+  };
+  var GLSL_TO_STD40_SIZE = {
+      float: 4,
+      vec2: 8,
+      vec3: 12,
+      vec4: 16,
+      int: 4,
+      ivec2: 8,
+      ivec3: 12,
+      ivec4: 16,
+      uint: 4,
+      uvec2: 8,
+      uvec3: 12,
+      uvec4: 16,
+      bool: 4,
+      bvec2: 8,
+      bvec3: 12,
+      bvec4: 16,
+      mat2: 16 * 2,
+      mat3: 16 * 3,
+      mat4: 16 * 4,
+  };
+  /**
+   * logic originally from here: https://github.com/sketchpunk/FunWithWebGL2/blob/master/lesson_022/Shaders.js
+   * rewrote it, but this was a great starting point to get a solid understanding of whats going on :)
+   * @ignore
+   * @param uniformData
+   */
+  function createUBOElements(uniformData) {
+      var uboElements = uniformData.map(function (data) {
+          return ({
+              data: data,
+              offset: 0,
+              dataLen: 0,
+              dirty: 0
+          });
+      });
+      var size = 0;
+      var chunkSize = 0;
+      var offset = 0;
+      for (var i = 0; i < uboElements.length; i++) {
+          var uboElement = uboElements[i];
+          size = GLSL_TO_STD40_SIZE[uboElement.data.type];
+          if (uboElement.data.size > 1) {
+              size = Math.max(size, 16) * uboElement.data.size;
+          }
+          uboElement.dataLen = size;
+          // add some size offset..
+          // must align to the nearest 16 bytes or internally nearest round size
+          if (chunkSize % size !== 0 && chunkSize < 16) {
+              // diff required to line up..
+              var lineUpValue = (chunkSize % size) % 16;
+              chunkSize += lineUpValue;
+              offset += lineUpValue;
+          }
+          if ((chunkSize + size) > 16) {
+              offset = Math.ceil(offset / 16) * 16;
+              uboElement.offset = offset;
+              offset += size;
+              chunkSize = size;
+          }
+          else {
+              uboElement.offset = offset;
+              chunkSize += size;
+              offset += size;
+          }
+      }
+      offset = Math.ceil(offset / 16) * 16;
+      return { uboElements: uboElements, size: offset };
+  }
+  function getUBOData(uniforms, uniformData) {
+      var usedUniformDatas = [];
+      // build..
+      for (var i in uniforms) {
+          if (uniformData[i]) {
+              usedUniformDatas.push(uniformData[i]);
+          }
+      }
+      // sort them out by index!
+      usedUniformDatas.sort(function (a, b) { return a.index - b.index; });
+      return usedUniformDatas;
+  }
+  function generateUniformBufferSync(group, uniformData) {
+      if (!group.autoManage) {
+          // if the group is nott automatically managed, we don't need to generate a special function for it...
+          return { size: 0, syncFunc: uboUpdate };
+      }
+      var usedUniformDatas = getUBOData(group.uniforms, uniformData);
+      var _a = createUBOElements(usedUniformDatas), uboElements = _a.uboElements, size = _a.size;
+      var funcFragments = ["\n    var v = null;\n    var v2 = null;\n    var cv = null;\n    var t = 0;\n    var gl = renderer.gl\n    var index = 0;\n    var data = buffer.data;\n    "];
+      for (var i = 0; i < uboElements.length; i++) {
+          var uboElement = uboElements[i];
+          var uniform = group.uniforms[uboElement.data.name];
+          var name = uboElement.data.name;
+          var parsed = false;
+          for (var j = 0; j < uniformParsers.length; j++) {
+              var uniformParser = uniformParsers[j];
+              if (uniformParser.codeUbo && uniformParser.test(uboElement.data, uniform)) {
+                  funcFragments.push("offset = " + uboElement.offset / 4 + ";", uniformParsers[j].codeUbo(uboElement.data.name, uniform));
+                  parsed = true;
+                  break;
+              }
+          }
+          if (!parsed) {
+              if (uboElement.data.size > 1) {
+                  var size_1 = mapSize(uboElement.data.type);
+                  var rowSize = Math.max(GLSL_TO_STD40_SIZE[uboElement.data.type] / 16, 1);
+                  var elementSize = size_1 / rowSize;
+                  var remainder = (4 - (elementSize % 4)) % 4;
+                  funcFragments.push("\n                cv = ud." + name + ".value;\n                v = uv." + name + ";\n                offset = " + uboElement.offset / 4 + ";\n\n                t = 0;\n\n                for(var i=0; i < " + uboElement.data.size * rowSize + "; i++)\n                {\n                    for(var j = 0; j < " + elementSize + "; j++)\n                    {\n                        data[offset++] = v[t++];\n                    }\n                    offset += " + remainder + ";\n                }\n\n                ");
+              }
+              else {
+                  var template = UBO_TO_SINGLE_SETTERS[uboElement.data.type];
+                  funcFragments.push("\n                cv = ud." + name + ".value;\n                v = uv." + name + ";\n                offset = " + uboElement.offset / 4 + ";\n                " + template + ";\n                ");
+              }
+          }
+      }
+      funcFragments.push("\n       renderer.buffer.update(buffer);\n    ");
+      return {
+          size: size,
+          // eslint-disable-next-line no-new-func
+          syncFunc: new Function('ud', 'uv', 'renderer', 'syncData', 'buffer', funcFragments.join('\n'))
+      };
+  }
 
-// References:
-// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
-// https://gist.github.com/1579671
-// http://updates.html5rocks.com/2012/05/requestAnimationFrame-API-now-with-sub-millisecond-precision
-// https://gist.github.com/timhall/4078614
-// https://github.com/Financial-Times/polyfill-service/tree/master/polyfills/requestAnimationFrame
+  /**
+   * @private
+   */
+  var IGLUniformData = /** @class */ (function () {
+      function IGLUniformData() {
+      }
+      return IGLUniformData;
+  }());
+  /**
+   * Helper class to create a WebGL Program
+   * @memberof PIXI
+   */
+  var GLProgram = /** @class */ (function () {
+      /**
+       * Makes a new Pixi program.
+       * @param program - webgl program
+       * @param uniformData - uniforms
+       */
+      function GLProgram(program, uniformData) {
+          this.program = program;
+          this.uniformData = uniformData;
+          this.uniformGroups = {};
+          this.uniformDirtyGroups = {};
+          this.uniformBufferBindings = {};
+      }
+      /** Destroys this program. */
+      GLProgram.prototype.destroy = function () {
+          this.uniformData = null;
+          this.uniformGroups = null;
+          this.uniformDirtyGroups = null;
+          this.uniformBufferBindings = null;
+          this.program = null;
+      };
+      return GLProgram;
+  }());
 
-// Expected to be used with Browserfiy
-// Browserify automatically detects the use of `global` and passes the
-// correct reference of `global`, `self`, and finally `window`
+  /**
+   * returns the attribute data from the program
+   * @private
+   * @param {WebGLProgram} [program] - the WebGL program
+   * @param {WebGLRenderingContext} [gl] - the WebGL context
+   * @returns {object} the attribute data for this program
+   */
+  function getAttributeData(program, gl) {
+      var attributes = {};
+      var totalAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+      for (var i = 0; i < totalAttributes; i++) {
+          var attribData = gl.getActiveAttrib(program, i);
+          if (attribData.name.indexOf('gl_') === 0) {
+              continue;
+          }
+          var type = mapType(gl, attribData.type);
+          var data = {
+              type: type,
+              name: attribData.name,
+              size: mapSize(type),
+              location: gl.getAttribLocation(program, attribData.name),
+          };
+          attributes[attribData.name] = data;
+      }
+      return attributes;
+  }
 
-var ONE_FRAME_TIME = 16;
+  /**
+   * returns the uniform data from the program
+   * @private
+   * @param program - the webgl program
+   * @param gl - the WebGL context
+   * @returns {object} the uniform data for this program
+   */
+  function getUniformData(program, gl) {
+      var uniforms = {};
+      var totalUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+      for (var i = 0; i < totalUniforms; i++) {
+          var uniformData = gl.getActiveUniform(program, i);
+          var name = uniformData.name.replace(/\[.*?\]$/, '');
+          var isArray = !!(uniformData.name.match(/\[.*?\]$/));
+          var type = mapType(gl, uniformData.type);
+          uniforms[name] = {
+              name: name,
+              index: i,
+              type: type,
+              size: uniformData.size,
+              isArray: isArray,
+              value: defaultValue(type, uniformData.size),
+          };
+      }
+      return uniforms;
+  }
 
-// Date.now
-if (!(Date.now && Date.prototype.getTime)) {
-    Date.now = function now() {
-        return new Date().getTime();
-    };
-}
+  /**
+   * generates a WebGL Program object from a high level Pixi Program.
+   * @param gl - a rendering context on which to generate the program
+   * @param program - the high level Pixi Program.
+   */
+  function generateProgram(gl, program) {
+      var glVertShader = compileShader(gl, gl.VERTEX_SHADER, program.vertexSrc);
+      var glFragShader = compileShader(gl, gl.FRAGMENT_SHADER, program.fragmentSrc);
+      var webGLProgram = gl.createProgram();
+      gl.attachShader(webGLProgram, glVertShader);
+      gl.attachShader(webGLProgram, glFragShader);
+      gl.linkProgram(webGLProgram);
+      if (!gl.getProgramParameter(webGLProgram, gl.LINK_STATUS)) {
+          logProgramError(gl, webGLProgram, glVertShader, glFragShader);
+      }
+      program.attributeData = getAttributeData(webGLProgram, gl);
+      program.uniformData = getUniformData(webGLProgram, gl);
+      // GLSL 1.00: bind attributes sorted by name in ascending order
+      // GLSL 3.00: don't change the attribute locations that where chosen by the compiler
+      //            or assigned by the layout specifier in the shader source code
+      if (!(/^[ \t]*#[ \t]*version[ \t]+300[ \t]+es[ \t]*$/m).test(program.vertexSrc)) {
+          var keys = Object.keys(program.attributeData);
+          keys.sort(function (a, b) { return (a > b) ? 1 : -1; }); // eslint-disable-line no-confusing-arrow
+          for (var i = 0; i < keys.length; i++) {
+              program.attributeData[keys[i]].location = i;
+              gl.bindAttribLocation(webGLProgram, i, keys[i]);
+          }
+          gl.linkProgram(webGLProgram);
+      }
+      gl.deleteShader(glVertShader);
+      gl.deleteShader(glFragShader);
+      var uniformData = {};
+      for (var i in program.uniformData) {
+          var data = program.uniformData[i];
+          uniformData[i] = {
+              location: gl.getUniformLocation(webGLProgram, i),
+              value: defaultValue(data.type, data.size),
+          };
+      }
+      var glProgram = new GLProgram(webGLProgram, uniformData);
+      return glProgram;
+  }
 
-// performance.now
-if (!(global.performance && global.performance.now)) {
-    var startTime = Date.now();
+  var UID = 0;
+  // default sync data so we don't create a new one each time!
+  var defaultSyncData = { textureCount: 0, uboCount: 0 };
+  /**
+   * System plugin to the renderer to manage shaders.
+   * @memberof PIXI
+   */
+  var ShaderSystem = /** @class */ (function () {
+      /** @param renderer - The renderer this System works for. */
+      function ShaderSystem(renderer) {
+          this.destroyed = false;
+          this.renderer = renderer;
+          // Validation check that this environment support `new Function`
+          this.systemCheck();
+          this.gl = null;
+          this.shader = null;
+          this.program = null;
+          this.cache = {};
+          this._uboCache = {};
+          this.id = UID++;
+      }
+      /**
+       * Overrideable function by `@pixi/unsafe-eval` to silence
+       * throwing an error if platform doesn't support unsafe-evals.
+       * @private
+       */
+      ShaderSystem.prototype.systemCheck = function () {
+          if (!unsafeEvalSupported()) {
+              throw new Error('Current environment does not allow unsafe-eval, '
+                  + 'please use @pixi/unsafe-eval module to enable support.');
+          }
+      };
+      ShaderSystem.prototype.contextChange = function (gl) {
+          this.gl = gl;
+          this.reset();
+      };
+      /**
+       * Changes the current shader to the one given in parameter.
+       * @param shader - the new shader
+       * @param dontSync - false if the shader should automatically sync its uniforms.
+       * @returns the glProgram that belongs to the shader.
+       */
+      ShaderSystem.prototype.bind = function (shader, dontSync) {
+          shader.disposeRunner.add(this);
+          shader.uniforms.globals = this.renderer.globalUniforms;
+          var program = shader.program;
+          var glProgram = program.glPrograms[this.renderer.CONTEXT_UID] || this.generateProgram(shader);
+          this.shader = shader;
+          // TODO - some current Pixi plugins bypass this.. so it not safe to use yet..
+          if (this.program !== program) {
+              this.program = program;
+              this.gl.useProgram(glProgram.program);
+          }
+          if (!dontSync) {
+              defaultSyncData.textureCount = 0;
+              defaultSyncData.uboCount = 0;
+              this.syncUniformGroup(shader.uniformGroup, defaultSyncData);
+          }
+          return glProgram;
+      };
+      /**
+       * Uploads the uniforms values to the currently bound shader.
+       * @param uniforms - the uniforms values that be applied to the current shader
+       */
+      ShaderSystem.prototype.setUniforms = function (uniforms) {
+          var shader = this.shader.program;
+          var glProgram = shader.glPrograms[this.renderer.CONTEXT_UID];
+          shader.syncUniforms(glProgram.uniformData, uniforms, this.renderer);
+      };
+      /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+      /**
+       * Syncs uniforms on the group
+       * @param group - the uniform group to sync
+       * @param syncData - this is data that is passed to the sync function and any nested sync functions
+       */
+      ShaderSystem.prototype.syncUniformGroup = function (group, syncData) {
+          var glProgram = this.getGlProgram();
+          if (!group.static || group.dirtyId !== glProgram.uniformDirtyGroups[group.id]) {
+              glProgram.uniformDirtyGroups[group.id] = group.dirtyId;
+              this.syncUniforms(group, glProgram, syncData);
+          }
+      };
+      /**
+       * Overrideable by the @pixi/unsafe-eval package to use static syncUniforms instead.
+       * @param group
+       * @param glProgram
+       * @param syncData
+       */
+      ShaderSystem.prototype.syncUniforms = function (group, glProgram, syncData) {
+          var syncFunc = group.syncUniforms[this.shader.program.id] || this.createSyncGroups(group);
+          syncFunc(glProgram.uniformData, group.uniforms, this.renderer, syncData);
+      };
+      ShaderSystem.prototype.createSyncGroups = function (group) {
+          var id = this.getSignature(group, this.shader.program.uniformData, 'u');
+          if (!this.cache[id]) {
+              this.cache[id] = generateUniformsSync(group, this.shader.program.uniformData);
+          }
+          group.syncUniforms[this.shader.program.id] = this.cache[id];
+          return group.syncUniforms[this.shader.program.id];
+      };
+      /**
+       * Syncs uniform buffers
+       * @param group - the uniform buffer group to sync
+       * @param name - the name of the uniform buffer
+       */
+      ShaderSystem.prototype.syncUniformBufferGroup = function (group, name) {
+          var glProgram = this.getGlProgram();
+          if (!group.static || group.dirtyId !== 0 || !glProgram.uniformGroups[group.id]) {
+              group.dirtyId = 0;
+              var syncFunc = glProgram.uniformGroups[group.id]
+                  || this.createSyncBufferGroup(group, glProgram, name);
+              // TODO wrap update in a cache??
+              group.buffer.update();
+              syncFunc(glProgram.uniformData, group.uniforms, this.renderer, defaultSyncData, group.buffer);
+          }
+          this.renderer.buffer.bindBufferBase(group.buffer, glProgram.uniformBufferBindings[name]);
+      };
+      /**
+       * Will create a function that uploads a uniform buffer using the STD140 standard.
+       * The upload function will then be cached for future calls
+       * If a group is manually managed, then a simple upload function is generated
+       * @param group - the uniform buffer group to sync
+       * @param glProgram - the gl program to attach the uniform bindings to
+       * @param name - the name of the uniform buffer (must exist on the shader)
+       */
+      ShaderSystem.prototype.createSyncBufferGroup = function (group, glProgram, name) {
+          var gl = this.renderer.gl;
+          this.renderer.buffer.bind(group.buffer);
+          // bind them...
+          var uniformBlockIndex = this.gl.getUniformBlockIndex(glProgram.program, name);
+          glProgram.uniformBufferBindings[name] = this.shader.uniformBindCount;
+          gl.uniformBlockBinding(glProgram.program, uniformBlockIndex, this.shader.uniformBindCount);
+          this.shader.uniformBindCount++;
+          var id = this.getSignature(group, this.shader.program.uniformData, 'ubo');
+          var uboData = this._uboCache[id];
+          if (!uboData) {
+              uboData = this._uboCache[id] = generateUniformBufferSync(group, this.shader.program.uniformData);
+          }
+          if (group.autoManage) {
+              var data = new Float32Array(uboData.size / 4);
+              group.buffer.update(data);
+          }
+          glProgram.uniformGroups[group.id] = uboData.syncFunc;
+          return glProgram.uniformGroups[group.id];
+      };
+      /**
+       * Takes a uniform group and data and generates a unique signature for them.
+       * @param group - The uniform group to get signature of
+       * @param group.uniforms
+       * @param uniformData - Uniform information generated by the shader
+       * @param preFix
+       * @returns Unique signature of the uniform group
+       */
+      ShaderSystem.prototype.getSignature = function (group, uniformData, preFix) {
+          var uniforms = group.uniforms;
+          var strings = [preFix + "-"];
+          for (var i in uniforms) {
+              strings.push(i);
+              if (uniformData[i]) {
+                  strings.push(uniformData[i].type);
+              }
+          }
+          return strings.join('-');
+      };
+      /**
+       * Returns the underlying GLShade rof the currently bound shader.
+       *
+       * This can be handy for when you to have a little more control over the setting of your uniforms.
+       * @returns The glProgram for the currently bound Shader for this context
+       */
+      ShaderSystem.prototype.getGlProgram = function () {
+          if (this.shader) {
+              return this.shader.program.glPrograms[this.renderer.CONTEXT_UID];
+          }
+          return null;
+      };
+      /**
+       * Generates a glProgram version of the Shader provided.
+       * @param shader - The shader that the glProgram will be based on.
+       * @returns A shiny new glProgram!
+       */
+      ShaderSystem.prototype.generateProgram = function (shader) {
+          var gl = this.gl;
+          var program = shader.program;
+          var glProgram = generateProgram(gl, program);
+          program.glPrograms[this.renderer.CONTEXT_UID] = glProgram;
+          return glProgram;
+      };
+      /** Resets ShaderSystem state, does not affect WebGL state. */
+      ShaderSystem.prototype.reset = function () {
+          this.program = null;
+          this.shader = null;
+      };
+      /**
+       * Disposes shader.
+       * If disposing one equals with current shader, set current as null.
+       * @param shader - Shader object
+       */
+      ShaderSystem.prototype.disposeShader = function (shader) {
+          if (this.shader === shader) {
+              this.shader = null;
+          }
+      };
+      /** Destroys this System and removes all its textures. */
+      ShaderSystem.prototype.destroy = function () {
+          this.renderer = null;
+          // TODO implement destroy method for ShaderSystem
+          this.destroyed = true;
+      };
+      return ShaderSystem;
+  }());
 
-    if (!global.performance) {
-        global.performance = {};
-    }
+  /**
+   * Maps gl blend combinations to WebGL.
+   * @memberof PIXI
+   * @function mapWebGLBlendModesToPixi
+   * @private
+   * @param {WebGLRenderingContext} gl - The rendering context.
+   * @param {number[][]} [array=[]] - The array to output into.
+   * @returns {number[][]} Mapped modes.
+   */
+  function mapWebGLBlendModesToPixi(gl, array) {
+      if (array === void 0) { array = []; }
+      // TODO - premultiply alpha would be different.
+      // add a boolean for that!
+      array[exports.BLEND_MODES.NORMAL] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.ADD] = [gl.ONE, gl.ONE];
+      array[exports.BLEND_MODES.MULTIPLY] = [gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.SCREEN] = [gl.ONE, gl.ONE_MINUS_SRC_COLOR, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.OVERLAY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.DARKEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.LIGHTEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.COLOR_DODGE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.COLOR_BURN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.HARD_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.SOFT_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.DIFFERENCE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.EXCLUSION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.HUE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.SATURATION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.COLOR] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.LUMINOSITY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.NONE] = [0, 0];
+      // not-premultiplied blend modes
+      array[exports.BLEND_MODES.NORMAL_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.ADD_NPM] = [gl.SRC_ALPHA, gl.ONE, gl.ONE, gl.ONE];
+      array[exports.BLEND_MODES.SCREEN_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_COLOR, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+      // composite operations
+      array[exports.BLEND_MODES.SRC_IN] = [gl.DST_ALPHA, gl.ZERO];
+      array[exports.BLEND_MODES.SRC_OUT] = [gl.ONE_MINUS_DST_ALPHA, gl.ZERO];
+      array[exports.BLEND_MODES.SRC_ATOP] = [gl.DST_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.DST_OVER] = [gl.ONE_MINUS_DST_ALPHA, gl.ONE];
+      array[exports.BLEND_MODES.DST_IN] = [gl.ZERO, gl.SRC_ALPHA];
+      array[exports.BLEND_MODES.DST_OUT] = [gl.ZERO, gl.ONE_MINUS_SRC_ALPHA];
+      array[exports.BLEND_MODES.DST_ATOP] = [gl.ONE_MINUS_DST_ALPHA, gl.SRC_ALPHA];
+      array[exports.BLEND_MODES.XOR] = [gl.ONE_MINUS_DST_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
+      // SUBTRACT from flash
+      array[exports.BLEND_MODES.SUBTRACT] = [gl.ONE, gl.ONE, gl.ONE, gl.ONE, gl.FUNC_REVERSE_SUBTRACT, gl.FUNC_ADD];
+      return array;
+  }
 
-    global.performance.now = function () {
-        return Date.now() - startTime;
-    };
-}
+  var BLEND = 0;
+  var OFFSET = 1;
+  var CULLING = 2;
+  var DEPTH_TEST = 3;
+  var WINDING = 4;
+  var DEPTH_MASK = 5;
+  /**
+   * System plugin to the renderer to manage WebGL state machines.
+   * @memberof PIXI
+   */
+  var StateSystem = /** @class */ (function () {
+      function StateSystem() {
+          this.gl = null;
+          this.stateId = 0;
+          this.polygonOffset = 0;
+          this.blendMode = exports.BLEND_MODES.NONE;
+          this._blendEq = false;
+          // map functions for when we set state..
+          this.map = [];
+          this.map[BLEND] = this.setBlend;
+          this.map[OFFSET] = this.setOffset;
+          this.map[CULLING] = this.setCullFace;
+          this.map[DEPTH_TEST] = this.setDepthTest;
+          this.map[WINDING] = this.setFrontFace;
+          this.map[DEPTH_MASK] = this.setDepthMask;
+          this.checks = [];
+          this.defaultState = new State();
+          this.defaultState.blend = true;
+      }
+      StateSystem.prototype.contextChange = function (gl) {
+          this.gl = gl;
+          this.blendModes = mapWebGLBlendModesToPixi(gl);
+          this.set(this.defaultState);
+          this.reset();
+      };
+      /**
+       * Sets the current state
+       * @param {*} state - The state to set.
+       */
+      StateSystem.prototype.set = function (state) {
+          state = state || this.defaultState;
+          // TODO maybe to an object check? ( this.state === state )?
+          if (this.stateId !== state.data) {
+              var diff = this.stateId ^ state.data;
+              var i = 0;
+              // order from least to most common
+              while (diff) {
+                  if (diff & 1) {
+                      // state change!
+                      this.map[i].call(this, !!(state.data & (1 << i)));
+                  }
+                  diff = diff >> 1;
+                  i++;
+              }
+              this.stateId = state.data;
+          }
+          // based on the above settings we check for specific modes..
+          // for example if blend is active we check and set the blend modes
+          // or of polygon offset is active we check the poly depth.
+          for (var i = 0; i < this.checks.length; i++) {
+              this.checks[i](this, state);
+          }
+      };
+      /**
+       * Sets the state, when previous state is unknown.
+       * @param {*} state - The state to set
+       */
+      StateSystem.prototype.forceState = function (state) {
+          state = state || this.defaultState;
+          for (var i = 0; i < this.map.length; i++) {
+              this.map[i].call(this, !!(state.data & (1 << i)));
+          }
+          for (var i = 0; i < this.checks.length; i++) {
+              this.checks[i](this, state);
+          }
+          this.stateId = state.data;
+      };
+      /**
+       * Sets whether to enable or disable blending.
+       * @param value - Turn on or off WebGl blending.
+       */
+      StateSystem.prototype.setBlend = function (value) {
+          this.updateCheck(StateSystem.checkBlendMode, value);
+          this.gl[value ? 'enable' : 'disable'](this.gl.BLEND);
+      };
+      /**
+       * Sets whether to enable or disable polygon offset fill.
+       * @param value - Turn on or off webgl polygon offset testing.
+       */
+      StateSystem.prototype.setOffset = function (value) {
+          this.updateCheck(StateSystem.checkPolygonOffset, value);
+          this.gl[value ? 'enable' : 'disable'](this.gl.POLYGON_OFFSET_FILL);
+      };
+      /**
+       * Sets whether to enable or disable depth test.
+       * @param value - Turn on or off webgl depth testing.
+       */
+      StateSystem.prototype.setDepthTest = function (value) {
+          this.gl[value ? 'enable' : 'disable'](this.gl.DEPTH_TEST);
+      };
+      /**
+       * Sets whether to enable or disable depth mask.
+       * @param value - Turn on or off webgl depth mask.
+       */
+      StateSystem.prototype.setDepthMask = function (value) {
+          this.gl.depthMask(value);
+      };
+      /**
+       * Sets whether to enable or disable cull face.
+       * @param {boolean} value - Turn on or off webgl cull face.
+       */
+      StateSystem.prototype.setCullFace = function (value) {
+          this.gl[value ? 'enable' : 'disable'](this.gl.CULL_FACE);
+      };
+      /**
+       * Sets the gl front face.
+       * @param {boolean} value - true is clockwise and false is counter-clockwise
+       */
+      StateSystem.prototype.setFrontFace = function (value) {
+          this.gl.frontFace(this.gl[value ? 'CW' : 'CCW']);
+      };
+      /**
+       * Sets the blend mode.
+       * @param {number} value - The blend mode to set to.
+       */
+      StateSystem.prototype.setBlendMode = function (value) {
+          if (value === this.blendMode) {
+              return;
+          }
+          this.blendMode = value;
+          var mode = this.blendModes[value];
+          var gl = this.gl;
+          if (mode.length === 2) {
+              gl.blendFunc(mode[0], mode[1]);
+          }
+          else {
+              gl.blendFuncSeparate(mode[0], mode[1], mode[2], mode[3]);
+          }
+          if (mode.length === 6) {
+              this._blendEq = true;
+              gl.blendEquationSeparate(mode[4], mode[5]);
+          }
+          else if (this._blendEq) {
+              this._blendEq = false;
+              gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD);
+          }
+      };
+      /**
+       * Sets the polygon offset.
+       * @param {number} value - the polygon offset
+       * @param {number} scale - the polygon offset scale
+       */
+      StateSystem.prototype.setPolygonOffset = function (value, scale) {
+          this.gl.polygonOffset(value, scale);
+      };
+      // used
+      /** Resets all the logic and disables the VAOs. */
+      StateSystem.prototype.reset = function () {
+          this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, false);
+          this.forceState(this.defaultState);
+          this._blendEq = true;
+          this.blendMode = -1;
+          this.setBlendMode(0);
+      };
+      /**
+       * Checks to see which updates should be checked based on which settings have been activated.
+       *
+       * For example, if blend is enabled then we should check the blend modes each time the state is changed
+       * or if polygon fill is activated then we need to check if the polygon offset changes.
+       * The idea is that we only check what we have too.
+       * @param func - the checking function to add or remove
+       * @param value - should the check function be added or removed.
+       */
+      StateSystem.prototype.updateCheck = function (func, value) {
+          var index = this.checks.indexOf(func);
+          if (value && index === -1) {
+              this.checks.push(func);
+          }
+          else if (!value && index !== -1) {
+              this.checks.splice(index, 1);
+          }
+      };
+      /**
+       * A private little wrapper function that we call to check the blend mode.
+       * @param system - the System to perform the state check on
+       * @param state - the state that the blendMode will pulled from
+       */
+      StateSystem.checkBlendMode = function (system, state) {
+          system.setBlendMode(state.blendMode);
+      };
+      /**
+       * A private little wrapper function that we call to check the polygon offset.
+       * @param system - the System to perform the state check on
+       * @param state - the state that the blendMode will pulled from
+       */
+      StateSystem.checkPolygonOffset = function (system, state) {
+          system.setPolygonOffset(1, state.polygonOffset);
+      };
+      /**
+       * @ignore
+       */
+      StateSystem.prototype.destroy = function () {
+          this.gl = null;
+      };
+      return StateSystem;
+  }());
 
-// requestAnimationFrame
-var lastTime = Date.now();
-var vendors = ['ms', 'moz', 'webkit', 'o'];
+  /**
+   * System plugin to the renderer to manage texture garbage collection on the GPU,
+   * ensuring that it does not get clogged up with textures that are no longer being used.
+   * @memberof PIXI
+   */
+  var TextureGCSystem = /** @class */ (function () {
+      /** @param renderer - The renderer this System works for. */
+      function TextureGCSystem(renderer) {
+          this.renderer = renderer;
+          this.count = 0;
+          this.checkCount = 0;
+          this.maxIdle = settings.GC_MAX_IDLE;
+          this.checkCountMax = settings.GC_MAX_CHECK_COUNT;
+          this.mode = settings.GC_MODE;
+      }
+      /**
+       * Checks to see when the last time a texture was used
+       * if the texture has not been used for a specified amount of time it will be removed from the GPU
+       */
+      TextureGCSystem.prototype.postrender = function () {
+          if (!this.renderer.renderingToScreen) {
+              return;
+          }
+          this.count++;
+          if (this.mode === exports.GC_MODES.MANUAL) {
+              return;
+          }
+          this.checkCount++;
+          if (this.checkCount > this.checkCountMax) {
+              this.checkCount = 0;
+              this.run();
+          }
+      };
+      /**
+       * Checks to see when the last time a texture was used
+       * if the texture has not been used for a specified amount of time it will be removed from the GPU
+       */
+      TextureGCSystem.prototype.run = function () {
+          var tm = this.renderer.texture;
+          var managedTextures = tm.managedTextures;
+          var wasRemoved = false;
+          for (var i = 0; i < managedTextures.length; i++) {
+              var texture = managedTextures[i];
+              // only supports non generated textures at the moment!
+              if (!texture.framebuffer && this.count - texture.touched > this.maxIdle) {
+                  tm.destroyTexture(texture, true);
+                  managedTextures[i] = null;
+                  wasRemoved = true;
+              }
+          }
+          if (wasRemoved) {
+              var j = 0;
+              for (var i = 0; i < managedTextures.length; i++) {
+                  if (managedTextures[i] !== null) {
+                      managedTextures[j++] = managedTextures[i];
+                  }
+              }
+              managedTextures.length = j;
+          }
+      };
+      /**
+       * Removes all the textures within the specified displayObject and its children from the GPU
+       * @param {PIXI.DisplayObject} displayObject - the displayObject to remove the textures from.
+       */
+      TextureGCSystem.prototype.unload = function (displayObject) {
+          var tm = this.renderer.texture;
+          var texture = displayObject._texture;
+          // only destroy non generated textures
+          if (texture && !texture.framebuffer) {
+              tm.destroyTexture(texture);
+          }
+          for (var i = displayObject.children.length - 1; i >= 0; i--) {
+              this.unload(displayObject.children[i]);
+          }
+      };
+      TextureGCSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return TextureGCSystem;
+  }());
 
-for (var x = 0; x < vendors.length && !global.requestAnimationFrame; ++x) {
-    var p = vendors[x];
+  /**
+   * Returns a lookup table that maps each type-format pair to a compatible internal format.
+   * @memberof PIXI
+   * @function mapTypeAndFormatToInternalFormat
+   * @private
+   * @param {WebGLRenderingContext} gl - The rendering context.
+   * @returns Lookup table.
+   */
+  function mapTypeAndFormatToInternalFormat(gl) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+      var table;
+      if ('WebGL2RenderingContext' in globalThis && gl instanceof globalThis.WebGL2RenderingContext) {
+          table = (_a = {},
+              _a[exports.TYPES.UNSIGNED_BYTE] = (_b = {},
+                  _b[exports.FORMATS.RGBA] = gl.RGBA8,
+                  _b[exports.FORMATS.RGB] = gl.RGB8,
+                  _b[exports.FORMATS.RG] = gl.RG8,
+                  _b[exports.FORMATS.RED] = gl.R8,
+                  _b[exports.FORMATS.RGBA_INTEGER] = gl.RGBA8UI,
+                  _b[exports.FORMATS.RGB_INTEGER] = gl.RGB8UI,
+                  _b[exports.FORMATS.RG_INTEGER] = gl.RG8UI,
+                  _b[exports.FORMATS.RED_INTEGER] = gl.R8UI,
+                  _b[exports.FORMATS.ALPHA] = gl.ALPHA,
+                  _b[exports.FORMATS.LUMINANCE] = gl.LUMINANCE,
+                  _b[exports.FORMATS.LUMINANCE_ALPHA] = gl.LUMINANCE_ALPHA,
+                  _b),
+              _a[exports.TYPES.BYTE] = (_c = {},
+                  _c[exports.FORMATS.RGBA] = gl.RGBA8_SNORM,
+                  _c[exports.FORMATS.RGB] = gl.RGB8_SNORM,
+                  _c[exports.FORMATS.RG] = gl.RG8_SNORM,
+                  _c[exports.FORMATS.RED] = gl.R8_SNORM,
+                  _c[exports.FORMATS.RGBA_INTEGER] = gl.RGBA8I,
+                  _c[exports.FORMATS.RGB_INTEGER] = gl.RGB8I,
+                  _c[exports.FORMATS.RG_INTEGER] = gl.RG8I,
+                  _c[exports.FORMATS.RED_INTEGER] = gl.R8I,
+                  _c),
+              _a[exports.TYPES.UNSIGNED_SHORT] = (_d = {},
+                  _d[exports.FORMATS.RGBA_INTEGER] = gl.RGBA16UI,
+                  _d[exports.FORMATS.RGB_INTEGER] = gl.RGB16UI,
+                  _d[exports.FORMATS.RG_INTEGER] = gl.RG16UI,
+                  _d[exports.FORMATS.RED_INTEGER] = gl.R16UI,
+                  _d[exports.FORMATS.DEPTH_COMPONENT] = gl.DEPTH_COMPONENT16,
+                  _d),
+              _a[exports.TYPES.SHORT] = (_e = {},
+                  _e[exports.FORMATS.RGBA_INTEGER] = gl.RGBA16I,
+                  _e[exports.FORMATS.RGB_INTEGER] = gl.RGB16I,
+                  _e[exports.FORMATS.RG_INTEGER] = gl.RG16I,
+                  _e[exports.FORMATS.RED_INTEGER] = gl.R16I,
+                  _e),
+              _a[exports.TYPES.UNSIGNED_INT] = (_f = {},
+                  _f[exports.FORMATS.RGBA_INTEGER] = gl.RGBA32UI,
+                  _f[exports.FORMATS.RGB_INTEGER] = gl.RGB32UI,
+                  _f[exports.FORMATS.RG_INTEGER] = gl.RG32UI,
+                  _f[exports.FORMATS.RED_INTEGER] = gl.R32UI,
+                  _f[exports.FORMATS.DEPTH_COMPONENT] = gl.DEPTH_COMPONENT24,
+                  _f),
+              _a[exports.TYPES.INT] = (_g = {},
+                  _g[exports.FORMATS.RGBA_INTEGER] = gl.RGBA32I,
+                  _g[exports.FORMATS.RGB_INTEGER] = gl.RGB32I,
+                  _g[exports.FORMATS.RG_INTEGER] = gl.RG32I,
+                  _g[exports.FORMATS.RED_INTEGER] = gl.R32I,
+                  _g),
+              _a[exports.TYPES.FLOAT] = (_h = {},
+                  _h[exports.FORMATS.RGBA] = gl.RGBA32F,
+                  _h[exports.FORMATS.RGB] = gl.RGB32F,
+                  _h[exports.FORMATS.RG] = gl.RG32F,
+                  _h[exports.FORMATS.RED] = gl.R32F,
+                  _h[exports.FORMATS.DEPTH_COMPONENT] = gl.DEPTH_COMPONENT32F,
+                  _h),
+              _a[exports.TYPES.HALF_FLOAT] = (_j = {},
+                  _j[exports.FORMATS.RGBA] = gl.RGBA16F,
+                  _j[exports.FORMATS.RGB] = gl.RGB16F,
+                  _j[exports.FORMATS.RG] = gl.RG16F,
+                  _j[exports.FORMATS.RED] = gl.R16F,
+                  _j),
+              _a[exports.TYPES.UNSIGNED_SHORT_5_6_5] = (_k = {},
+                  _k[exports.FORMATS.RGB] = gl.RGB565,
+                  _k),
+              _a[exports.TYPES.UNSIGNED_SHORT_4_4_4_4] = (_l = {},
+                  _l[exports.FORMATS.RGBA] = gl.RGBA4,
+                  _l),
+              _a[exports.TYPES.UNSIGNED_SHORT_5_5_5_1] = (_m = {},
+                  _m[exports.FORMATS.RGBA] = gl.RGB5_A1,
+                  _m),
+              _a[exports.TYPES.UNSIGNED_INT_2_10_10_10_REV] = (_o = {},
+                  _o[exports.FORMATS.RGBA] = gl.RGB10_A2,
+                  _o[exports.FORMATS.RGBA_INTEGER] = gl.RGB10_A2UI,
+                  _o),
+              _a[exports.TYPES.UNSIGNED_INT_10F_11F_11F_REV] = (_p = {},
+                  _p[exports.FORMATS.RGB] = gl.R11F_G11F_B10F,
+                  _p),
+              _a[exports.TYPES.UNSIGNED_INT_5_9_9_9_REV] = (_q = {},
+                  _q[exports.FORMATS.RGB] = gl.RGB9_E5,
+                  _q),
+              _a[exports.TYPES.UNSIGNED_INT_24_8] = (_r = {},
+                  _r[exports.FORMATS.DEPTH_STENCIL] = gl.DEPTH24_STENCIL8,
+                  _r),
+              _a[exports.TYPES.FLOAT_32_UNSIGNED_INT_24_8_REV] = (_s = {},
+                  _s[exports.FORMATS.DEPTH_STENCIL] = gl.DEPTH32F_STENCIL8,
+                  _s),
+              _a);
+      }
+      else {
+          table = (_t = {},
+              _t[exports.TYPES.UNSIGNED_BYTE] = (_u = {},
+                  _u[exports.FORMATS.RGBA] = gl.RGBA,
+                  _u[exports.FORMATS.RGB] = gl.RGB,
+                  _u[exports.FORMATS.ALPHA] = gl.ALPHA,
+                  _u[exports.FORMATS.LUMINANCE] = gl.LUMINANCE,
+                  _u[exports.FORMATS.LUMINANCE_ALPHA] = gl.LUMINANCE_ALPHA,
+                  _u),
+              _t[exports.TYPES.UNSIGNED_SHORT_5_6_5] = (_v = {},
+                  _v[exports.FORMATS.RGB] = gl.RGB,
+                  _v),
+              _t[exports.TYPES.UNSIGNED_SHORT_4_4_4_4] = (_w = {},
+                  _w[exports.FORMATS.RGBA] = gl.RGBA,
+                  _w),
+              _t[exports.TYPES.UNSIGNED_SHORT_5_5_5_1] = (_x = {},
+                  _x[exports.FORMATS.RGBA] = gl.RGBA,
+                  _x),
+              _t);
+      }
+      return table;
+  }
 
-    global.requestAnimationFrame = global[p + 'RequestAnimationFrame'];
-    global.cancelAnimationFrame = global[p + 'CancelAnimationFrame'] || global[p + 'CancelRequestAnimationFrame'];
-}
+  /**
+   * Internal texture for WebGL context.
+   * @memberof PIXI
+   */
+  var GLTexture = /** @class */ (function () {
+      function GLTexture(texture) {
+          this.texture = texture;
+          this.width = -1;
+          this.height = -1;
+          this.dirtyId = -1;
+          this.dirtyStyleId = -1;
+          this.mipmap = false;
+          this.wrapMode = 33071;
+          this.type = exports.TYPES.UNSIGNED_BYTE;
+          this.internalFormat = exports.FORMATS.RGBA;
+          this.samplerType = 0;
+      }
+      return GLTexture;
+  }());
 
-if (!global.requestAnimationFrame) {
-    global.requestAnimationFrame = function (callback) {
-        if (typeof callback !== 'function') {
-            throw new TypeError(callback + 'is not a function');
-        }
+  /**
+   * System plugin to the renderer to manage textures.
+   * @memberof PIXI
+   */
+  var TextureSystem = /** @class */ (function () {
+      /**
+       * @param renderer - The renderer this system works for.
+       */
+      function TextureSystem(renderer) {
+          this.renderer = renderer;
+          // TODO set to max textures...
+          this.boundTextures = [];
+          this.currentLocation = -1;
+          this.managedTextures = [];
+          this._unknownBoundTextures = false;
+          this.unknownTexture = new BaseTexture();
+          this.hasIntegerTextures = false;
+      }
+      /** Sets up the renderer context and necessary buffers. */
+      TextureSystem.prototype.contextChange = function () {
+          var gl = this.gl = this.renderer.gl;
+          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+          this.webGLVersion = this.renderer.context.webGLVersion;
+          this.internalFormats = mapTypeAndFormatToInternalFormat(gl);
+          var maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
+          this.boundTextures.length = maxTextures;
+          for (var i = 0; i < maxTextures; i++) {
+              this.boundTextures[i] = null;
+          }
+          // TODO move this.. to a nice make empty textures class..
+          this.emptyTextures = {};
+          var emptyTexture2D = new GLTexture(gl.createTexture());
+          gl.bindTexture(gl.TEXTURE_2D, emptyTexture2D.texture);
+          gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4));
+          this.emptyTextures[gl.TEXTURE_2D] = emptyTexture2D;
+          this.emptyTextures[gl.TEXTURE_CUBE_MAP] = new GLTexture(gl.createTexture());
+          gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.emptyTextures[gl.TEXTURE_CUBE_MAP].texture);
+          for (var i = 0; i < 6; i++) {
+              gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+          }
+          gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+          gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+          for (var i = 0; i < this.boundTextures.length; i++) {
+              this.bind(null, i);
+          }
+      };
+      /**
+       * Bind a texture to a specific location
+       *
+       * If you want to unbind something, please use `unbind(texture)` instead of `bind(null, textureLocation)`
+       * @param texture - Texture to bind
+       * @param [location=0] - Location to bind at
+       */
+      TextureSystem.prototype.bind = function (texture, location) {
+          if (location === void 0) { location = 0; }
+          var gl = this.gl;
+          texture = texture === null || texture === void 0 ? void 0 : texture.castToBaseTexture();
+          // cannot bind partial texture
+          // TODO: report a warning
+          if (texture && texture.valid && !texture.parentTextureArray) {
+              texture.touched = this.renderer.textureGC.count;
+              var glTexture = texture._glTextures[this.CONTEXT_UID] || this.initTexture(texture);
+              if (this.boundTextures[location] !== texture) {
+                  if (this.currentLocation !== location) {
+                      this.currentLocation = location;
+                      gl.activeTexture(gl.TEXTURE0 + location);
+                  }
+                  gl.bindTexture(texture.target, glTexture.texture);
+              }
+              if (glTexture.dirtyId !== texture.dirtyId) {
+                  if (this.currentLocation !== location) {
+                      this.currentLocation = location;
+                      gl.activeTexture(gl.TEXTURE0 + location);
+                  }
+                  this.updateTexture(texture);
+              }
+              else if (glTexture.dirtyStyleId !== texture.dirtyStyleId) {
+                  this.updateTextureStyle(texture);
+              }
+              this.boundTextures[location] = texture;
+          }
+          else {
+              if (this.currentLocation !== location) {
+                  this.currentLocation = location;
+                  gl.activeTexture(gl.TEXTURE0 + location);
+              }
+              gl.bindTexture(gl.TEXTURE_2D, this.emptyTextures[gl.TEXTURE_2D].texture);
+              this.boundTextures[location] = null;
+          }
+      };
+      /** Resets texture location and bound textures Actual `bind(null, i)` calls will be performed at next `unbind()` call */
+      TextureSystem.prototype.reset = function () {
+          this._unknownBoundTextures = true;
+          this.hasIntegerTextures = false;
+          this.currentLocation = -1;
+          for (var i = 0; i < this.boundTextures.length; i++) {
+              this.boundTextures[i] = this.unknownTexture;
+          }
+      };
+      /**
+       * Unbind a texture.
+       * @param texture - Texture to bind
+       */
+      TextureSystem.prototype.unbind = function (texture) {
+          var _a = this, gl = _a.gl, boundTextures = _a.boundTextures;
+          if (this._unknownBoundTextures) {
+              this._unknownBoundTextures = false;
+              // someone changed webGL state,
+              // we have to be sure that our texture does not appear in multi-texture renderer samplers
+              for (var i = 0; i < boundTextures.length; i++) {
+                  if (boundTextures[i] === this.unknownTexture) {
+                      this.bind(null, i);
+                  }
+              }
+          }
+          for (var i = 0; i < boundTextures.length; i++) {
+              if (boundTextures[i] === texture) {
+                  if (this.currentLocation !== i) {
+                      gl.activeTexture(gl.TEXTURE0 + i);
+                      this.currentLocation = i;
+                  }
+                  gl.bindTexture(texture.target, this.emptyTextures[texture.target].texture);
+                  boundTextures[i] = null;
+              }
+          }
+      };
+      /**
+       * Ensures that current boundTextures all have FLOAT sampler type,
+       * see {@link PIXI.SAMPLER_TYPES} for explanation.
+       * @param maxTextures - number of locations to check
+       */
+      TextureSystem.prototype.ensureSamplerType = function (maxTextures) {
+          var _a = this, boundTextures = _a.boundTextures, hasIntegerTextures = _a.hasIntegerTextures, CONTEXT_UID = _a.CONTEXT_UID;
+          if (!hasIntegerTextures) {
+              return;
+          }
+          for (var i = maxTextures - 1; i >= 0; --i) {
+              var tex = boundTextures[i];
+              if (tex) {
+                  var glTexture = tex._glTextures[CONTEXT_UID];
+                  if (glTexture.samplerType !== exports.SAMPLER_TYPES.FLOAT) {
+                      this.renderer.texture.unbind(tex);
+                  }
+              }
+          }
+      };
+      /**
+       * Initialize a texture
+       * @private
+       * @param texture - Texture to initialize
+       */
+      TextureSystem.prototype.initTexture = function (texture) {
+          var glTexture = new GLTexture(this.gl.createTexture());
+          // guarantee an update..
+          glTexture.dirtyId = -1;
+          texture._glTextures[this.CONTEXT_UID] = glTexture;
+          this.managedTextures.push(texture);
+          texture.on('dispose', this.destroyTexture, this);
+          return glTexture;
+      };
+      TextureSystem.prototype.initTextureType = function (texture, glTexture) {
+          var _a, _b;
+          glTexture.internalFormat = (_b = (_a = this.internalFormats[texture.type]) === null || _a === void 0 ? void 0 : _a[texture.format]) !== null && _b !== void 0 ? _b : texture.format;
+          if (this.webGLVersion === 2 && texture.type === exports.TYPES.HALF_FLOAT) {
+              // TYPES.HALF_FLOAT is WebGL1 HALF_FLOAT_OES
+              // we have to convert it to WebGL HALF_FLOAT
+              glTexture.type = this.gl.HALF_FLOAT;
+          }
+          else {
+              glTexture.type = texture.type;
+          }
+      };
+      /**
+       * Update a texture
+       * @private
+       * @param {PIXI.BaseTexture} texture - Texture to initialize
+       */
+      TextureSystem.prototype.updateTexture = function (texture) {
+          var glTexture = texture._glTextures[this.CONTEXT_UID];
+          if (!glTexture) {
+              return;
+          }
+          var renderer = this.renderer;
+          this.initTextureType(texture, glTexture);
+          if (texture.resource && texture.resource.upload(renderer, texture, glTexture)) {
+              // texture is uploaded, dont do anything!
+              if (glTexture.samplerType !== exports.SAMPLER_TYPES.FLOAT) {
+                  this.hasIntegerTextures = true;
+              }
+          }
+          else {
+              // default, renderTexture-like logic
+              var width = texture.realWidth;
+              var height = texture.realHeight;
+              var gl = renderer.gl;
+              if (glTexture.width !== width
+                  || glTexture.height !== height
+                  || glTexture.dirtyId < 0) {
+                  glTexture.width = width;
+                  glTexture.height = height;
+                  gl.texImage2D(texture.target, 0, glTexture.internalFormat, width, height, 0, texture.format, glTexture.type, null);
+              }
+          }
+          // lets only update what changes..
+          if (texture.dirtyStyleId !== glTexture.dirtyStyleId) {
+              this.updateTextureStyle(texture);
+          }
+          glTexture.dirtyId = texture.dirtyId;
+      };
+      /**
+       * Deletes the texture from WebGL
+       * @private
+       * @param texture - the texture to destroy
+       * @param [skipRemove=false] - Whether to skip removing the texture from the TextureManager.
+       */
+      TextureSystem.prototype.destroyTexture = function (texture, skipRemove) {
+          var gl = this.gl;
+          texture = texture.castToBaseTexture();
+          if (texture._glTextures[this.CONTEXT_UID]) {
+              this.unbind(texture);
+              gl.deleteTexture(texture._glTextures[this.CONTEXT_UID].texture);
+              texture.off('dispose', this.destroyTexture, this);
+              delete texture._glTextures[this.CONTEXT_UID];
+              if (!skipRemove) {
+                  var i = this.managedTextures.indexOf(texture);
+                  if (i !== -1) {
+                      removeItems(this.managedTextures, i, 1);
+                  }
+              }
+          }
+      };
+      /**
+       * Update texture style such as mipmap flag
+       * @private
+       * @param {PIXI.BaseTexture} texture - Texture to update
+       */
+      TextureSystem.prototype.updateTextureStyle = function (texture) {
+          var glTexture = texture._glTextures[this.CONTEXT_UID];
+          if (!glTexture) {
+              return;
+          }
+          if ((texture.mipmap === exports.MIPMAP_MODES.POW2 || this.webGLVersion !== 2) && !texture.isPowerOfTwo) {
+              glTexture.mipmap = false;
+          }
+          else {
+              glTexture.mipmap = texture.mipmap >= 1;
+          }
+          if (this.webGLVersion !== 2 && !texture.isPowerOfTwo) {
+              glTexture.wrapMode = exports.WRAP_MODES.CLAMP;
+          }
+          else {
+              glTexture.wrapMode = texture.wrapMode;
+          }
+          if (texture.resource && texture.resource.style(this.renderer, texture, glTexture)) { ; }
+          else {
+              this.setStyle(texture, glTexture);
+          }
+          glTexture.dirtyStyleId = texture.dirtyStyleId;
+      };
+      /**
+       * Set style for texture
+       * @private
+       * @param texture - Texture to update
+       * @param glTexture
+       */
+      TextureSystem.prototype.setStyle = function (texture, glTexture) {
+          var gl = this.gl;
+          if (glTexture.mipmap && texture.mipmap !== exports.MIPMAP_MODES.ON_MANUAL) {
+              gl.generateMipmap(texture.target);
+          }
+          gl.texParameteri(texture.target, gl.TEXTURE_WRAP_S, glTexture.wrapMode);
+          gl.texParameteri(texture.target, gl.TEXTURE_WRAP_T, glTexture.wrapMode);
+          if (glTexture.mipmap) {
+              /* eslint-disable max-len */
+              gl.texParameteri(texture.target, gl.TEXTURE_MIN_FILTER, texture.scaleMode === exports.SCALE_MODES.LINEAR ? gl.LINEAR_MIPMAP_LINEAR : gl.NEAREST_MIPMAP_NEAREST);
+              /* eslint-disable max-len */
+              var anisotropicExt = this.renderer.context.extensions.anisotropicFiltering;
+              if (anisotropicExt && texture.anisotropicLevel > 0 && texture.scaleMode === exports.SCALE_MODES.LINEAR) {
+                  var level = Math.min(texture.anisotropicLevel, gl.getParameter(anisotropicExt.MAX_TEXTURE_MAX_ANISOTROPY_EXT));
+                  gl.texParameterf(texture.target, anisotropicExt.TEXTURE_MAX_ANISOTROPY_EXT, level);
+              }
+          }
+          else {
+              gl.texParameteri(texture.target, gl.TEXTURE_MIN_FILTER, texture.scaleMode === exports.SCALE_MODES.LINEAR ? gl.LINEAR : gl.NEAREST);
+          }
+          gl.texParameteri(texture.target, gl.TEXTURE_MAG_FILTER, texture.scaleMode === exports.SCALE_MODES.LINEAR ? gl.LINEAR : gl.NEAREST);
+      };
+      TextureSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return TextureSystem;
+  }());
+
+  var _systems = {
+      __proto__: null,
+      FilterSystem: FilterSystem,
+      BatchSystem: BatchSystem,
+      ContextSystem: ContextSystem,
+      FramebufferSystem: FramebufferSystem,
+      GeometrySystem: GeometrySystem,
+      MaskSystem: MaskSystem,
+      ScissorSystem: ScissorSystem,
+      StencilSystem: StencilSystem,
+      ProjectionSystem: ProjectionSystem,
+      RenderTextureSystem: RenderTextureSystem,
+      ShaderSystem: ShaderSystem,
+      StateSystem: StateSystem,
+      TextureGCSystem: TextureGCSystem,
+      TextureSystem: TextureSystem
+  };
 
-        var currentTime = Date.now();
-        var delay = ONE_FRAME_TIME + lastTime - currentTime;
+  var tempMatrix = new Matrix();
+  /**
+   * The AbstractRenderer is the base for a PixiJS Renderer. It is extended by the {@link PIXI.CanvasRenderer}
+   * and {@link PIXI.Renderer} which can be used for rendering a PixiJS scene.
+   * @abstract
+   * @class
+   * @extends PIXI.utils.EventEmitter
+   * @memberof PIXI
+   */
+  var AbstractRenderer = /** @class */ (function (_super) {
+      __extends$i(AbstractRenderer, _super);
+      /**
+       * @param type - The renderer type.
+       * @param {PIXI.IRendererOptions} [options] - The optional renderer parameters.
+       * @param {boolean} [options.antialias=false] -
+       *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
+       * @param {boolean} [options.autoDensity=false] -
+       *  Whether the CSS dimensions of the renderer's view should be resized automatically.
+       * @param {number} [options.backgroundAlpha=1] -
+       *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
+       * @param {number} [options.backgroundColor=0x000000] -
+       *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
+       * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
+       * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
+       * @param {number} [options.height=600] - The height of the renderer's view.
+       * @param {string} [options.powerPreference] -
+       *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
+       *  can be `'default'`, `'high-performance'` or `'low-power'`.
+       *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
+       *  while setting to `'low-power'` will prioritize power saving over rendering performance.
+       * @param {boolean} [options.premultipliedAlpha=true] -
+       *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
+       * @param {boolean} [options.preserveDrawingBuffer=false] -
+       *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
+       *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
+       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
+       *  The resolution / device pixel ratio of the renderer.
+       * @param {boolean} [options.transparent] -
+       *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
+       *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
+       * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
+       *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
+       *  canvas needs to be opaque, possibly for performance reasons on some older devices.
+       *  If you want to set transparency, please use `backgroundAlpha`. \
+       *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
+       *  set to `true` and `premultipliedAlpha` will be to `false`.
+       * @param {HTMLCanvasElement} [options.view=null] -
+       *  The canvas to use as the view. If omitted, a new canvas will be created.
+       * @param {number} [options.width=800] - The width of the renderer's view.
+       */
+      function AbstractRenderer(type, options) {
+          if (type === void 0) { type = exports.RENDERER_TYPE.UNKNOWN; }
+          var _this = _super.call(this) || this;
+          // Add the default render options
+          options = Object.assign({}, settings.RENDER_OPTIONS, options);
+          /**
+           * The supplied constructor options.
+           * @member {object}
+           * @readonly
+           */
+          _this.options = options;
+          /**
+           * The type of the renderer.
+           * @member {number}
+           * @default PIXI.RENDERER_TYPE.UNKNOWN
+           * @see PIXI.RENDERER_TYPE
+           */
+          _this.type = type;
+          /**
+           * Measurements of the screen. (0, 0, screenWidth, screenHeight).
+           *
+           * Its safe to use as filterArea or hitArea for the whole stage.
+           * @member {PIXI.Rectangle}
+           */
+          _this.screen = new Rectangle(0, 0, options.width, options.height);
+          /**
+           * The canvas element that everything is drawn to.
+           * @member {HTMLCanvasElement}
+           */
+          _this.view = options.view || settings.ADAPTER.createCanvas();
+          /**
+           * The resolution / device pixel ratio of the renderer.
+           * @member {number}
+           * @default PIXI.settings.RESOLUTION
+           */
+          _this.resolution = options.resolution || settings.RESOLUTION;
+          /**
+           * Pass-thru setting for the canvas' context `alpha` property. This is typically
+           * not something you need to fiddle with. If you want transparency, use `backgroundAlpha`.
+           * @member {boolean}
+           */
+          _this.useContextAlpha = options.useContextAlpha;
+          /**
+           * Whether CSS dimensions of canvas view should be resized to screen dimensions automatically.
+           * @member {boolean}
+           */
+          _this.autoDensity = !!options.autoDensity;
+          /**
+           * The value of the preserveDrawingBuffer flag affects whether or not the contents of
+           * the stencil buffer is retained after rendering.
+           * @member {boolean}
+           */
+          _this.preserveDrawingBuffer = options.preserveDrawingBuffer;
+          /**
+           * This sets if the CanvasRenderer will clear the canvas or not before the new render pass.
+           * If the scene is NOT transparent PixiJS will use a canvas sized fillRect operation every
+           * frame to set the canvas background color. If the scene is transparent PixiJS will use clearRect
+           * to clear the canvas every frame. Disable this by setting this to false. For example, if
+           * your game has a canvas filling background image you often don't need this set.
+           * @member {boolean}
+           * @default
+           */
+          _this.clearBeforeRender = options.clearBeforeRender;
+          /**
+           * The background color as a number.
+           * @member {number}
+           * @protected
+           */
+          _this._backgroundColor = 0x000000;
+          /**
+           * The background color as an [R, G, B, A] array.
+           * @member {number[]}
+           * @protected
+           */
+          _this._backgroundColorRgba = [0, 0, 0, 1];
+          /**
+           * The background color as a string.
+           * @member {string}
+           * @protected
+           */
+          _this._backgroundColorString = '#000000';
+          _this.backgroundColor = options.backgroundColor || _this._backgroundColor; // run bg color setter
+          _this.backgroundAlpha = options.backgroundAlpha;
+          // @deprecated
+          if (options.transparent !== undefined) {
+              deprecation('6.0.0', 'Option transparent is deprecated, please use backgroundAlpha instead.');
+              _this.useContextAlpha = options.transparent;
+              _this.backgroundAlpha = options.transparent ? 0 : 1;
+          }
+          /**
+           * The last root object that the renderer tried to render.
+           * @member {PIXI.DisplayObject}
+           * @protected
+           */
+          _this._lastObjectRendered = null;
+          /**
+           * Collection of plugins.
+           * @readonly
+           * @member {object}
+           */
+          _this.plugins = {};
+          return _this;
+      }
+      /**
+       * Initialize the plugins.
+       * @protected
+       * @param {object} staticMap - The dictionary of statically saved plugins.
+       */
+      AbstractRenderer.prototype.initPlugins = function (staticMap) {
+          for (var o in staticMap) {
+              this.plugins[o] = new (staticMap[o])(this);
+          }
+      };
+      Object.defineProperty(AbstractRenderer.prototype, "width", {
+          /**
+           * Same as view.width, actual number of pixels in the canvas by horizontal.
+           * @member {number}
+           * @readonly
+           * @default 800
+           */
+          get: function () {
+              return this.view.width;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(AbstractRenderer.prototype, "height", {
+          /**
+           * Same as view.height, actual number of pixels in the canvas by vertical.
+           * @member {number}
+           * @readonly
+           * @default 600
+           */
+          get: function () {
+              return this.view.height;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Resizes the screen and canvas as close as possible to the specified width and height.
+       * Canvas dimensions are multiplied by resolution and rounded to the nearest integers.
+       * The new canvas dimensions divided by the resolution become the new screen dimensions.
+       * @param desiredScreenWidth - The desired width of the screen.
+       * @param desiredScreenHeight - The desired height of the screen.
+       */
+      AbstractRenderer.prototype.resize = function (desiredScreenWidth, desiredScreenHeight) {
+          this.view.width = Math.round(desiredScreenWidth * this.resolution);
+          this.view.height = Math.round(desiredScreenHeight * this.resolution);
+          var screenWidth = this.view.width / this.resolution;
+          var screenHeight = this.view.height / this.resolution;
+          this.screen.width = screenWidth;
+          this.screen.height = screenHeight;
+          if (this.autoDensity) {
+              this.view.style.width = screenWidth + "px";
+              this.view.style.height = screenHeight + "px";
+          }
+          /**
+           * Fired after view has been resized.
+           * @event PIXI.Renderer#resize
+           * @param {number} screenWidth - The new width of the screen.
+           * @param {number} screenHeight - The new height of the screen.
+           */
+          this.emit('resize', screenWidth, screenHeight);
+      };
+      /**
+       * @ignore
+       */
+      AbstractRenderer.prototype.generateTexture = function (displayObject, options, resolution, region) {
+          if (options === void 0) { options = {}; }
+          // @deprecated parameters spread, use options instead
+          if (typeof options === 'number') {
+              deprecation('6.1.0', 'generateTexture options (scaleMode, resolution, region) are now object options.');
+              options = { scaleMode: options, resolution: resolution, region: region };
+          }
+          var manualRegion = options.region, textureOptions = __rest(options, ["region"]);
+          region = manualRegion || displayObject.getLocalBounds(null, true);
+          // minimum texture size is 1x1, 0x0 will throw an error
+          if (region.width === 0)
+              { region.width = 1; }
+          if (region.height === 0)
+              { region.height = 1; }
+          var renderTexture = RenderTexture.create(__assign({ width: region.width, height: region.height }, textureOptions));
+          tempMatrix.tx = -region.x;
+          tempMatrix.ty = -region.y;
+          this.render(displayObject, {
+              renderTexture: renderTexture,
+              clear: false,
+              transform: tempMatrix,
+              skipUpdateTransform: !!displayObject.parent
+          });
+          return renderTexture;
+      };
+      /**
+       * Removes everything from the renderer and optionally removes the Canvas DOM element.
+       * @param [removeView=false] - Removes the Canvas element from the DOM.
+       */
+      AbstractRenderer.prototype.destroy = function (removeView) {
+          for (var o in this.plugins) {
+              this.plugins[o].destroy();
+              this.plugins[o] = null;
+          }
+          if (removeView && this.view.parentNode) {
+              this.view.parentNode.removeChild(this.view);
+          }
+          var thisAny = this;
+          // null-ing all objects, that's a tradition!
+          thisAny.plugins = null;
+          thisAny.type = exports.RENDERER_TYPE.UNKNOWN;
+          thisAny.view = null;
+          thisAny.screen = null;
+          thisAny._tempDisplayObjectParent = null;
+          thisAny.options = null;
+          this._backgroundColorRgba = null;
+          this._backgroundColorString = null;
+          this._lastObjectRendered = null;
+      };
+      Object.defineProperty(AbstractRenderer.prototype, "backgroundColor", {
+          /**
+           * The background color to fill if not transparent
+           * @member {number}
+           */
+          get: function () {
+              return this._backgroundColor;
+          },
+          set: function (value) {
+              this._backgroundColor = value;
+              this._backgroundColorString = hex2string(value);
+              hex2rgb(value, this._backgroundColorRgba);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(AbstractRenderer.prototype, "backgroundAlpha", {
+          /**
+           * The background color alpha. Setting this to 0 will make the canvas transparent.
+           * @member {number}
+           */
+          get: function () {
+              return this._backgroundColorRgba[3];
+          },
+          set: function (value) {
+              this._backgroundColorRgba[3] = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return AbstractRenderer;
+  }(eventemitter3));
+
+  var GLBuffer = /** @class */ (function () {
+      function GLBuffer(buffer) {
+          this.buffer = buffer || null;
+          this.updateID = -1;
+          this.byteLength = -1;
+          this.refCount = 0;
+      }
+      return GLBuffer;
+  }());
 
-        if (delay < 0) {
-            delay = 0;
-        }
+  /**
+   * System plugin to the renderer to manage buffers.
+   *
+   * WebGL uses Buffers as a way to store objects to the GPU.
+   * This system makes working with them a lot easier.
+   *
+   * Buffers are used in three main places in WebGL
+   * - geometry information
+   * - Uniform information (via uniform buffer objects - a WebGL 2 only feature)
+   * - Transform feedback information. (WebGL 2 only feature)
+   *
+   * This system will handle the binding of buffers to the GPU as well as uploading
+   * them. With this system, you never need to work directly with GPU buffers, but instead work with
+   * the PIXI.Buffer class.
+   * @class
+   * @memberof PIXI
+   */
+  var BufferSystem = /** @class */ (function () {
+      /**
+       * @param {PIXI.Renderer} renderer - The renderer this System works for.
+       */
+      function BufferSystem(renderer) {
+          this.renderer = renderer;
+          this.managedBuffers = {};
+          this.boundBufferBases = {};
+      }
+      /**
+       * @ignore
+       */
+      BufferSystem.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      /** Sets up the renderer context and necessary buffers. */
+      BufferSystem.prototype.contextChange = function () {
+          this.disposeAll(true);
+          this.gl = this.renderer.gl;
+          // TODO fill out...
+          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+      };
+      /**
+       * This binds specified buffer. On first run, it will create the webGL buffers for the context too
+       * @param buffer - the buffer to bind to the renderer
+       */
+      BufferSystem.prototype.bind = function (buffer) {
+          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
+          var glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
+          gl.bindBuffer(buffer.type, glBuffer.buffer);
+      };
+      /**
+       * Binds an uniform buffer to at the given index.
+       *
+       * A cache is used so a buffer will not be bound again if already bound.
+       * @param buffer - the buffer to bind
+       * @param index - the base index to bind it to.
+       */
+      BufferSystem.prototype.bindBufferBase = function (buffer, index) {
+          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
+          if (this.boundBufferBases[index] !== buffer) {
+              var glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
+              this.boundBufferBases[index] = buffer;
+              gl.bindBufferBase(gl.UNIFORM_BUFFER, index, glBuffer.buffer);
+          }
+      };
+      /**
+       * Binds a buffer whilst also binding its range.
+       * This will make the buffer start from the offset supplied rather than 0 when it is read.
+       * @param buffer - the buffer to bind
+       * @param index - the base index to bind at, defaults to 0
+       * @param offset - the offset to bind at (this is blocks of 256). 0 = 0, 1 = 256, 2 = 512 etc
+       */
+      BufferSystem.prototype.bindBufferRange = function (buffer, index, offset) {
+          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
+          offset = offset || 0;
+          var glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
+          gl.bindBufferRange(gl.UNIFORM_BUFFER, index || 0, glBuffer.buffer, offset * 256, 256);
+      };
+      /**
+       * Will ensure the data in the buffer is uploaded to the GPU.
+       * @param {PIXI.Buffer} buffer - the buffer to update
+       */
+      BufferSystem.prototype.update = function (buffer) {
+          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
+          var glBuffer = buffer._glBuffers[CONTEXT_UID];
+          if (buffer._updateID === glBuffer.updateID) {
+              return;
+          }
+          glBuffer.updateID = buffer._updateID;
+          gl.bindBuffer(buffer.type, glBuffer.buffer);
+          if (glBuffer.byteLength >= buffer.data.byteLength) {
+              // offset is always zero for now!
+              gl.bufferSubData(buffer.type, 0, buffer.data);
+          }
+          else {
+              var drawType = buffer.static ? gl.STATIC_DRAW : gl.DYNAMIC_DRAW;
+              glBuffer.byteLength = buffer.data.byteLength;
+              gl.bufferData(buffer.type, buffer.data, drawType);
+          }
+      };
+      /**
+       * Disposes buffer
+       * @param {PIXI.Buffer} buffer - buffer with data
+       * @param {boolean} [contextLost=false] - If context was lost, we suppress deleteVertexArray
+       */
+      BufferSystem.prototype.dispose = function (buffer, contextLost) {
+          if (!this.managedBuffers[buffer.id]) {
+              return;
+          }
+          delete this.managedBuffers[buffer.id];
+          var glBuffer = buffer._glBuffers[this.CONTEXT_UID];
+          var gl = this.gl;
+          buffer.disposeRunner.remove(this);
+          if (!glBuffer) {
+              return;
+          }
+          if (!contextLost) {
+              gl.deleteBuffer(glBuffer.buffer);
+          }
+          delete buffer._glBuffers[this.CONTEXT_UID];
+      };
+      /**
+       * dispose all WebGL resources of all managed buffers
+       * @param {boolean} [contextLost=false] - If context was lost, we suppress `gl.delete` calls
+       */
+      BufferSystem.prototype.disposeAll = function (contextLost) {
+          var all = Object.keys(this.managedBuffers);
+          for (var i = 0; i < all.length; i++) {
+              this.dispose(this.managedBuffers[all[i]], contextLost);
+          }
+      };
+      /**
+       * creates and attaches a GLBuffer object tied to the current context.
+       * @param buffer
+       * @protected
+       */
+      BufferSystem.prototype.createGLBuffer = function (buffer) {
+          var _a = this, CONTEXT_UID = _a.CONTEXT_UID, gl = _a.gl;
+          buffer._glBuffers[CONTEXT_UID] = new GLBuffer(gl.createBuffer());
+          this.managedBuffers[buffer.id] = buffer;
+          buffer.disposeRunner.add(this);
+          return buffer._glBuffers[CONTEXT_UID];
+      };
+      return BufferSystem;
+  }());
 
-        lastTime = currentTime;
+  /**
+   * The Renderer draws the scene and all its content onto a WebGL enabled canvas.
+   *
+   * This renderer should be used for browsers that support WebGL.
+   *
+   * This renderer works by automatically managing WebGLBatchesm, so no need for Sprite Batches or Sprite Clouds.
+   * Don't forget to add the view to your DOM or you will not see anything!
+   *
+   * Renderer is composed of systems that manage specific tasks. The following systems are added by default
+   * whenever you create a renderer:
+   *
+   * | System                               | Description                                                                   |
+   * | ------------------------------------ | ----------------------------------------------------------------------------- |
+   * | {@link PIXI.BatchSystem}             | This manages object renderers that defer rendering until a flush.             |
+   * | {@link PIXI.ContextSystem}           | This manages the WebGL context and extensions.                                |
+   * | {@link PIXI.EventSystem}             | This manages UI events.                                                       |
+   * | {@link PIXI.FilterSystem}            | This manages the filtering pipeline for post-processing effects.              |
+   * | {@link PIXI.FramebufferSystem}       | This manages framebuffers, which are used for offscreen rendering.            |
+   * | {@link PIXI.GeometrySystem}          | This manages geometries & buffers, which are used to draw object meshes.      |
+   * | {@link PIXI.MaskSystem}              | This manages masking operations.                                              |
+   * | {@link PIXI.ProjectionSystem}        | This manages the `projectionMatrix`, used by shaders to get NDC coordinates.  |
+   * | {@link PIXI.RenderTextureSystem}     | This manages render-textures, which are an abstraction over framebuffers.     |
+   * | {@link PIXI.ScissorSystem}           | This handles scissor masking, and is used internally by {@link MaskSystem}    |
+   * | {@link PIXI.ShaderSystem}            | This manages shaders, programs that run on the GPU to calculate 'em pixels.   |
+   * | {@link PIXI.StateSystem}             | This manages the WebGL state variables like blend mode, depth testing, etc.   |
+   * | {@link PIXI.StencilSystem}           | This handles stencil masking, and is used internally by {@link MaskSystem}    |
+   * | {@link PIXI.TextureSystem}           | This manages textures and their resources on the GPU.                         |
+   * | {@link PIXI.TextureGCSystem}         | This will automatically remove textures from the GPU if they are not used.    |
+   *
+   * The breadth of the API surface provided by the renderer is contained within these systems.
+   * @memberof PIXI
+   */
+  var Renderer = /** @class */ (function (_super) {
+      __extends$i(Renderer, _super);
+      /**
+       * @param {PIXI.IRendererOptions} [options] - The optional renderer parameters.
+       * @param {boolean} [options.antialias=false] -
+       *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
+       * @param {boolean} [options.autoDensity=false] -
+       *  Whether the CSS dimensions of the renderer's view should be resized automatically.
+       * @param {number} [options.backgroundAlpha=1] -
+       *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
+       * @param {number} [options.backgroundColor=0x000000] -
+       *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
+       * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
+       * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
+       * @param {number} [options.height=600] - The height of the renderer's view.
+       * @param {string} [options.powerPreference] -
+       *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
+       *  can be `'default'`, `'high-performance'` or `'low-power'`.
+       *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
+       *  while setting to `'low-power'` will prioritize power saving over rendering performance.
+       * @param {boolean} [options.premultipliedAlpha=true] -
+       *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
+       * @param {boolean} [options.preserveDrawingBuffer=false] -
+       *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
+       *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
+       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
+       *  The resolution / device pixel ratio of the renderer.
+       * @param {boolean} [options.transparent] -
+       *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
+       *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
+       * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
+       *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
+       *  canvas needs to be opaque, possibly for performance reasons on some older devices.
+       *  If you want to set transparency, please use `backgroundAlpha`. \
+       *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
+       *  set to `true` and `premultipliedAlpha` will be to `false`.
+       * @param {HTMLCanvasElement} [options.view=null] -
+       *  The canvas to use as the view. If omitted, a new canvas will be created.
+       * @param {number} [options.width=800] - The width of the renderer's view.
+       */
+      function Renderer(options) {
+          var _this = _super.call(this, exports.RENDERER_TYPE.WEBGL, options) || this;
+          // the options will have been modified here in the super constructor with pixi's default settings..
+          options = _this.options;
+          _this.gl = null;
+          _this.CONTEXT_UID = 0;
+          _this.runners = {
+              destroy: new Runner('destroy'),
+              contextChange: new Runner('contextChange'),
+              reset: new Runner('reset'),
+              update: new Runner('update'),
+              postrender: new Runner('postrender'),
+              prerender: new Runner('prerender'),
+              resize: new Runner('resize'),
+          };
+          _this.runners.contextChange.add(_this);
+          _this.globalUniforms = new UniformGroup({
+              projectionMatrix: new Matrix(),
+          }, true);
+          _this.addSystem(MaskSystem, 'mask')
+              .addSystem(ContextSystem, 'context')
+              .addSystem(StateSystem, 'state')
+              .addSystem(ShaderSystem, 'shader')
+              .addSystem(TextureSystem, 'texture')
+              .addSystem(BufferSystem, 'buffer')
+              .addSystem(GeometrySystem, 'geometry')
+              .addSystem(FramebufferSystem, 'framebuffer')
+              .addSystem(ScissorSystem, 'scissor')
+              .addSystem(StencilSystem, 'stencil')
+              .addSystem(ProjectionSystem, 'projection')
+              .addSystem(TextureGCSystem, 'textureGC')
+              .addSystem(FilterSystem, 'filter')
+              .addSystem(RenderTextureSystem, 'renderTexture')
+              .addSystem(BatchSystem, 'batch');
+          _this.initPlugins(Renderer.__plugins);
+          _this.multisample = undefined;
+          /*
+           * The options passed in to create a new WebGL context.
+           */
+          if (options.context) {
+              _this.context.initFromContext(options.context);
+          }
+          else {
+              _this.context.initFromOptions({
+                  alpha: !!_this.useContextAlpha,
+                  antialias: options.antialias,
+                  premultipliedAlpha: _this.useContextAlpha && _this.useContextAlpha !== 'notMultiplied',
+                  stencil: true,
+                  preserveDrawingBuffer: options.preserveDrawingBuffer,
+                  powerPreference: _this.options.powerPreference,
+              });
+          }
+          _this.renderingToScreen = true;
+          sayHello(_this.context.webGLVersion === 2 ? 'WebGL 2' : 'WebGL 1');
+          _this.resize(_this.options.width, _this.options.height);
+          return _this;
+      }
+      /**
+       * Create renderer if WebGL is available. Overrideable
+       * by the **@pixi/canvas-renderer** package to allow fallback.
+       * throws error if WebGL is not available.
+       * @param options
+       * @private
+       */
+      Renderer.create = function (options) {
+          if (isWebGLSupported()) {
+              return new Renderer(options);
+          }
+          throw new Error('WebGL unsupported in this browser, use "pixi.js-legacy" for fallback canvas2d support.');
+      };
+      Renderer.prototype.contextChange = function () {
+          var gl = this.gl;
+          var samples;
+          if (this.context.webGLVersion === 1) {
+              var framebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+              gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+              samples = gl.getParameter(gl.SAMPLES);
+              gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+          }
+          else {
+              var framebuffer = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+              gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+              samples = gl.getParameter(gl.SAMPLES);
+              gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, framebuffer);
+          }
+          if (samples >= exports.MSAA_QUALITY.HIGH) {
+              this.multisample = exports.MSAA_QUALITY.HIGH;
+          }
+          else if (samples >= exports.MSAA_QUALITY.MEDIUM) {
+              this.multisample = exports.MSAA_QUALITY.MEDIUM;
+          }
+          else if (samples >= exports.MSAA_QUALITY.LOW) {
+              this.multisample = exports.MSAA_QUALITY.LOW;
+          }
+          else {
+              this.multisample = exports.MSAA_QUALITY.NONE;
+          }
+      };
+      /**
+       * Add a new system to the renderer.
+       * @param ClassRef - Class reference
+       * @param name - Property name for system, if not specified
+       *        will use a static `name` property on the class itself. This
+       *        name will be assigned as s property on the Renderer so make
+       *        sure it doesn't collide with properties on Renderer.
+       * @returns Return instance of renderer
+       */
+      Renderer.prototype.addSystem = function (ClassRef, name) {
+          var system = new ClassRef(this);
+          if (this[name]) {
+              throw new Error("Whoops! The name \"" + name + "\" is already in use");
+          }
+          this[name] = system;
+          for (var i in this.runners) {
+              this.runners[i].add(system);
+          }
+          /**
+           * Fired after rendering finishes.
+           * @event PIXI.Renderer#postrender
+           */
+          /**
+           * Fired before rendering starts.
+           * @event PIXI.Renderer#prerender
+           */
+          /**
+           * Fired when the WebGL context is set.
+           * @event PIXI.Renderer#context
+           * @param {WebGLRenderingContext} gl - WebGL context.
+           */
+          return this;
+      };
+      /**
+       * @ignore
+       */
+      Renderer.prototype.render = function (displayObject, options) {
+          var renderTexture;
+          var clear;
+          var transform;
+          var skipUpdateTransform;
+          if (options) {
+              if (options instanceof RenderTexture) {
+                  deprecation('6.0.0', 'Renderer#render arguments changed, use options instead.');
+                  /* eslint-disable prefer-rest-params */
+                  renderTexture = options;
+                  clear = arguments[2];
+                  transform = arguments[3];
+                  skipUpdateTransform = arguments[4];
+                  /* eslint-enable prefer-rest-params */
+              }
+              else {
+                  renderTexture = options.renderTexture;
+                  clear = options.clear;
+                  transform = options.transform;
+                  skipUpdateTransform = options.skipUpdateTransform;
+              }
+          }
+          // can be handy to know!
+          this.renderingToScreen = !renderTexture;
+          this.runners.prerender.emit();
+          this.emit('prerender');
+          // apply a transform at a GPU level
+          this.projection.transform = transform;
+          // no point rendering if our context has been blown up!
+          if (this.context.isLost) {
+              return;
+          }
+          if (!renderTexture) {
+              this._lastObjectRendered = displayObject;
+          }
+          if (!skipUpdateTransform) {
+              // update the scene graph
+              var cacheParent = displayObject.enableTempParent();
+              displayObject.updateTransform();
+              displayObject.disableTempParent(cacheParent);
+              // displayObject.hitArea = //TODO add a temp hit area
+          }
+          this.renderTexture.bind(renderTexture);
+          this.batch.currentRenderer.start();
+          if (clear !== undefined ? clear : this.clearBeforeRender) {
+              this.renderTexture.clear();
+          }
+          displayObject.render(this);
+          // apply transform..
+          this.batch.currentRenderer.flush();
+          if (renderTexture) {
+              renderTexture.baseTexture.update();
+          }
+          this.runners.postrender.emit();
+          // reset transform after render
+          this.projection.transform = null;
+          this.emit('postrender');
+      };
+      /**
+       * @override
+       * @ignore
+       */
+      Renderer.prototype.generateTexture = function (displayObject, options, resolution, region) {
+          if (options === void 0) { options = {}; }
+          var renderTexture = _super.prototype.generateTexture.call(this, displayObject, options, resolution, region);
+          this.framebuffer.blit();
+          return renderTexture;
+      };
+      /**
+       * Resizes the WebGL view to the specified width and height.
+       * @param desiredScreenWidth - The desired width of the screen.
+       * @param desiredScreenHeight - The desired height of the screen.
+       */
+      Renderer.prototype.resize = function (desiredScreenWidth, desiredScreenHeight) {
+          _super.prototype.resize.call(this, desiredScreenWidth, desiredScreenHeight);
+          this.runners.resize.emit(this.screen.height, this.screen.width);
+      };
+      /**
+       * Resets the WebGL state so you can render things however you fancy!
+       * @returns Returns itself.
+       */
+      Renderer.prototype.reset = function () {
+          this.runners.reset.emit();
+          return this;
+      };
+      /** Clear the frame buffer. */
+      Renderer.prototype.clear = function () {
+          this.renderTexture.bind();
+          this.renderTexture.clear();
+      };
+      /**
+       * Removes everything from the renderer (event listeners, spritebatch, etc...)
+       * @param [removeView=false] - Removes the Canvas element from the DOM.
+       *  See: https://github.com/pixijs/pixi.js/issues/2233
+       */
+      Renderer.prototype.destroy = function (removeView) {
+          this.runners.destroy.emit();
+          for (var r in this.runners) {
+              this.runners[r].destroy();
+          }
+          // call base destroy
+          _super.prototype.destroy.call(this, removeView);
+          // TODO nullify all the managers..
+          this.gl = null;
+      };
+      Object.defineProperty(Renderer.prototype, "extract", {
+          /**
+           * Please use `plugins.extract` instead.
+           * @member {PIXI.Extract} extract
+           * @deprecated since 6.0.0
+           * @readonly
+           */
+          get: function () {
+              deprecation('6.0.0', 'Renderer#extract has been deprecated, please use Renderer#plugins.extract instead.');
+              return this.plugins.extract;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Use the {@link PIXI.extensions.add} API to register plugins.
+       * @deprecated since 6.5.0
+       * @param pluginName - The name of the plugin.
+       * @param ctor - The constructor function or class for the plugin.
+       */
+      Renderer.registerPlugin = function (pluginName, ctor) {
+          deprecation('6.5.0', 'Renderer.registerPlugin() has been deprecated, please use extensions.add() instead.');
+          extensions.add({
+              name: pluginName,
+              type: exports.ExtensionType.RendererPlugin,
+              ref: ctor,
+          });
+      };
+      /**
+       * Collection of installed plugins. These are included by default in PIXI, but can be excluded
+       * by creating a custom build. Consult the README for more information about creating custom
+       * builds and excluding plugins.
+       * @readonly
+       * @property {PIXI.AccessibilityManager} accessibility Support tabbing interactive elements.
+       * @property {PIXI.Extract} extract Extract image data from renderer.
+       * @property {PIXI.InteractionManager} interaction Handles mouse, touch and pointer events.
+       * @property {PIXI.ParticleRenderer} particle Renderer for ParticleContainer objects.
+       * @property {PIXI.Prepare} prepare Pre-render display objects.
+       * @property {PIXI.BatchRenderer} batch Batching of Sprite, Graphics and Mesh objects.
+       * @property {PIXI.TilingSpriteRenderer} tilingSprite Renderer for TilingSprite objects.
+       */
+      Renderer.__plugins = {};
+      return Renderer;
+  }(AbstractRenderer));
+  // Handle registration of extensions
+  extensions.handleByMap(exports.ExtensionType.RendererPlugin, Renderer.__plugins);
 
-        return setTimeout(function () {
-            lastTime = Date.now();
-            callback(performance.now());
-        }, delay);
-    };
-}
+  /**
+   * This helper function will automatically detect which renderer you should be using.
+   * WebGL is the preferred renderer as it is a lot faster. If WebGL is not supported by
+   * the browser then this function will return a canvas renderer.
+   * @memberof PIXI
+   * @function autoDetectRenderer
+   * @param {PIXI.IRendererOptionsAuto} [options] - The optional renderer parameters.
+   * @param {boolean} [options.antialias=false] -
+   *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
+   * @param {boolean} [options.autoDensity=false] -
+   *  Whether the CSS dimensions of the renderer's view should be resized automatically.
+   * @param {number} [options.backgroundAlpha=1] -
+   *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
+   * @param {number} [options.backgroundColor=0x000000] -
+   *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
+   * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
+   * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
+   * @param {boolean} [options.forceCanvas=false] -
+   *  Force using {@link PIXI.CanvasRenderer}, even if WebGL is available. This option only is available when
+   *  using **pixi.js-legacy** or **@pixi/canvas-renderer** packages, otherwise it is ignored.
+   * @param {number} [options.height=600] - The height of the renderer's view.
+   * @param {string} [options.powerPreference] -
+   *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
+   *  can be `'default'`, `'high-performance'` or `'low-power'`.
+   *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
+   *  while setting to `'low-power'` will prioritize power saving over rendering performance.
+   * @param {boolean} [options.premultipliedAlpha=true] -
+   *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
+   * @param {boolean} [options.preserveDrawingBuffer=false] -
+   *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
+   *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
+   * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
+   *  The resolution / device pixel ratio of the renderer.
+   * @param {boolean} [options.transparent] -
+   *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
+   *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
+   * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
+   *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
+   *  canvas needs to be opaque, possibly for performance reasons on some older devices.
+   *  If you want to set transparency, please use `backgroundAlpha`. \
+   *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
+   *  set to `true` and `premultipliedAlpha` will be to `false`.
+   * @param {HTMLCanvasElement} [options.view=null] -
+   *  The canvas to use as the view. If omitted, a new canvas will be created.
+   * @param {number} [options.width=800] - The width of the renderer's view.
+   * @returns {PIXI.Renderer|PIXI.CanvasRenderer}
+   *  Returns {@link PIXI.Renderer} if WebGL is available, otherwise {@link PIXI.CanvasRenderer}.
+   */
+  function autoDetectRenderer(options) {
+      return Renderer.create(options);
+  }
 
-if (!global.cancelAnimationFrame) {
-    global.cancelAnimationFrame = function (id) {
-        return clearTimeout(id);
-    };
-}
+  var $defaultVertex = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n}";
 
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+  var $defaultFilterVertex = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";
 
-},{}],182:[function(require,module,exports){
-'use strict';
+  /**
+   * Default vertex shader
+   * @memberof PIXI
+   * @member {string} defaultVertex
+   */
+  /**
+   * Default filter vertex shader
+   * @memberof PIXI
+   * @member {string} defaultFilterVertex
+   */
+  // NOTE: This black magic is so that @microsoft/api-extractor does not complain! This explicitly specifies the types
+  // of defaultVertex, defaultFilterVertex.
+  var defaultVertex$1 = $defaultVertex;
+  var defaultFilterVertex = $defaultFilterVertex;
 
-exports.__esModule = true;
+  /**
+   * Use the ISystem interface instead.
+   * @deprecated since 6.1.0
+   * @memberof PIXI
+   */
+  var System = /** @class */ (function () {
+      /**
+       * @param renderer - Reference to Renderer
+       */
+      function System(renderer) {
+          deprecation('6.1.0', 'System class is deprecated, implemement ISystem interface instead.');
+          this.renderer = renderer;
+      }
+      /** Destroy and don't use after this. */
+      System.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      return System;
+  }());
 
-var _core = require('../core');
+  /**
+   * Used by the batcher to draw batches.
+   * Each one of these contains all information required to draw a bound geometry.
+   * @memberof PIXI
+   */
+  var BatchDrawCall = /** @class */ (function () {
+      function BatchDrawCall() {
+          this.texArray = null;
+          this.blend = 0;
+          this.type = exports.DRAW_MODES.TRIANGLES;
+          this.start = 0;
+          this.size = 0;
+          this.data = null;
+      }
+      return BatchDrawCall;
+  }());
 
-var core = _interopRequireWildcard(_core);
+  /**
+   * Used by the batcher to build texture batches.
+   * Holds list of textures and their respective locations.
+   * @memberof PIXI
+   */
+  var BatchTextureArray = /** @class */ (function () {
+      function BatchTextureArray() {
+          this.elements = [];
+          this.ids = [];
+          this.count = 0;
+      }
+      BatchTextureArray.prototype.clear = function () {
+          for (var i = 0; i < this.count; i++) {
+              this.elements[i] = null;
+          }
+          this.count = 0;
+      };
+      return BatchTextureArray;
+  }());
 
-var _CountLimiter = require('./limiters/CountLimiter');
+  /**
+   * Flexible wrapper around `ArrayBuffer` that also provides typed array views on demand.
+   * @memberof PIXI
+   */
+  var ViewableBuffer = /** @class */ (function () {
+      function ViewableBuffer(sizeOrBuffer) {
+          if (typeof sizeOrBuffer === 'number') {
+              this.rawBinaryData = new ArrayBuffer(sizeOrBuffer);
+          }
+          else if (sizeOrBuffer instanceof Uint8Array) {
+              this.rawBinaryData = sizeOrBuffer.buffer;
+          }
+          else {
+              this.rawBinaryData = sizeOrBuffer;
+          }
+          this.uint32View = new Uint32Array(this.rawBinaryData);
+          this.float32View = new Float32Array(this.rawBinaryData);
+      }
+      Object.defineProperty(ViewableBuffer.prototype, "int8View", {
+          /** View on the raw binary data as a `Int8Array`. */
+          get: function () {
+              if (!this._int8View) {
+                  this._int8View = new Int8Array(this.rawBinaryData);
+              }
+              return this._int8View;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(ViewableBuffer.prototype, "uint8View", {
+          /** View on the raw binary data as a `Uint8Array`. */
+          get: function () {
+              if (!this._uint8View) {
+                  this._uint8View = new Uint8Array(this.rawBinaryData);
+              }
+              return this._uint8View;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(ViewableBuffer.prototype, "int16View", {
+          /**  View on the raw binary data as a `Int16Array`. */
+          get: function () {
+              if (!this._int16View) {
+                  this._int16View = new Int16Array(this.rawBinaryData);
+              }
+              return this._int16View;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(ViewableBuffer.prototype, "uint16View", {
+          /** View on the raw binary data as a `Uint16Array`. */
+          get: function () {
+              if (!this._uint16View) {
+                  this._uint16View = new Uint16Array(this.rawBinaryData);
+              }
+              return this._uint16View;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(ViewableBuffer.prototype, "int32View", {
+          /** View on the raw binary data as a `Int32Array`. */
+          get: function () {
+              if (!this._int32View) {
+                  this._int32View = new Int32Array(this.rawBinaryData);
+              }
+              return this._int32View;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Returns the view of the given type.
+       * @param type - One of `int8`, `uint8`, `int16`,
+       *    `uint16`, `int32`, `uint32`, and `float32`.
+       * @returns - typed array of given type
+       */
+      ViewableBuffer.prototype.view = function (type) {
+          return this[type + "View"];
+      };
+      /** Destroys all buffer references. Do not use after calling this. */
+      ViewableBuffer.prototype.destroy = function () {
+          this.rawBinaryData = null;
+          this._int8View = null;
+          this._uint8View = null;
+          this._int16View = null;
+          this._uint16View = null;
+          this._int32View = null;
+          this.uint32View = null;
+          this.float32View = null;
+      };
+      ViewableBuffer.sizeOf = function (type) {
+          switch (type) {
+              case 'int8':
+              case 'uint8':
+                  return 1;
+              case 'int16':
+              case 'uint16':
+                  return 2;
+              case 'int32':
+              case 'uint32':
+              case 'float32':
+                  return 4;
+              default:
+                  throw new Error(type + " isn't a valid view type");
+          }
+      };
+      return ViewableBuffer;
+  }());
 
-var _CountLimiter2 = _interopRequireDefault(_CountLimiter);
+  /**
+   * Renderer dedicated to drawing and batching sprites.
+   *
+   * This is the default batch renderer. It buffers objects
+   * with texture-based geometries and renders them in
+   * batches. It uploads multiple textures to the GPU to
+   * reduce to the number of draw calls.
+   * @memberof PIXI
+   */
+  var AbstractBatchRenderer = /** @class */ (function (_super) {
+      __extends$i(AbstractBatchRenderer, _super);
+      /**
+       * This will hook onto the renderer's `contextChange`
+       * and `prerender` signals.
+       * @param {PIXI.Renderer} renderer - The renderer this works for.
+       */
+      function AbstractBatchRenderer(renderer) {
+          var _this = _super.call(this, renderer) || this;
+          _this.shaderGenerator = null;
+          _this.geometryClass = null;
+          _this.vertexSize = null;
+          _this.state = State.for2d();
+          _this.size = settings.SPRITE_BATCH_SIZE * 4;
+          _this._vertexCount = 0;
+          _this._indexCount = 0;
+          _this._bufferedElements = [];
+          _this._bufferedTextures = [];
+          _this._bufferSize = 0;
+          _this._shader = null;
+          _this._packedGeometries = [];
+          _this._packedGeometryPoolSize = 2;
+          _this._flushId = 0;
+          _this._aBuffers = {};
+          _this._iBuffers = {};
+          _this.MAX_TEXTURES = 1;
+          _this.renderer.on('prerender', _this.onPrerender, _this);
+          renderer.runners.contextChange.add(_this);
+          _this._dcIndex = 0;
+          _this._aIndex = 0;
+          _this._iIndex = 0;
+          _this._attributeBuffer = null;
+          _this._indexBuffer = null;
+          _this._tempBoundTextures = [];
+          return _this;
+      }
+      /**
+       * Handles the `contextChange` signal.
+       *
+       * It calculates `this.MAX_TEXTURES` and allocating the packed-geometry object pool.
+       */
+      AbstractBatchRenderer.prototype.contextChange = function () {
+          var gl = this.renderer.gl;
+          if (settings.PREFER_ENV === exports.ENV.WEBGL_LEGACY) {
+              this.MAX_TEXTURES = 1;
+          }
+          else {
+              // step 1: first check max textures the GPU can handle.
+              this.MAX_TEXTURES = Math.min(gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS), settings.SPRITE_MAX_TEXTURES);
+              // step 2: check the maximum number of if statements the shader can have too..
+              this.MAX_TEXTURES = checkMaxIfStatementsInShader(this.MAX_TEXTURES, gl);
+          }
+          this._shader = this.shaderGenerator.generateShader(this.MAX_TEXTURES);
+          // we use the second shader as the first one depending on your browser
+          // may omit aTextureId as it is not used by the shader so is optimized out.
+          for (var i = 0; i < this._packedGeometryPoolSize; i++) {
+              /* eslint-disable max-len */
+              this._packedGeometries[i] = new (this.geometryClass)();
+          }
+          this.initFlushBuffers();
+      };
+      /** Makes sure that static and dynamic flush pooled objects have correct dimensions. */
+      AbstractBatchRenderer.prototype.initFlushBuffers = function () {
+          var _drawCallPool = AbstractBatchRenderer._drawCallPool, _textureArrayPool = AbstractBatchRenderer._textureArrayPool;
+          // max draw calls
+          var MAX_SPRITES = this.size / 4;
+          // max texture arrays
+          var MAX_TA = Math.floor(MAX_SPRITES / this.MAX_TEXTURES) + 1;
+          while (_drawCallPool.length < MAX_SPRITES) {
+              _drawCallPool.push(new BatchDrawCall());
+          }
+          while (_textureArrayPool.length < MAX_TA) {
+              _textureArrayPool.push(new BatchTextureArray());
+          }
+          for (var i = 0; i < this.MAX_TEXTURES; i++) {
+              this._tempBoundTextures[i] = null;
+          }
+      };
+      /** Handles the `prerender` signal. It ensures that flushes start from the first geometry object again. */
+      AbstractBatchRenderer.prototype.onPrerender = function () {
+          this._flushId = 0;
+      };
+      /**
+       * Buffers the "batchable" object. It need not be rendered immediately.
+       * @param {PIXI.DisplayObject} element - the element to render when
+       *    using this renderer
+       */
+      AbstractBatchRenderer.prototype.render = function (element) {
+          if (!element._texture.valid) {
+              return;
+          }
+          if (this._vertexCount + (element.vertexData.length / 2) > this.size) {
+              this.flush();
+          }
+          this._vertexCount += element.vertexData.length / 2;
+          this._indexCount += element.indices.length;
+          this._bufferedTextures[this._bufferSize] = element._texture.baseTexture;
+          this._bufferedElements[this._bufferSize++] = element;
+      };
+      AbstractBatchRenderer.prototype.buildTexturesAndDrawCalls = function () {
+          var _a = this, textures = _a._bufferedTextures, MAX_TEXTURES = _a.MAX_TEXTURES;
+          var textureArrays = AbstractBatchRenderer._textureArrayPool;
+          var batch = this.renderer.batch;
+          var boundTextures = this._tempBoundTextures;
+          var touch = this.renderer.textureGC.count;
+          var TICK = ++BaseTexture._globalBatch;
+          var countTexArrays = 0;
+          var texArray = textureArrays[0];
+          var start = 0;
+          batch.copyBoundTextures(boundTextures, MAX_TEXTURES);
+          for (var i = 0; i < this._bufferSize; ++i) {
+              var tex = textures[i];
+              textures[i] = null;
+              if (tex._batchEnabled === TICK) {
+                  continue;
+              }
+              if (texArray.count >= MAX_TEXTURES) {
+                  batch.boundArray(texArray, boundTextures, TICK, MAX_TEXTURES);
+                  this.buildDrawCalls(texArray, start, i);
+                  start = i;
+                  texArray = textureArrays[++countTexArrays];
+                  ++TICK;
+              }
+              tex._batchEnabled = TICK;
+              tex.touched = touch;
+              texArray.elements[texArray.count++] = tex;
+          }
+          if (texArray.count > 0) {
+              batch.boundArray(texArray, boundTextures, TICK, MAX_TEXTURES);
+              this.buildDrawCalls(texArray, start, this._bufferSize);
+              ++countTexArrays;
+              ++TICK;
+          }
+          // Clean-up
+          for (var i = 0; i < boundTextures.length; i++) {
+              boundTextures[i] = null;
+          }
+          BaseTexture._globalBatch = TICK;
+      };
+      /**
+       * Populating drawcalls for rendering
+       * @param texArray
+       * @param start
+       * @param finish
+       */
+      AbstractBatchRenderer.prototype.buildDrawCalls = function (texArray, start, finish) {
+          var _a = this, elements = _a._bufferedElements, _attributeBuffer = _a._attributeBuffer, _indexBuffer = _a._indexBuffer, vertexSize = _a.vertexSize;
+          var drawCalls = AbstractBatchRenderer._drawCallPool;
+          var dcIndex = this._dcIndex;
+          var aIndex = this._aIndex;
+          var iIndex = this._iIndex;
+          var drawCall = drawCalls[dcIndex];
+          drawCall.start = this._iIndex;
+          drawCall.texArray = texArray;
+          for (var i = start; i < finish; ++i) {
+              var sprite = elements[i];
+              var tex = sprite._texture.baseTexture;
+              var spriteBlendMode = premultiplyBlendMode[tex.alphaMode ? 1 : 0][sprite.blendMode];
+              elements[i] = null;
+              if (start < i && drawCall.blend !== spriteBlendMode) {
+                  drawCall.size = iIndex - drawCall.start;
+                  start = i;
+                  drawCall = drawCalls[++dcIndex];
+                  drawCall.texArray = texArray;
+                  drawCall.start = iIndex;
+              }
+              this.packInterleavedGeometry(sprite, _attributeBuffer, _indexBuffer, aIndex, iIndex);
+              aIndex += sprite.vertexData.length / 2 * vertexSize;
+              iIndex += sprite.indices.length;
+              drawCall.blend = spriteBlendMode;
+          }
+          if (start < finish) {
+              drawCall.size = iIndex - drawCall.start;
+              ++dcIndex;
+          }
+          this._dcIndex = dcIndex;
+          this._aIndex = aIndex;
+          this._iIndex = iIndex;
+      };
+      /**
+       * Bind textures for current rendering
+       * @param texArray
+       */
+      AbstractBatchRenderer.prototype.bindAndClearTexArray = function (texArray) {
+          var textureSystem = this.renderer.texture;
+          for (var j = 0; j < texArray.count; j++) {
+              textureSystem.bind(texArray.elements[j], texArray.ids[j]);
+              texArray.elements[j] = null;
+          }
+          texArray.count = 0;
+      };
+      AbstractBatchRenderer.prototype.updateGeometry = function () {
+          var _a = this, packedGeometries = _a._packedGeometries, attributeBuffer = _a._attributeBuffer, indexBuffer = _a._indexBuffer;
+          if (!settings.CAN_UPLOAD_SAME_BUFFER) { /* Usually on iOS devices, where the browser doesn't
+              like uploads to the same buffer in a single frame. */
+              if (this._packedGeometryPoolSize <= this._flushId) {
+                  this._packedGeometryPoolSize++;
+                  packedGeometries[this._flushId] = new (this.geometryClass)();
+              }
+              packedGeometries[this._flushId]._buffer.update(attributeBuffer.rawBinaryData);
+              packedGeometries[this._flushId]._indexBuffer.update(indexBuffer);
+              this.renderer.geometry.bind(packedGeometries[this._flushId]);
+              this.renderer.geometry.updateBuffers();
+              this._flushId++;
+          }
+          else {
+              // lets use the faster option, always use buffer number 0
+              packedGeometries[this._flushId]._buffer.update(attributeBuffer.rawBinaryData);
+              packedGeometries[this._flushId]._indexBuffer.update(indexBuffer);
+              this.renderer.geometry.updateBuffers();
+          }
+      };
+      AbstractBatchRenderer.prototype.drawBatches = function () {
+          var dcCount = this._dcIndex;
+          var _a = this.renderer, gl = _a.gl, stateSystem = _a.state;
+          var drawCalls = AbstractBatchRenderer._drawCallPool;
+          var curTexArray = null;
+          // Upload textures and do the draw calls
+          for (var i = 0; i < dcCount; i++) {
+              var _b = drawCalls[i], texArray = _b.texArray, type = _b.type, size = _b.size, start = _b.start, blend = _b.blend;
+              if (curTexArray !== texArray) {
+                  curTexArray = texArray;
+                  this.bindAndClearTexArray(texArray);
+              }
+              this.state.blendMode = blend;
+              stateSystem.set(this.state);
+              gl.drawElements(type, size, gl.UNSIGNED_SHORT, start * 2);
+          }
+      };
+      /** Renders the content _now_ and empties the current batch. */
+      AbstractBatchRenderer.prototype.flush = function () {
+          if (this._vertexCount === 0) {
+              return;
+          }
+          this._attributeBuffer = this.getAttributeBuffer(this._vertexCount);
+          this._indexBuffer = this.getIndexBuffer(this._indexCount);
+          this._aIndex = 0;
+          this._iIndex = 0;
+          this._dcIndex = 0;
+          this.buildTexturesAndDrawCalls();
+          this.updateGeometry();
+          this.drawBatches();
+          // reset elements buffer for the next flush
+          this._bufferSize = 0;
+          this._vertexCount = 0;
+          this._indexCount = 0;
+      };
+      /** Starts a new sprite batch. */
+      AbstractBatchRenderer.prototype.start = function () {
+          this.renderer.state.set(this.state);
+          this.renderer.texture.ensureSamplerType(this.MAX_TEXTURES);
+          this.renderer.shader.bind(this._shader);
+          if (settings.CAN_UPLOAD_SAME_BUFFER) {
+              // bind buffer #0, we don't need others
+              this.renderer.geometry.bind(this._packedGeometries[this._flushId]);
+          }
+      };
+      /** Stops and flushes the current batch. */
+      AbstractBatchRenderer.prototype.stop = function () {
+          this.flush();
+      };
+      /** Destroys this `AbstractBatchRenderer`. It cannot be used again. */
+      AbstractBatchRenderer.prototype.destroy = function () {
+          for (var i = 0; i < this._packedGeometryPoolSize; i++) {
+              if (this._packedGeometries[i]) {
+                  this._packedGeometries[i].destroy();
+              }
+          }
+          this.renderer.off('prerender', this.onPrerender, this);
+          this._aBuffers = null;
+          this._iBuffers = null;
+          this._packedGeometries = null;
+          this._attributeBuffer = null;
+          this._indexBuffer = null;
+          if (this._shader) {
+              this._shader.destroy();
+              this._shader = null;
+          }
+          _super.prototype.destroy.call(this);
+      };
+      /**
+       * Fetches an attribute buffer from `this._aBuffers` that can hold atleast `size` floats.
+       * @param size - minimum capacity required
+       * @returns - buffer than can hold atleast `size` floats
+       */
+      AbstractBatchRenderer.prototype.getAttributeBuffer = function (size) {
+          // 8 vertices is enough for 2 quads
+          var roundedP2 = nextPow2(Math.ceil(size / 8));
+          var roundedSizeIndex = log2(roundedP2);
+          var roundedSize = roundedP2 * 8;
+          if (this._aBuffers.length <= roundedSizeIndex) {
+              this._iBuffers.length = roundedSizeIndex + 1;
+          }
+          var buffer = this._aBuffers[roundedSize];
+          if (!buffer) {
+              this._aBuffers[roundedSize] = buffer = new ViewableBuffer(roundedSize * this.vertexSize * 4);
+          }
+          return buffer;
+      };
+      /**
+       * Fetches an index buffer from `this._iBuffers` that can
+       * have at least `size` capacity.
+       * @param size - minimum required capacity
+       * @returns - buffer that can fit `size` indices.
+       */
+      AbstractBatchRenderer.prototype.getIndexBuffer = function (size) {
+          // 12 indices is enough for 2 quads
+          var roundedP2 = nextPow2(Math.ceil(size / 12));
+          var roundedSizeIndex = log2(roundedP2);
+          var roundedSize = roundedP2 * 12;
+          if (this._iBuffers.length <= roundedSizeIndex) {
+              this._iBuffers.length = roundedSizeIndex + 1;
+          }
+          var buffer = this._iBuffers[roundedSizeIndex];
+          if (!buffer) {
+              this._iBuffers[roundedSizeIndex] = buffer = new Uint16Array(roundedSize);
+          }
+          return buffer;
+      };
+      /**
+       * Takes the four batching parameters of `element`, interleaves
+       * and pushes them into the batching attribute/index buffers given.
+       *
+       * It uses these properties: `vertexData` `uvs`, `textureId` and
+       * `indicies`. It also uses the "tint" of the base-texture, if
+       * present.
+       * @param {PIXI.DisplayObject} element - element being rendered
+       * @param attributeBuffer - attribute buffer.
+       * @param indexBuffer - index buffer
+       * @param aIndex - number of floats already in the attribute buffer
+       * @param iIndex - number of indices already in `indexBuffer`
+       */
+      AbstractBatchRenderer.prototype.packInterleavedGeometry = function (element, attributeBuffer, indexBuffer, aIndex, iIndex) {
+          var uint32View = attributeBuffer.uint32View, float32View = attributeBuffer.float32View;
+          var packedVertices = aIndex / this.vertexSize;
+          var uvs = element.uvs;
+          var indicies = element.indices;
+          var vertexData = element.vertexData;
+          var textureId = element._texture.baseTexture._batchLocation;
+          var alpha = Math.min(element.worldAlpha, 1.0);
+          var argb = (alpha < 1.0
+              && element._texture.baseTexture.alphaMode)
+              ? premultiplyTint(element._tintRGB, alpha)
+              : element._tintRGB + (alpha * 255 << 24);
+          // lets not worry about tint! for now..
+          for (var i = 0; i < vertexData.length; i += 2) {
+              float32View[aIndex++] = vertexData[i];
+              float32View[aIndex++] = vertexData[i + 1];
+              float32View[aIndex++] = uvs[i];
+              float32View[aIndex++] = uvs[i + 1];
+              uint32View[aIndex++] = argb;
+              float32View[aIndex++] = textureId;
+          }
+          for (var i = 0; i < indicies.length; i++) {
+              indexBuffer[iIndex++] = packedVertices + indicies[i];
+          }
+      };
+      /**
+       * Pool of `BatchDrawCall` objects that `flush` used
+       * to create "batches" of the objects being rendered.
+       *
+       * These are never re-allocated again.
+       * Shared between all batch renderers because it can be only one "flush" working at the moment.
+       * @member {PIXI.BatchDrawCall[]}
+       */
+      AbstractBatchRenderer._drawCallPool = [];
+      /**
+       * Pool of `BatchDrawCall` objects that `flush` used
+       * to create "batches" of the objects being rendered.
+       *
+       * These are never re-allocated again.
+       * Shared between all batch renderers because it can be only one "flush" working at the moment.
+       * @member {PIXI.BatchTextureArray[]}
+       */
+      AbstractBatchRenderer._textureArrayPool = [];
+      return AbstractBatchRenderer;
+  }(ObjectRenderer));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  /**
+   * Helper that generates batching multi-texture shader. Use it with your new BatchRenderer
+   * @memberof PIXI
+   */
+  var BatchShaderGenerator = /** @class */ (function () {
+      /**
+       * @param vertexSrc - Vertex shader
+       * @param fragTemplate - Fragment shader template
+       */
+      function BatchShaderGenerator(vertexSrc, fragTemplate) {
+          this.vertexSrc = vertexSrc;
+          this.fragTemplate = fragTemplate;
+          this.programCache = {};
+          this.defaultGroupCache = {};
+          if (fragTemplate.indexOf('%count%') < 0) {
+              throw new Error('Fragment template must contain "%count%".');
+          }
+          if (fragTemplate.indexOf('%forloop%') < 0) {
+              throw new Error('Fragment template must contain "%forloop%".');
+          }
+      }
+      BatchShaderGenerator.prototype.generateShader = function (maxTextures) {
+          if (!this.programCache[maxTextures]) {
+              var sampleValues = new Int32Array(maxTextures);
+              for (var i = 0; i < maxTextures; i++) {
+                  sampleValues[i] = i;
+              }
+              this.defaultGroupCache[maxTextures] = UniformGroup.from({ uSamplers: sampleValues }, true);
+              var fragmentSrc = this.fragTemplate;
+              fragmentSrc = fragmentSrc.replace(/%count%/gi, "" + maxTextures);
+              fragmentSrc = fragmentSrc.replace(/%forloop%/gi, this.generateSampleSrc(maxTextures));
+              this.programCache[maxTextures] = new Program(this.vertexSrc, fragmentSrc);
+          }
+          var uniforms = {
+              tint: new Float32Array([1, 1, 1, 1]),
+              translationMatrix: new Matrix(),
+              default: this.defaultGroupCache[maxTextures],
+          };
+          return new Shader(this.programCache[maxTextures], uniforms);
+      };
+      BatchShaderGenerator.prototype.generateSampleSrc = function (maxTextures) {
+          var src = '';
+          src += '\n';
+          src += '\n';
+          for (var i = 0; i < maxTextures; i++) {
+              if (i > 0) {
+                  src += '\nelse ';
+              }
+              if (i < maxTextures - 1) {
+                  src += "if(vTextureId < " + i + ".5)";
+              }
+              src += '\n{';
+              src += "\n\tcolor = texture2D(uSamplers[" + i + "], vTextureCoord);";
+              src += '\n}';
+          }
+          src += '\n';
+          src += '\n';
+          return src;
+      };
+      return BatchShaderGenerator;
+  }());
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+  /**
+   * Geometry used to batch standard PIXI content (e.g. Mesh, Sprite, Graphics objects).
+   * @memberof PIXI
+   */
+  var BatchGeometry = /** @class */ (function (_super) {
+      __extends$i(BatchGeometry, _super);
+      /**
+       * @param {boolean} [_static=false] - Optimization flag, where `false`
+       *        is updated every frame, `true` doesn't change frame-to-frame.
+       */
+      function BatchGeometry(_static) {
+          if (_static === void 0) { _static = false; }
+          var _this = _super.call(this) || this;
+          _this._buffer = new Buffer(null, _static, false);
+          _this._indexBuffer = new Buffer(null, _static, true);
+          _this.addAttribute('aVertexPosition', _this._buffer, 2, false, exports.TYPES.FLOAT)
+              .addAttribute('aTextureCoord', _this._buffer, 2, false, exports.TYPES.FLOAT)
+              .addAttribute('aColor', _this._buffer, 4, true, exports.TYPES.UNSIGNED_BYTE)
+              .addAttribute('aTextureId', _this._buffer, 1, true, exports.TYPES.FLOAT)
+              .addIndex(_this._indexBuffer);
+          return _this;
+      }
+      return BatchGeometry;
+  }(Geometry));
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  var defaultVertex = "precision highp float;\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\nattribute float aTextureId;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform vec4 tint;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\n\nvoid main(void){\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vTextureId = aTextureId;\n    vColor = aColor * tint;\n}\n";
 
-var SharedTicker = core.ticker.shared;
+  var defaultFragment = "varying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\nuniform sampler2D uSamplers[%count%];\n\nvoid main(void){\n    vec4 color;\n    %forloop%\n    gl_FragColor = color * vColor;\n}\n";
 
-/**
- * Default number of uploads per frame using prepare plugin.
- *
- * @static
- * @memberof PIXI.settings
- * @name UPLOADS_PER_FRAME
- * @type {number}
- * @default 4
- */
-core.settings.UPLOADS_PER_FRAME = 4;
+  /** @memberof PIXI */
+  var BatchPluginFactory = /** @class */ (function () {
+      function BatchPluginFactory() {
+      }
+      /**
+       * Create a new BatchRenderer plugin for Renderer. this convenience can provide an easy way
+       * to extend BatchRenderer with all the necessary pieces.
+       * @example
+       * const fragment = `
+       * varying vec2 vTextureCoord;
+       * varying vec4 vColor;
+       * varying float vTextureId;
+       * uniform sampler2D uSamplers[%count%];
+       *
+       * void main(void){
+       *     vec4 color;
+       *     %forloop%
+       *     gl_FragColor = vColor * vec4(color.a - color.rgb, color.a);
+       * }
+       * `;
+       * const InvertBatchRenderer = PIXI.BatchPluginFactory.create({ fragment });
+       * PIXI.extensions.add({
+       *  name: 'invert',
+       *  ref: InvertBatchRenderer,
+       *  type: PIXI.ExtensionType.RendererPlugin,
+       * });
+       * const sprite = new PIXI.Sprite();
+       * sprite.pluginName = 'invert';
+       * @param {object} [options]
+       * @param {string} [options.vertex=PIXI.BatchPluginFactory.defaultVertexSrc] - Vertex shader source
+       * @param {string} [options.fragment=PIXI.BatchPluginFactory.defaultFragmentTemplate] - Fragment shader template
+       * @param {number} [options.vertexSize=6] - Vertex size
+       * @param {object} [options.geometryClass=PIXI.BatchGeometry]
+       * @returns {*} New batch renderer plugin
+       */
+      BatchPluginFactory.create = function (options) {
+          var _a = Object.assign({
+              vertex: defaultVertex,
+              fragment: defaultFragment,
+              geometryClass: BatchGeometry,
+              vertexSize: 6,
+          }, options), vertex = _a.vertex, fragment = _a.fragment, vertexSize = _a.vertexSize, geometryClass = _a.geometryClass;
+          return /** @class */ (function (_super) {
+              __extends$i(BatchPlugin, _super);
+              function BatchPlugin(renderer) {
+                  var _this = _super.call(this, renderer) || this;
+                  _this.shaderGenerator = new BatchShaderGenerator(vertex, fragment);
+                  _this.geometryClass = geometryClass;
+                  _this.vertexSize = vertexSize;
+                  return _this;
+              }
+              return BatchPlugin;
+          }(AbstractBatchRenderer));
+      };
+      Object.defineProperty(BatchPluginFactory, "defaultVertexSrc", {
+          /**
+           * The default vertex shader source
+           * @readonly
+           */
+          get: function () {
+              return defaultVertex;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BatchPluginFactory, "defaultFragmentTemplate", {
+          /**
+           * The default fragment shader source
+           * @readonly
+           */
+          get: function () {
+              return defaultFragment;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return BatchPluginFactory;
+  }());
+  // Setup the default BatchRenderer plugin, this is what
+  // we'll actually export at the root level
+  var BatchRenderer = BatchPluginFactory.create();
+  Object.assign(BatchRenderer, {
+      extension: {
+          name: 'batch',
+          type: exports.ExtensionType.RendererPlugin,
+      },
+  });
 
-/**
- * The prepare manager provides functionality to upload content to the GPU. BasePrepare handles
- * basic queuing functionality and is extended by {@link PIXI.prepare.WebGLPrepare} and {@link PIXI.prepare.CanvasPrepare}
- * to provide preparation capabilities specific to their respective renderers.
- *
- * @example
- * // Create a sprite
- * const sprite = new PIXI.Sprite.fromImage('something.png');
- *
- * // Load object into GPU
- * app.renderer.plugins.prepare.upload(sprite, () => {
- *
- *     //Texture(s) has been uploaded to GPU
- *     app.stage.addChild(sprite);
- *
- * })
- *
- * @abstract
- * @class
- * @memberof PIXI.prepare
- */
+  /**
+   * @memberof PIXI
+   * @namespace resources
+   * @see PIXI
+   * @deprecated since 6.0.0
+   */
+  var resources = {};
+  var _loop_1 = function (name) {
+      Object.defineProperty(resources, name, {
+          get: function () {
+              deprecation('6.0.0', "PIXI.systems." + name + " has moved to PIXI." + name);
+              return _resources[name];
+          },
+      });
+  };
+  for (var name in _resources) {
+      _loop_1(name);
+  }
+  /**
+   * @memberof PIXI
+   * @namespace systems
+   * @see PIXI
+   * @deprecated since 6.0.0
+   */
+  var systems = {};
+  var _loop_2 = function (name) {
+      Object.defineProperty(systems, name, {
+          get: function () {
+              deprecation('6.0.0', "PIXI.resources." + name + " has moved to PIXI." + name);
+              return _systems[name];
+          },
+      });
+  };
+  for (var name in _systems) {
+      _loop_2(name);
+  }
 
-var BasePrepare = function () {
-    /**
-     * @param {PIXI.SystemRenderer} renderer - A reference to the current renderer
-     */
-    function BasePrepare(renderer) {
-        var _this = this;
-
-        _classCallCheck(this, BasePrepare);
-
-        /**
-         * The limiter to be used to control how quickly items are prepared.
-         * @type {PIXI.prepare.CountLimiter|PIXI.prepare.TimeLimiter}
-         */
-        this.limiter = new _CountLimiter2.default(core.settings.UPLOADS_PER_FRAME);
-
-        /**
-         * Reference to the renderer.
-         * @type {PIXI.SystemRenderer}
-         * @protected
-         */
-        this.renderer = renderer;
-
-        /**
-         * The only real difference between CanvasPrepare and WebGLPrepare is what they pass
-         * to upload hooks. That different parameter is stored here.
-         * @type {PIXI.prepare.CanvasPrepare|PIXI.WebGLRenderer}
-         * @protected
-         */
-        this.uploadHookHelper = null;
-
-        /**
-         * Collection of items to uploads at once.
-         * @type {Array<*>}
-         * @private
-         */
-        this.queue = [];
-
-        /**
-         * Collection of additional hooks for finding assets.
-         * @type {Array<Function>}
-         * @private
-         */
-        this.addHooks = [];
-
-        /**
-         * Collection of additional hooks for processing assets.
-         * @type {Array<Function>}
-         * @private
-         */
-        this.uploadHooks = [];
-
-        /**
-         * Callback to call after completed.
-         * @type {Array<Function>}
-         * @private
-         */
-        this.completes = [];
-
-        /**
-         * If prepare is ticking (running).
-         * @type {boolean}
-         * @private
-         */
-        this.ticking = false;
-
-        /**
-         * 'bound' call for prepareItems().
-         * @type {Function}
-         * @private
-         */
-        this.delayedTick = function () {
-            // unlikely, but in case we were destroyed between tick() and delayedTick()
-            if (!_this.queue) {
-                return;
-            }
-            _this.prepareItems();
-        };
-
-        // hooks to find the correct texture
-        this.registerFindHook(findText);
-        this.registerFindHook(findTextStyle);
-        this.registerFindHook(findMultipleBaseTextures);
-        this.registerFindHook(findBaseTexture);
-        this.registerFindHook(findTexture);
-
-        // upload hooks
-        this.registerUploadHook(drawText);
-        this.registerUploadHook(calculateTextStyle);
-    }
+  /**
+   * @namespace PIXI
+   */
+  /**
+   * String of the current PIXI version.
+   * @memberof PIXI
+   */
+  var VERSION = '6.5.10';
 
-    /**
-     * Upload all the textures and graphics to the GPU.
-     *
-     * @param {Function|PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text} item -
-     *        Either the container or display object to search for items to upload, the items to upload themselves,
-     *        or the callback function, if items have been added using `prepare.add`.
-     * @param {Function} [done] - Optional callback when all queued uploads have completed
-     */
+  /*!
+   * @pixi/accessibility - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/accessibility is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
+  /**
+   * Default property values of accessible objects
+   * used by {@link PIXI.AccessibilityManager}.
+   * @private
+   * @function accessibleTarget
+   * @memberof PIXI
+   * @type {object}
+   * @example
+   *      function MyObject() {}
+   *
+   *      Object.assign(
+   *          MyObject.prototype,
+   *          PIXI.accessibleTarget
+   *      );
+   */
+  var accessibleTarget = {
+      /**
+       *  Flag for if the object is accessible. If true AccessibilityManager will overlay a
+       *   shadow div with attributes set
+       * @member {boolean}
+       * @memberof PIXI.DisplayObject#
+       */
+      accessible: false,
+      /**
+       * Sets the title attribute of the shadow div
+       * If accessibleTitle AND accessibleHint has not been this will default to 'displayObject [tabIndex]'
+       * @member {?string}
+       * @memberof PIXI.DisplayObject#
+       */
+      accessibleTitle: null,
+      /**
+       * Sets the aria-label attribute of the shadow div
+       * @member {string}
+       * @memberof PIXI.DisplayObject#
+       */
+      accessibleHint: null,
+      /**
+       * @member {number}
+       * @memberof PIXI.DisplayObject#
+       * @private
+       * @todo Needs docs.
+       */
+      tabIndex: 0,
+      /**
+       * @member {boolean}
+       * @memberof PIXI.DisplayObject#
+       * @todo Needs docs.
+       */
+      _accessibleActive: false,
+      /**
+       * @member {boolean}
+       * @memberof PIXI.DisplayObject#
+       * @todo Needs docs.
+       */
+      _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 PIXI.DisplayObject#
+       * @default 'button'
+       */
+      accessibleType: 'button',
+      /**
+       * Specify the pointer-events the accessible div will use
+       * Defaults to auto.
+       * @member {string}
+       * @memberof PIXI.DisplayObject#
+       * @default 'auto'
+       */
+      accessiblePointerEvents: 'auto',
+      /**
+       * Setting to false will prevent any children inside this container to
+       * be accessible. Defaults to true.
+       * @member {boolean}
+       * @memberof PIXI.DisplayObject#
+       * @default true
+       */
+      accessibleChildren: true,
+      renderId: -1,
+  };
 
-    BasePrepare.prototype.upload = function upload(item, done) {
-        if (typeof item === 'function') {
-            done = item;
-            item = null;
-        }
+  // add some extra variables to the container..
+  DisplayObject.mixin(accessibleTarget);
+  var KEY_CODE_TAB = 9;
+  var DIV_TOUCH_SIZE = 100;
+  var DIV_TOUCH_POS_X = 0;
+  var DIV_TOUCH_POS_Y = 0;
+  var DIV_TOUCH_ZINDEX = 2;
+  var DIV_HOOK_SIZE = 1;
+  var DIV_HOOK_POS_X = -1000;
+  var DIV_HOOK_POS_Y = -1000;
+  var DIV_HOOK_ZINDEX = 2;
+  /**
+   * The Accessibility manager 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 DisplayObject 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.plugins.accessibility`
+   * @class
+   * @memberof PIXI
+   */
+  var AccessibilityManager = /** @class */ (function () {
+      /**
+       * @param {PIXI.CanvasRenderer|PIXI.Renderer} renderer - A reference to the current renderer
+       */
+      function AccessibilityManager(renderer) {
+          /** 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; // 2fps
+          this._hookDiv = null;
+          if (isMobile.tablet || isMobile.phone) {
+              this.createTouchHook();
+          }
+          // first we create a div that will sit over the PixiJS element. This is where the div overlays will go.
+          var 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;
+          /**
+           * pre-bind the functions
+           * @type {Function}
+           * @private
+           */
+          this._onKeyDown = this._onKeyDown.bind(this);
+          /**
+           * pre-bind the functions
+           * @type {Function}
+           * @private
+           */
+          this._onMouseMove = this._onMouseMove.bind(this);
+          // let listen for tab.. once pressed we can fire up and show the accessibility layer
+          globalThis.addEventListener('keydown', this._onKeyDown, false);
+      }
+      Object.defineProperty(AccessibilityManager.prototype, "isActive", {
+          /**
+           * Value of `true` if accessibility is currently active and accessibility layers are showing.
+           * @member {boolean}
+           * @readonly
+           */
+          get: function () {
+              return this._isActive;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(AccessibilityManager.prototype, "isMobileAccessibility", {
+          /**
+           * Value of `true` if accessibility is enabled for touch devices.
+           * @member {boolean}
+           * @readonly
+           */
+          get: function () {
+              return this._isMobileAccessibility;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Creates the touch hooks.
+       * @private
+       */
+      AccessibilityManager.prototype.createTouchHook = function () {
+          var _this = this;
+          var 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', function () {
+              _this._isMobileAccessibility = true;
+              _this.activate();
+              _this.destroyTouchHook();
+          });
+          document.body.appendChild(hookDiv);
+          this._hookDiv = hookDiv;
+      };
+      /**
+       * Destroys the touch hooks.
+       * @private
+       */
+      AccessibilityManager.prototype.destroyTouchHook = function () {
+          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
+       */
+      AccessibilityManager.prototype.activate = function () {
+          var _a;
+          if (this._isActive) {
+              return;
+          }
+          this._isActive = true;
+          globalThis.document.addEventListener('mousemove', this._onMouseMove, true);
+          globalThis.removeEventListener('keydown', this._onKeyDown, false);
+          this.renderer.on('postrender', this.update, this);
+          (_a = this.renderer.view.parentNode) === null || _a === void 0 ? void 0 : _a.appendChild(this.div);
+      };
+      /**
+       * Deactivating will cause the Accessibility layer to be hidden.
+       * This is called when a user moves the mouse.
+       * @private
+       */
+      AccessibilityManager.prototype.deactivate = function () {
+          var _a;
+          if (!this._isActive || this._isMobileAccessibility) {
+              return;
+          }
+          this._isActive = false;
+          globalThis.document.removeEventListener('mousemove', this._onMouseMove, true);
+          globalThis.addEventListener('keydown', this._onKeyDown, false);
+          this.renderer.off('postrender', this.update);
+          (_a = this.div.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(this.div);
+      };
+      /**
+       * This recursive function will run through the scene graph and add any new accessible objects to the DOM layer.
+       * @private
+       * @param {PIXI.Container} displayObject - The DisplayObject to check.
+       */
+      AccessibilityManager.prototype.updateAccessibleObjects = function (displayObject) {
+          if (!displayObject.visible || !displayObject.accessibleChildren) {
+              return;
+          }
+          if (displayObject.accessible && displayObject.interactive) {
+              if (!displayObject._accessibleActive) {
+                  this.addChild(displayObject);
+              }
+              displayObject.renderId = this.renderId;
+          }
+          var children = displayObject.children;
+          if (children) {
+              for (var i = 0; i < children.length; i++) {
+                  this.updateAccessibleObjects(children[i]);
+              }
+          }
+      };
+      /**
+       * Before each render this function will ensure that all divs are mapped correctly to their DisplayObjects.
+       * @private
+       */
+      AccessibilityManager.prototype.update = function () {
+          /* On Android default web browser, tab order seems to be calculated by position rather than tabIndex,
+          *  moving buttons can cause focus to flicker between two buttons making it hard/impossible to navigate,
+          *  so I am just running update every half a second, seems to fix it.
+          */
+          var now = performance.now();
+          if (isMobile.android.device && now < this.androidUpdateCount) {
+              return;
+          }
+          this.androidUpdateCount = now + this.androidUpdateFrequency;
+          if (!this.renderer.renderingToScreen) {
+              return;
+          }
+          // update children...
+          if (this.renderer._lastObjectRendered) {
+              this.updateAccessibleObjects(this.renderer._lastObjectRendered);
+          }
+          var _a = this.renderer.view.getBoundingClientRect(), left = _a.left, top = _a.top, width = _a.width, height = _a.height;
+          var _b = this.renderer, viewWidth = _b.width, viewHeight = _b.height, resolution = _b.resolution;
+          var sx = (width / viewWidth) * resolution;
+          var sy = (height / viewHeight) * resolution;
+          var div = this.div;
+          div.style.left = left + "px";
+          div.style.top = top + "px";
+          div.style.width = viewWidth + "px";
+          div.style.height = viewHeight + "px";
+          for (var i = 0; i < this.children.length; i++) {
+              var 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 {
+                  // map div to display..
+                  div = child._accessibleDiv;
+                  var hitArea = child.hitArea;
+                  var 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();
+                      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";
+                      // update button titles and hints if they exist and they've changed
+                      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);
+                      }
+                  }
+                  // the title or index may have changed, if so lets update it!
+                  if (child.accessibleTitle !== div.title || child.tabIndex !== div.tabIndex) {
+                      div.title = child.accessibleTitle;
+                      div.tabIndex = child.tabIndex;
+                      if (this.debug)
+                          { this.updateDebugHTML(div); }
+                  }
+              }
+          }
+          // increment the render id..
+          this.renderId++;
+      };
+      /**
+       * private function that will visually add the information to the
+       * accessability div
+       * @param {HTMLElement} div -
+       */
+      AccessibilityManager.prototype.updateDebugHTML = function (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 {PIXI.Rectangle} hitArea - Bounds of the child
+       */
+      AccessibilityManager.prototype.capHitArea = function (hitArea) {
+          if (hitArea.x < 0) {
+              hitArea.width += hitArea.x;
+              hitArea.x = 0;
+          }
+          if (hitArea.y < 0) {
+              hitArea.height += hitArea.y;
+              hitArea.y = 0;
+          }
+          var _a = this.renderer, viewWidth = _a.width, viewHeight = _a.height;
+          if (hitArea.x + hitArea.width > viewWidth) {
+              hitArea.width = viewWidth - hitArea.x;
+          }
+          if (hitArea.y + hitArea.height > viewHeight) {
+              hitArea.height = viewHeight - hitArea.y;
+          }
+      };
+      /**
+       * Adds a DisplayObject to the accessibility manager
+       * @private
+       * @param {PIXI.DisplayObject} displayObject - The child to make accessible.
+       */
+      AccessibilityManager.prototype.addChild = function (displayObject) {
+          //    this.activate();
+          var 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';
+              // ARIA attributes ensure that button title and hint updates are announced properly
+              if (navigator.userAgent.toLowerCase().indexOf('chrome') > -1) {
+                  // Chrome doesn't need aria-live to work as intended; in fact it just gets more confused.
+                  div.setAttribute('aria-live', 'off');
+              }
+              else {
+                  div.setAttribute('aria-live', 'polite');
+              }
+              if (navigator.userAgent.match(/rv:.*Gecko\//)) {
+                  // FireFox needs this to announce only the new button name
+                  div.setAttribute('aria-relevant', 'additions');
+              }
+              else {
+                  // required by IE, other browsers don't much care
+                  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));
+          }
+          // set pointer events
+          div.style.pointerEvents = displayObject.accessiblePointerEvents;
+          // set the type, this defaults to button!
+          div.type = displayObject.accessibleType;
+          if (displayObject.accessibleTitle && displayObject.accessibleTitle !== null) {
+              div.title = displayObject.accessibleTitle;
+          }
+          else if (!displayObject.accessibleHint
+              || displayObject.accessibleHint === null) {
+              div.title = "displayObject " + displayObject.tabIndex;
+          }
+          if (displayObject.accessibleHint
+              && displayObject.accessibleHint !== null) {
+              div.setAttribute('aria-label', displayObject.accessibleHint);
+          }
+          if (this.debug)
+              { this.updateDebugHTML(div); }
+          displayObject._accessibleActive = true;
+          displayObject._accessibleDiv = div;
+          div.displayObject = displayObject;
+          this.children.push(displayObject);
+          this.div.appendChild(displayObject._accessibleDiv);
+          displayObject._accessibleDiv.tabIndex = displayObject.tabIndex;
+      };
+      /**
+       * Maps the div button press to pixi's InteractionManager (click)
+       * @private
+       * @param {MouseEvent} e - The click event.
+       */
+      AccessibilityManager.prototype._onClick = function (e) {
+          var interactionManager = this.renderer.plugins.interaction;
+          var displayObject = e.target.displayObject;
+          var eventData = interactionManager.eventData;
+          interactionManager.dispatchEvent(displayObject, 'click', eventData);
+          interactionManager.dispatchEvent(displayObject, 'pointertap', eventData);
+          interactionManager.dispatchEvent(displayObject, 'tap', eventData);
+      };
+      /**
+       * Maps the div focus events to pixi's InteractionManager (mouseover)
+       * @private
+       * @param {FocusEvent} e - The focus event.
+       */
+      AccessibilityManager.prototype._onFocus = function (e) {
+          if (!e.target.getAttribute('aria-live')) {
+              e.target.setAttribute('aria-live', 'assertive');
+          }
+          var interactionManager = this.renderer.plugins.interaction;
+          var displayObject = e.target.displayObject;
+          var eventData = interactionManager.eventData;
+          interactionManager.dispatchEvent(displayObject, 'mouseover', eventData);
+      };
+      /**
+       * Maps the div focus events to pixi's InteractionManager (mouseout)
+       * @private
+       * @param {FocusEvent} e - The focusout event.
+       */
+      AccessibilityManager.prototype._onFocusOut = function (e) {
+          if (!e.target.getAttribute('aria-live')) {
+              e.target.setAttribute('aria-live', 'polite');
+          }
+          var interactionManager = this.renderer.plugins.interaction;
+          var displayObject = e.target.displayObject;
+          var eventData = interactionManager.eventData;
+          interactionManager.dispatchEvent(displayObject, 'mouseout', eventData);
+      };
+      /**
+       * Is called when a key is pressed
+       * @private
+       * @param {KeyboardEvent} e - The keydown event.
+       */
+      AccessibilityManager.prototype._onKeyDown = function (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.
+       */
+      AccessibilityManager.prototype._onMouseMove = function (e) {
+          if (e.movementX === 0 && e.movementY === 0) {
+              return;
+          }
+          this.deactivate();
+      };
+      /** Destroys the accessibility manager */
+      AccessibilityManager.prototype.destroy = function () {
+          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 */
+      AccessibilityManager.extension = {
+          name: 'accessibility',
+          type: [
+              exports.ExtensionType.RendererPlugin,
+              exports.ExtensionType.CanvasRendererPlugin ],
+      };
+      return AccessibilityManager;
+  }());
+
+  /*!
+   * @pixi/interaction - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/interaction is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-        // If a display object, search for items
-        // that we could upload
-        if (item) {
-            this.add(item);
-        }
+  /**
+   * Holds all information related to an Interaction event
+   * @memberof PIXI
+   */
+  var InteractionData = /** @class */ (function () {
+      function InteractionData() {
+          /**
+           * Pressure applied by the pointing device during the event. A Touch's force property
+           * will be represented by this value.
+           * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pressure
+           */
+          this.pressure = 0;
+          /**
+           * From TouchEvents (not PointerEvents triggered by touches), the rotationAngle of the Touch.
+           * @see https://developer.mozilla.org/en-US/docs/Web/API/Touch/rotationAngle
+           */
+          this.rotationAngle = 0;
+          /**
+           * Twist of a stylus pointer.
+           * @see https://w3c.github.io/pointerevents/#pointerevent-interface
+           */
+          this.twist = 0;
+          /**
+           * Barrel pressure on a stylus pointer.
+           * @see https://w3c.github.io/pointerevents/#pointerevent-interface
+           */
+          this.tangentialPressure = 0;
+          this.global = new Point();
+          this.target = null;
+          this.originalEvent = null;
+          this.identifier = null;
+          this.isPrimary = false;
+          this.button = 0;
+          this.buttons = 0;
+          this.width = 0;
+          this.height = 0;
+          this.tiltX = 0;
+          this.tiltY = 0;
+          this.pointerType = null;
+          this.pressure = 0;
+          this.rotationAngle = 0;
+          this.twist = 0;
+          this.tangentialPressure = 0;
+      }
+      Object.defineProperty(InteractionData.prototype, "pointerId", {
+          /**
+           * The unique identifier of the pointer. It will be the same as `identifier`.
+           * @readonly
+           * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId
+           */
+          get: function () {
+              return this.identifier;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * This will return the local coordinates of the specified displayObject for this InteractionData
+       * @param displayObject - The DisplayObject that you would like the local
+       *  coords off
+       * @param point - A Point object in which to store the value, optional (otherwise
+       *  will create a new point)
+       * @param globalPos - A Point object containing your custom global coords, optional
+       *  (otherwise will use the current global coords)
+       * @returns - A point containing the coordinates of the InteractionData position relative
+       *  to the DisplayObject
+       */
+      InteractionData.prototype.getLocalPosition = function (displayObject, point, globalPos) {
+          return displayObject.worldTransform.applyInverse(globalPos || this.global, point);
+      };
+      /**
+       * Copies properties from normalized event data.
+       * @param {Touch|MouseEvent|PointerEvent} event - The normalized event data
+       */
+      InteractionData.prototype.copyEvent = function (event) {
+          // isPrimary should only change on touchstart/pointerdown, so we don't want to overwrite
+          // it with "false" on later events when our shim for it on touch events might not be
+          // accurate
+          if ('isPrimary' in event && event.isPrimary) {
+              this.isPrimary = true;
+          }
+          this.button = 'button' in event && event.button;
+          // event.buttons is not available in all browsers (ie. Safari), but it does have a non-standard
+          // event.which property instead, which conveys the same information.
+          var buttons = 'buttons' in event && event.buttons;
+          this.buttons = Number.isInteger(buttons) ? buttons : 'which' in event && event.which;
+          this.width = 'width' in event && event.width;
+          this.height = 'height' in event && event.height;
+          this.tiltX = 'tiltX' in event && event.tiltX;
+          this.tiltY = 'tiltY' in event && event.tiltY;
+          this.pointerType = 'pointerType' in event && event.pointerType;
+          this.pressure = 'pressure' in event && event.pressure;
+          this.rotationAngle = 'rotationAngle' in event && event.rotationAngle;
+          this.twist = ('twist' in event && event.twist) || 0;
+          this.tangentialPressure = ('tangentialPressure' in event && event.tangentialPressure) || 0;
+      };
+      /** Resets the data for pooling. */
+      InteractionData.prototype.reset = function () {
+          // isPrimary is the only property that we really need to reset - everything else is
+          // guaranteed to be overwritten
+          this.isPrimary = false;
+      };
+      return InteractionData;
+  }());
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$h = function(d, b) {
+      extendStatics$h = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$h(d, b);
+  };
 
-        // Get the items for upload from the display
-        if (this.queue.length) {
-            if (done) {
-                this.completes.push(done);
-            }
+  function __extends$h(d, b) {
+      extendStatics$h(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-            if (!this.ticking) {
-                this.ticking = true;
-                SharedTicker.addOnce(this.tick, this, core.UPDATE_PRIORITY.UTILITY);
-            }
-        } else if (done) {
-            done();
-        }
-    };
+  /**
+   * Event class that mimics native DOM events.
+   * @memberof PIXI
+   */
+  var InteractionEvent = /** @class */ (function () {
+      function InteractionEvent() {
+          this.stopped = false;
+          this.stopsPropagatingAt = null;
+          this.stopPropagationHint = false;
+          this.target = null;
+          this.currentTarget = null;
+          this.type = null;
+          this.data = null;
+      }
+      /** Prevents event from reaching any objects other than the current object. */
+      InteractionEvent.prototype.stopPropagation = function () {
+          this.stopped = true;
+          this.stopPropagationHint = true;
+          this.stopsPropagatingAt = this.currentTarget;
+      };
+      /** Resets the event. */
+      InteractionEvent.prototype.reset = function () {
+          this.stopped = false;
+          this.stopsPropagatingAt = null;
+          this.stopPropagationHint = false;
+          this.currentTarget = null;
+          this.target = null;
+      };
+      return InteractionEvent;
+  }());
 
-    /**
-     * Handle tick update
-     *
-     * @private
-     */
+  /**
+   * DisplayObjects with the {@link PIXI.interactiveTarget} mixin use this class to track interactions
+   * @class
+   * @private
+   * @memberof PIXI
+   */
+  var InteractionTrackingData = /** @class */ (function () {
+      /**
+       * @param {number} pointerId - Unique pointer id of the event
+       * @private
+       */
+      function InteractionTrackingData(pointerId) {
+          this._pointerId = pointerId;
+          this._flags = InteractionTrackingData.FLAGS.NONE;
+      }
+      /**
+       *
+       * @private
+       * @param {number} flag - The interaction flag to set
+       * @param {boolean} yn - Should the flag be set or unset
+       */
+      InteractionTrackingData.prototype._doSet = function (flag, yn) {
+          if (yn) {
+              this._flags = this._flags | flag;
+          }
+          else {
+              this._flags = this._flags & (~flag);
+          }
+      };
+      Object.defineProperty(InteractionTrackingData.prototype, "pointerId", {
+          /**
+           * Unique pointer id of the event
+           * @readonly
+           * @private
+           * @member {number}
+           */
+          get: function () {
+              return this._pointerId;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(InteractionTrackingData.prototype, "flags", {
+          /**
+           * State of the tracking data, expressed as bit flags
+           * @private
+           * @member {number}
+           */
+          get: function () {
+              return this._flags;
+          },
+          set: function (flags) {
+              this._flags = flags;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(InteractionTrackingData.prototype, "none", {
+          /**
+           * Is the tracked event inactive (not over or down)?
+           * @private
+           * @member {number}
+           */
+          get: function () {
+              return this._flags === InteractionTrackingData.FLAGS.NONE;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(InteractionTrackingData.prototype, "over", {
+          /**
+           * Is the tracked event over the DisplayObject?
+           * @private
+           * @member {boolean}
+           */
+          get: function () {
+              return (this._flags & InteractionTrackingData.FLAGS.OVER) !== 0;
+          },
+          set: function (yn) {
+              this._doSet(InteractionTrackingData.FLAGS.OVER, yn);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(InteractionTrackingData.prototype, "rightDown", {
+          /**
+           * Did the right mouse button come down in the DisplayObject?
+           * @private
+           * @member {boolean}
+           */
+          get: function () {
+              return (this._flags & InteractionTrackingData.FLAGS.RIGHT_DOWN) !== 0;
+          },
+          set: function (yn) {
+              this._doSet(InteractionTrackingData.FLAGS.RIGHT_DOWN, yn);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(InteractionTrackingData.prototype, "leftDown", {
+          /**
+           * Did the left mouse button come down in the DisplayObject?
+           * @private
+           * @member {boolean}
+           */
+          get: function () {
+              return (this._flags & InteractionTrackingData.FLAGS.LEFT_DOWN) !== 0;
+          },
+          set: function (yn) {
+              this._doSet(InteractionTrackingData.FLAGS.LEFT_DOWN, yn);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      InteractionTrackingData.FLAGS = Object.freeze({
+          NONE: 0,
+          OVER: 1 << 0,
+          LEFT_DOWN: 1 << 1,
+          RIGHT_DOWN: 1 << 2,
+      });
+      return InteractionTrackingData;
+  }());
 
+  /**
+   * Strategy how to search through stage tree for interactive objects
+   * @memberof PIXI
+   */
+  var TreeSearch = /** @class */ (function () {
+      function TreeSearch() {
+          this._tempPoint = new Point();
+      }
+      /**
+       * Recursive implementation for findHit
+       * @private
+       * @param interactionEvent - event containing the point that
+       *  is tested for collision
+       * @param displayObject - the displayObject
+       *  that will be hit test (recursively crawls its children)
+       * @param func - the function that will be called on each interactive object. The
+       *  interactionEvent, displayObject and hit will be passed to the function
+       * @param hitTest - this indicates if the objects inside should be hit test against the point
+       * @param interactive - Whether the displayObject is interactive
+       * @returns - Returns true if the displayObject hit the point
+       */
+      TreeSearch.prototype.recursiveFindHit = function (interactionEvent, displayObject, func, hitTest, interactive) {
+          var _a;
+          if (!displayObject || !displayObject.visible) {
+              return false;
+          }
+          var point = interactionEvent.data.global;
+          // Took a little while to rework this function correctly! But now it is done and nice and optimized! ^_^
+          //
+          // This function will now loop through all objects and then only hit test the objects it HAS
+          // to, not all of them. MUCH faster..
+          // An object will be hit test if the following is true:
+          //
+          // 1: It is interactive.
+          // 2: It belongs to a parent that is interactive AND one of the parents children have not already been hit.
+          //
+          // As another little optimization once an interactive object has been hit we can carry on
+          // through the scenegraph, but we know that there will be no more hits! So we can avoid extra hit tests
+          // A final optimization is that an object is not hit test directly if a child has already been hit.
+          interactive = displayObject.interactive || interactive;
+          var hit = false;
+          var interactiveParent = interactive;
+          // Flag here can set to false if the event is outside the parents hitArea or mask
+          var hitTestChildren = true;
+          // If there is a hitArea, no need to test against anything else if the pointer is not within the hitArea
+          // There is also no longer a need to hitTest children.
+          if (displayObject.hitArea) {
+              if (hitTest) {
+                  displayObject.worldTransform.applyInverse(point, this._tempPoint);
+                  if (!displayObject.hitArea.contains(this._tempPoint.x, this._tempPoint.y)) {
+                      hitTest = false;
+                      hitTestChildren = false;
+                  }
+                  else {
+                      hit = true;
+                  }
+              }
+              interactiveParent = false;
+          }
+          // If there is a mask, no need to hitTest against anything else if the pointer is not within the mask.
+          // We still want to hitTestChildren, however, to ensure a mouseout can still be generated.
+          // https://github.com/pixijs/pixi.js/issues/5135
+          else if (displayObject._mask) {
+              if (hitTest) {
+                  var maskObject = (displayObject._mask.isMaskData
+                      ? displayObject._mask.maskObject : displayObject._mask);
+                  if (maskObject && !((_a = maskObject.containsPoint) === null || _a === void 0 ? void 0 : _a.call(maskObject, point))) {
+                      hitTest = false;
+                  }
+              }
+          }
+          // ** FREE TIP **! If an object is not interactive or has no buttons in it
+          // (such as a game scene!) set interactiveChildren to false for that displayObject.
+          // This will allow PixiJS to completely ignore and bypass checking the displayObjects children.
+          if (hitTestChildren && displayObject.interactiveChildren && displayObject.children) {
+              var children = displayObject.children;
+              for (var i = children.length - 1; i >= 0; i--) {
+                  var child = children[i];
+                  // time to get recursive.. if this function will return if something is hit..
+                  var childHit = this.recursiveFindHit(interactionEvent, child, func, hitTest, interactiveParent);
+                  if (childHit) {
+                      // its a good idea to check if a child has lost its parent.
+                      // this means it has been removed whilst looping so its best
+                      if (!child.parent) {
+                          continue;
+                      }
+                      // we no longer need to hit test any more objects in this container as we we
+                      // now know the parent has been hit
+                      interactiveParent = false;
+                      // If the child is interactive , that means that the object hit was actually
+                      // interactive and not just the child of an interactive object.
+                      // This means we no longer need to hit test anything else. We still need to run
+                      // through all objects, but we don't need to perform any hit tests.
+                      if (childHit) {
+                          if (interactionEvent.target) {
+                              hitTest = false;
+                          }
+                          hit = true;
+                      }
+                  }
+              }
+          }
+          // no point running this if the item is not interactive or does not have an interactive parent.
+          if (interactive) {
+              // if we are hit testing (as in we have no hit any objects yet)
+              // We also don't need to worry about hit testing if once of the displayObjects children
+              // has already been hit - but only if it was interactive, otherwise we need to keep
+              // looking for an interactive child, just in case we hit one
+              if (hitTest && !interactionEvent.target) {
+                  // already tested against hitArea if it is defined
+                  if (!displayObject.hitArea && displayObject.containsPoint) {
+                      if (displayObject.containsPoint(point)) {
+                          hit = true;
+                      }
+                  }
+              }
+              if (displayObject.interactive) {
+                  if (hit && !interactionEvent.target) {
+                      interactionEvent.target = displayObject;
+                  }
+                  if (func) {
+                      func(interactionEvent, displayObject, !!hit);
+                  }
+              }
+          }
+          return hit;
+      };
+      /**
+       * This function is provides a neat way of crawling through the scene graph and running a
+       * specified function on all interactive objects it finds. It will also take care of hit
+       * testing the interactive objects and passes the hit across in the function.
+       * @private
+       * @param interactionEvent - event containing the point that
+       *  is tested for collision
+       * @param displayObject - the displayObject
+       *  that will be hit test (recursively crawls its children)
+       * @param func - the function that will be called on each interactive object. The
+       *  interactionEvent, displayObject and hit will be passed to the function
+       * @param hitTest - this indicates if the objects inside should be hit test against the point
+       * @returns - Returns true if the displayObject hit the point
+       */
+      TreeSearch.prototype.findHit = function (interactionEvent, displayObject, func, hitTest) {
+          this.recursiveFindHit(interactionEvent, displayObject, func, hitTest, false);
+      };
+      return TreeSearch;
+  }());
 
-    BasePrepare.prototype.tick = function tick() {
-        setTimeout(this.delayedTick, 0);
-    };
+  /**
+   * Interface for classes that represent a hit area.
+   *
+   * It is implemented by the following classes:
+   * - {@link PIXI.Circle}
+   * - {@link PIXI.Ellipse}
+   * - {@link PIXI.Polygon}
+   * - {@link PIXI.RoundedRectangle}
+   * @interface IHitArea
+   * @memberof PIXI
+   */
+  /**
+   * Checks whether the x and y coordinates given are contained within this area
+   * @method
+   * @name contains
+   * @memberof PIXI.IHitArea#
+   * @param {number} x - The X coordinate of the point to test
+   * @param {number} y - The Y coordinate of the point to test
+   * @returns {boolean} Whether the x/y coordinates are within this area
+   */
+  /**
+   * Default property values of interactive objects
+   * Used by {@link PIXI.InteractionManager} to automatically give all DisplayObjects these properties
+   * @private
+   * @name interactiveTarget
+   * @type {object}
+   * @memberof PIXI
+   * @example
+   *      function MyObject() {}
+   *
+   *      Object.assign(
+   *          DisplayObject.prototype,
+   *          PIXI.interactiveTarget
+   *      );
+   */
+  var interactiveTarget = {
+      interactive: false,
+      interactiveChildren: true,
+      hitArea: null,
+      /**
+       * If enabled, the mouse cursor use the pointer behavior when hovered over the displayObject if it is interactive
+       * Setting this changes the 'cursor' property to `'pointer'`.
+       * @example
+       * const sprite = new PIXI.Sprite(texture);
+       * sprite.interactive = true;
+       * sprite.buttonMode = true;
+       * @member {boolean}
+       * @memberof PIXI.DisplayObject#
+       */
+      get buttonMode() {
+          return this.cursor === 'pointer';
+      },
+      set buttonMode(value) {
+          if (value) {
+              this.cursor = 'pointer';
+          }
+          else if (this.cursor === 'pointer') {
+              this.cursor = null;
+          }
+      },
+      /**
+       * This defines what cursor mode is used when the mouse cursor
+       * is hovered over the displayObject.
+       * @example
+       * const sprite = new PIXI.Sprite(texture);
+       * sprite.interactive = true;
+       * sprite.cursor = 'wait';
+       * @see https://developer.mozilla.org/en/docs/Web/CSS/cursor
+       * @member {string}
+       * @memberof PIXI.DisplayObject#
+       */
+      cursor: null,
+      /**
+       * Internal set of all active pointers, by identifier
+       * @member {Map<number, InteractionTrackingData>}
+       * @memberof PIXI.DisplayObject#
+       * @private
+       */
+      get trackedPointers() {
+          if (this._trackedPointers === undefined)
+              { this._trackedPointers = {}; }
+          return this._trackedPointers;
+      },
+      /**
+       * Map of all tracked pointers, by identifier. Use trackedPointers to access.
+       * @private
+       * @type {Map<number, InteractionTrackingData>}
+       */
+      _trackedPointers: undefined,
+  };
 
-    /**
-     * Actually prepare items. This is handled outside of the tick because it will take a while
-     * and we do NOT want to block the current animation frame from rendering.
-     *
-     * @private
-     */
-
-
-    BasePrepare.prototype.prepareItems = function prepareItems() {
-        this.limiter.beginFrame();
-        // Upload the graphics
-        while (this.queue.length && this.limiter.allowedToUpload()) {
-            var item = this.queue[0];
-            var uploaded = false;
-
-            if (item && !item._destroyed) {
-                for (var i = 0, len = this.uploadHooks.length; i < len; i++) {
-                    if (this.uploadHooks[i](this.uploadHookHelper, item)) {
-                        this.queue.shift();
-                        uploaded = true;
-                        break;
-                    }
-                }
-            }
+  // Mix interactiveTarget into DisplayObject.prototype
+  DisplayObject.mixin(interactiveTarget);
+  var MOUSE_POINTER_ID = 1;
+  // helpers for hitTest() - only used inside hitTest()
+  var hitTestEvent = {
+      target: null,
+      data: {
+          global: null,
+      },
+  };
+  /**
+   * The interaction manager deals with mouse, touch and pointer events.
+   *
+   * Any DisplayObject can be interactive if its `interactive` property is set to true.
+   *
+   * This manager also supports multitouch.
+   *
+   * An instance of this class is automatically created by default, and can be found at `renderer.plugins.interaction`
+   * @memberof PIXI
+   */
+  var InteractionManager = /** @class */ (function (_super) {
+      __extends$h(InteractionManager, _super);
+      /**
+       * @param {PIXI.CanvasRenderer|PIXI.Renderer} renderer - A reference to the current renderer
+       * @param options - The options for the manager.
+       * @param {boolean} [options.autoPreventDefault=true] - Should the manager automatically prevent default browser actions.
+       * @param {number} [options.interactionFrequency=10] - Maximum frequency (ms) at pointer over/out states will be checked.
+       * @param {number} [options.useSystemTicker=true] - Whether to add {@link tickerUpdate} to {@link PIXI.Ticker.system}.
+       */
+      function InteractionManager(renderer, options) {
+          var _this = _super.call(this) || this;
+          options = options || {};
+          _this.renderer = renderer;
+          _this.autoPreventDefault = options.autoPreventDefault !== undefined ? options.autoPreventDefault : true;
+          _this.interactionFrequency = options.interactionFrequency || 10;
+          _this.mouse = new InteractionData();
+          _this.mouse.identifier = MOUSE_POINTER_ID;
+          // setting the mouse to start off far off screen will mean that mouse over does
+          //  not get called before we even move the mouse.
+          _this.mouse.global.set(-999999);
+          _this.activeInteractionData = {};
+          _this.activeInteractionData[MOUSE_POINTER_ID] = _this.mouse;
+          _this.interactionDataPool = [];
+          _this.eventData = new InteractionEvent();
+          _this.interactionDOMElement = null;
+          _this.moveWhenInside = false;
+          _this.eventsAdded = false;
+          _this.tickerAdded = false;
+          _this.mouseOverRenderer = !('PointerEvent' in globalThis);
+          _this.supportsTouchEvents = 'ontouchstart' in globalThis;
+          _this.supportsPointerEvents = !!globalThis.PointerEvent;
+          // this will make it so that you don't have to call bind all the time
+          _this.onPointerUp = _this.onPointerUp.bind(_this);
+          _this.processPointerUp = _this.processPointerUp.bind(_this);
+          _this.onPointerCancel = _this.onPointerCancel.bind(_this);
+          _this.processPointerCancel = _this.processPointerCancel.bind(_this);
+          _this.onPointerDown = _this.onPointerDown.bind(_this);
+          _this.processPointerDown = _this.processPointerDown.bind(_this);
+          _this.onPointerMove = _this.onPointerMove.bind(_this);
+          _this.processPointerMove = _this.processPointerMove.bind(_this);
+          _this.onPointerOut = _this.onPointerOut.bind(_this);
+          _this.processPointerOverOut = _this.processPointerOverOut.bind(_this);
+          _this.onPointerOver = _this.onPointerOver.bind(_this);
+          _this.cursorStyles = {
+              default: 'inherit',
+              pointer: 'pointer',
+          };
+          _this.currentCursorMode = null;
+          _this.cursor = null;
+          _this.resolution = 1;
+          _this.delayedEvents = [];
+          _this.search = new TreeSearch();
+          _this._tempDisplayObject = new TemporaryDisplayObject();
+          _this._eventListenerOptions = { capture: true, passive: false };
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is pressed on the display
+           * object.
+           * @event PIXI.InteractionManager#mousedown
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
+           * on the display object.
+           * @event PIXI.InteractionManager#rightdown
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is released over the display
+           * object.
+           * @event PIXI.InteractionManager#mouseup
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is released
+           * over the display object.
+           * @event PIXI.InteractionManager#rightup
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is pressed and released on
+           * the display object.
+           * @event PIXI.InteractionManager#click
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
+           * and released on the display object.
+           * @event PIXI.InteractionManager#rightclick
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is released outside the
+           * display object that initially registered a
+           * [mousedown]{@link PIXI.InteractionManager#event:mousedown}.
+           * @event PIXI.InteractionManager#mouseupoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is released
+           * outside the display object that initially registered a
+           * [rightdown]{@link PIXI.InteractionManager#event:rightdown}.
+           * @event PIXI.InteractionManager#rightupoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device (usually a mouse) is moved while over the display object
+           * @event PIXI.InteractionManager#mousemove
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device (usually a mouse) is moved onto the display object
+           * @event PIXI.InteractionManager#mouseover
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device (usually a mouse) is moved off the display object
+           * @event PIXI.InteractionManager#mouseout
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is pressed on the display object.
+           * @event PIXI.InteractionManager#pointerdown
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is released over the display object.
+           * Not always fired when some buttons are held down while others are released. In those cases,
+           * use [mousedown]{@link PIXI.InteractionManager#event:mousedown} and
+           * [mouseup]{@link PIXI.InteractionManager#event:mouseup} instead.
+           * @event PIXI.InteractionManager#pointerup
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when the operating system cancels a pointer event
+           * @event PIXI.InteractionManager#pointercancel
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is pressed and released on the display object.
+           * @event PIXI.InteractionManager#pointertap
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is released outside the display object that initially
+           * registered a [pointerdown]{@link PIXI.InteractionManager#event:pointerdown}.
+           * @event PIXI.InteractionManager#pointerupoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device is moved while over the display object
+           * @event PIXI.InteractionManager#pointermove
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device is moved onto the display object
+           * @event PIXI.InteractionManager#pointerover
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device is moved off the display object
+           * @event PIXI.InteractionManager#pointerout
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is placed on the display object.
+           * @event PIXI.InteractionManager#touchstart
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is removed from the display object.
+           * @event PIXI.InteractionManager#touchend
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when the operating system cancels a touch
+           * @event PIXI.InteractionManager#touchcancel
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is placed and removed from the display object.
+           * @event PIXI.InteractionManager#tap
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is removed outside of the display object that initially
+           * registered a [touchstart]{@link PIXI.InteractionManager#event:touchstart}.
+           * @event PIXI.InteractionManager#touchendoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is moved along the display object.
+           * @event PIXI.InteractionManager#touchmove
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is pressed on the display.
+           * object. DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#mousedown
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
+           * on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#rightdown
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is released over the display
+           * object. DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#mouseup
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is released
+           * over the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#rightup
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is pressed and released on
+           * the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#click
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
+           * and released on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#rightclick
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button (usually a mouse left-button) is released outside the
+           * display object that initially registered a
+           * [mousedown]{@link PIXI.DisplayObject#event:mousedown}.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#mouseupoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device secondary button (usually a mouse right-button) is released
+           * outside the display object that initially registered a
+           * [rightdown]{@link PIXI.DisplayObject#event:rightdown}.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#rightupoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device (usually a mouse) is moved while over the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#mousemove
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device (usually a mouse) is moved onto the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#mouseover
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device (usually a mouse) is moved off the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#mouseout
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is pressed on the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointerdown
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is released over the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointerup
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when the operating system cancels a pointer event.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointercancel
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is pressed and released on the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointertap
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device button is released outside the display object that initially
+           * registered a [pointerdown]{@link PIXI.DisplayObject#event:pointerdown}.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointerupoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device is moved while over the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointermove
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device is moved onto the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointerover
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a pointer device is moved off the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#pointerout
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is placed on the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#touchstart
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is removed from the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#touchend
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when the operating system cancels a touch.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#touchcancel
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is placed and removed from the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#tap
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is removed outside of the display object that initially
+           * registered a [touchstart]{@link PIXI.DisplayObject#event:touchstart}.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#touchendoutside
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          /**
+           * Fired when a touch point is moved along the display object.
+           * DisplayObject's `interactive` property must be set to `true` to fire event.
+           *
+           * This comes from the @pixi/interaction package.
+           * @event PIXI.DisplayObject#touchmove
+           * @param {PIXI.InteractionEvent} event - Interaction event
+           */
+          _this._useSystemTicker = options.useSystemTicker !== undefined ? options.useSystemTicker : true;
+          _this.setTargetElement(_this.renderer.view, _this.renderer.resolution);
+          return _this;
+      }
+      Object.defineProperty(InteractionManager.prototype, "useSystemTicker", {
+          /**
+           * Should the InteractionManager automatically add {@link tickerUpdate} to {@link PIXI.Ticker.system}.
+           * @default true
+           */
+          get: function () {
+              return this._useSystemTicker;
+          },
+          set: function (useSystemTicker) {
+              this._useSystemTicker = useSystemTicker;
+              if (useSystemTicker) {
+                  this.addTickerListener();
+              }
+              else {
+                  this.removeTickerListener();
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(InteractionManager.prototype, "lastObjectRendered", {
+          /**
+           * Last rendered object or temp object.
+           * @readonly
+           * @protected
+           */
+          get: function () {
+              return this.renderer._lastObjectRendered || this._tempDisplayObject;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Hit tests a point against the display tree, returning the first interactive object that is hit.
+       * @param globalPoint - A point to hit test with, in global space.
+       * @param root - The root display object to start from. If omitted, defaults
+       * to the last rendered root of the associated renderer.
+       * @returns - The hit display object, if any.
+       */
+      InteractionManager.prototype.hitTest = function (globalPoint, root) {
+          // clear the target for our hit test
+          hitTestEvent.target = null;
+          // assign the global point
+          hitTestEvent.data.global = globalPoint;
+          // ensure safety of the root
+          if (!root) {
+              root = this.lastObjectRendered;
+          }
+          // run the hit test
+          this.processInteractive(hitTestEvent, root, null, true);
+          // return our found object - it'll be null if we didn't hit anything
+          return hitTestEvent.target;
+      };
+      /**
+       * Sets the DOM element which will receive mouse/touch events. This is useful for when you have
+       * other DOM elements on top of the renderers Canvas element. With this you'll be bale to delegate
+       * another DOM element to receive those events.
+       * @param element - the DOM element which will receive mouse and touch events.
+       * @param resolution - The resolution / device pixel ratio of the new element (relative to the canvas).
+       */
+      InteractionManager.prototype.setTargetElement = function (element, resolution) {
+          if (resolution === void 0) { resolution = 1; }
+          this.removeTickerListener();
+          this.removeEvents();
+          this.interactionDOMElement = element;
+          this.resolution = resolution;
+          this.addEvents();
+          this.addTickerListener();
+      };
+      /** Adds the ticker listener. */
+      InteractionManager.prototype.addTickerListener = function () {
+          if (this.tickerAdded || !this.interactionDOMElement || !this._useSystemTicker) {
+              return;
+          }
+          Ticker.system.add(this.tickerUpdate, this, exports.UPDATE_PRIORITY.INTERACTION);
+          this.tickerAdded = true;
+      };
+      /** Removes the ticker listener. */
+      InteractionManager.prototype.removeTickerListener = function () {
+          if (!this.tickerAdded) {
+              return;
+          }
+          Ticker.system.remove(this.tickerUpdate, this);
+          this.tickerAdded = false;
+      };
+      /** Registers all the DOM events. */
+      InteractionManager.prototype.addEvents = function () {
+          if (this.eventsAdded || !this.interactionDOMElement) {
+              return;
+          }
+          var style = this.interactionDOMElement.style;
+          if (globalThis.navigator.msPointerEnabled) {
+              style.msContentZooming = 'none';
+              style.msTouchAction = 'none';
+          }
+          else if (this.supportsPointerEvents) {
+              style.touchAction = 'none';
+          }
+          /*
+           * These events are added first, so that if pointer events are normalized, they are fired
+           * in the same order as non-normalized events. ie. pointer event 1st, mouse / touch 2nd
+           */
+          if (this.supportsPointerEvents) {
+              globalThis.document.addEventListener('pointermove', this.onPointerMove, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('pointerdown', this.onPointerDown, this._eventListenerOptions);
+              // pointerout is fired in addition to pointerup (for touch events) and pointercancel
+              // we already handle those, so for the purposes of what we do in onPointerOut, we only
+              // care about the pointerleave event
+              this.interactionDOMElement.addEventListener('pointerleave', this.onPointerOut, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('pointerover', this.onPointerOver, this._eventListenerOptions);
+              globalThis.addEventListener('pointercancel', this.onPointerCancel, this._eventListenerOptions);
+              globalThis.addEventListener('pointerup', this.onPointerUp, this._eventListenerOptions);
+          }
+          else {
+              globalThis.document.addEventListener('mousemove', this.onPointerMove, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('mousedown', this.onPointerDown, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('mouseout', this.onPointerOut, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('mouseover', this.onPointerOver, this._eventListenerOptions);
+              globalThis.addEventListener('mouseup', this.onPointerUp, this._eventListenerOptions);
+          }
+          // always look directly for touch events so that we can provide original data
+          // In a future version we should change this to being just a fallback and rely solely on
+          // PointerEvents whenever available
+          if (this.supportsTouchEvents) {
+              this.interactionDOMElement.addEventListener('touchstart', this.onPointerDown, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('touchcancel', this.onPointerCancel, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('touchend', this.onPointerUp, this._eventListenerOptions);
+              this.interactionDOMElement.addEventListener('touchmove', this.onPointerMove, this._eventListenerOptions);
+          }
+          this.eventsAdded = true;
+      };
+      /** Removes all the DOM events that were previously registered. */
+      InteractionManager.prototype.removeEvents = function () {
+          if (!this.eventsAdded || !this.interactionDOMElement) {
+              return;
+          }
+          var style = this.interactionDOMElement.style;
+          if (globalThis.navigator.msPointerEnabled) {
+              style.msContentZooming = '';
+              style.msTouchAction = '';
+          }
+          else if (this.supportsPointerEvents) {
+              style.touchAction = '';
+          }
+          if (this.supportsPointerEvents) {
+              globalThis.document.removeEventListener('pointermove', this.onPointerMove, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('pointerdown', this.onPointerDown, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('pointerleave', this.onPointerOut, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('pointerover', this.onPointerOver, this._eventListenerOptions);
+              globalThis.removeEventListener('pointercancel', this.onPointerCancel, this._eventListenerOptions);
+              globalThis.removeEventListener('pointerup', this.onPointerUp, this._eventListenerOptions);
+          }
+          else {
+              globalThis.document.removeEventListener('mousemove', this.onPointerMove, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('mousedown', this.onPointerDown, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('mouseout', this.onPointerOut, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('mouseover', this.onPointerOver, this._eventListenerOptions);
+              globalThis.removeEventListener('mouseup', this.onPointerUp, this._eventListenerOptions);
+          }
+          if (this.supportsTouchEvents) {
+              this.interactionDOMElement.removeEventListener('touchstart', this.onPointerDown, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('touchcancel', this.onPointerCancel, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('touchend', this.onPointerUp, this._eventListenerOptions);
+              this.interactionDOMElement.removeEventListener('touchmove', this.onPointerMove, this._eventListenerOptions);
+          }
+          this.interactionDOMElement = null;
+          this.eventsAdded = false;
+      };
+      /**
+       * Updates the state of interactive objects if at least {@link interactionFrequency}
+       * milliseconds have passed since the last invocation.
+       *
+       * Invoked by a throttled ticker update from {@link PIXI.Ticker.system}.
+       * @param deltaTime - time delta since the last call
+       */
+      InteractionManager.prototype.tickerUpdate = function (deltaTime) {
+          this._deltaTime += deltaTime;
+          if (this._deltaTime < this.interactionFrequency) {
+              return;
+          }
+          this._deltaTime = 0;
+          this.update();
+      };
+      /** Updates the state of interactive objects. */
+      InteractionManager.prototype.update = function () {
+          if (!this.interactionDOMElement) {
+              return;
+          }
+          // if the user move the mouse this check has already been done using the mouse move!
+          if (this._didMove) {
+              this._didMove = false;
+              return;
+          }
+          this.cursor = null;
+          // Resets the flag as set by a stopPropagation call. This flag is usually reset by a user interaction of any kind,
+          // but there was a scenario of a display object moving under a static mouse cursor.
+          // In this case, mouseover and mouseevents would not pass the flag test in dispatchEvent function
+          for (var k in this.activeInteractionData) {
+              // eslint-disable-next-line no-prototype-builtins
+              if (this.activeInteractionData.hasOwnProperty(k)) {
+                  var interactionData = this.activeInteractionData[k];
+                  if (interactionData.originalEvent && interactionData.pointerType !== 'touch') {
+                      var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, interactionData.originalEvent, interactionData);
+                      this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerOverOut, true);
+                  }
+              }
+          }
+          this.setCursorMode(this.cursor);
+      };
+      /**
+       * Sets the current cursor mode, handling any callbacks or CSS style changes.
+       * @param mode - cursor mode, a key from the cursorStyles dictionary
+       */
+      InteractionManager.prototype.setCursorMode = function (mode) {
+          mode = mode || 'default';
+          var applyStyles = true;
+          // offscreen canvas does not support setting styles, but cursor modes can be functions,
+          // in order to handle pixi rendered cursors, so we can't bail
+          if (globalThis.OffscreenCanvas && this.interactionDOMElement instanceof OffscreenCanvas) {
+              applyStyles = false;
+          }
+          // if the mode didn't actually change, bail early
+          if (this.currentCursorMode === mode) {
+              return;
+          }
+          this.currentCursorMode = mode;
+          var style = this.cursorStyles[mode];
+          // only do things if there is a cursor style for it
+          if (style) {
+              switch (typeof style) {
+                  case 'string':
+                      // string styles are handled as cursor CSS
+                      if (applyStyles) {
+                          this.interactionDOMElement.style.cursor = style;
+                      }
+                      break;
+                  case 'function':
+                      // functions are just called, and passed the cursor mode
+                      style(mode);
+                      break;
+                  case 'object':
+                      // if it is an object, assume that it is a dictionary of CSS styles,
+                      // apply it to the interactionDOMElement
+                      if (applyStyles) {
+                          Object.assign(this.interactionDOMElement.style, style);
+                      }
+                      break;
+              }
+          }
+          else if (applyStyles && typeof mode === 'string' && !Object.prototype.hasOwnProperty.call(this.cursorStyles, mode)) {
+              // if it mode is a string (not a Symbol) and cursorStyles doesn't have any entry
+              // for the mode, then assume that the dev wants it to be CSS for the cursor.
+              this.interactionDOMElement.style.cursor = mode;
+          }
+      };
+      /**
+       * Dispatches an event on the display object that was interacted with.
+       * @param displayObject - the display object in question
+       * @param eventString - the name of the event (e.g, mousedown)
+       * @param eventData - the event data object
+       */
+      InteractionManager.prototype.dispatchEvent = function (displayObject, eventString, eventData) {
+          // Even if the event was stopped, at least dispatch any remaining events
+          // for the same display object.
+          if (!eventData.stopPropagationHint || displayObject === eventData.stopsPropagatingAt) {
+              eventData.currentTarget = displayObject;
+              eventData.type = eventString;
+              displayObject.emit(eventString, eventData);
+              if (displayObject[eventString]) {
+                  displayObject[eventString](eventData);
+              }
+          }
+      };
+      /**
+       * Puts a event on a queue to be dispatched later. This is used to guarantee correct
+       * ordering of over/out events.
+       * @param displayObject - the display object in question
+       * @param eventString - the name of the event (e.g, mousedown)
+       * @param eventData - the event data object
+       */
+      InteractionManager.prototype.delayDispatchEvent = function (displayObject, eventString, eventData) {
+          this.delayedEvents.push({ displayObject: displayObject, eventString: eventString, eventData: eventData });
+      };
+      /**
+       * Maps x and y coords from a DOM object and maps them correctly to the PixiJS view. The
+       * resulting value is stored in the point. This takes into account the fact that the DOM
+       * element could be scaled and positioned anywhere on the screen.
+       * @param point - the point that the result will be stored in
+       * @param x - the x coord of the position to map
+       * @param y - the y coord of the position to map
+       */
+      InteractionManager.prototype.mapPositionToPoint = function (point, x, y) {
+          var rect;
+          // IE 11 fix
+          if (!this.interactionDOMElement.parentElement) {
+              rect = {
+                  x: 0,
+                  y: 0,
+                  width: this.interactionDOMElement.width,
+                  height: this.interactionDOMElement.height,
+                  left: 0,
+                  top: 0
+              };
+          }
+          else {
+              rect = this.interactionDOMElement.getBoundingClientRect();
+          }
+          var resolutionMultiplier = 1.0 / this.resolution;
+          point.x = ((x - rect.left) * (this.interactionDOMElement.width / rect.width)) * resolutionMultiplier;
+          point.y = ((y - rect.top) * (this.interactionDOMElement.height / rect.height)) * resolutionMultiplier;
+      };
+      /**
+       * This function is provides a neat way of crawling through the scene graph and running a
+       * specified function on all interactive objects it finds. It will also take care of hit
+       * testing the interactive objects and passes the hit across in the function.
+       * @protected
+       * @param interactionEvent - event containing the point that
+       *  is tested for collision
+       * @param displayObject - the displayObject
+       *  that will be hit test (recursively crawls its children)
+       * @param func - the function that will be called on each interactive object. The
+       *  interactionEvent, displayObject and hit will be passed to the function
+       * @param hitTest - indicates whether we want to calculate hits
+       *  or just iterate through all interactive objects
+       */
+      InteractionManager.prototype.processInteractive = function (interactionEvent, displayObject, func, hitTest) {
+          var hit = this.search.findHit(interactionEvent, displayObject, func, hitTest);
+          var delayedEvents = this.delayedEvents;
+          if (!delayedEvents.length) {
+              return hit;
+          }
+          // Reset the propagation hint, because we start deeper in the tree again.
+          interactionEvent.stopPropagationHint = false;
+          var delayedLen = delayedEvents.length;
+          this.delayedEvents = [];
+          for (var i = 0; i < delayedLen; i++) {
+              var _a = delayedEvents[i], displayObject_1 = _a.displayObject, eventString = _a.eventString, eventData = _a.eventData;
+              // When we reach the object we wanted to stop propagating at,
+              // set the propagation hint.
+              if (eventData.stopsPropagatingAt === displayObject_1) {
+                  eventData.stopPropagationHint = true;
+              }
+              this.dispatchEvent(displayObject_1, eventString, eventData);
+          }
+          return hit;
+      };
+      /**
+       * Is called when the pointer button is pressed down on the renderer element
+       * @param originalEvent - The DOM event of a pointer button being pressed down
+       */
+      InteractionManager.prototype.onPointerDown = function (originalEvent) {
+          // if we support touch events, then only use those for touch events, not pointer events
+          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
+              { return; }
+          var events = this.normalizeToPointerData(originalEvent);
+          /*
+           * No need to prevent default on natural pointer events, as there are no side effects
+           * Normalized events, however, may have the double mousedown/touchstart issue on the native android browser,
+           * so still need to be prevented.
+           */
+          // Guaranteed that there will be at least one event in events, and all events must have the same pointer type
+          if (this.autoPreventDefault && events[0].isNormalized) {
+              var cancelable = originalEvent.cancelable || !('cancelable' in originalEvent);
+              if (cancelable) {
+                  originalEvent.preventDefault();
+              }
+          }
+          var eventLen = events.length;
+          for (var i = 0; i < eventLen; i++) {
+              var event = events[i];
+              var interactionData = this.getInteractionDataForPointerId(event);
+              var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
+              interactionEvent.data.originalEvent = originalEvent;
+              this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerDown, true);
+              this.emit('pointerdown', interactionEvent);
+              if (event.pointerType === 'touch') {
+                  this.emit('touchstart', interactionEvent);
+              }
+              // emit a mouse event for "pen" pointers, the way a browser would emit a fallback event
+              else if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
+                  var isRightButton = event.button === 2;
+                  this.emit(isRightButton ? 'rightdown' : 'mousedown', this.eventData);
+              }
+          }
+      };
+      /**
+       * Processes the result of the pointer down check and dispatches the event if need be
+       * @param interactionEvent - The interaction event wrapping the DOM event
+       * @param displayObject - The display object that was tested
+       * @param hit - the result of the hit test on the display object
+       */
+      InteractionManager.prototype.processPointerDown = function (interactionEvent, displayObject, hit) {
+          var data = interactionEvent.data;
+          var id = interactionEvent.data.identifier;
+          if (hit) {
+              if (!displayObject.trackedPointers[id]) {
+                  displayObject.trackedPointers[id] = new InteractionTrackingData(id);
+              }
+              this.dispatchEvent(displayObject, 'pointerdown', interactionEvent);
+              if (data.pointerType === 'touch') {
+                  this.dispatchEvent(displayObject, 'touchstart', interactionEvent);
+              }
+              else if (data.pointerType === 'mouse' || data.pointerType === 'pen') {
+                  var isRightButton = data.button === 2;
+                  if (isRightButton) {
+                      displayObject.trackedPointers[id].rightDown = true;
+                  }
+                  else {
+                      displayObject.trackedPointers[id].leftDown = true;
+                  }
+                  this.dispatchEvent(displayObject, isRightButton ? 'rightdown' : 'mousedown', interactionEvent);
+              }
+          }
+      };
+      /**
+       * Is called when the pointer button is released on the renderer element
+       * @param originalEvent - The DOM event of a pointer button being released
+       * @param cancelled - true if the pointer is cancelled
+       * @param func - Function passed to {@link processInteractive}
+       */
+      InteractionManager.prototype.onPointerComplete = function (originalEvent, cancelled, func) {
+          var events = this.normalizeToPointerData(originalEvent);
+          var eventLen = events.length;
+          // if the event wasn't targeting our canvas, then consider it to be pointerupoutside
+          // in all cases (unless it was a pointercancel)
+          var target = originalEvent.target;
+          // if in shadow DOM use composedPath to access target
+          if (originalEvent.composedPath && originalEvent.composedPath().length > 0) {
+              target = originalEvent.composedPath()[0];
+          }
+          var eventAppend = target !== this.interactionDOMElement ? 'outside' : '';
+          for (var i = 0; i < eventLen; i++) {
+              var event = events[i];
+              var interactionData = this.getInteractionDataForPointerId(event);
+              var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
+              interactionEvent.data.originalEvent = originalEvent;
+              // perform hit testing for events targeting our canvas or cancel events
+              this.processInteractive(interactionEvent, this.lastObjectRendered, func, cancelled || !eventAppend);
+              this.emit(cancelled ? 'pointercancel' : "pointerup" + eventAppend, interactionEvent);
+              if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
+                  var isRightButton = event.button === 2;
+                  this.emit(isRightButton ? "rightup" + eventAppend : "mouseup" + eventAppend, interactionEvent);
+              }
+              else if (event.pointerType === 'touch') {
+                  this.emit(cancelled ? 'touchcancel' : "touchend" + eventAppend, interactionEvent);
+                  this.releaseInteractionDataForPointerId(event.pointerId);
+              }
+          }
+      };
+      /**
+       * Is called when the pointer button is cancelled
+       * @param event - The DOM event of a pointer button being released
+       */
+      InteractionManager.prototype.onPointerCancel = function (event) {
+          // if we support touch events, then only use those for touch events, not pointer events
+          if (this.supportsTouchEvents && event.pointerType === 'touch')
+              { return; }
+          this.onPointerComplete(event, true, this.processPointerCancel);
+      };
+      /**
+       * Processes the result of the pointer cancel check and dispatches the event if need be
+       * @param interactionEvent - The interaction event wrapping the DOM event
+       * @param displayObject - The display object that was tested
+       */
+      InteractionManager.prototype.processPointerCancel = function (interactionEvent, displayObject) {
+          var data = interactionEvent.data;
+          var id = interactionEvent.data.identifier;
+          if (displayObject.trackedPointers[id] !== undefined) {
+              delete displayObject.trackedPointers[id];
+              this.dispatchEvent(displayObject, 'pointercancel', interactionEvent);
+              if (data.pointerType === 'touch') {
+                  this.dispatchEvent(displayObject, 'touchcancel', interactionEvent);
+              }
+          }
+      };
+      /**
+       * Is called when the pointer button is released on the renderer element
+       * @param event - The DOM event of a pointer button being released
+       */
+      InteractionManager.prototype.onPointerUp = function (event) {
+          // if we support touch events, then only use those for touch events, not pointer events
+          if (this.supportsTouchEvents && event.pointerType === 'touch')
+              { return; }
+          this.onPointerComplete(event, false, this.processPointerUp);
+      };
+      /**
+       * Processes the result of the pointer up check and dispatches the event if need be
+       * @param interactionEvent - The interaction event wrapping the DOM event
+       * @param displayObject - The display object that was tested
+       * @param hit - the result of the hit test on the display object
+       */
+      InteractionManager.prototype.processPointerUp = function (interactionEvent, displayObject, hit) {
+          var data = interactionEvent.data;
+          var id = interactionEvent.data.identifier;
+          var trackingData = displayObject.trackedPointers[id];
+          var isTouch = data.pointerType === 'touch';
+          var isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');
+          // need to track mouse down status in the mouse block so that we can emit
+          // event in a later block
+          var isMouseTap = false;
+          // Mouse only
+          if (isMouse) {
+              var isRightButton = data.button === 2;
+              var flags = InteractionTrackingData.FLAGS;
+              var test = isRightButton ? flags.RIGHT_DOWN : flags.LEFT_DOWN;
+              var isDown = trackingData !== undefined && (trackingData.flags & test);
+              if (hit) {
+                  this.dispatchEvent(displayObject, isRightButton ? 'rightup' : 'mouseup', interactionEvent);
+                  if (isDown) {
+                      this.dispatchEvent(displayObject, isRightButton ? 'rightclick' : 'click', interactionEvent);
+                      // because we can confirm that the mousedown happened on this object, flag for later emit of pointertap
+                      isMouseTap = true;
+                  }
+              }
+              else if (isDown) {
+                  this.dispatchEvent(displayObject, isRightButton ? 'rightupoutside' : 'mouseupoutside', interactionEvent);
+              }
+              // update the down state of the tracking data
+              if (trackingData) {
+                  if (isRightButton) {
+                      trackingData.rightDown = false;
+                  }
+                  else {
+                      trackingData.leftDown = false;
+                  }
+              }
+          }
+          // Pointers and Touches, and Mouse
+          if (hit) {
+              this.dispatchEvent(displayObject, 'pointerup', interactionEvent);
+              if (isTouch)
+                  { this.dispatchEvent(displayObject, 'touchend', interactionEvent); }
+              if (trackingData) {
+                  // emit pointertap if not a mouse, or if the mouse block decided it was a tap
+                  if (!isMouse || isMouseTap) {
+                      this.dispatchEvent(displayObject, 'pointertap', interactionEvent);
+                  }
+                  if (isTouch) {
+                      this.dispatchEvent(displayObject, 'tap', interactionEvent);
+                      // touches are no longer over (if they ever were) when we get the touchend
+                      // so we should ensure that we don't keep pretending that they are
+                      trackingData.over = false;
+                  }
+              }
+          }
+          else if (trackingData) {
+              this.dispatchEvent(displayObject, 'pointerupoutside', interactionEvent);
+              if (isTouch)
+                  { this.dispatchEvent(displayObject, 'touchendoutside', interactionEvent); }
+          }
+          // Only remove the tracking data if there is no over/down state still associated with it
+          if (trackingData && trackingData.none) {
+              delete displayObject.trackedPointers[id];
+          }
+      };
+      /**
+       * Is called when the pointer moves across the renderer element
+       * @param originalEvent - The DOM event of a pointer moving
+       */
+      InteractionManager.prototype.onPointerMove = function (originalEvent) {
+          // if we support touch events, then only use those for touch events, not pointer events
+          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
+              { return; }
+          var events = this.normalizeToPointerData(originalEvent);
+          if (events[0].pointerType === 'mouse' || events[0].pointerType === 'pen') {
+              this._didMove = true;
+              this.cursor = null;
+          }
+          var eventLen = events.length;
+          for (var i = 0; i < eventLen; i++) {
+              var event = events[i];
+              var interactionData = this.getInteractionDataForPointerId(event);
+              var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
+              interactionEvent.data.originalEvent = originalEvent;
+              this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerMove, true);
+              this.emit('pointermove', interactionEvent);
+              if (event.pointerType === 'touch')
+                  { this.emit('touchmove', interactionEvent); }
+              if (event.pointerType === 'mouse' || event.pointerType === 'pen')
+                  { this.emit('mousemove', interactionEvent); }
+          }
+          if (events[0].pointerType === 'mouse') {
+              this.setCursorMode(this.cursor);
+              // TODO BUG for parents interactive object (border order issue)
+          }
+      };
+      /**
+       * Processes the result of the pointer move check and dispatches the event if need be
+       * @param interactionEvent - The interaction event wrapping the DOM event
+       * @param displayObject - The display object that was tested
+       * @param hit - the result of the hit test on the display object
+       */
+      InteractionManager.prototype.processPointerMove = function (interactionEvent, displayObject, hit) {
+          var data = interactionEvent.data;
+          var isTouch = data.pointerType === 'touch';
+          var isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');
+          if (isMouse) {
+              this.processPointerOverOut(interactionEvent, displayObject, hit);
+          }
+          if (!this.moveWhenInside || hit) {
+              this.dispatchEvent(displayObject, 'pointermove', interactionEvent);
+              if (isTouch)
+                  { this.dispatchEvent(displayObject, 'touchmove', interactionEvent); }
+              if (isMouse)
+                  { this.dispatchEvent(displayObject, 'mousemove', interactionEvent); }
+          }
+      };
+      /**
+       * Is called when the pointer is moved out of the renderer element
+       * @private
+       * @param {PointerEvent} originalEvent - The DOM event of a pointer being moved out
+       */
+      InteractionManager.prototype.onPointerOut = function (originalEvent) {
+          // if we support touch events, then only use those for touch events, not pointer events
+          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
+              { return; }
+          var events = this.normalizeToPointerData(originalEvent);
+          // Only mouse and pointer can call onPointerOut, so events will always be length 1
+          var event = events[0];
+          if (event.pointerType === 'mouse') {
+              this.mouseOverRenderer = false;
+              this.setCursorMode(null);
+          }
+          var interactionData = this.getInteractionDataForPointerId(event);
+          var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
+          interactionEvent.data.originalEvent = event;
+          this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerOverOut, false);
+          this.emit('pointerout', interactionEvent);
+          if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
+              this.emit('mouseout', interactionEvent);
+          }
+          else {
+              // we can get touchleave events after touchend, so we want to make sure we don't
+              // introduce memory leaks
+              this.releaseInteractionDataForPointerId(interactionData.identifier);
+          }
+      };
+      /**
+       * Processes the result of the pointer over/out check and dispatches the event if need be.
+       * @param interactionEvent - The interaction event wrapping the DOM event
+       * @param displayObject - The display object that was tested
+       * @param hit - the result of the hit test on the display object
+       */
+      InteractionManager.prototype.processPointerOverOut = function (interactionEvent, displayObject, hit) {
+          var data = interactionEvent.data;
+          var id = interactionEvent.data.identifier;
+          var isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');
+          var trackingData = displayObject.trackedPointers[id];
+          // if we just moused over the display object, then we need to track that state
+          if (hit && !trackingData) {
+              trackingData = displayObject.trackedPointers[id] = new InteractionTrackingData(id);
+          }
+          if (trackingData === undefined)
+              { return; }
+          if (hit && this.mouseOverRenderer) {
+              if (!trackingData.over) {
+                  trackingData.over = true;
+                  this.delayDispatchEvent(displayObject, 'pointerover', interactionEvent);
+                  if (isMouse) {
+                      this.delayDispatchEvent(displayObject, 'mouseover', interactionEvent);
+                  }
+              }
+              // only change the cursor if it has not already been changed (by something deeper in the
+              // display tree)
+              if (isMouse && this.cursor === null) {
+                  this.cursor = displayObject.cursor;
+              }
+          }
+          else if (trackingData.over) {
+              trackingData.over = false;
+              this.dispatchEvent(displayObject, 'pointerout', this.eventData);
+              if (isMouse) {
+                  this.dispatchEvent(displayObject, 'mouseout', interactionEvent);
+              }
+              // if there is no mouse down information for the pointer, then it is safe to delete
+              if (trackingData.none) {
+                  delete displayObject.trackedPointers[id];
+              }
+          }
+      };
+      /**
+       * Is called when the pointer is moved into the renderer element.
+       * @param originalEvent - The DOM event of a pointer button being moved into the renderer view.
+       */
+      InteractionManager.prototype.onPointerOver = function (originalEvent) {
+          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
+              { return; }
+          var events = this.normalizeToPointerData(originalEvent);
+          // Only mouse and pointer can call onPointerOver, so events will always be length 1
+          var event = events[0];
+          var interactionData = this.getInteractionDataForPointerId(event);
+          var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
+          interactionEvent.data.originalEvent = event;
+          if (event.pointerType === 'mouse') {
+              this.mouseOverRenderer = true;
+          }
+          this.emit('pointerover', interactionEvent);
+          if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
+              this.emit('mouseover', interactionEvent);
+          }
+      };
+      /**
+       * Get InteractionData for a given pointerId. Store that data as well.
+       * @param event - Normalized pointer event, output from normalizeToPointerData.
+       * @returns - Interaction data for the given pointer identifier.
+       */
+      InteractionManager.prototype.getInteractionDataForPointerId = function (event) {
+          var pointerId = event.pointerId;
+          var interactionData;
+          if (pointerId === MOUSE_POINTER_ID || event.pointerType === 'mouse') {
+              interactionData = this.mouse;
+          }
+          else if (this.activeInteractionData[pointerId]) {
+              interactionData = this.activeInteractionData[pointerId];
+          }
+          else {
+              interactionData = this.interactionDataPool.pop() || new InteractionData();
+              interactionData.identifier = pointerId;
+              this.activeInteractionData[pointerId] = interactionData;
+          }
+          // copy properties from the event, so that we can make sure that touch/pointer specific
+          // data is available
+          interactionData.copyEvent(event);
+          return interactionData;
+      };
+      /**
+       * Return unused InteractionData to the pool, for a given pointerId
+       * @param pointerId - Identifier from a pointer event
+       */
+      InteractionManager.prototype.releaseInteractionDataForPointerId = function (pointerId) {
+          var interactionData = this.activeInteractionData[pointerId];
+          if (interactionData) {
+              delete this.activeInteractionData[pointerId];
+              interactionData.reset();
+              this.interactionDataPool.push(interactionData);
+          }
+      };
+      /**
+       * Configure an InteractionEvent to wrap a DOM PointerEvent and InteractionData
+       * @param interactionEvent - The event to be configured
+       * @param pointerEvent - The DOM event that will be paired with the InteractionEvent
+       * @param interactionData - The InteractionData that will be paired
+       *        with the InteractionEvent
+       * @returns - the interaction event that was passed in
+       */
+      InteractionManager.prototype.configureInteractionEventForDOMEvent = function (interactionEvent, pointerEvent, interactionData) {
+          interactionEvent.data = interactionData;
+          this.mapPositionToPoint(interactionData.global, pointerEvent.clientX, pointerEvent.clientY);
+          // Not really sure why this is happening, but it's how a previous version handled things
+          if (pointerEvent.pointerType === 'touch') {
+              pointerEvent.globalX = interactionData.global.x;
+              pointerEvent.globalY = interactionData.global.y;
+          }
+          interactionData.originalEvent = pointerEvent;
+          interactionEvent.reset();
+          return interactionEvent;
+      };
+      /**
+       * Ensures that the original event object contains all data that a regular pointer event would have
+       * @param {TouchEvent|MouseEvent|PointerEvent} event - The original event data from a touch or mouse event
+       * @returns - An array containing a single normalized pointer event, in the case of a pointer
+       *  or mouse event, or a multiple normalized pointer events if there are multiple changed touches
+       */
+      InteractionManager.prototype.normalizeToPointerData = function (event) {
+          var normalizedEvents = [];
+          if (this.supportsTouchEvents && event instanceof TouchEvent) {
+              for (var i = 0, li = event.changedTouches.length; i < li; i++) {
+                  var touch = event.changedTouches[i];
+                  if (typeof touch.button === 'undefined')
+                      { touch.button = event.touches.length ? 1 : 0; }
+                  if (typeof touch.buttons === 'undefined')
+                      { touch.buttons = event.touches.length ? 1 : 0; }
+                  if (typeof touch.isPrimary === 'undefined') {
+                      touch.isPrimary = event.touches.length === 1 && event.type === 'touchstart';
+                  }
+                  if (typeof touch.width === 'undefined')
+                      { touch.width = touch.radiusX || 1; }
+                  if (typeof touch.height === 'undefined')
+                      { touch.height = touch.radiusY || 1; }
+                  if (typeof touch.tiltX === 'undefined')
+                      { touch.tiltX = 0; }
+                  if (typeof touch.tiltY === 'undefined')
+                      { touch.tiltY = 0; }
+                  if (typeof touch.pointerType === 'undefined')
+                      { touch.pointerType = 'touch'; }
+                  if (typeof touch.pointerId === 'undefined')
+                      { touch.pointerId = touch.identifier || 0; }
+                  if (typeof touch.pressure === 'undefined')
+                      { touch.pressure = touch.force || 0.5; }
+                  if (typeof touch.twist === 'undefined')
+                      { touch.twist = 0; }
+                  if (typeof touch.tangentialPressure === 'undefined')
+                      { touch.tangentialPressure = 0; }
+                  // TODO: Remove these, as layerX/Y is not a standard, is deprecated, has uneven
+                  // support, and the fill ins are not quite the same
+                  // offsetX/Y might be okay, but is not the same as clientX/Y when the canvas's top
+                  // left is not 0,0 on the page
+                  if (typeof touch.layerX === 'undefined')
+                      { touch.layerX = touch.offsetX = touch.clientX; }
+                  if (typeof touch.layerY === 'undefined')
+                      { touch.layerY = touch.offsetY = touch.clientY; }
+                  // mark the touch as normalized, just so that we know we did it
+                  touch.isNormalized = true;
+                  normalizedEvents.push(touch);
+              }
+          }
+          // apparently PointerEvent subclasses MouseEvent, so yay
+          else if (!globalThis.MouseEvent
+              || (event instanceof MouseEvent && (!this.supportsPointerEvents || !(event instanceof globalThis.PointerEvent)))) {
+              var tempEvent = event;
+              if (typeof tempEvent.isPrimary === 'undefined')
+                  { tempEvent.isPrimary = true; }
+              if (typeof tempEvent.width === 'undefined')
+                  { tempEvent.width = 1; }
+              if (typeof tempEvent.height === 'undefined')
+                  { tempEvent.height = 1; }
+              if (typeof tempEvent.tiltX === 'undefined')
+                  { tempEvent.tiltX = 0; }
+              if (typeof tempEvent.tiltY === 'undefined')
+                  { tempEvent.tiltY = 0; }
+              if (typeof tempEvent.pointerType === 'undefined')
+                  { tempEvent.pointerType = 'mouse'; }
+              if (typeof tempEvent.pointerId === 'undefined')
+                  { tempEvent.pointerId = MOUSE_POINTER_ID; }
+              if (typeof tempEvent.pressure === 'undefined')
+                  { tempEvent.pressure = 0.5; }
+              if (typeof tempEvent.twist === 'undefined')
+                  { tempEvent.twist = 0; }
+              if (typeof tempEvent.tangentialPressure === 'undefined')
+                  { tempEvent.tangentialPressure = 0; }
+              // mark the mouse event as normalized, just so that we know we did it
+              tempEvent.isNormalized = true;
+              normalizedEvents.push(tempEvent);
+          }
+          else {
+              normalizedEvents.push(event);
+          }
+          return normalizedEvents;
+      };
+      /** Destroys the interaction manager. */
+      InteractionManager.prototype.destroy = function () {
+          this.removeEvents();
+          this.removeTickerListener();
+          this.removeAllListeners();
+          this.renderer = null;
+          this.mouse = null;
+          this.eventData = null;
+          this.interactionDOMElement = null;
+          this.onPointerDown = null;
+          this.processPointerDown = null;
+          this.onPointerUp = null;
+          this.processPointerUp = null;
+          this.onPointerCancel = null;
+          this.processPointerCancel = null;
+          this.onPointerMove = null;
+          this.processPointerMove = null;
+          this.onPointerOut = null;
+          this.processPointerOverOut = null;
+          this.onPointerOver = null;
+          this.search = null;
+      };
+      /** @ignore */
+      InteractionManager.extension = {
+          name: 'interaction',
+          type: [
+              exports.ExtensionType.RendererPlugin,
+              exports.ExtensionType.CanvasRendererPlugin ],
+      };
+      return InteractionManager;
+  }(eventemitter3));
+
+  /*!
+   * @pixi/extract - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/extract is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-            if (!uploaded) {
-                this.queue.shift();
-            }
-        }
+  var TEMP_RECT = new Rectangle();
+  var BYTES_PER_PIXEL = 4;
+  /**
+   * This class provides renderer-specific plugins for exporting content from a renderer.
+   * For instance, these plugins can be used for saving an Image, Canvas element or for exporting the raw image data (pixels).
+   *
+   * Do not instantiate these plugins directly. It is available from the `renderer.plugins` property.
+   * See {@link PIXI.CanvasRenderer#plugins} or {@link PIXI.Renderer#plugins}.
+   * @example
+   * // Create a new app (will auto-add extract plugin to renderer)
+   * const app = new PIXI.Application();
+   *
+   * // Draw a red circle
+   * const graphics = new PIXI.Graphics()
+   *     .beginFill(0xFF0000)
+   *     .drawCircle(0, 0, 50);
+   *
+   * // Render the graphics as an HTMLImageElement
+   * const image = app.renderer.plugins.extract.image(graphics);
+   * document.body.appendChild(image);
+   * @memberof PIXI
+   */
+  var Extract = /** @class */ (function () {
+      /**
+       * @param renderer - A reference to the current renderer
+       */
+      function Extract(renderer) {
+          this.renderer = renderer;
+      }
+      /**
+       * Will return a HTML Image of the target
+       * @param target - A displayObject or renderTexture
+       *  to convert. If left empty will use the main renderer
+       * @param format - Image format, e.g. "image/jpeg" or "image/webp".
+       * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.
+       * @returns - HTML Image of the target
+       */
+      Extract.prototype.image = function (target, format, quality) {
+          var image = new Image();
+          image.src = this.base64(target, format, quality);
+          return image;
+      };
+      /**
+       * Will return a base64 encoded string of this target. It works by calling
+       *  `Extract.getCanvas` and then running toDataURL on that.
+       * @param target - A displayObject or renderTexture
+       *  to convert. If left empty will use the main renderer
+       * @param format - Image format, e.g. "image/jpeg" or "image/webp".
+       * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.
+       * @returns - A base64 encoded string of the texture.
+       */
+      Extract.prototype.base64 = function (target, format, quality) {
+          return this.canvas(target).toDataURL(format, quality);
+      };
+      /**
+       * Creates a Canvas element, renders this target to it and then returns it.
+       * @param target - A displayObject or renderTexture
+       *  to convert. If left empty will use the main renderer
+       * @param frame - The frame the extraction is restricted to.
+       * @returns - A Canvas element with the texture rendered on.
+       */
+      Extract.prototype.canvas = function (target, frame) {
+          var _a = this._rawPixels(target, frame), pixels = _a.pixels, width = _a.width, height = _a.height, flipY = _a.flipY;
+          var canvasBuffer = new CanvasRenderTarget(width, height, 1);
+          // Add the pixels to the canvas
+          var canvasData = canvasBuffer.context.getImageData(0, 0, width, height);
+          Extract.arrayPostDivide(pixels, canvasData.data);
+          canvasBuffer.context.putImageData(canvasData, 0, 0);
+          // Flipping pixels
+          if (flipY) {
+              var target_1 = new CanvasRenderTarget(canvasBuffer.width, canvasBuffer.height, 1);
+              target_1.context.scale(1, -1);
+              // We can't render to itself because we should be empty before render.
+              target_1.context.drawImage(canvasBuffer.canvas, 0, -height);
+              canvasBuffer.destroy();
+              canvasBuffer = target_1;
+          }
+          // Send the canvas back
+          return canvasBuffer.canvas;
+      };
+      /**
+       * Will return a one-dimensional array containing the pixel data of the entire texture in RGBA
+       * order, with integer values between 0 and 255 (included).
+       * @param target - A displayObject or renderTexture
+       *  to convert. If left empty will use the main renderer
+       * @param frame - The frame the extraction is restricted to.
+       * @returns - One-dimensional array containing the pixel data of the entire texture
+       */
+      Extract.prototype.pixels = function (target, frame) {
+          var pixels = this._rawPixels(target, frame).pixels;
+          Extract.arrayPostDivide(pixels, pixels);
+          return pixels;
+      };
+      Extract.prototype._rawPixels = function (target, frame) {
+          var renderer = this.renderer;
+          var resolution;
+          var flipY = false;
+          var renderTexture;
+          var generated = false;
+          if (target) {
+              if (target instanceof RenderTexture) {
+                  renderTexture = target;
+              }
+              else {
+                  var multisample = renderer.context.webGLVersion >= 2 ? renderer.multisample : exports.MSAA_QUALITY.NONE;
+                  renderTexture = this.renderer.generateTexture(target, { multisample: multisample });
+                  if (multisample !== exports.MSAA_QUALITY.NONE) {
+                      // Resolve the multisampled texture to a non-multisampled texture
+                      var resolvedTexture = RenderTexture.create({
+                          width: renderTexture.width,
+                          height: renderTexture.height,
+                      });
+                      renderer.framebuffer.bind(renderTexture.framebuffer);
+                      renderer.framebuffer.blit(resolvedTexture.framebuffer);
+                      renderer.framebuffer.bind(null);
+                      renderTexture.destroy(true);
+                      renderTexture = resolvedTexture;
+                  }
+                  generated = true;
+              }
+          }
+          if (renderTexture) {
+              resolution = renderTexture.baseTexture.resolution;
+              frame = frame !== null && frame !== void 0 ? frame : renderTexture.frame;
+              flipY = false;
+              renderer.renderTexture.bind(renderTexture);
+          }
+          else {
+              resolution = renderer.resolution;
+              if (!frame) {
+                  frame = TEMP_RECT;
+                  frame.width = renderer.width;
+                  frame.height = renderer.height;
+              }
+              flipY = true;
+              renderer.renderTexture.bind(null);
+          }
+          var width = Math.round(frame.width * resolution);
+          var height = Math.round(frame.height * resolution);
+          var pixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
+          // Read pixels to the array
+          var gl = renderer.gl;
+          gl.readPixels(Math.round(frame.x * resolution), Math.round(frame.y * resolution), width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+          if (generated) {
+              renderTexture.destroy(true);
+          }
+          return { pixels: pixels, width: width, height: height, flipY: flipY };
+      };
+      /** Destroys the extract. */
+      Extract.prototype.destroy = function () {
+          this.renderer = null;
+      };
+      /**
+       * Takes premultiplied pixel data and produces regular pixel data
+       * @private
+       * @param pixels - array of pixel data
+       * @param out - output array
+       */
+      Extract.arrayPostDivide = function (pixels, out) {
+          for (var i = 0; i < pixels.length; i += 4) {
+              var alpha = out[i + 3] = pixels[i + 3];
+              if (alpha !== 0) {
+                  out[i] = Math.round(Math.min(pixels[i] * 255.0 / alpha, 255.0));
+                  out[i + 1] = Math.round(Math.min(pixels[i + 1] * 255.0 / alpha, 255.0));
+                  out[i + 2] = Math.round(Math.min(pixels[i + 2] * 255.0 / alpha, 255.0));
+              }
+              else {
+                  out[i] = pixels[i];
+                  out[i + 1] = pixels[i + 1];
+                  out[i + 2] = pixels[i + 2];
+              }
+          }
+      };
+      /** @ignore */
+      Extract.extension = {
+          name: 'extract',
+          type: exports.ExtensionType.RendererPlugin,
+      };
+      return Extract;
+  }());
+
+  /*!
+   * @pixi/loaders - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/loaders is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-        // We're finished
-        if (!this.queue.length) {
-            this.ticking = false;
+  /* jshint -W097 */
+  /**
+   * @memberof PIXI
+   */
+  var SignalBinding = /** @class */ (function () {
+      /**
+       * SignalBinding constructor.
+       * @constructs SignalBinding
+       * @param {Function} fn - Event handler to be called.
+       * @param {boolean} [once=false] - Should this listener be removed after dispatch
+       * @param {object} [thisArg] - The context of the callback function.
+       * @api private
+       */
+      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+      function SignalBinding(fn, once, thisArg) {
+          if (once === void 0) { once = false; }
+          this._fn = fn;
+          this._once = once;
+          this._thisArg = thisArg;
+          this._next = this._prev = this._owner = null;
+      }
+      SignalBinding.prototype.detach = function () {
+          if (this._owner === null)
+              { return false; }
+          this._owner.detach(this);
+          return true;
+      };
+      return SignalBinding;
+  }());
+  /**
+   * @param self
+   * @param node
+   * @private
+   */
+  function _addSignalBinding(self, node) {
+      if (!self._head) {
+          self._head = node;
+          self._tail = node;
+      }
+      else {
+          self._tail._next = node;
+          node._prev = self._tail;
+          self._tail = node;
+      }
+      node._owner = self;
+      return node;
+  }
+  /**
+   * @memberof PIXI
+   */
+  var Signal = /** @class */ (function () {
+      /**
+       * MiniSignal constructor.
+       * @example
+       * let mySignal = new Signal();
+       * let binding = mySignal.add(onSignal);
+       * mySignal.dispatch('foo', 'bar');
+       * mySignal.detach(binding);
+       */
+      function Signal() {
+          this._head = this._tail = undefined;
+      }
+      /**
+       * Return an array of attached SignalBinding.
+       * @param {boolean} [exists=false] - We only need to know if there are handlers.
+       * @returns {PIXI.SignalBinding[] | boolean} Array of attached SignalBinding or Boolean if called with exists = true
+       * @api public
+       */
+      Signal.prototype.handlers = function (exists) {
+          if (exists === void 0) { exists = false; }
+          var node = this._head;
+          if (exists)
+              { return !!node; }
+          var ee = [];
+          while (node) {
+              ee.push(node);
+              node = node._next;
+          }
+          return ee;
+      };
+      /**
+       * Return true if node is a SignalBinding attached to this MiniSignal
+       * @param {PIXI.SignalBinding} node - Node to check.
+       * @returns {boolean} True if node is attache to mini-signal
+       */
+      Signal.prototype.has = function (node) {
+          if (!(node instanceof SignalBinding)) {
+              throw new Error('MiniSignal#has(): First arg must be a SignalBinding object.');
+          }
+          return node._owner === this;
+      };
+      /**
+       * Dispaches a signal to all registered listeners.
+       * @param {...any} args
+       * @returns {boolean} Indication if we've emitted an event.
+       */
+      Signal.prototype.dispatch = function () {
+          var arguments$1 = arguments;
 
-            var completes = this.completes.slice(0);
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments$1[_i];
+          }
+          var node = this._head;
+          if (!node)
+              { return false; }
+          while (node) {
+              if (node._once)
+                  { this.detach(node); }
+              node._fn.apply(node._thisArg, args);
+              node = node._next;
+          }
+          return true;
+      };
+      /**
+       * Register a new listener.
+       * @param {Function} fn - Callback function.
+       * @param {object} [thisArg] - The context of the callback function.
+       * @returns {PIXI.SignalBinding} The SignalBinding node that was added.
+       */
+      Signal.prototype.add = function (fn, thisArg) {
+          if (thisArg === void 0) { thisArg = null; }
+          if (typeof fn !== 'function') {
+              throw new Error('MiniSignal#add(): First arg must be a Function.');
+          }
+          return _addSignalBinding(this, new SignalBinding(fn, false, thisArg));
+      };
+      /**
+       * Register a new listener that will be executed only once.
+       * @param {Function} fn - Callback function.
+       * @param {object} [thisArg] - The context of the callback function.
+       * @returns {PIXI.SignalBinding} The SignalBinding node that was added.
+       */
+      Signal.prototype.once = function (fn, thisArg) {
+          if (thisArg === void 0) { thisArg = null; }
+          if (typeof fn !== 'function') {
+              throw new Error('MiniSignal#once(): First arg must be a Function.');
+          }
+          return _addSignalBinding(this, new SignalBinding(fn, true, thisArg));
+      };
+      /**
+       * Remove binding object.
+       * @param {PIXI.SignalBinding} node - The binding node that will be removed.
+       * @returns {Signal} The instance on which this method was called.
+        @api public */
+      Signal.prototype.detach = function (node) {
+          if (!(node instanceof SignalBinding)) {
+              throw new Error('MiniSignal#detach(): First arg must be a SignalBinding object.');
+          }
+          if (node._owner !== this)
+              { return this; } // todo: or error?
+          if (node._prev)
+              { node._prev._next = node._next; }
+          if (node._next)
+              { node._next._prev = node._prev; }
+          if (node === this._head) { // first node
+              this._head = node._next;
+              if (node._next === null) {
+                  this._tail = null;
+              }
+          }
+          else if (node === this._tail) { // last node
+              this._tail = node._prev;
+              this._tail._next = null;
+          }
+          node._owner = null;
+          return this;
+      };
+      /**
+       * Detach all listeners.
+       * @returns {Signal} The instance on which this method was called.
+       */
+      Signal.prototype.detachAll = function () {
+          var node = this._head;
+          if (!node)
+              { return this; }
+          this._head = this._tail = null;
+          while (node) {
+              node._owner = null;
+              node = node._next;
+          }
+          return this;
+      };
+      return Signal;
+  }());
 
-            this.completes.length = 0;
+  /**
+   * function from npm package `parseUri`, converted to TS to avoid leftpad incident
+   * @param {string} str
+   * @param [opts] - options
+   * @param {boolean} [opts.strictMode] - type of parser
+   */
+  function parseUri(str, opts) {
+      opts = opts || {};
+      var o = {
+          // eslint-disable-next-line max-len
+          key: ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'],
+          q: {
+              name: 'queryKey',
+              parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+          },
+          parser: {
+              // eslint-disable-next-line max-len
+              strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+              // eslint-disable-next-line max-len
+              loose: /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+          }
+      };
+      var m = o.parser[opts.strictMode ? 'strict' : 'loose'].exec(str);
+      var uri = {};
+      var i = 14;
+      while (i--)
+          { uri[o.key[i]] = m[i] || ''; }
+      uri[o.q.name] = {};
+      uri[o.key[12]].replace(o.q.parser, function (_t0, t1, t2) {
+          if (t1)
+              { uri[o.q.name][t1] = t2; }
+      });
+      return uri;
+  }
 
-            for (var _i = 0, _len = completes.length; _i < _len; _i++) {
-                completes[_i]();
-            }
-        } else {
-            // if we are not finished, on the next rAF do this again
-            SharedTicker.addOnce(this.tick, this, core.UPDATE_PRIORITY.UTILITY);
-        }
-    };
+  // tests if CORS is supported in XHR, if not we need to use XDR
+  var useXdr;
+  var tempAnchor = null;
+  // some status constants
+  var STATUS_NONE = 0;
+  var STATUS_OK = 200;
+  var STATUS_EMPTY = 204;
+  var STATUS_IE_BUG_EMPTY = 1223;
+  var STATUS_TYPE_OK = 2;
+  // noop
+  function _noop$1() { }
+  /**
+   * Quick helper to set a value on one of the extension maps. Ensures there is no
+   * dot at the start of the extension.
+   * @ignore
+   * @param map - The map to set on.
+   * @param extname - The extension (or key) to set.
+   * @param val - The value to set.
+   */
+  function setExtMap(map, extname, val) {
+      if (extname && extname.indexOf('.') === 0) {
+          extname = extname.substring(1);
+      }
+      if (!extname) {
+          return;
+      }
+      map[extname] = val;
+  }
+  /**
+   * Quick helper to get string xhr type.
+   * @ignore
+   * @param xhr - The request to check.
+   * @returns The type.
+   */
+  function reqType(xhr) {
+      return xhr.toString().replace('object ', '');
+  }
+  /**
+   * Manages the state and loading of a resource and all child resources.
+   *
+   * Can be extended in `GlobalMixins.LoaderResource`.
+   * @memberof PIXI
+   */
+  exports.LoaderResource = /** @class */ (function () {
+      /**
+       * @param {string} name - The name of the resource to load.
+       * @param {string|string[]} url - The url for this resource, for audio/video loads you can pass
+       *      an array of sources.
+       * @param {object} [options] - The options for the load.
+       * @param {string|boolean} [options.crossOrigin] - Is this request cross-origin? Default is to
+       *      determine automatically.
+       * @param {number} [options.timeout=0] - A timeout in milliseconds for the load. If the load takes
+       *      longer than this time it is cancelled and the load is considered a failure. If this value is
+       *      set to `0` then there is no explicit timeout.
+       * @param {PIXI.LoaderResource.LOAD_TYPE} [options.loadType=LOAD_TYPE.XHR] - How should this resource
+       *      be loaded?
+       * @param {PIXI.LoaderResource.XHR_RESPONSE_TYPE} [options.xhrType=XHR_RESPONSE_TYPE.DEFAULT] - How
+       *      should the data being loaded be interpreted when using XHR?
+       * @param {PIXI.LoaderResource.IMetadata} [options.metadata] - Extra configuration for middleware
+       *      and the Resource object.
+       */
+      function LoaderResource(name, url, options) {
+          /**
+           * The `dequeue` method that will be used a storage place for the async queue dequeue method
+           * used privately by the loader.
+           * @private
+           * @member {Function}
+           */
+          this._dequeue = _noop$1;
+          /**
+           * Used a storage place for the on load binding used privately by the loader.
+           * @private
+           * @member {Function}
+           */
+          this._onLoadBinding = null;
+          /**
+           * The timer for element loads to check if they timeout.
+           * @private
+           */
+          this._elementTimer = 0;
+          /**
+           * The `complete` function bound to this resource's context.
+           * @private
+           * @type {Function}
+           */
+          this._boundComplete = null;
+          /**
+           * The `_onError` function bound to this resource's context.
+           * @private
+           * @type {Function}
+           */
+          this._boundOnError = null;
+          /**
+           * The `_onProgress` function bound to this resource's context.
+           * @private
+           * @type {Function}
+           */
+          this._boundOnProgress = null;
+          /**
+           * The `_onTimeout` function bound to this resource's context.
+           * @private
+           * @type {Function}
+           */
+          this._boundOnTimeout = null;
+          this._boundXhrOnError = null;
+          this._boundXhrOnTimeout = null;
+          this._boundXhrOnAbort = null;
+          this._boundXhrOnLoad = null;
+          if (typeof name !== 'string' || typeof url !== 'string') {
+              throw new Error('Both name and url are required for constructing a resource.');
+          }
+          options = options || {};
+          this._flags = 0;
+          // set data url flag, needs to be set early for some _determineX checks to work.
+          this._setFlag(LoaderResource.STATUS_FLAGS.DATA_URL, url.indexOf('data:') === 0);
+          this.name = name;
+          this.url = url;
+          this.extension = this._getExtension();
+          this.data = null;
+          this.crossOrigin = options.crossOrigin === true ? 'anonymous' : options.crossOrigin;
+          this.timeout = options.timeout || 0;
+          this.loadType = options.loadType || this._determineLoadType();
+          // The type used to load the resource via XHR. If unset, determined automatically.
+          this.xhrType = options.xhrType;
+          // Extra info for middleware, and controlling specifics about how the resource loads.
+          // Note that if you pass in a `loadElement`, the Resource class takes ownership of it.
+          // Meaning it will modify it as it sees fit.
+          this.metadata = options.metadata || {};
+          // The error that occurred while loading (if any).
+          this.error = null;
+          // The XHR object that was used to load this resource. This is only set
+          // when `loadType` is `LoaderResource.LOAD_TYPE.XHR`.
+          this.xhr = null;
+          // The child resources this resource owns.
+          this.children = [];
+          // The resource type.
+          this.type = LoaderResource.TYPE.UNKNOWN;
+          // The progress chunk owned by this resource.
+          this.progressChunk = 0;
+          // The `dequeue` method that will be used a storage place for the async queue dequeue method
+          // used privately by the loader.
+          this._dequeue = _noop$1;
+          // Used a storage place for the on load binding used privately by the loader.
+          this._onLoadBinding = null;
+          // The timer for element loads to check if they timeout.
+          this._elementTimer = 0;
+          this._boundComplete = this.complete.bind(this);
+          this._boundOnError = this._onError.bind(this);
+          this._boundOnProgress = this._onProgress.bind(this);
+          this._boundOnTimeout = this._onTimeout.bind(this);
+          // xhr callbacks
+          this._boundXhrOnError = this._xhrOnError.bind(this);
+          this._boundXhrOnTimeout = this._xhrOnTimeout.bind(this);
+          this._boundXhrOnAbort = this._xhrOnAbort.bind(this);
+          this._boundXhrOnLoad = this._xhrOnLoad.bind(this);
+          // Dispatched when the resource beings to load.
+          this.onStart = new Signal();
+          // Dispatched each time progress of this resource load updates.
+          // Not all resources types and loader systems can support this event
+          // so sometimes it may not be available. If the resource
+          // is being loaded on a modern browser, using XHR, and the remote server
+          // properly sets Content-Length headers, then this will be available.
+          this.onProgress = new Signal();
+          // Dispatched once this resource has loaded, if there was an error it will
+          // be in the `error` property.
+          this.onComplete = new Signal();
+          // Dispatched after this resource has had all the *after* middleware run on it.
+          this.onAfterMiddleware = new Signal();
+      }
+      /**
+       * Sets the load type to be used for a specific extension.
+       * @static
+       * @param {string} extname - The extension to set the type for, e.g. "png" or "fnt"
+       * @param {PIXI.LoaderResource.LOAD_TYPE} loadType - The load type to set it to.
+       */
+      LoaderResource.setExtensionLoadType = function (extname, loadType) {
+          setExtMap(LoaderResource._loadTypeMap, extname, loadType);
+      };
+      /**
+       * Sets the load type to be used for a specific extension.
+       * @static
+       * @param {string} extname - The extension to set the type for, e.g. "png" or "fnt"
+       * @param {PIXI.LoaderResource.XHR_RESPONSE_TYPE} xhrType - The xhr type to set it to.
+       */
+      LoaderResource.setExtensionXhrType = function (extname, xhrType) {
+          setExtMap(LoaderResource._xhrTypeMap, extname, xhrType);
+      };
+      Object.defineProperty(LoaderResource.prototype, "isDataUrl", {
+          /**
+           * When the resource starts to load.
+           * @memberof PIXI.LoaderResource
+           * @callback OnStartSignal
+           * @param {PIXI.Resource} resource - The resource that the event happened on.
+           */
+          /**
+           * When the resource reports loading progress.
+           * @memberof PIXI.LoaderResource
+           * @callback OnProgressSignal
+           * @param {PIXI.Resource} resource - The resource that the event happened on.
+           * @param {number} percentage - The progress of the load in the range [0, 1].
+           */
+          /**
+           * When the resource finishes loading.
+           * @memberof PIXI.LoaderResource
+           * @callback OnCompleteSignal
+           * @param {PIXI.Resource} resource - The resource that the event happened on.
+           */
+          /**
+           * @memberof PIXI.LoaderResource
+           * @typedef {object} IMetadata
+           * @property {HTMLImageElement|HTMLAudioElement|HTMLVideoElement} [loadElement=null] - The
+           *      element to use for loading, instead of creating one.
+           * @property {boolean} [skipSource=false] - Skips adding source(s) to the load element. This
+           *      is useful if you want to pass in a `loadElement` that you already added load sources to.
+           * @property {string|string[]} [mimeType] - The mime type to use for the source element
+           *      of a video/audio elment. If the urls are an array, you can pass this as an array as well
+           *      where each index is the mime type to use for the corresponding url index.
+           */
+          /**
+           * Stores whether or not this url is a data url.
+           * @readonly
+           * @member {boolean}
+           */
+          get: function () {
+              return this._hasFlag(LoaderResource.STATUS_FLAGS.DATA_URL);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(LoaderResource.prototype, "isComplete", {
+          /**
+           * Describes if this resource has finished loading. Is true when the resource has completely
+           * loaded.
+           * @readonly
+           * @member {boolean}
+           */
+          get: function () {
+              return this._hasFlag(LoaderResource.STATUS_FLAGS.COMPLETE);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(LoaderResource.prototype, "isLoading", {
+          /**
+           * Describes if this resource is currently loading. Is true when the resource starts loading,
+           * and is false again when complete.
+           * @readonly
+           * @member {boolean}
+           */
+          get: function () {
+              return this._hasFlag(LoaderResource.STATUS_FLAGS.LOADING);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Marks the resource as complete. */
+      LoaderResource.prototype.complete = function () {
+          this._clearEvents();
+          this._finish();
+      };
+      /**
+       * Aborts the loading of this resource, with an optional message.
+       * @param {string} message - The message to use for the error
+       */
+      LoaderResource.prototype.abort = function (message) {
+          // abort can be called multiple times, ignore subsequent calls.
+          if (this.error) {
+              return;
+          }
+          // store error
+          this.error = new Error(message);
+          // clear events before calling aborts
+          this._clearEvents();
+          // abort the actual loading
+          if (this.xhr) {
+              this.xhr.abort();
+          }
+          else if (this.xdr) {
+              this.xdr.abort();
+          }
+          else if (this.data) {
+              // single source
+              if (this.data.src) {
+                  this.data.src = LoaderResource.EMPTY_GIF;
+              }
+              // multi-source
+              else {
+                  while (this.data.firstChild) {
+                      this.data.removeChild(this.data.firstChild);
+                  }
+              }
+          }
+          // done now.
+          this._finish();
+      };
+      /**
+       * Kicks off loading of this resource. This method is asynchronous.
+       * @param {PIXI.LoaderResource.OnCompleteSignal} [cb] - Optional callback to call once the resource is loaded.
+       */
+      LoaderResource.prototype.load = function (cb) {
+          var _this = this;
+          if (this.isLoading) {
+              return;
+          }
+          if (this.isComplete) {
+              if (cb) {
+                  setTimeout(function () { return cb(_this); }, 1);
+              }
+              return;
+          }
+          else if (cb) {
+              this.onComplete.once(cb);
+          }
+          this._setFlag(LoaderResource.STATUS_FLAGS.LOADING, true);
+          this.onStart.dispatch(this);
+          // if unset, determine the value
+          if (this.crossOrigin === false || typeof this.crossOrigin !== 'string') {
+              this.crossOrigin = this._determineCrossOrigin(this.url);
+          }
+          switch (this.loadType) {
+              case LoaderResource.LOAD_TYPE.IMAGE:
+                  this.type = LoaderResource.TYPE.IMAGE;
+                  this._loadElement('image');
+                  break;
+              case LoaderResource.LOAD_TYPE.AUDIO:
+                  this.type = LoaderResource.TYPE.AUDIO;
+                  this._loadSourceElement('audio');
+                  break;
+              case LoaderResource.LOAD_TYPE.VIDEO:
+                  this.type = LoaderResource.TYPE.VIDEO;
+                  this._loadSourceElement('video');
+                  break;
+              case LoaderResource.LOAD_TYPE.XHR:
+              /* falls through */
+              default:
+                  if (typeof useXdr === 'undefined') {
+                      useXdr = !!(globalThis.XDomainRequest && !('withCredentials' in (new XMLHttpRequest())));
+                  }
+                  if (useXdr && this.crossOrigin) {
+                      this._loadXdr();
+                  }
+                  else {
+                      this._loadXhr();
+                  }
+                  break;
+          }
+      };
+      /**
+       * Checks if the flag is set.
+       * @param flag - The flag to check.
+       * @returns True if the flag is set.
+       */
+      LoaderResource.prototype._hasFlag = function (flag) {
+          return (this._flags & flag) !== 0;
+      };
+      /**
+       * (Un)Sets the flag.
+       * @param flag - The flag to (un)set.
+       * @param value - Whether to set or (un)set the flag.
+       */
+      LoaderResource.prototype._setFlag = function (flag, value) {
+          this._flags = value ? (this._flags | flag) : (this._flags & ~flag);
+      };
+      /** Clears all the events from the underlying loading source. */
+      LoaderResource.prototype._clearEvents = function () {
+          clearTimeout(this._elementTimer);
+          if (this.data && this.data.removeEventListener) {
+              this.data.removeEventListener('error', this._boundOnError, false);
+              this.data.removeEventListener('load', this._boundComplete, false);
+              this.data.removeEventListener('progress', this._boundOnProgress, false);
+              this.data.removeEventListener('canplaythrough', this._boundComplete, false);
+          }
+          if (this.xhr) {
+              if (this.xhr.removeEventListener) {
+                  this.xhr.removeEventListener('error', this._boundXhrOnError, false);
+                  this.xhr.removeEventListener('timeout', this._boundXhrOnTimeout, false);
+                  this.xhr.removeEventListener('abort', this._boundXhrOnAbort, false);
+                  this.xhr.removeEventListener('progress', this._boundOnProgress, false);
+                  this.xhr.removeEventListener('load', this._boundXhrOnLoad, false);
+              }
+              else {
+                  this.xhr.onerror = null;
+                  this.xhr.ontimeout = null;
+                  this.xhr.onprogress = null;
+                  this.xhr.onload = null;
+              }
+          }
+      };
+      /** Finalizes the load. */
+      LoaderResource.prototype._finish = function () {
+          if (this.isComplete) {
+              throw new Error('Complete called again for an already completed resource.');
+          }
+          this._setFlag(LoaderResource.STATUS_FLAGS.COMPLETE, true);
+          this._setFlag(LoaderResource.STATUS_FLAGS.LOADING, false);
+          this.onComplete.dispatch(this);
+      };
+      /**
+       * Loads this resources using an element that has a single source,
+       * like an HTMLImageElement.
+       * @private
+       * @param type - The type of element to use.
+       */
+      LoaderResource.prototype._loadElement = function (type) {
+          if (this.metadata.loadElement) {
+              this.data = this.metadata.loadElement;
+          }
+          else if (type === 'image' && typeof globalThis.Image !== 'undefined') {
+              this.data = new Image();
+          }
+          else {
+              this.data = document.createElement(type);
+          }
+          if (this.crossOrigin) {
+              this.data.crossOrigin = this.crossOrigin;
+          }
+          if (!this.metadata.skipSource) {
+              this.data.src = this.url;
+          }
+          this.data.addEventListener('error', this._boundOnError, false);
+          this.data.addEventListener('load', this._boundComplete, false);
+          this.data.addEventListener('progress', this._boundOnProgress, false);
+          if (this.timeout) {
+              this._elementTimer = setTimeout(this._boundOnTimeout, this.timeout);
+          }
+      };
+      /**
+       * Loads this resources using an element that has multiple sources,
+       * like an HTMLAudioElement or HTMLVideoElement.
+       * @param type - The type of element to use.
+       */
+      LoaderResource.prototype._loadSourceElement = function (type) {
+          if (this.metadata.loadElement) {
+              this.data = this.metadata.loadElement;
+          }
+          else if (type === 'audio' && typeof globalThis.Audio !== 'undefined') {
+              this.data = new Audio();
+          }
+          else {
+              this.data = document.createElement(type);
+          }
+          if (this.data === null) {
+              this.abort("Unsupported element: " + type);
+              return;
+          }
+          if (this.crossOrigin) {
+              this.data.crossOrigin = this.crossOrigin;
+          }
+          if (!this.metadata.skipSource) {
+              // support for CocoonJS Canvas+ runtime, lacks document.createElement('source')
+              if (navigator.isCocoonJS) {
+                  this.data.src = Array.isArray(this.url) ? this.url[0] : this.url;
+              }
+              else if (Array.isArray(this.url)) {
+                  var mimeTypes = this.metadata.mimeType;
+                  for (var i = 0; i < this.url.length; ++i) {
+                      this.data.appendChild(this._createSource(type, this.url[i], Array.isArray(mimeTypes) ? mimeTypes[i] : mimeTypes));
+                  }
+              }
+              else {
+                  var mimeTypes = this.metadata.mimeType;
+                  this.data.appendChild(this._createSource(type, this.url, Array.isArray(mimeTypes) ? mimeTypes[0] : mimeTypes));
+              }
+          }
+          this.data.addEventListener('error', this._boundOnError, false);
+          this.data.addEventListener('load', this._boundComplete, false);
+          this.data.addEventListener('progress', this._boundOnProgress, false);
+          this.data.addEventListener('canplaythrough', this._boundComplete, false);
+          this.data.load();
+          if (this.timeout) {
+              this._elementTimer = setTimeout(this._boundOnTimeout, this.timeout);
+          }
+      };
+      /** Loads this resources using an XMLHttpRequest. */
+      LoaderResource.prototype._loadXhr = function () {
+          // if unset, determine the value
+          if (typeof this.xhrType !== 'string') {
+              this.xhrType = this._determineXhrType();
+          }
+          var xhr = this.xhr = new XMLHttpRequest();
+          // send credentials when crossOrigin with credentials requested
+          if (this.crossOrigin === 'use-credentials') {
+              xhr.withCredentials = true;
+          }
+          // set the request type and url
+          xhr.open('GET', this.url, true);
+          xhr.timeout = this.timeout;
+          // load json as text and parse it ourselves. We do this because some browsers
+          // *cough* safari *cough* can't deal with it.
+          if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.JSON
+              || this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT) {
+              xhr.responseType = LoaderResource.XHR_RESPONSE_TYPE.TEXT;
+          }
+          else {
+              xhr.responseType = this.xhrType;
+          }
+          xhr.addEventListener('error', this._boundXhrOnError, false);
+          xhr.addEventListener('timeout', this._boundXhrOnTimeout, false);
+          xhr.addEventListener('abort', this._boundXhrOnAbort, false);
+          xhr.addEventListener('progress', this._boundOnProgress, false);
+          xhr.addEventListener('load', this._boundXhrOnLoad, false);
+          xhr.send();
+      };
+      /** Loads this resources using an XDomainRequest. This is here because we need to support IE9 (gross). */
+      LoaderResource.prototype._loadXdr = function () {
+          // if unset, determine the value
+          if (typeof this.xhrType !== 'string') {
+              this.xhrType = this._determineXhrType();
+          }
+          var xdr = this.xhr = new globalThis.XDomainRequest(); // eslint-disable-line no-undef
+          // XDomainRequest has a few quirks. Occasionally it will abort requests
+          // A way to avoid this is to make sure ALL callbacks are set even if not used
+          // More info here: http://stackoverflow.com/questions/15786966/xdomainrequest-aborts-post-on-ie-9
+          xdr.timeout = this.timeout || 5000; // XDR needs a timeout value or it breaks in IE9
+          xdr.onerror = this._boundXhrOnError;
+          xdr.ontimeout = this._boundXhrOnTimeout;
+          xdr.onprogress = this._boundOnProgress;
+          xdr.onload = this._boundXhrOnLoad;
+          xdr.open('GET', this.url, true);
+          // Note: The xdr.send() call is wrapped in a timeout to prevent an
+          // issue with the interface where some requests are lost if multiple
+          // XDomainRequests are being sent at the same time.
+          // Some info here: https://github.com/photonstorm/phaser/issues/1248
+          setTimeout(function () { return xdr.send(); }, 1);
+      };
+      /**
+       * Creates a source used in loading via an element.
+       * @param type - The element type (video or audio).
+       * @param url - The source URL to load from.
+       * @param [mime] - The mime type of the video
+       * @returns The source element.
+       */
+      LoaderResource.prototype._createSource = function (type, url, mime) {
+          if (!mime) {
+              mime = type + "/" + this._getExtension(url);
+          }
+          var source = document.createElement('source');
+          source.src = url;
+          source.type = mime;
+          return source;
+      };
+      /**
+       * Called if a load errors out.
+       * @param event - The error event from the element that emits it.
+       */
+      LoaderResource.prototype._onError = function (event) {
+          this.abort("Failed to load element using: " + event.target.nodeName);
+      };
+      /**
+       * Called if a load progress event fires for an element or xhr/xdr.
+       * @param event - Progress event.
+       */
+      LoaderResource.prototype._onProgress = function (event) {
+          if (event && event.lengthComputable) {
+              this.onProgress.dispatch(this, event.loaded / event.total);
+          }
+      };
+      /** Called if a timeout event fires for an element. */
+      LoaderResource.prototype._onTimeout = function () {
+          this.abort("Load timed out.");
+      };
+      /** Called if an error event fires for xhr/xdr. */
+      LoaderResource.prototype._xhrOnError = function () {
+          var xhr = this.xhr;
+          this.abort(reqType(xhr) + " Request failed. Status: " + xhr.status + ", text: \"" + xhr.statusText + "\"");
+      };
+      /** Called if an error event fires for xhr/xdr. */
+      LoaderResource.prototype._xhrOnTimeout = function () {
+          var xhr = this.xhr;
+          this.abort(reqType(xhr) + " Request timed out.");
+      };
+      /** Called if an abort event fires for xhr/xdr. */
+      LoaderResource.prototype._xhrOnAbort = function () {
+          var xhr = this.xhr;
+          this.abort(reqType(xhr) + " Request was aborted by the user.");
+      };
+      /** Called when data successfully loads from an xhr/xdr request. */
+      LoaderResource.prototype._xhrOnLoad = function () {
+          var xhr = this.xhr;
+          var text = '';
+          var status = typeof xhr.status === 'undefined' ? STATUS_OK : xhr.status; // XDR has no `.status`, assume 200.
+          // responseText is accessible only if responseType is '' or 'text' and on older browsers
+          if (xhr.responseType === '' || xhr.responseType === 'text' || typeof xhr.responseType === 'undefined') {
+              text = xhr.responseText;
+          }
+          // status can be 0 when using the `file://` protocol so we also check if a response is set.
+          // If it has a response, we assume 200; otherwise a 0 status code with no contents is an aborted request.
+          if (status === STATUS_NONE && (text.length > 0 || xhr.responseType === LoaderResource.XHR_RESPONSE_TYPE.BUFFER)) {
+              status = STATUS_OK;
+          }
+          // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request
+          else if (status === STATUS_IE_BUG_EMPTY) {
+              status = STATUS_EMPTY;
+          }
+          var statusType = (status / 100) | 0;
+          if (statusType === STATUS_TYPE_OK) {
+              // if text, just return it
+              if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.TEXT) {
+                  this.data = text;
+                  this.type = LoaderResource.TYPE.TEXT;
+              }
+              // if json, parse into json object
+              else if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.JSON) {
+                  try {
+                      this.data = JSON.parse(text);
+                      this.type = LoaderResource.TYPE.JSON;
+                  }
+                  catch (e) {
+                      this.abort("Error trying to parse loaded json: " + e);
+                      return;
+                  }
+              }
+              // if xml, parse into an xml document or div element
+              else if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT) {
+                  try {
+                      if (globalThis.DOMParser) {
+                          var domparser = new DOMParser();
+                          this.data = domparser.parseFromString(text, 'text/xml');
+                      }
+                      else {
+                          var div = document.createElement('div');
+                          div.innerHTML = text;
+                          this.data = div;
+                      }
+                      this.type = LoaderResource.TYPE.XML;
+                  }
+                  catch (e$1) {
+                      this.abort("Error trying to parse loaded xml: " + e$1);
+                      return;
+                  }
+              }
+              // other types just return the response
+              else {
+                  this.data = xhr.response || text;
+              }
+          }
+          else {
+              this.abort("[" + xhr.status + "] " + xhr.statusText + ": " + xhr.responseURL);
+              return;
+          }
+          this.complete();
+      };
+      /**
+       * Sets the `crossOrigin` property for this resource based on if the url
+       * for this resource is cross-origin. If crossOrigin was manually set, this
+       * function does nothing.
+       * @private
+       * @param url - The url to test.
+       * @param [loc=globalThis.location] - The location object to test against.
+       * @returns The crossOrigin value to use (or empty string for none).
+       */
+      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+      LoaderResource.prototype._determineCrossOrigin = function (url, loc) {
+          // data: and javascript: urls are considered same-origin
+          if (url.indexOf('data:') === 0) {
+              return '';
+          }
+          // A sandboxed iframe without the 'allow-same-origin' attribute will have a special
+          // origin designed not to match globalThis.location.origin, and will always require
+          // crossOrigin requests regardless of whether the location matches.
+          if (globalThis.origin !== globalThis.location.origin) {
+              return 'anonymous';
+          }
+          // default is globalThis.location
+          loc = loc || globalThis.location;
+          if (!tempAnchor) {
+              tempAnchor = document.createElement('a');
+          }
+          // let the browser determine the full href for the url of this resource and then
+          // parse with the node url lib, we can't use the properties of the anchor element
+          // because they don't work in IE9 :(
+          tempAnchor.href = url;
+          var parsedUrl = parseUri(tempAnchor.href, { strictMode: true });
+          var samePort = (!parsedUrl.port && loc.port === '') || (parsedUrl.port === loc.port);
+          var protocol = parsedUrl.protocol ? parsedUrl.protocol + ":" : '';
+          // if cross origin
+          if (parsedUrl.host !== loc.hostname || !samePort || protocol !== loc.protocol) {
+              return 'anonymous';
+          }
+          return '';
+      };
+      /**
+       * Determines the responseType of an XHR request based on the extension of the
+       * resource being loaded.
+       * @private
+       * @returns {PIXI.LoaderResource.XHR_RESPONSE_TYPE} The responseType to use.
+       */
+      LoaderResource.prototype._determineXhrType = function () {
+          return LoaderResource._xhrTypeMap[this.extension] || LoaderResource.XHR_RESPONSE_TYPE.TEXT;
+      };
+      /**
+       * Determines the loadType of a resource based on the extension of the
+       * resource being loaded.
+       * @private
+       * @returns {PIXI.LoaderResource.LOAD_TYPE} The loadType to use.
+       */
+      LoaderResource.prototype._determineLoadType = function () {
+          return LoaderResource._loadTypeMap[this.extension] || LoaderResource.LOAD_TYPE.XHR;
+      };
+      /**
+       * Extracts the extension (sans '.') of the file being loaded by the resource.
+       * @param [url] - url to parse, `this.url` by default.
+       * @returns The extension.
+       */
+      LoaderResource.prototype._getExtension = function (url) {
+          if (url === void 0) { url = this.url; }
+          var ext = '';
+          if (this.isDataUrl) {
+              var slashIndex = url.indexOf('/');
+              ext = url.substring(slashIndex + 1, url.indexOf(';', slashIndex));
+          }
+          else {
+              var queryStart = url.indexOf('?');
+              var hashStart = url.indexOf('#');
+              var index = Math.min(queryStart > -1 ? queryStart : url.length, hashStart > -1 ? hashStart : url.length);
+              url = url.substring(0, index);
+              ext = url.substring(url.lastIndexOf('.') + 1);
+          }
+          return ext.toLowerCase();
+      };
+      /**
+       * Determines the mime type of an XHR request based on the responseType of
+       * resource being loaded.
+       * @param type - The type to get a mime type for.
+       * @private
+       * @returns The mime type to use.
+       */
+      LoaderResource.prototype._getMimeFromXhrType = function (type) {
+          switch (type) {
+              case LoaderResource.XHR_RESPONSE_TYPE.BUFFER:
+                  return 'application/octet-binary';
+              case LoaderResource.XHR_RESPONSE_TYPE.BLOB:
+                  return 'application/blob';
+              case LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT:
+                  return 'application/xml';
+              case LoaderResource.XHR_RESPONSE_TYPE.JSON:
+                  return 'application/json';
+              case LoaderResource.XHR_RESPONSE_TYPE.DEFAULT:
+              case LoaderResource.XHR_RESPONSE_TYPE.TEXT:
+              /* falls through */
+              default:
+                  return 'text/plain';
+          }
+      };
+      return LoaderResource;
+  }());
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  (function (LoaderResource) {
+      (function (STATUS_FLAGS) {
+          /** None */
+          STATUS_FLAGS[STATUS_FLAGS["NONE"] = 0] = "NONE";
+          /** Data URL */
+          STATUS_FLAGS[STATUS_FLAGS["DATA_URL"] = 1] = "DATA_URL";
+          /** Complete */
+          STATUS_FLAGS[STATUS_FLAGS["COMPLETE"] = 2] = "COMPLETE";
+          /** Loading */
+          STATUS_FLAGS[STATUS_FLAGS["LOADING"] = 4] = "LOADING";
+      })(LoaderResource.STATUS_FLAGS || (LoaderResource.STATUS_FLAGS = {}));
+      (function (TYPE) {
+          /** Unknown */
+          TYPE[TYPE["UNKNOWN"] = 0] = "UNKNOWN";
+          /** JSON */
+          TYPE[TYPE["JSON"] = 1] = "JSON";
+          /** XML */
+          TYPE[TYPE["XML"] = 2] = "XML";
+          /** Image */
+          TYPE[TYPE["IMAGE"] = 3] = "IMAGE";
+          /** Audio */
+          TYPE[TYPE["AUDIO"] = 4] = "AUDIO";
+          /** Video */
+          TYPE[TYPE["VIDEO"] = 5] = "VIDEO";
+          /** Plain text */
+          TYPE[TYPE["TEXT"] = 6] = "TEXT";
+      })(LoaderResource.TYPE || (LoaderResource.TYPE = {}));
+      (function (LOAD_TYPE) {
+          /** Uses XMLHttpRequest to load the resource. */
+          LOAD_TYPE[LOAD_TYPE["XHR"] = 1] = "XHR";
+          /** Uses an `Image` object to load the resource. */
+          LOAD_TYPE[LOAD_TYPE["IMAGE"] = 2] = "IMAGE";
+          /** Uses an `Audio` object to load the resource. */
+          LOAD_TYPE[LOAD_TYPE["AUDIO"] = 3] = "AUDIO";
+          /** Uses a `Video` object to load the resource. */
+          LOAD_TYPE[LOAD_TYPE["VIDEO"] = 4] = "VIDEO";
+      })(LoaderResource.LOAD_TYPE || (LoaderResource.LOAD_TYPE = {}));
+      (function (XHR_RESPONSE_TYPE) {
+          /** string */
+          XHR_RESPONSE_TYPE["DEFAULT"] = "text";
+          /** ArrayBuffer */
+          XHR_RESPONSE_TYPE["BUFFER"] = "arraybuffer";
+          /** Blob */
+          XHR_RESPONSE_TYPE["BLOB"] = "blob";
+          /** Document */
+          XHR_RESPONSE_TYPE["DOCUMENT"] = "document";
+          /** Object */
+          XHR_RESPONSE_TYPE["JSON"] = "json";
+          /** String */
+          XHR_RESPONSE_TYPE["TEXT"] = "text";
+      })(LoaderResource.XHR_RESPONSE_TYPE || (LoaderResource.XHR_RESPONSE_TYPE = {}));
+      LoaderResource._loadTypeMap = {
+          // images
+          gif: LoaderResource.LOAD_TYPE.IMAGE,
+          png: LoaderResource.LOAD_TYPE.IMAGE,
+          bmp: LoaderResource.LOAD_TYPE.IMAGE,
+          jpg: LoaderResource.LOAD_TYPE.IMAGE,
+          jpeg: LoaderResource.LOAD_TYPE.IMAGE,
+          tif: LoaderResource.LOAD_TYPE.IMAGE,
+          tiff: LoaderResource.LOAD_TYPE.IMAGE,
+          webp: LoaderResource.LOAD_TYPE.IMAGE,
+          tga: LoaderResource.LOAD_TYPE.IMAGE,
+          avif: LoaderResource.LOAD_TYPE.IMAGE,
+          svg: LoaderResource.LOAD_TYPE.IMAGE,
+          'svg+xml': LoaderResource.LOAD_TYPE.IMAGE,
+          // audio
+          mp3: LoaderResource.LOAD_TYPE.AUDIO,
+          ogg: LoaderResource.LOAD_TYPE.AUDIO,
+          wav: LoaderResource.LOAD_TYPE.AUDIO,
+          // videos
+          mp4: LoaderResource.LOAD_TYPE.VIDEO,
+          webm: LoaderResource.LOAD_TYPE.VIDEO,
+      };
+      LoaderResource._xhrTypeMap = {
+          // xml
+          xhtml: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
+          html: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
+          htm: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
+          xml: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
+          tmx: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
+          svg: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
+          // This was added to handle Tiled Tileset XML, but .tsx is also a TypeScript React Component.
+          // Since it is way less likely for people to be loading TypeScript files instead of Tiled files,
+          // this should probably be fine.
+          tsx: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
+          // images
+          gif: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          png: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          bmp: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          jpg: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          jpeg: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          tif: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          tiff: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          webp: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          tga: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          avif: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
+          // json
+          json: LoaderResource.XHR_RESPONSE_TYPE.JSON,
+          // text
+          text: LoaderResource.XHR_RESPONSE_TYPE.TEXT,
+          txt: LoaderResource.XHR_RESPONSE_TYPE.TEXT,
+          // fonts
+          ttf: LoaderResource.XHR_RESPONSE_TYPE.BUFFER,
+          otf: LoaderResource.XHR_RESPONSE_TYPE.BUFFER,
+      };
+      // We can't set the `src` attribute to empty string, so on abort we set it to this 1px transparent gif
+      LoaderResource.EMPTY_GIF = 'data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
+  })(exports.LoaderResource || (exports.LoaderResource = {}));
 
-    /**
-     * Adds hooks for finding items.
-     *
-     * @param {Function} addHook - Function call that takes two parameters: `item:*, queue:Array`
-     *          function must return `true` if it was able to add item to the queue.
-     * @return {PIXI.BasePrepare} Instance of plugin for chaining.
-     */
+  /**
+   * Smaller version of the async library constructs.
+   * @ignore
+   */
+  function _noop() {
+  }
+  /**
+   * Ensures a function is only called once.
+   * @ignore
+   * @param {Function} fn - The function to wrap.
+   * @returns {Function} The wrapping function.
+   */
+  function onlyOnce(fn) {
+      return function onceWrapper() {
+          var arguments$1 = arguments;
 
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments$1[_i];
+          }
+          if (fn === null) {
+              throw new Error('Callback was already called.');
+          }
+          var callFn = fn;
+          fn = null;
+          callFn.apply(this, args);
+      };
+  }
+  /**
+   * @private
+   * @memberof PIXI
+   */
+  var AsyncQueueItem = /** @class */ (function () {
+      /**
+       * @param data
+       * @param callback
+       * @private
+       */
+      function AsyncQueueItem(data, callback) {
+          this.data = data;
+          this.callback = callback;
+      }
+      return AsyncQueueItem;
+  }());
+  /**
+   * @private
+   * @memberof PIXI
+   */
+  var AsyncQueue = /** @class */ (function () {
+      /**
+       * @param worker
+       * @param concurrency
+       * @private
+       */
+      function AsyncQueue(worker, concurrency) {
+          var _this = this;
+          if (concurrency === void 0) { concurrency = 1; }
+          this.workers = 0;
+          this.saturated = _noop;
+          this.unsaturated = _noop;
+          this.empty = _noop;
+          this.drain = _noop;
+          this.error = _noop;
+          this.started = false;
+          this.paused = false;
+          this._tasks = [];
+          this._insert = function (data, insertAtFront, callback) {
+              if (callback && typeof callback !== 'function') {
+                  throw new Error('task callback must be a function');
+              }
+              _this.started = true;
+              // eslint-disable-next-line no-eq-null,eqeqeq
+              if (data == null && _this.idle()) {
+                  // call drain immediately if there are no tasks
+                  setTimeout(function () { return _this.drain(); }, 1);
+                  return;
+              }
+              var item = new AsyncQueueItem(data, typeof callback === 'function' ? callback : _noop);
+              if (insertAtFront) {
+                  _this._tasks.unshift(item);
+              }
+              else {
+                  _this._tasks.push(item);
+              }
+              setTimeout(_this.process, 1);
+          };
+          this.process = function () {
+              while (!_this.paused && _this.workers < _this.concurrency && _this._tasks.length) {
+                  var task = _this._tasks.shift();
+                  if (_this._tasks.length === 0) {
+                      _this.empty();
+                  }
+                  _this.workers += 1;
+                  if (_this.workers === _this.concurrency) {
+                      _this.saturated();
+                  }
+                  _this._worker(task.data, onlyOnce(_this._next(task)));
+              }
+          };
+          this._worker = worker;
+          if (concurrency === 0) {
+              throw new Error('Concurrency must not be zero');
+          }
+          this.concurrency = concurrency;
+          this.buffer = concurrency / 4.0;
+      }
+      /**
+       * @param task
+       * @private
+       */
+      AsyncQueue.prototype._next = function (task) {
+          var _this = this;
+          return function () {
+              var arguments$1 = arguments;
+
+              var args = [];
+              for (var _i = 0; _i < arguments.length; _i++) {
+                  args[_i] = arguments$1[_i];
+              }
+              _this.workers -= 1;
+              task.callback.apply(task, args);
+              // eslint-disable-next-line no-eq-null,eqeqeq
+              if (args[0] != null) {
+                  _this.error(args[0], task.data);
+              }
+              if (_this.workers <= (_this.concurrency - _this.buffer)) {
+                  _this.unsaturated();
+              }
+              if (_this.idle()) {
+                  _this.drain();
+              }
+              _this.process();
+          };
+      };
+      // That was in object
+      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+      AsyncQueue.prototype.push = function (data, callback) {
+          this._insert(data, false, callback);
+      };
+      AsyncQueue.prototype.kill = function () {
+          this.workers = 0;
+          this.drain = _noop;
+          this.started = false;
+          this._tasks = [];
+      };
+      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+      AsyncQueue.prototype.unshift = function (data, callback) {
+          this._insert(data, true, callback);
+      };
+      AsyncQueue.prototype.length = function () {
+          return this._tasks.length;
+      };
+      AsyncQueue.prototype.running = function () {
+          return this.workers;
+      };
+      AsyncQueue.prototype.idle = function () {
+          return this._tasks.length + this.workers === 0;
+      };
+      AsyncQueue.prototype.pause = function () {
+          if (this.paused === true) {
+              return;
+          }
+          this.paused = true;
+      };
+      AsyncQueue.prototype.resume = function () {
+          if (this.paused === false) {
+              return;
+          }
+          this.paused = false;
+          // Need to call this.process once per concurrent
+          // worker to preserve full concurrency after pause
+          for (var w = 1; w <= this.concurrency; w++) {
+              this.process();
+          }
+      };
+      /**
+       * Iterates an array in series.
+       * @param {Array.<*>} array - Array to iterate.
+       * @param {Function} iterator - Function to call for each element.
+       * @param {Function} callback - Function to call when done, or on error.
+       * @param {boolean} [deferNext=false] - Break synchronous each loop by calling next with a setTimeout of 1.
+       */
+      AsyncQueue.eachSeries = function (array, iterator, callback, deferNext) {
+          var i = 0;
+          var len = array.length;
+          function next(err) {
+              if (err || i === len) {
+                  if (callback) {
+                      callback(err);
+                  }
+                  return;
+              }
+              if (deferNext) {
+                  setTimeout(function () {
+                      iterator(array[i++], next);
+                  }, 1);
+              }
+              else {
+                  iterator(array[i++], next);
+              }
+          }
+          next();
+      };
+      /**
+       * Async queue implementation,
+       * @param {Function} worker - The worker function to call for each task.
+       * @param {number} concurrency - How many workers to run in parrallel.
+       * @returns {*} The async queue object.
+       */
+      AsyncQueue.queue = function (worker, concurrency) {
+          return new AsyncQueue(worker, concurrency);
+      };
+      return AsyncQueue;
+  }());
+
+  // some constants
+  var MAX_PROGRESS = 100;
+  var rgxExtractUrlHash = /(#[\w-]+)?$/;
+  /**
+   * The new loader, forked from Resource Loader by Chad Engler: https://github.com/englercj/resource-loader
+   *
+   * ```js
+   * const loader = PIXI.Loader.shared; // PixiJS exposes a premade instance for you to use.
+   * // or
+   * const loader = new PIXI.Loader(); // You can also create your own if you want
+   *
+   * const sprites = {};
+   *
+   * // Chainable `add` to enqueue a resource
+   * loader.add('bunny', 'data/bunny.png')
+   *       .add('spaceship', 'assets/spritesheet.json');
+   * loader.add('scoreFont', 'assets/score.fnt');
+   *
+   * // Chainable `pre` to add a middleware that runs for each resource, *before* loading that resource.
+   * // This is useful to implement custom caching modules (using filesystem, indexeddb, memory, etc).
+   * loader.pre(cachingMiddleware);
+   *
+   * // Chainable `use` to add a middleware that runs for each resource, *after* loading that resource.
+   * // This is useful to implement custom parsing modules (like spritesheet parsers, spine parser, etc).
+   * loader.use(parsingMiddleware);
+   *
+   * // The `load` method loads the queue of resources, and calls the passed in callback called once all
+   * // resources have loaded.
+   * loader.load((loader, resources) => {
+   *     // resources is an object where the key is the name of the resource loaded and the value is the resource object.
+   *     // They have a couple default properties:
+   *     // - `url`: The URL that the resource was loaded from
+   *     // - `error`: The error that happened when trying to load (if any)
+   *     // - `data`: The raw data that was loaded
+   *     // also may contain other properties based on the middleware that runs.
+   *     sprites.bunny = new PIXI.TilingSprite(resources.bunny.texture);
+   *     sprites.spaceship = new PIXI.TilingSprite(resources.spaceship.texture);
+   *     sprites.scoreFont = new PIXI.TilingSprite(resources.scoreFont.texture);
+   * });
+   *
+   * // throughout the process multiple signals can be dispatched.
+   * loader.onProgress.add(() => {}); // called once per loaded/errored file
+   * loader.onError.add(() => {}); // called once per errored file
+   * loader.onLoad.add(() => {}); // called once per loaded file
+   * loader.onComplete.add(() => {}); // called once when the queued resources all load.
+   * ```
+   * @memberof PIXI
+   */
+  var Loader = /** @class */ (function () {
+      /**
+       * @param baseUrl - The base url for all resources loaded by this loader.
+       * @param concurrency - The number of resources to load concurrently.
+       */
+      function Loader(baseUrl, concurrency) {
+          var _this = this;
+          if (baseUrl === void 0) { baseUrl = ''; }
+          if (concurrency === void 0) { concurrency = 10; }
+          /** The progress percent of the loader going through the queue. */
+          this.progress = 0;
+          /** Loading state of the loader, true if it is currently loading resources. */
+          this.loading = false;
+          /**
+           * A querystring to append to every URL added to the loader.
+           *
+           * This should be a valid query string *without* the question-mark (`?`). The loader will
+           * also *not* escape values for you. Make sure to escape your parameters with
+           * [`encodeURIComponent`](https://mdn.io/encodeURIComponent) before assigning this property.
+           * @example
+           * const loader = new Loader();
+           *
+           * loader.defaultQueryString = 'user=me&password=secret';
+           *
+           * // This will request 'image.png?user=me&password=secret'
+           * loader.add('image.png').load();
+           *
+           * loader.reset();
+           *
+           * // This will request 'image.png?v=1&user=me&password=secret'
+           * loader.add('iamge.png?v=1').load();
+           */
+          this.defaultQueryString = '';
+          /** The middleware to run before loading each resource. */
+          this._beforeMiddleware = [];
+          /** The middleware to run after loading each resource. */
+          this._afterMiddleware = [];
+          /** The tracks the resources we are currently completing parsing for. */
+          this._resourcesParsing = [];
+          /**
+           * The `_loadResource` function bound with this object context.
+           * @param r - The resource to load
+           * @param d - The dequeue function
+           */
+          this._boundLoadResource = function (r, d) { return _this._loadResource(r, d); };
+          /** All the resources for this loader keyed by name. */
+          this.resources = {};
+          this.baseUrl = baseUrl;
+          this._beforeMiddleware = [];
+          this._afterMiddleware = [];
+          this._resourcesParsing = [];
+          this._boundLoadResource = function (r, d) { return _this._loadResource(r, d); };
+          this._queue = AsyncQueue.queue(this._boundLoadResource, concurrency);
+          this._queue.pause();
+          this.resources = {};
+          this.onProgress = new Signal();
+          this.onError = new Signal();
+          this.onLoad = new Signal();
+          this.onStart = new Signal();
+          this.onComplete = new Signal();
+          for (var i = 0; i < Loader._plugins.length; ++i) {
+              var plugin = Loader._plugins[i];
+              var pre = plugin.pre, use = plugin.use;
+              if (pre) {
+                  this.pre(pre);
+              }
+              if (use) {
+                  this.use(use);
+              }
+          }
+          this._protected = false;
+      }
+      /**
+       * Same as add, params have strict order
+       * @private
+       * @param name - The name of the resource to load.
+       * @param url - The url for this resource, relative to the baseUrl of this loader.
+       * @param options - The options for the load.
+       * @param callback - Function to call when this specific resource completes loading.
+       * @returns The loader itself.
+       */
+      Loader.prototype._add = function (name, url, options, callback) {
+          // if loading already you can only add resources that have a parent.
+          if (this.loading && (!options || !options.parentResource)) {
+              throw new Error('Cannot add resources while the loader is running.');
+          }
+          // check if resource already exists.
+          if (this.resources[name]) {
+              throw new Error("Resource named \"" + name + "\" already exists.");
+          }
+          // add base url if this isn't an absolute url
+          url = this._prepareUrl(url);
+          // create the store the resource
+          this.resources[name] = new exports.LoaderResource(name, url, options);
+          if (typeof callback === 'function') {
+              this.resources[name].onAfterMiddleware.once(callback);
+          }
+          // if actively loading, make sure to adjust progress chunks for that parent and its children
+          if (this.loading) {
+              var parent = options.parentResource;
+              var incompleteChildren = [];
+              for (var i = 0; i < parent.children.length; ++i) {
+                  if (!parent.children[i].isComplete) {
+                      incompleteChildren.push(parent.children[i]);
+                  }
+              }
+              var fullChunk = parent.progressChunk * (incompleteChildren.length + 1); // +1 for parent
+              var eachChunk = fullChunk / (incompleteChildren.length + 2); // +2 for parent & new child
+              parent.children.push(this.resources[name]);
+              parent.progressChunk = eachChunk;
+              for (var i = 0; i < incompleteChildren.length; ++i) {
+                  incompleteChildren[i].progressChunk = eachChunk;
+              }
+              this.resources[name].progressChunk = eachChunk;
+          }
+          // add the resource to the queue
+          this._queue.push(this.resources[name]);
+          return this;
+      };
+      /* eslint-enable require-jsdoc,valid-jsdoc */
+      /**
+       * Sets up a middleware function that will run *before* the
+       * resource is loaded.
+       * @param fn - The middleware function to register.
+       * @returns The loader itself.
+       */
+      Loader.prototype.pre = function (fn) {
+          this._beforeMiddleware.push(fn);
+          return this;
+      };
+      /**
+       * Sets up a middleware function that will run *after* the
+       * resource is loaded.
+       * @param fn - The middleware function to register.
+       * @returns The loader itself.
+       */
+      Loader.prototype.use = function (fn) {
+          this._afterMiddleware.push(fn);
+          return this;
+      };
+      /**
+       * Resets the queue of the loader to prepare for a new load.
+       * @returns The loader itself.
+       */
+      Loader.prototype.reset = function () {
+          this.progress = 0;
+          this.loading = false;
+          this._queue.kill();
+          this._queue.pause();
+          // abort all resource loads
+          for (var k in this.resources) {
+              var res = this.resources[k];
+              if (res._onLoadBinding) {
+                  res._onLoadBinding.detach();
+              }
+              if (res.isLoading) {
+                  res.abort('loader reset');
+              }
+          }
+          this.resources = {};
+          return this;
+      };
+      /**
+       * Starts loading the queued resources.
+       * @param cb - Optional callback that will be bound to the `complete` event.
+       * @returns The loader itself.
+       */
+      Loader.prototype.load = function (cb) {
+          deprecation('6.5.0', '@pixi/loaders is being replaced with @pixi/assets in the next major release.');
+          // register complete callback if they pass one
+          if (typeof cb === 'function') {
+              this.onComplete.once(cb);
+          }
+          // if the queue has already started we are done here
+          if (this.loading) {
+              return this;
+          }
+          if (this._queue.idle()) {
+              this._onStart();
+              this._onComplete();
+          }
+          else {
+              // distribute progress chunks
+              var numTasks = this._queue._tasks.length;
+              var chunk = MAX_PROGRESS / numTasks;
+              for (var i = 0; i < this._queue._tasks.length; ++i) {
+                  this._queue._tasks[i].data.progressChunk = chunk;
+              }
+              // notify we are starting
+              this._onStart();
+              // start loading
+              this._queue.resume();
+          }
+          return this;
+      };
+      Object.defineProperty(Loader.prototype, "concurrency", {
+          /**
+           * The number of resources to load concurrently.
+           * @default 10
+           */
+          get: function () {
+              return this._queue.concurrency;
+          },
+          set: function (concurrency) {
+              this._queue.concurrency = concurrency;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Prepares a url for usage based on the configuration of this object
+       * @param url - The url to prepare.
+       * @returns The prepared url.
+       */
+      Loader.prototype._prepareUrl = function (url) {
+          var parsedUrl = parseUri(url, { strictMode: true });
+          var result;
+          // absolute url, just use it as is.
+          if (parsedUrl.protocol || !parsedUrl.path || url.indexOf('//') === 0) {
+              result = url;
+          }
+          // if baseUrl doesn't end in slash and url doesn't start with slash, then add a slash inbetween
+          else if (this.baseUrl.length
+              && this.baseUrl.lastIndexOf('/') !== this.baseUrl.length - 1
+              && url.charAt(0) !== '/') {
+              result = this.baseUrl + "/" + url;
+          }
+          else {
+              result = this.baseUrl + url;
+          }
+          // if we need to add a default querystring, there is a bit more work
+          if (this.defaultQueryString) {
+              var hash = rgxExtractUrlHash.exec(result)[0];
+              result = result.slice(0, result.length - hash.length);
+              if (result.indexOf('?') !== -1) {
+                  result += "&" + this.defaultQueryString;
+              }
+              else {
+                  result += "?" + this.defaultQueryString;
+              }
+              result += hash;
+          }
+          return result;
+      };
+      /**
+       * Loads a single resource.
+       * @param resource - The resource to load.
+       * @param dequeue - The function to call when we need to dequeue this item.
+       */
+      Loader.prototype._loadResource = function (resource, dequeue) {
+          var _this = this;
+          resource._dequeue = dequeue;
+          // run before middleware
+          AsyncQueue.eachSeries(this._beforeMiddleware, function (fn, next) {
+              fn.call(_this, resource, function () {
+                  // if the before middleware marks the resource as complete,
+                  // break and don't process any more before middleware
+                  next(resource.isComplete ? {} : null);
+              });
+          }, function () {
+              if (resource.isComplete) {
+                  _this._onLoad(resource);
+              }
+              else {
+                  resource._onLoadBinding = resource.onComplete.once(_this._onLoad, _this);
+                  resource.load();
+              }
+          }, true);
+      };
+      /** Called once loading has started. */
+      Loader.prototype._onStart = function () {
+          this.progress = 0;
+          this.loading = true;
+          this.onStart.dispatch(this);
+      };
+      /** Called once each resource has loaded. */
+      Loader.prototype._onComplete = function () {
+          this.progress = MAX_PROGRESS;
+          this.loading = false;
+          this.onComplete.dispatch(this, this.resources);
+      };
+      /**
+       * Called each time a resources is loaded.
+       * @param resource - The resource that was loaded
+       */
+      Loader.prototype._onLoad = function (resource) {
+          var _this = this;
+          resource._onLoadBinding = null;
+          // remove this resource from the async queue, and add it to our list of resources that are being parsed
+          this._resourcesParsing.push(resource);
+          resource._dequeue();
+          // run all the after middleware for this resource
+          AsyncQueue.eachSeries(this._afterMiddleware, function (fn, next) {
+              fn.call(_this, resource, next);
+          }, function () {
+              resource.onAfterMiddleware.dispatch(resource);
+              _this.progress = Math.min(MAX_PROGRESS, _this.progress + resource.progressChunk);
+              _this.onProgress.dispatch(_this, resource);
+              if (resource.error) {
+                  _this.onError.dispatch(resource.error, _this, resource);
+              }
+              else {
+                  _this.onLoad.dispatch(_this, resource);
+              }
+              _this._resourcesParsing.splice(_this._resourcesParsing.indexOf(resource), 1);
+              // do completion check
+              if (_this._queue.idle() && _this._resourcesParsing.length === 0) {
+                  _this._onComplete();
+              }
+          }, true);
+      };
+      /** Destroy the loader, removes references. */
+      Loader.prototype.destroy = function () {
+          if (!this._protected) {
+              this.reset();
+          }
+      };
+      Object.defineProperty(Loader, "shared", {
+          /** A premade instance of the loader that can be used to load resources. */
+          get: function () {
+              var shared = Loader._shared;
+              if (!shared) {
+                  shared = new Loader();
+                  shared._protected = true;
+                  Loader._shared = shared;
+              }
+              return shared;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Use the {@link PIXI.extensions.add} API to register plugins.
+       * @deprecated since 6.5.0
+       * @param plugin - The plugin to add
+       * @returns Reference to PIXI.Loader for chaining
+       */
+      Loader.registerPlugin = function (plugin) {
+          deprecation('6.5.0', 'Loader.registerPlugin() is deprecated, use extensions.add() instead.');
+          extensions.add({
+              type: exports.ExtensionType.Loader,
+              ref: plugin,
+          });
+          return Loader;
+      };
+      Loader._plugins = [];
+      return Loader;
+  }());
+  extensions.handleByList(exports.ExtensionType.Loader, Loader._plugins);
+  Loader.prototype.add = function add(name, url, options, callback) {
+      // special case of an array of objects or urls
+      if (Array.isArray(name)) {
+          for (var i = 0; i < name.length; ++i) {
+              this.add(name[i]);
+          }
+          return this;
+      }
+      // if an object is passed instead of params
+      if (typeof name === 'object') {
+          options = name;
+          callback = url || options.callback || options.onComplete;
+          url = options.url;
+          name = options.name || options.key || options.url;
+      }
+      // case where no name is passed shift all args over by one.
+      if (typeof url !== 'string') {
+          callback = options;
+          options = url;
+          url = name;
+      }
+      // now that we shifted make sure we have a proper url.
+      if (typeof url !== 'string') {
+          throw new Error('No url passed to add resource to loader.');
+      }
+      // options are optional so people might pass a function and no options
+      if (typeof options === 'function') {
+          callback = options;
+          options = null;
+      }
+      return this._add(name, url, options, callback);
+  };
 
-    BasePrepare.prototype.registerFindHook = function registerFindHook(addHook) {
-        if (addHook) {
-            this.addHooks.push(addHook);
-        }
+  /**
+   * Application plugin for supporting loader option. Installing the LoaderPlugin
+   * is not necessary if using **pixi.js** or **pixi.js-legacy**.
+   * @example
+   * import {AppLoaderPlugin} from '@pixi/loaders';
+   * import {extensions} from '@pixi/core';
+   * extensions.add(AppLoaderPlugin);
+   * @memberof PIXI
+   */
+  var AppLoaderPlugin = /** @class */ (function () {
+      function AppLoaderPlugin() {
+      }
+      /**
+       * Called on application constructor
+       * @param options
+       * @private
+       */
+      AppLoaderPlugin.init = function (options) {
+          options = Object.assign({
+              sharedLoader: false,
+          }, options);
+          this.loader = options.sharedLoader ? Loader.shared : new Loader();
+      };
+      /**
+       * Called when application destroyed
+       * @private
+       */
+      AppLoaderPlugin.destroy = function () {
+          if (this.loader) {
+              this.loader.destroy();
+              this.loader = null;
+          }
+      };
+      /** @ignore */
+      AppLoaderPlugin.extension = exports.ExtensionType.Application;
+      return AppLoaderPlugin;
+  }());
 
-        return this;
-    };
+  /**
+   * Loader plugin for handling Texture resources.
+   * @memberof PIXI
+   */
+  var TextureLoader = /** @class */ (function () {
+      function TextureLoader() {
+      }
+      /** Handle SVG elements a text, render with SVGResource. */
+      TextureLoader.add = function () {
+          exports.LoaderResource.setExtensionLoadType('svg', exports.LoaderResource.LOAD_TYPE.XHR);
+          exports.LoaderResource.setExtensionXhrType('svg', exports.LoaderResource.XHR_RESPONSE_TYPE.TEXT);
+      };
+      /**
+       * Called after a resource is loaded.
+       * @see PIXI.Loader.loaderMiddleware
+       * @param resource
+       * @param {Function} next
+       */
+      TextureLoader.use = function (resource, next) {
+          // create a new texture if the data is an Image object
+          if (resource.data && (resource.type === exports.LoaderResource.TYPE.IMAGE || resource.extension === 'svg')) {
+              var data = resource.data, url = resource.url, name = resource.name, metadata = resource.metadata;
+              Texture.fromLoader(data, url, name, metadata).then(function (texture) {
+                  resource.texture = texture;
+                  next();
+              })
+                  // TODO: handle errors in Texture.fromLoader
+                  // so we can pass them to the Loader
+                  .catch(next);
+          }
+          else {
+              next();
+          }
+      };
+      /** @ignore */
+      TextureLoader.extension = exports.ExtensionType.Loader;
+      return TextureLoader;
+  }());
 
-    /**
-     * Adds hooks for uploading items.
-     *
-     * @param {Function} uploadHook - Function call that takes two parameters: `prepare:CanvasPrepare, item:*` and
-     *          function must return `true` if it was able to handle upload of item.
-     * @return {PIXI.BasePrepare} Instance of plugin for chaining.
-     */
+  var _keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+  /**
+   * Encodes binary into base64.
+   * @function encodeBinary
+   * @param {string} input - The input data to encode.
+   * @returns {string} The encoded base64 string
+   */
+  function encodeBinary(input) {
+      var output = '';
+      var inx = 0;
+      while (inx < input.length) {
+          // Fill byte buffer array
+          var bytebuffer = [0, 0, 0];
+          var encodedCharIndexes = [0, 0, 0, 0];
+          for (var jnx = 0; jnx < bytebuffer.length; ++jnx) {
+              if (inx < input.length) {
+                  // throw away high-order byte, as documented at:
+                  // https://developer.mozilla.org/En/Using_XMLHttpRequest#Handling_binary_data
+                  bytebuffer[jnx] = input.charCodeAt(inx++) & 0xff;
+              }
+              else {
+                  bytebuffer[jnx] = 0;
+              }
+          }
+          // Get each encoded character, 6 bits at a time
+          // index 1: first 6 bits
+          encodedCharIndexes[0] = bytebuffer[0] >> 2;
+          // index 2: second 6 bits (2 least significant bits from input byte 1 + 4 most significant bits from byte 2)
+          encodedCharIndexes[1] = ((bytebuffer[0] & 0x3) << 4) | (bytebuffer[1] >> 4);
+          // index 3: third 6 bits (4 least significant bits from input byte 2 + 2 most significant bits from byte 3)
+          encodedCharIndexes[2] = ((bytebuffer[1] & 0x0f) << 2) | (bytebuffer[2] >> 6);
+          // index 3: forth 6 bits (6 least significant bits from input byte 3)
+          encodedCharIndexes[3] = bytebuffer[2] & 0x3f;
+          // Determine whether padding happened, and adjust accordingly
+          var paddingBytes = inx - (input.length - 1);
+          switch (paddingBytes) {
+              case 2:
+                  // Set last 2 characters to padding char
+                  encodedCharIndexes[3] = 64;
+                  encodedCharIndexes[2] = 64;
+                  break;
+              case 1:
+                  // Set last character to padding char
+                  encodedCharIndexes[3] = 64;
+                  break;
+          }
+          // Now we will grab each appropriate character out of our keystring
+          // based on our index array and append it to the output string
+          for (var jnx = 0; jnx < encodedCharIndexes.length; ++jnx) {
+              output += _keyStr.charAt(encodedCharIndexes[jnx]);
+          }
+      }
+      return output;
+  }
 
+  /**
+   * A middleware for transforming XHR loaded Blobs into more useful objects
+   * @ignore
+   * @function parsing
+   * @example
+   * import { Loader, middleware } from 'resource-loader';
+   * const loader = new Loader();
+   * loader.use(middleware.parsing);
+   * @param resource - Current Resource
+   * @param next - Callback when complete
+   */
+  function parsing(resource, next) {
+      if (!resource.data) {
+          next();
+          return;
+      }
+      // if this was an XHR load of a blob
+      if (resource.xhr && resource.xhrType === exports.LoaderResource.XHR_RESPONSE_TYPE.BLOB) {
+          // if there is no blob support we probably got a binary string back
+          if (!self.Blob || typeof resource.data === 'string') {
+              var type = resource.xhr.getResponseHeader('content-type');
+              // this is an image, convert the binary string into a data url
+              if (type && type.indexOf('image') === 0) {
+                  resource.data = new Image();
+                  resource.data.src = "data:" + type + ";base64," + encodeBinary(resource.xhr.responseText);
+                  resource.type = exports.LoaderResource.TYPE.IMAGE;
+                  // wait until the image loads and then callback
+                  resource.data.onload = function () {
+                      resource.data.onload = null;
+                      next();
+                  };
+                  // next will be called on load
+                  return;
+              }
+          }
+          // if content type says this is an image, then we should transform the blob into an Image object
+          else if (resource.data.type.indexOf('image') === 0) {
+              var Url_1 = globalThis.URL || globalThis.webkitURL;
+              var src_1 = Url_1.createObjectURL(resource.data);
+              resource.blob = resource.data;
+              resource.data = new Image();
+              resource.data.src = src_1;
+              resource.type = exports.LoaderResource.TYPE.IMAGE;
+              // cleanup the no longer used blob after the image loads
+              // TODO: Is this correct? Will the image be invalid after revoking?
+              resource.data.onload = function () {
+                  Url_1.revokeObjectURL(src_1);
+                  resource.data.onload = null;
+                  next();
+              };
+              // next will be called on load.
+              return;
+          }
+      }
+      next();
+  }
 
-    BasePrepare.prototype.registerUploadHook = function registerUploadHook(uploadHook) {
-        if (uploadHook) {
-            this.uploadHooks.push(uploadHook);
-        }
+  /**
+   * Parse any blob into more usable objects (e.g. Image).
+   * @memberof PIXI
+   */
+  var ParsingLoader = /** @class */ (function () {
+      function ParsingLoader() {
+      }
+      /** @ignore */
+      ParsingLoader.extension = exports.ExtensionType.Loader;
+      ParsingLoader.use = parsing;
+      return ParsingLoader;
+  }());
 
-        return this;
-    };
+  extensions.add(TextureLoader, ParsingLoader);
 
-    /**
-     * Manually add an item to the uploading queue.
-     *
-     * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text|*} item - Object to
-     *        add to the queue
-     * @return {PIXI.CanvasPrepare} Instance of plugin for chaining.
-     */
-
-
-    BasePrepare.prototype.add = function add(item) {
-        // Add additional hooks for finding elements on special
-        // types of objects that
-        for (var i = 0, len = this.addHooks.length; i < len; i++) {
-            if (this.addHooks[i](item, this.queue)) {
-                break;
-            }
-        }
+  /*!
+   * @pixi/compressed-textures - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/compressed-textures is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-        // Get childen recursively
-        if (item instanceof core.Container) {
-            for (var _i2 = item.children.length - 1; _i2 >= 0; _i2--) {
-                this.add(item.children[_i2]);
-            }
-        }
+  var _a$2;
+  /**
+   * WebGL internal formats, including compressed texture formats provided by extensions
+   * @memberof PIXI
+   * @static
+   * @name INTERNAL_FORMATS
+   * @enum {number}
+   * @property {number} [COMPRESSED_RGB_S3TC_DXT1_EXT=0x83F0] -
+   * @property {number} [COMPRESSED_RGBA_S3TC_DXT1_EXT=0x83F1] -
+   * @property {number} [COMPRESSED_RGBA_S3TC_DXT3_EXT=0x83F2] -
+   * @property {number} [COMPRESSED_RGBA_S3TC_DXT5_EXT=0x83F3] -
+   * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=35917] -
+   * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=35918] -
+   * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=35919] -
+   * @property {number} [COMPRESSED_SRGB_S3TC_DXT1_EXT=35916] -
+   * @property {number} [COMPRESSED_R11_EAC=0x9270] -
+   * @property {number} [COMPRESSED_SIGNED_R11_EAC=0x9271] -
+   * @property {number} [COMPRESSED_RG11_EAC=0x9272] -
+   * @property {number} [COMPRESSED_SIGNED_RG11_EAC=0x9273] -
+   * @property {number} [COMPRESSED_RGB8_ETC2=0x9274] -
+   * @property {number} [COMPRESSED_RGBA8_ETC2_EAC=0x9278] -
+   * @property {number} [COMPRESSED_SRGB8_ETC2=0x9275] -
+   * @property {number} [COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=0x9279] -
+   * @property {number} [COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=0x9276] -
+   * @property {number} [COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=0x9277] -
+   * @property {number} [COMPRESSED_RGB_PVRTC_4BPPV1_IMG=0x8C00] -
+   * @property {number} [COMPRESSED_RGBA_PVRTC_4BPPV1_IMG=0x8C02] -
+   * @property {number} [COMPRESSED_RGB_PVRTC_2BPPV1_IMG=0x8C01] -
+   * @property {number} [COMPRESSED_RGBA_PVRTC_2BPPV1_IMG=0x8C03] -
+   * @property {number} [COMPRESSED_RGB_ETC1_WEBGL=0x8D64] -
+   * @property {number} [COMPRESSED_RGB_ATC_WEBGL=0x8C92] -
+   * @property {number} [COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL=0x8C92] -
+   * @property {number} [COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL=0x87EE] -
+   * @property {number} [COMPRESSED_RGBA_ASTC_4x4_KHR=0x93B0] -
+   */
+  exports.INTERNAL_FORMATS = void 0;
+  (function (INTERNAL_FORMATS) {
+      // WEBGL_compressed_texture_s3tc
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT";
+      // WEBGL_compressed_texture_s3tc_srgb
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT";
+      // WEBGL_compressed_texture_etc
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA8_ETC2_EAC"] = 37496] = "COMPRESSED_RGBA8_ETC2_EAC";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ETC2"] = 37493] = "COMPRESSED_SRGB8_ETC2";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37497] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37494] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37495] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+      // WEBGL_compressed_texture_pvrtc
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG";
+      // WEBGL_compressed_texture_etc1
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL";
+      // WEBGL_compressed_texture_atc
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL";
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL";
+      // WEBGL_compressed_texture_astc
+      /* eslint-disable-next-line camelcase */
+      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR";
+  })(exports.INTERNAL_FORMATS || (exports.INTERNAL_FORMATS = {}));
+  /**
+   * Maps the compressed texture formats in {@link PIXI.INTERNAL_FORMATS} to the number of bytes taken by
+   * each texel.
+   * @memberof PIXI
+   * @static
+   * @ignore
+   */
+  var INTERNAL_FORMAT_TO_BYTES_PER_PIXEL = (_a$2 = {},
+      // WEBGL_compressed_texture_s3tc
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_S3TC_DXT1_EXT] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT] = 1,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT] = 1,
+      // WEBGL_compressed_texture_s3tc
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_S3TC_DXT1_EXT] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT] = 1,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT] = 1,
+      // WEBGL_compressed_texture_etc
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_R11_EAC] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SIGNED_R11_EAC] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RG11_EAC] = 1,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SIGNED_RG11_EAC] = 1,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB8_ETC2] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA8_ETC2_EAC] = 1,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB8_ETC2] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC] = 1,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 0.5,
+      // WEBGL_compressed_texture_pvrtc
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = 0.25,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = 0.25,
+      // WEBGL_compressed_texture_etc1
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_ETC1_WEBGL] = 0.5,
+      // @see https://www.khronos.org/registry/OpenGL/extensions/AMD/AMD_compressed_ATC_texture.txt
+      // WEBGL_compressed_texture_atc
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_ATC_WEBGL] = 0.5,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = 1,
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = 1,
+      // @see https://registry.khronos.org/OpenGL/extensions/KHR/KHR_texture_compression_astc_hdr.txt
+      // WEBGL_compressed_texture_astc
+      /* eslint-disable-next-line camelcase */
+      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_4x4_KHR] = 1,
+      _a$2);
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$g = function(d, b) {
+      extendStatics$g = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$g(d, b);
+  };
 
-        return this;
-    };
+  function __extends$g(d, b) {
+      extendStatics$g(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-    /**
-     * Destroys the plugin, don't use after this.
-     *
-     */
+  function __awaiter(thisArg, _arguments, P, generator) {
+      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+      return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  }
 
+  function __generator(thisArg, body) {
+      var _ = { label: 0, sent: function() { if (t[0] & 1) { throw t[1]; } return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      function step(op) {
+          if (f) { throw new TypeError("Generator is already executing."); }
+          while (_) { try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) { return t; }
+              if (y = 0, t) { op = [op[0] & 2, t.value]; }
+              switch (op[0]) {
+                  case 0: case 1: t = op; break;
+                  case 4: _.label++; return { value: op[1], done: false };
+                  case 5: _.label++; y = op[1]; op = [0]; continue;
+                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                  default:
+                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                      if (t[2]) { _.ops.pop(); }
+                      _.trys.pop(); continue;
+              }
+              op = body.call(thisArg, _);
+          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } }
+          if (op[0] & 5) { throw op[1]; } return { value: op[0] ? op[1] : void 0, done: true };
+      }
+  }
 
-    BasePrepare.prototype.destroy = function destroy() {
-        if (this.ticking) {
-            SharedTicker.remove(this.tick, this);
-        }
-        this.ticking = false;
-        this.addHooks = null;
-        this.uploadHooks = null;
-        this.renderer = null;
-        this.completes = null;
-        this.queue = null;
-        this.limiter = null;
-        this.uploadHookHelper = null;
-    };
+  /**
+   * Resource that fetches texture data over the network and stores it in a buffer.
+   * @class
+   * @extends PIXI.Resource
+   * @memberof PIXI
+   */
+  var BlobResource = /** @class */ (function (_super) {
+      __extends$g(BlobResource, _super);
+      /**
+       * @param {string} source - the URL of the texture file
+       * @param {PIXI.IBlobOptions} options
+       * @param {boolean}[options.autoLoad] - whether to fetch the data immediately;
+       *  you can fetch it later via {@link BlobResource#load}
+       * @param {boolean}[options.width] - the width in pixels.
+       * @param {boolean}[options.height] - the height in pixels.
+       */
+      function BlobResource(source, options) {
+          if (options === void 0) { options = { width: 1, height: 1, autoLoad: true }; }
+          var _this = this;
+          var origin;
+          var data;
+          if (typeof source === 'string') {
+              origin = source;
+              data = new Uint8Array();
+          }
+          else {
+              origin = null;
+              data = source;
+          }
+          _this = _super.call(this, data, options) || this;
+          /**
+           * The URL of the texture file
+           * @member {string}
+           */
+          _this.origin = origin;
+          /**
+           * The viewable buffer on the data
+           * @member {ViewableBuffer}
+           */
+          // HINT: BlobResource allows "null" sources, assuming the child class provides an alternative
+          _this.buffer = data ? new ViewableBuffer(data) : null;
+          // Allow autoLoad = "undefined" still load the resource by default
+          if (_this.origin && options.autoLoad !== false) {
+              _this.load();
+          }
+          if (data && data.length) {
+              _this.loaded = true;
+              _this.onBlobLoaded(_this.buffer.rawBinaryData);
+          }
+          return _this;
+      }
+      BlobResource.prototype.onBlobLoaded = function (_data) {
+          // TODO: Override this method
+      };
+      /** Loads the blob */
+      BlobResource.prototype.load = function () {
+          return __awaiter(this, void 0, Promise, function () {
+              var response, blob, arrayBuffer;
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0: return [4 /*yield*/, fetch(this.origin)];
+                      case 1:
+                          response = _a.sent();
+                          return [4 /*yield*/, response.blob()];
+                      case 2:
+                          blob = _a.sent();
+                          return [4 /*yield*/, blob.arrayBuffer()];
+                      case 3:
+                          arrayBuffer = _a.sent();
+                          this.data = new Uint32Array(arrayBuffer);
+                          this.buffer = new ViewableBuffer(arrayBuffer);
+                          this.loaded = true;
+                          this.onBlobLoaded(arrayBuffer);
+                          this.update();
+                          return [2 /*return*/, this];
+                  }
+              });
+          });
+      };
+      return BlobResource;
+  }(BufferResource));
 
-    return BasePrepare;
-}();
+  /**
+   * Resource for compressed texture formats, as follows: S3TC/DXTn (& their sRGB formats), ATC, ASTC, ETC 1/2, PVRTC.
+   *
+   * Compressed textures improve performance when rendering is texture-bound. The texture data stays compressed in
+   * graphics memory, increasing memory locality and speeding up texture fetches. These formats can also be used to store
+   * more detail in the same amount of memory.
+   *
+   * For most developers, container file formats are a better abstraction instead of directly handling raw texture
+   * data. PixiJS provides native support for the following texture file formats (via {@link PIXI.Loader}):
+   *
+   * **.dds** - the DirectDraw Surface file format stores DXTn (DXT-1,3,5) data. See {@link PIXI.DDSLoader}
+   * **.ktx** - the Khronos Texture Container file format supports storing all the supported WebGL compression formats.
+   *  See {@link PIXI.KTXLoader}.
+   * **.basis** - the BASIS supercompressed file format stores texture data in an internal format that is transcoded
+   *  to the compression format supported on the device at _runtime_. It also supports transcoding into a uncompressed
+   *  format as a fallback; you must install the `@pixi/basis-loader`, `@pixi/basis-transcoder` packages separately to
+   *  use these files. See {@link PIXI.BasisLoader}.
+   *
+   * The loaders for the aforementioned formats use `CompressedTextureResource` internally. It is strongly suggested that
+   * they be used instead.
+   *
+   * ## Working directly with CompressedTextureResource
+   *
+   * Since `CompressedTextureResource` inherits `BlobResource`, you can provide it a URL pointing to a file containing
+   * the raw texture data (with no file headers!):
+   *
+   * ```js
+   * // The resource backing the texture data for your textures.
+   * // NOTE: You can also provide a ArrayBufferView instead of a URL. This is used when loading data from a container file
+   * //   format such as KTX, DDS, or BASIS.
+   * const compressedResource = new PIXI.CompressedTextureResource("bunny.dxt5", {
+   *   format: PIXI.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+   *   width: 256,
+   *   height: 256
+   * });
+   *
+   * // You can create a base-texture to the cache, so that future `Texture`s can be created using the `Texture.from` API.
+   * const baseTexture = new PIXI.BaseTexture(compressedResource, { pmaMode: PIXI.ALPHA_MODES.NPM });
+   *
+   * // Create a Texture to add to the TextureCache
+   * const texture = new PIXI.Texture(baseTexture);
+   *
+   * // Add baseTexture & texture to the global texture cache
+   * PIXI.BaseTexture.addToCache(baseTexture, "bunny.dxt5");
+   * PIXI.Texture.addToCache(texture, "bunny.dxt5");
+   * ```
+   * @memberof PIXI
+   */
+  var CompressedTextureResource = /** @class */ (function (_super) {
+      __extends$g(CompressedTextureResource, _super);
+      /**
+       * @param source - the buffer/URL holding the compressed texture data
+       * @param options
+       * @param {PIXI.INTERNAL_FORMATS} options.format - the compression format
+       * @param {number} options.width - the image width in pixels.
+       * @param {number} options.height - the image height in pixels.
+       * @param {number} [options.level=1] - the mipmap levels stored in the compressed texture, including level 0.
+       * @param {number} [options.levelBuffers] - the buffers for each mipmap level. `CompressedTextureResource` can allows you
+       *      to pass `null` for `source`, for cases where each level is stored in non-contiguous memory.
+       */
+      function CompressedTextureResource(source, options) {
+          var _this = _super.call(this, source, options) || this;
+          _this.format = options.format;
+          _this.levels = options.levels || 1;
+          _this._width = options.width;
+          _this._height = options.height;
+          _this._extension = CompressedTextureResource._formatToExtension(_this.format);
+          if (options.levelBuffers || _this.buffer) {
+              // ViewableBuffer doesn't support byteOffset :-( so allow source to be Uint8Array
+              _this._levelBuffers = options.levelBuffers
+                  || CompressedTextureResource._createLevelBuffers(source instanceof Uint8Array ? source : _this.buffer.uint8View, _this.format, _this.levels, 4, 4, // PVRTC has 8x4 blocks in 2bpp mode
+                  _this.width, _this.height);
+          }
+          return _this;
+      }
+      /**
+       * @override
+       * @param renderer - A reference to the current renderer
+       * @param _texture - the texture
+       * @param _glTexture - texture instance for this webgl context
+       */
+      CompressedTextureResource.prototype.upload = function (renderer, _texture, _glTexture) {
+          var gl = renderer.gl;
+          var extension = renderer.context.extensions[this._extension];
+          if (!extension) {
+              throw new Error(this._extension + " textures are not supported on the current machine");
+          }
+          if (!this._levelBuffers) {
+              // Do not try to upload data before BlobResource loads, unless the levelBuffers were provided directly!
+              return false;
+          }
+          for (var i = 0, j = this.levels; i < j; i++) {
+              var _a = this._levelBuffers[i], levelID = _a.levelID, levelWidth = _a.levelWidth, levelHeight = _a.levelHeight, levelBuffer = _a.levelBuffer;
+              gl.compressedTexImage2D(gl.TEXTURE_2D, levelID, this.format, levelWidth, levelHeight, 0, levelBuffer);
+          }
+          return true;
+      };
+      /** @protected */
+      CompressedTextureResource.prototype.onBlobLoaded = function () {
+          this._levelBuffers = CompressedTextureResource._createLevelBuffers(this.buffer.uint8View, this.format, this.levels, 4, 4, // PVRTC has 8x4 blocks in 2bpp mode
+          this.width, this.height);
+      };
+      /**
+       * Returns the key (to ContextSystem#extensions) for the WebGL extension supporting the compression format
+       * @private
+       * @param format - the compression format to get the extension for.
+       */
+      CompressedTextureResource._formatToExtension = function (format) {
+          if (format >= 0x83F0 && format <= 0x83F3) {
+              return 's3tc';
+          }
+          else if (format >= 0x9270 && format <= 0x9279) {
+              return 'etc';
+          }
+          else if (format >= 0x8C00 && format <= 0x8C03) {
+              return 'pvrtc';
+          }
+          else if (format >= 0x8D64) {
+              return 'etc1';
+          }
+          else if (format >= 0x8C92 && format <= 0x87EE) {
+              return 'atc';
+          }
+          throw new Error('Invalid (compressed) texture format given!');
+      };
+      /**
+       * Pre-creates buffer views for each mipmap level
+       * @private
+       * @param buffer -
+       * @param format - compression formats
+       * @param levels - mipmap levels
+       * @param blockWidth -
+       * @param blockHeight -
+       * @param imageWidth - width of the image in pixels
+       * @param imageHeight - height of the image in pixels
+       */
+      CompressedTextureResource._createLevelBuffers = function (buffer, format, levels, blockWidth, blockHeight, imageWidth, imageHeight) {
+          // The byte-size of the first level buffer
+          var buffers = new Array(levels);
+          var offset = buffer.byteOffset;
+          var levelWidth = imageWidth;
+          var levelHeight = imageHeight;
+          var alignedLevelWidth = (levelWidth + blockWidth - 1) & ~(blockWidth - 1);
+          var alignedLevelHeight = (levelHeight + blockHeight - 1) & ~(blockHeight - 1);
+          var levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];
+          for (var i = 0; i < levels; i++) {
+              buffers[i] = {
+                  levelID: i,
+                  levelWidth: levels > 1 ? levelWidth : alignedLevelWidth,
+                  levelHeight: levels > 1 ? levelHeight : alignedLevelHeight,
+                  levelBuffer: new Uint8Array(buffer.buffer, offset, levelSize)
+              };
+              offset += levelSize;
+              // Calculate levelBuffer dimensions for next iteration
+              levelWidth = (levelWidth >> 1) || 1;
+              levelHeight = (levelHeight >> 1) || 1;
+              alignedLevelWidth = (levelWidth + blockWidth - 1) & ~(blockWidth - 1);
+              alignedLevelHeight = (levelHeight + blockHeight - 1) & ~(blockHeight - 1);
+              levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];
+          }
+          return buffers;
+      };
+      return CompressedTextureResource;
+  }(BlobResource));
 
-/**
- * Built-in hook to find multiple textures from objects like AnimatedSprites.
- *
- * @private
- * @param {PIXI.DisplayObject} item - Display object to check
- * @param {Array<*>} queue - Collection of items to upload
- * @return {boolean} if a PIXI.Texture object was found.
- */
+  /* eslint-enable camelcase */
+  /**
+   * Loader plugin for handling compressed textures for all platforms.
+   * @class
+   * @memberof PIXI
+   * @implements {PIXI.ILoaderPlugin}
+   */
+  var CompressedTextureLoader = /** @class */ (function () {
+      function CompressedTextureLoader() {
+      }
+      /**
+       * Called after a compressed-textures manifest is loaded.
+       *
+       * This will then load the correct compression format for the device. Your manifest should adhere
+       * to the following schema:
+       *
+       * ```js
+       * import { INTERNAL_FORMATS } from '@pixi/constants';
+       *
+       * type CompressedTextureManifest = {
+       *  textures: Array<{ src: string, format?: keyof INTERNAL_FORMATS}>,
+       *  cacheID: string;
+       * };
+       * ```
+       *
+       * This is an example of a .json manifest file
+       *
+       * ```json
+       * {
+       *   "cacheID":"asset",
+       *   "textures":[
+       *     { "src":"asset.fallback.png" },
+       *     { "format":"COMPRESSED_RGBA_S3TC_DXT5_EXT", "src":"asset.s3tc.ktx" },
+       *     { "format":"COMPRESSED_RGBA8_ETC2_EAC", "src":"asset.etc.ktx" },
+       *     { "format":"RGBA_PVRTC_4BPPV1_IMG", "src":"asset.pvrtc.ktx" }
+       *   ]
+       * }
+       * ```
+       */
+      CompressedTextureLoader.use = function (resource, next) {
+          var data = resource.data;
+          var loader = this;
+          if (resource.type === exports.LoaderResource.TYPE.JSON
+              && data
+              && data.cacheID
+              && data.textures) {
+              var textures = data.textures;
+              var textureURL = void 0;
+              var fallbackURL = void 0;
+              // Search for an extension that holds one the formats
+              for (var i = 0, j = textures.length; i < j; i++) {
+                  var texture = textures[i];
+                  var url_1 = texture.src;
+                  var format = texture.format;
+                  if (!format) {
+                      fallbackURL = url_1;
+                  }
+                  if (CompressedTextureLoader.textureFormats[format]) {
+                      textureURL = url_1;
+                      break;
+                  }
+              }
+              textureURL = textureURL || fallbackURL;
+              // Make sure we have a URL
+              if (!textureURL) {
+                  next(new Error("Cannot load compressed-textures in " + resource.url + ", make sure you provide a fallback"));
+                  return;
+              }
+              if (textureURL === resource.url) {
+                  // Prevent infinite loops
+                  next(new Error('URL of compressed texture cannot be the same as the manifest\'s URL'));
+                  return;
+              }
+              var loadOptions = {
+                  crossOrigin: resource.crossOrigin,
+                  metadata: resource.metadata.imageMetadata,
+                  parentResource: resource
+              };
+              var resourcePath = url.resolve(resource.url.replace(loader.baseUrl, ''), textureURL);
+              var resourceName = data.cacheID;
+              // The appropriate loader should register the texture
+              loader.add(resourceName, resourcePath, loadOptions, function (res) {
+                  if (res.error) {
+                      next(res.error);
+                      return;
+                  }
+                  var _a = res.texture, texture = _a === void 0 ? null : _a, _b = res.textures, textures = _b === void 0 ? {} : _b;
+                  // Make sure texture/textures is assigned to parent resource
+                  Object.assign(resource, { texture: texture, textures: textures });
+                  // Pass along any error
+                  next();
+              });
+          }
+          else {
+              next();
+          }
+      };
+      Object.defineProperty(CompressedTextureLoader, "textureExtensions", {
+          /**  Map of available texture extensions. */
+          get: function () {
+              if (!CompressedTextureLoader._textureExtensions) {
+                  // Auto-detect WebGL compressed-texture extensions
+                  var canvas = settings.ADAPTER.createCanvas();
+                  var gl = canvas.getContext('webgl');
+                  if (!gl) {
+                      console.warn('WebGL not available for compressed textures. Silently failing.');
+                      return {};
+                  }
+                  var extensions = {
+                      s3tc: gl.getExtension('WEBGL_compressed_texture_s3tc'),
+                      s3tc_sRGB: gl.getExtension('WEBGL_compressed_texture_s3tc_srgb'),
+                      etc: gl.getExtension('WEBGL_compressed_texture_etc'),
+                      etc1: gl.getExtension('WEBGL_compressed_texture_etc1'),
+                      pvrtc: gl.getExtension('WEBGL_compressed_texture_pvrtc')
+                          || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+                      atc: gl.getExtension('WEBGL_compressed_texture_atc'),
+                      astc: gl.getExtension('WEBGL_compressed_texture_astc')
+                  };
+                  CompressedTextureLoader._textureExtensions = extensions;
+              }
+              return CompressedTextureLoader._textureExtensions;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(CompressedTextureLoader, "textureFormats", {
+          /** Map of available texture formats. */
+          get: function () {
+              if (!CompressedTextureLoader._textureFormats) {
+                  var extensions = CompressedTextureLoader.textureExtensions;
+                  CompressedTextureLoader._textureFormats = {};
+                  // Assign all available compressed-texture formats
+                  for (var extensionName in extensions) {
+                      var extension = extensions[extensionName];
+                      if (!extension) {
+                          continue;
+                      }
+                      Object.assign(CompressedTextureLoader._textureFormats, Object.getPrototypeOf(extension));
+                  }
+              }
+              return CompressedTextureLoader._textureFormats;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** @ignore */
+      CompressedTextureLoader.extension = exports.ExtensionType.Loader;
+      return CompressedTextureLoader;
+  }());
 
+  /**
+   * Creates base-textures and textures for each compressed-texture resource and adds them into the global
+   * texture cache. The first texture has two IDs - `${url}`, `${url}-1`; while the rest have an ID of the
+   * form `${url}-i`.
+   * @param url - the original address of the resources
+   * @param resources - the resources backing texture data
+   * @ignore
+   */
+  function registerCompressedTextures(url, resources, metadata) {
+      var result = {
+          textures: {},
+          texture: null,
+      };
+      if (!resources) {
+          return result;
+      }
+      var textures = resources.map(function (resource) {
+          return (new Texture(new BaseTexture(resource, Object.assign({
+              mipmap: exports.MIPMAP_MODES.OFF,
+              alphaMode: exports.ALPHA_MODES.NO_PREMULTIPLIED_ALPHA
+          }, metadata))));
+      });
+      textures.forEach(function (texture, i) {
+          var baseTexture = texture.baseTexture;
+          var cacheID = url + "-" + (i + 1);
+          BaseTexture.addToCache(baseTexture, cacheID);
+          Texture.addToCache(texture, cacheID);
+          if (i === 0) {
+              BaseTexture.addToCache(baseTexture, url);
+              Texture.addToCache(texture, url);
+              result.texture = texture;
+          }
+          result.textures[cacheID] = texture;
+      });
+      return result;
+  }
 
-exports.default = BasePrepare;
-function findMultipleBaseTextures(item, queue) {
-    var result = false;
+  var _a$1, _b$1;
+  var DDS_MAGIC_SIZE = 4;
+  var DDS_HEADER_SIZE = 124;
+  var DDS_HEADER_PF_SIZE = 32;
+  var DDS_HEADER_DX10_SIZE = 20;
+  // DDS file format magic word
+  var DDS_MAGIC = 0x20534444;
+  /**
+   * DWORD offsets of the DDS file header fields (relative to file start).
+   * @ignore
+   */
+  var DDS_FIELDS = {
+      SIZE: 1,
+      FLAGS: 2,
+      HEIGHT: 3,
+      WIDTH: 4,
+      MIPMAP_COUNT: 7,
+      PIXEL_FORMAT: 19,
+  };
+  /**
+   * DWORD offsets of the DDS PIXEL_FORMAT fields.
+   * @ignore
+   */
+  var DDS_PF_FIELDS = {
+      SIZE: 0,
+      FLAGS: 1,
+      FOURCC: 2,
+      RGB_BITCOUNT: 3,
+      R_BIT_MASK: 4,
+      G_BIT_MASK: 5,
+      B_BIT_MASK: 6,
+      A_BIT_MASK: 7
+  };
+  /**
+   * DWORD offsets of the DDS_HEADER_DX10 fields.
+   * @ignore
+   */
+  var DDS_DX10_FIELDS = {
+      DXGI_FORMAT: 0,
+      RESOURCE_DIMENSION: 1,
+      MISC_FLAG: 2,
+      ARRAY_SIZE: 3,
+      MISC_FLAGS2: 4
+  };
+  /**
+   * @see https://docs.microsoft.com/en-us/windows/win32/api/dxgiformat/ne-dxgiformat-dxgi_format
+   * @ignore
+   */
+  // This is way over-blown for us! Lend us a hand, and remove the ones that aren't used (but set the remaining
+  // ones to their correct value)
+  var DXGI_FORMAT;
+  (function (DXGI_FORMAT) {
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_UNKNOWN"] = 0] = "DXGI_FORMAT_UNKNOWN";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_TYPELESS"] = 1] = "DXGI_FORMAT_R32G32B32A32_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_FLOAT"] = 2] = "DXGI_FORMAT_R32G32B32A32_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_UINT"] = 3] = "DXGI_FORMAT_R32G32B32A32_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_SINT"] = 4] = "DXGI_FORMAT_R32G32B32A32_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_TYPELESS"] = 5] = "DXGI_FORMAT_R32G32B32_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_FLOAT"] = 6] = "DXGI_FORMAT_R32G32B32_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_UINT"] = 7] = "DXGI_FORMAT_R32G32B32_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_SINT"] = 8] = "DXGI_FORMAT_R32G32B32_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_TYPELESS"] = 9] = "DXGI_FORMAT_R16G16B16A16_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_FLOAT"] = 10] = "DXGI_FORMAT_R16G16B16A16_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_UNORM"] = 11] = "DXGI_FORMAT_R16G16B16A16_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_UINT"] = 12] = "DXGI_FORMAT_R16G16B16A16_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_SNORM"] = 13] = "DXGI_FORMAT_R16G16B16A16_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_SINT"] = 14] = "DXGI_FORMAT_R16G16B16A16_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_TYPELESS"] = 15] = "DXGI_FORMAT_R32G32_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_FLOAT"] = 16] = "DXGI_FORMAT_R32G32_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_UINT"] = 17] = "DXGI_FORMAT_R32G32_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_SINT"] = 18] = "DXGI_FORMAT_R32G32_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G8X24_TYPELESS"] = 19] = "DXGI_FORMAT_R32G8X24_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D32_FLOAT_S8X24_UINT"] = 20] = "DXGI_FORMAT_D32_FLOAT_S8X24_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS"] = 21] = "DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_X32_TYPELESS_G8X24_UINT"] = 22] = "DXGI_FORMAT_X32_TYPELESS_G8X24_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10A2_TYPELESS"] = 23] = "DXGI_FORMAT_R10G10B10A2_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10A2_UNORM"] = 24] = "DXGI_FORMAT_R10G10B10A2_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10A2_UINT"] = 25] = "DXGI_FORMAT_R10G10B10A2_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R11G11B10_FLOAT"] = 26] = "DXGI_FORMAT_R11G11B10_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_TYPELESS"] = 27] = "DXGI_FORMAT_R8G8B8A8_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_UNORM"] = 28] = "DXGI_FORMAT_R8G8B8A8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_UNORM_SRGB"] = 29] = "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_UINT"] = 30] = "DXGI_FORMAT_R8G8B8A8_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_SNORM"] = 31] = "DXGI_FORMAT_R8G8B8A8_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_SINT"] = 32] = "DXGI_FORMAT_R8G8B8A8_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_TYPELESS"] = 33] = "DXGI_FORMAT_R16G16_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_FLOAT"] = 34] = "DXGI_FORMAT_R16G16_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_UNORM"] = 35] = "DXGI_FORMAT_R16G16_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_UINT"] = 36] = "DXGI_FORMAT_R16G16_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_SNORM"] = 37] = "DXGI_FORMAT_R16G16_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_SINT"] = 38] = "DXGI_FORMAT_R16G16_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_TYPELESS"] = 39] = "DXGI_FORMAT_R32_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D32_FLOAT"] = 40] = "DXGI_FORMAT_D32_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_FLOAT"] = 41] = "DXGI_FORMAT_R32_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_UINT"] = 42] = "DXGI_FORMAT_R32_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_SINT"] = 43] = "DXGI_FORMAT_R32_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R24G8_TYPELESS"] = 44] = "DXGI_FORMAT_R24G8_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D24_UNORM_S8_UINT"] = 45] = "DXGI_FORMAT_D24_UNORM_S8_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R24_UNORM_X8_TYPELESS"] = 46] = "DXGI_FORMAT_R24_UNORM_X8_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_X24_TYPELESS_G8_UINT"] = 47] = "DXGI_FORMAT_X24_TYPELESS_G8_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_TYPELESS"] = 48] = "DXGI_FORMAT_R8G8_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_UNORM"] = 49] = "DXGI_FORMAT_R8G8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_UINT"] = 50] = "DXGI_FORMAT_R8G8_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_SNORM"] = 51] = "DXGI_FORMAT_R8G8_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_SINT"] = 52] = "DXGI_FORMAT_R8G8_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_TYPELESS"] = 53] = "DXGI_FORMAT_R16_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_FLOAT"] = 54] = "DXGI_FORMAT_R16_FLOAT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D16_UNORM"] = 55] = "DXGI_FORMAT_D16_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_UNORM"] = 56] = "DXGI_FORMAT_R16_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_UINT"] = 57] = "DXGI_FORMAT_R16_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_SNORM"] = 58] = "DXGI_FORMAT_R16_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_SINT"] = 59] = "DXGI_FORMAT_R16_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_TYPELESS"] = 60] = "DXGI_FORMAT_R8_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_UNORM"] = 61] = "DXGI_FORMAT_R8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_UINT"] = 62] = "DXGI_FORMAT_R8_UINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_SNORM"] = 63] = "DXGI_FORMAT_R8_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_SINT"] = 64] = "DXGI_FORMAT_R8_SINT";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_A8_UNORM"] = 65] = "DXGI_FORMAT_A8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R1_UNORM"] = 66] = "DXGI_FORMAT_R1_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R9G9B9E5_SHAREDEXP"] = 67] = "DXGI_FORMAT_R9G9B9E5_SHAREDEXP";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_B8G8_UNORM"] = 68] = "DXGI_FORMAT_R8G8_B8G8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_G8R8_G8B8_UNORM"] = 69] = "DXGI_FORMAT_G8R8_G8B8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC1_TYPELESS"] = 70] = "DXGI_FORMAT_BC1_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC1_UNORM"] = 71] = "DXGI_FORMAT_BC1_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC1_UNORM_SRGB"] = 72] = "DXGI_FORMAT_BC1_UNORM_SRGB";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC2_TYPELESS"] = 73] = "DXGI_FORMAT_BC2_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC2_UNORM"] = 74] = "DXGI_FORMAT_BC2_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC2_UNORM_SRGB"] = 75] = "DXGI_FORMAT_BC2_UNORM_SRGB";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC3_TYPELESS"] = 76] = "DXGI_FORMAT_BC3_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC3_UNORM"] = 77] = "DXGI_FORMAT_BC3_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC3_UNORM_SRGB"] = 78] = "DXGI_FORMAT_BC3_UNORM_SRGB";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC4_TYPELESS"] = 79] = "DXGI_FORMAT_BC4_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC4_UNORM"] = 80] = "DXGI_FORMAT_BC4_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC4_SNORM"] = 81] = "DXGI_FORMAT_BC4_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC5_TYPELESS"] = 82] = "DXGI_FORMAT_BC5_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC5_UNORM"] = 83] = "DXGI_FORMAT_BC5_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC5_SNORM"] = 84] = "DXGI_FORMAT_BC5_SNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B5G6R5_UNORM"] = 85] = "DXGI_FORMAT_B5G6R5_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B5G5R5A1_UNORM"] = 86] = "DXGI_FORMAT_B5G5R5A1_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8A8_UNORM"] = 87] = "DXGI_FORMAT_B8G8R8A8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8X8_UNORM"] = 88] = "DXGI_FORMAT_B8G8R8X8_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM"] = 89] = "DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8A8_TYPELESS"] = 90] = "DXGI_FORMAT_B8G8R8A8_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8A8_UNORM_SRGB"] = 91] = "DXGI_FORMAT_B8G8R8A8_UNORM_SRGB";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8X8_TYPELESS"] = 92] = "DXGI_FORMAT_B8G8R8X8_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8X8_UNORM_SRGB"] = 93] = "DXGI_FORMAT_B8G8R8X8_UNORM_SRGB";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC6H_TYPELESS"] = 94] = "DXGI_FORMAT_BC6H_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC6H_UF16"] = 95] = "DXGI_FORMAT_BC6H_UF16";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC6H_SF16"] = 96] = "DXGI_FORMAT_BC6H_SF16";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC7_TYPELESS"] = 97] = "DXGI_FORMAT_BC7_TYPELESS";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC7_UNORM"] = 98] = "DXGI_FORMAT_BC7_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC7_UNORM_SRGB"] = 99] = "DXGI_FORMAT_BC7_UNORM_SRGB";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_AYUV"] = 100] = "DXGI_FORMAT_AYUV";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y410"] = 101] = "DXGI_FORMAT_Y410";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y416"] = 102] = "DXGI_FORMAT_Y416";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_NV12"] = 103] = "DXGI_FORMAT_NV12";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P010"] = 104] = "DXGI_FORMAT_P010";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P016"] = 105] = "DXGI_FORMAT_P016";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_420_OPAQUE"] = 106] = "DXGI_FORMAT_420_OPAQUE";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_YUY2"] = 107] = "DXGI_FORMAT_YUY2";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y210"] = 108] = "DXGI_FORMAT_Y210";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y216"] = 109] = "DXGI_FORMAT_Y216";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_NV11"] = 110] = "DXGI_FORMAT_NV11";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_AI44"] = 111] = "DXGI_FORMAT_AI44";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_IA44"] = 112] = "DXGI_FORMAT_IA44";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P8"] = 113] = "DXGI_FORMAT_P8";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_A8P8"] = 114] = "DXGI_FORMAT_A8P8";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B4G4R4A4_UNORM"] = 115] = "DXGI_FORMAT_B4G4R4A4_UNORM";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P208"] = 116] = "DXGI_FORMAT_P208";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_V208"] = 117] = "DXGI_FORMAT_V208";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_V408"] = 118] = "DXGI_FORMAT_V408";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE"] = 119] = "DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE"] = 120] = "DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE";
+      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_FORCE_UINT"] = 121] = "DXGI_FORMAT_FORCE_UINT";
+  })(DXGI_FORMAT || (DXGI_FORMAT = {}));
+  /**
+   * Possible values of the field {@link DDS_DX10_FIELDS.RESOURCE_DIMENSION}
+   * @ignore
+   */
+  var D3D10_RESOURCE_DIMENSION;
+  (function (D3D10_RESOURCE_DIMENSION) {
+      D3D10_RESOURCE_DIMENSION[D3D10_RESOURCE_DIMENSION["DDS_DIMENSION_TEXTURE1D"] = 2] = "DDS_DIMENSION_TEXTURE1D";
+      D3D10_RESOURCE_DIMENSION[D3D10_RESOURCE_DIMENSION["DDS_DIMENSION_TEXTURE2D"] = 3] = "DDS_DIMENSION_TEXTURE2D";
+      D3D10_RESOURCE_DIMENSION[D3D10_RESOURCE_DIMENSION["DDS_DIMENSION_TEXTURE3D"] = 6] = "DDS_DIMENSION_TEXTURE3D";
+  })(D3D10_RESOURCE_DIMENSION || (D3D10_RESOURCE_DIMENSION = {}));
+  var PF_FLAGS = 1;
+  // PIXEL_FORMAT flags
+  var DDPF_ALPHA = 0x2;
+  var DDPF_FOURCC = 0x4;
+  var DDPF_RGB = 0x40;
+  var DDPF_YUV = 0x200;
+  var DDPF_LUMINANCE = 0x20000;
+  // Four character codes for DXTn formats
+  var FOURCC_DXT1 = 0x31545844;
+  var FOURCC_DXT3 = 0x33545844;
+  var FOURCC_DXT5 = 0x35545844;
+  var FOURCC_DX10 = 0x30315844;
+  // Cubemap texture flag (for DDS_DX10_FIELDS.MISC_FLAG)
+  var DDS_RESOURCE_MISC_TEXTURECUBE = 0x4;
+  /**
+   * Maps `FOURCC_*` formats to internal formats (see {@link PIXI.INTERNAL_FORMATS}).
+   * @ignore
+   */
+  var FOURCC_TO_FORMAT = (_a$1 = {},
+      _a$1[FOURCC_DXT1] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+      _a$1[FOURCC_DXT3] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+      _a$1[FOURCC_DXT5] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+      _a$1);
+  /**
+   * Maps {@link DXGI_FORMAT} to types/internal-formats (see {@link PIXI.TYPES}, {@link PIXI.INTERNAL_FORMATS})
+   * @ignore
+   */
+  var DXGI_TO_FORMAT = (_b$1 = {},
+      // WEBGL_compressed_texture_s3tc
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC1_TYPELESS] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC2_TYPELESS] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC3_TYPELESS] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+      // WEBGL_compressed_texture_s3tc_srgb
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM_SRGB] = exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM_SRGB] = exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM_SRGB] = exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
+      _b$1);
+  /**
+   * @class
+   * @memberof PIXI
+   * @implements {PIXI.ILoaderPlugin}
+   * @see https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide
+   */
+  /**
+   * Parses the DDS file header, generates base-textures, and puts them into the texture cache.
+   * @param arrayBuffer
+   */
+  function parseDDS(arrayBuffer) {
+      var data = new Uint32Array(arrayBuffer);
+      var magicWord = data[0];
+      if (magicWord !== DDS_MAGIC) {
+          throw new Error('Invalid DDS file magic word');
+      }
+      var header = new Uint32Array(arrayBuffer, 0, DDS_HEADER_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+      // DDS header fields
+      var height = header[DDS_FIELDS.HEIGHT];
+      var width = header[DDS_FIELDS.WIDTH];
+      var mipmapCount = header[DDS_FIELDS.MIPMAP_COUNT];
+      // PIXEL_FORMAT fields
+      var pixelFormat = new Uint32Array(arrayBuffer, DDS_FIELDS.PIXEL_FORMAT * Uint32Array.BYTES_PER_ELEMENT, DDS_HEADER_PF_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+      var formatFlags = pixelFormat[PF_FLAGS];
+      // File contains compressed texture(s)
+      if (formatFlags & DDPF_FOURCC) {
+          var fourCC = pixelFormat[DDS_PF_FIELDS.FOURCC];
+          // File contains one DXTn compressed texture
+          if (fourCC !== FOURCC_DX10) {
+              var internalFormat_1 = FOURCC_TO_FORMAT[fourCC];
+              var dataOffset_1 = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;
+              var texData = new Uint8Array(arrayBuffer, dataOffset_1);
+              var resource = new CompressedTextureResource(texData, {
+                  format: internalFormat_1,
+                  width: width,
+                  height: height,
+                  levels: mipmapCount // CompressedTextureResource will separate the levelBuffers for us!
+              });
+              return [resource];
+          }
+          // FOURCC_DX10 indicates there is a 20-byte DDS_HEADER_DX10 after DDS_HEADER
+          var dx10Offset = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;
+          var dx10Header = new Uint32Array(data.buffer, dx10Offset, DDS_HEADER_DX10_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+          var dxgiFormat = dx10Header[DDS_DX10_FIELDS.DXGI_FORMAT];
+          var resourceDimension = dx10Header[DDS_DX10_FIELDS.RESOURCE_DIMENSION];
+          var miscFlag = dx10Header[DDS_DX10_FIELDS.MISC_FLAG];
+          var arraySize = dx10Header[DDS_DX10_FIELDS.ARRAY_SIZE];
+          // Map dxgiFormat to PIXI.INTERNAL_FORMATS
+          var internalFormat_2 = DXGI_TO_FORMAT[dxgiFormat];
+          if (internalFormat_2 === undefined) {
+              throw new Error("DDSParser cannot parse texture data with DXGI format " + dxgiFormat);
+          }
+          if (miscFlag === DDS_RESOURCE_MISC_TEXTURECUBE) {
+              // FIXME: Anybody excited about cubemap compressed textures?
+              throw new Error('DDSParser does not support cubemap textures');
+          }
+          if (resourceDimension === D3D10_RESOURCE_DIMENSION.DDS_DIMENSION_TEXTURE3D) {
+              // FIXME: Anybody excited about 3D compressed textures?
+              throw new Error('DDSParser does not supported 3D texture data');
+          }
+          // Uint8Array buffers of image data, including all mipmap levels in each image
+          var imageBuffers = new Array();
+          var dataOffset = DDS_MAGIC_SIZE
+              + DDS_HEADER_SIZE
+              + DDS_HEADER_DX10_SIZE;
+          if (arraySize === 1) {
+              // No need bothering with the imageSize calculation!
+              imageBuffers.push(new Uint8Array(arrayBuffer, dataOffset));
+          }
+          else {
+              // Calculate imageSize for each texture, and then locate each image's texture data
+              var pixelSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[internalFormat_2];
+              var imageSize = 0;
+              var levelWidth = width;
+              var levelHeight = height;
+              for (var i = 0; i < mipmapCount; i++) {
+                  var alignedLevelWidth = Math.max(1, (levelWidth + 3) & ~3);
+                  var alignedLevelHeight = Math.max(1, (levelHeight + 3) & ~3);
+                  var levelSize = alignedLevelWidth * alignedLevelHeight * pixelSize;
+                  imageSize += levelSize;
+                  levelWidth = levelWidth >>> 1;
+                  levelHeight = levelHeight >>> 1;
+              }
+              var imageOffset = dataOffset;
+              // NOTE: Cubemaps have 6-images per texture (but they aren't supported so ^_^)
+              for (var i = 0; i < arraySize; i++) {
+                  imageBuffers.push(new Uint8Array(arrayBuffer, imageOffset, imageSize));
+                  imageOffset += imageSize;
+              }
+          }
+          // Uint8Array -> CompressedTextureResource, and we're done!
+          return imageBuffers.map(function (buffer) { return new CompressedTextureResource(buffer, {
+              format: internalFormat_2,
+              width: width,
+              height: height,
+              levels: mipmapCount
+          }); });
+      }
+      if (formatFlags & DDPF_RGB) {
+          // FIXME: We might want to allow uncompressed *.dds files?
+          throw new Error('DDSParser does not support uncompressed texture data.');
+      }
+      if (formatFlags & DDPF_YUV) {
+          // FIXME: Does anybody need this feature?
+          throw new Error('DDSParser does not supported YUV uncompressed texture data.');
+      }
+      if (formatFlags & DDPF_LUMINANCE) {
+          // FIXME: Microsoft says older DDS filers use this feature! Probably not worth the effort!
+          throw new Error('DDSParser does not support single-channel (lumninance) texture data!');
+      }
+      if (formatFlags & DDPF_ALPHA) {
+          // FIXME: I'm tired! See above =)
+          throw new Error('DDSParser does not support single-channel (alpha) texture data!');
+      }
+      throw new Error('DDSParser failed to load a texture file due to an unknown reason!');
+  }
 
-    // Objects with mutliple textures
-    if (item && item._textures && item._textures.length) {
-        for (var i = 0; i < item._textures.length; i++) {
-            if (item._textures[i] instanceof core.Texture) {
-                var baseTexture = item._textures[i].baseTexture;
+  var _a$3, _b, _c;
+  /**
+   * The 12-byte KTX file identifier
+   * @see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/#2.1
+   * @ignore
+   */
+  var FILE_IDENTIFIER = [0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A];
+  /**
+   * The value stored in the "endianness" field.
+   * @see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/#2.2
+   * @ignore
+   */
+  var ENDIANNESS = 0x04030201;
+  /**
+   * Byte offsets of the KTX file header fields
+   * @ignore
+   */
+  var KTX_FIELDS = {
+      FILE_IDENTIFIER: 0,
+      ENDIANNESS: 12,
+      GL_TYPE: 16,
+      GL_TYPE_SIZE: 20,
+      GL_FORMAT: 24,
+      GL_INTERNAL_FORMAT: 28,
+      GL_BASE_INTERNAL_FORMAT: 32,
+      PIXEL_WIDTH: 36,
+      PIXEL_HEIGHT: 40,
+      PIXEL_DEPTH: 44,
+      NUMBER_OF_ARRAY_ELEMENTS: 48,
+      NUMBER_OF_FACES: 52,
+      NUMBER_OF_MIPMAP_LEVELS: 56,
+      BYTES_OF_KEY_VALUE_DATA: 60
+  };
+  /**
+   * Byte size of the file header fields in {@code KTX_FIELDS}
+   * @ignore
+   */
+  var FILE_HEADER_SIZE = 64;
+  /**
+   * Maps {@link PIXI.TYPES} to the bytes taken per component, excluding those ones that are bit-fields.
+   * @ignore
+   */
+  var TYPES_TO_BYTES_PER_COMPONENT = (_a$3 = {},
+      _a$3[exports.TYPES.UNSIGNED_BYTE] = 1,
+      _a$3[exports.TYPES.UNSIGNED_SHORT] = 2,
+      _a$3[exports.TYPES.INT] = 4,
+      _a$3[exports.TYPES.UNSIGNED_INT] = 4,
+      _a$3[exports.TYPES.FLOAT] = 4,
+      _a$3[exports.TYPES.HALF_FLOAT] = 8,
+      _a$3);
+  /**
+   * Number of components in each {@link PIXI.FORMATS}
+   * @ignore
+   */
+  var FORMATS_TO_COMPONENTS = (_b = {},
+      _b[exports.FORMATS.RGBA] = 4,
+      _b[exports.FORMATS.RGB] = 3,
+      _b[exports.FORMATS.RG] = 2,
+      _b[exports.FORMATS.RED] = 1,
+      _b[exports.FORMATS.LUMINANCE] = 1,
+      _b[exports.FORMATS.LUMINANCE_ALPHA] = 2,
+      _b[exports.FORMATS.ALPHA] = 1,
+      _b);
+  /**
+   * Number of bytes per pixel in bit-field types in {@link PIXI.TYPES}
+   * @ignore
+   */
+  var TYPES_TO_BYTES_PER_PIXEL = (_c = {},
+      _c[exports.TYPES.UNSIGNED_SHORT_4_4_4_4] = 2,
+      _c[exports.TYPES.UNSIGNED_SHORT_5_5_5_1] = 2,
+      _c[exports.TYPES.UNSIGNED_SHORT_5_6_5] = 2,
+      _c);
+  function parseKTX(url, arrayBuffer, loadKeyValueData) {
+      if (loadKeyValueData === void 0) { loadKeyValueData = false; }
+      var dataView = new DataView(arrayBuffer);
+      if (!validate(url, dataView)) {
+          return null;
+      }
+      var littleEndian = dataView.getUint32(KTX_FIELDS.ENDIANNESS, true) === ENDIANNESS;
+      var glType = dataView.getUint32(KTX_FIELDS.GL_TYPE, littleEndian);
+      // const glTypeSize = dataView.getUint32(KTX_FIELDS.GL_TYPE_SIZE, littleEndian);
+      var glFormat = dataView.getUint32(KTX_FIELDS.GL_FORMAT, littleEndian);
+      var glInternalFormat = dataView.getUint32(KTX_FIELDS.GL_INTERNAL_FORMAT, littleEndian);
+      var pixelWidth = dataView.getUint32(KTX_FIELDS.PIXEL_WIDTH, littleEndian);
+      var pixelHeight = dataView.getUint32(KTX_FIELDS.PIXEL_HEIGHT, littleEndian) || 1; // "pixelHeight = 0" -> "1"
+      var pixelDepth = dataView.getUint32(KTX_FIELDS.PIXEL_DEPTH, littleEndian) || 1; // ^^
+      var numberOfArrayElements = dataView.getUint32(KTX_FIELDS.NUMBER_OF_ARRAY_ELEMENTS, littleEndian) || 1; // ^^
+      var numberOfFaces = dataView.getUint32(KTX_FIELDS.NUMBER_OF_FACES, littleEndian);
+      var numberOfMipmapLevels = dataView.getUint32(KTX_FIELDS.NUMBER_OF_MIPMAP_LEVELS, littleEndian);
+      var bytesOfKeyValueData = dataView.getUint32(KTX_FIELDS.BYTES_OF_KEY_VALUE_DATA, littleEndian);
+      // Whether the platform architecture is little endian. If littleEndian !== platformLittleEndian, then the
+      // file contents must be endian-converted!
+      // TODO: Endianness conversion
+      // const platformLittleEndian = new Uint8Array((new Uint32Array([ENDIANNESS])).buffer)[0] === 0x01;
+      if (pixelHeight === 0 || pixelDepth !== 1) {
+          throw new Error('Only 2D textures are supported');
+      }
+      if (numberOfFaces !== 1) {
+          throw new Error('CubeTextures are not supported by KTXLoader yet!');
+      }
+      if (numberOfArrayElements !== 1) {
+          // TODO: Support splitting array-textures into multiple BaseTextures
+          throw new Error('WebGL does not support array textures');
+      }
+      // TODO: 8x4 blocks for 2bpp pvrtc
+      var blockWidth = 4;
+      var blockHeight = 4;
+      var alignedWidth = (pixelWidth + 3) & ~3;
+      var alignedHeight = (pixelHeight + 3) & ~3;
+      var imageBuffers = new Array(numberOfArrayElements);
+      var imagePixels = pixelWidth * pixelHeight;
+      if (glType === 0) {
+          // Align to 16 pixels (4x4 blocks)
+          imagePixels = alignedWidth * alignedHeight;
+      }
+      var imagePixelByteSize;
+      if (glType !== 0) {
+          // Uncompressed texture format
+          if (TYPES_TO_BYTES_PER_COMPONENT[glType]) {
+              imagePixelByteSize = TYPES_TO_BYTES_PER_COMPONENT[glType] * FORMATS_TO_COMPONENTS[glFormat];
+          }
+          else {
+              imagePixelByteSize = TYPES_TO_BYTES_PER_PIXEL[glType];
+          }
+      }
+      else {
+          imagePixelByteSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[glInternalFormat];
+      }
+      if (imagePixelByteSize === undefined) {
+          throw new Error('Unable to resolve the pixel format stored in the *.ktx file!');
+      }
+      var kvData = loadKeyValueData
+          ? parseKvData(dataView, bytesOfKeyValueData, littleEndian)
+          : null;
+      var imageByteSize = imagePixels * imagePixelByteSize;
+      var mipByteSize = imageByteSize;
+      var mipWidth = pixelWidth;
+      var mipHeight = pixelHeight;
+      var alignedMipWidth = alignedWidth;
+      var alignedMipHeight = alignedHeight;
+      var imageOffset = FILE_HEADER_SIZE + bytesOfKeyValueData;
+      for (var mipmapLevel = 0; mipmapLevel < numberOfMipmapLevels; mipmapLevel++) {
+          var imageSize = dataView.getUint32(imageOffset, littleEndian);
+          var elementOffset = imageOffset + 4;
+          for (var arrayElement = 0; arrayElement < numberOfArrayElements; arrayElement++) {
+              // TODO: Maybe support 3D textures? :-)
+              // for (let zSlice = 0; zSlice < pixelDepth; zSlice)
+              var mips = imageBuffers[arrayElement];
+              if (!mips) {
+                  mips = imageBuffers[arrayElement] = new Array(numberOfMipmapLevels);
+              }
+              mips[mipmapLevel] = {
+                  levelID: mipmapLevel,
+                  // don't align mipWidth when texture not compressed! (glType not zero)
+                  levelWidth: numberOfMipmapLevels > 1 || glType !== 0 ? mipWidth : alignedMipWidth,
+                  levelHeight: numberOfMipmapLevels > 1 || glType !== 0 ? mipHeight : alignedMipHeight,
+                  levelBuffer: new Uint8Array(arrayBuffer, elementOffset, mipByteSize)
+              };
+              elementOffset += mipByteSize;
+          }
+          // HINT: Aligns to 4-byte boundary after jumping imageSize (in lieu of mipPadding)
+          imageOffset += imageSize + 4; // (+4 to jump the imageSize field itself)
+          imageOffset = imageOffset % 4 !== 0 ? imageOffset + 4 - (imageOffset % 4) : imageOffset;
+          // Calculate mipWidth, mipHeight for _next_ iteration
+          mipWidth = (mipWidth >> 1) || 1;
+          mipHeight = (mipHeight >> 1) || 1;
+          alignedMipWidth = (mipWidth + blockWidth - 1) & ~(blockWidth - 1);
+          alignedMipHeight = (mipHeight + blockHeight - 1) & ~(blockHeight - 1);
+          // Each mipmap level is 4-times smaller?
+          mipByteSize = alignedMipWidth * alignedMipHeight * imagePixelByteSize;
+      }
+      // We use the levelBuffers feature of CompressedTextureResource b/c texture data is image-major, not level-major.
+      if (glType !== 0) {
+          return {
+              uncompressed: imageBuffers.map(function (levelBuffers) {
+                  var buffer = levelBuffers[0].levelBuffer;
+                  var convertToInt = false;
+                  if (glType === exports.TYPES.FLOAT) {
+                      buffer = new Float32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
+                  }
+                  else if (glType === exports.TYPES.UNSIGNED_INT) {
+                      convertToInt = true;
+                      buffer = new Uint32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
+                  }
+                  else if (glType === exports.TYPES.INT) {
+                      convertToInt = true;
+                      buffer = new Int32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
+                  }
+                  return {
+                      resource: new BufferResource(buffer, {
+                          width: levelBuffers[0].levelWidth,
+                          height: levelBuffers[0].levelHeight,
+                      }),
+                      type: glType,
+                      format: convertToInt ? convertFormatToInteger(glFormat) : glFormat,
+                  };
+              }),
+              kvData: kvData
+          };
+      }
+      return {
+          compressed: imageBuffers.map(function (levelBuffers) { return new CompressedTextureResource(null, {
+              format: glInternalFormat,
+              width: pixelWidth,
+              height: pixelHeight,
+              levels: numberOfMipmapLevels,
+              levelBuffers: levelBuffers,
+          }); }),
+          kvData: kvData
+      };
+  }
+  /**
+   * Checks whether the arrayBuffer contains a valid *.ktx file.
+   * @param url
+   * @param dataView
+   */
+  function validate(url, dataView) {
+      // NOTE: Do not optimize this into 3 32-bit integer comparison because the endianness
+      // of the data is not specified.
+      for (var i = 0; i < FILE_IDENTIFIER.length; i++) {
+          if (dataView.getUint8(i) !== FILE_IDENTIFIER[i]) {
+              console.error(url + " is not a valid *.ktx file!");
+              return false;
+          }
+      }
+      return true;
+  }
+  function convertFormatToInteger(format) {
+      switch (format) {
+          case exports.FORMATS.RGBA: return exports.FORMATS.RGBA_INTEGER;
+          case exports.FORMATS.RGB: return exports.FORMATS.RGB_INTEGER;
+          case exports.FORMATS.RG: return exports.FORMATS.RG_INTEGER;
+          case exports.FORMATS.RED: return exports.FORMATS.RED_INTEGER;
+          default: return format;
+      }
+  }
+  function parseKvData(dataView, bytesOfKeyValueData, littleEndian) {
+      var kvData = new Map();
+      var bytesIntoKeyValueData = 0;
+      while (bytesIntoKeyValueData < bytesOfKeyValueData) {
+          var keyAndValueByteSize = dataView.getUint32(FILE_HEADER_SIZE + bytesIntoKeyValueData, littleEndian);
+          var keyAndValueByteOffset = FILE_HEADER_SIZE + bytesIntoKeyValueData + 4;
+          var valuePadding = 3 - ((keyAndValueByteSize + 3) % 4);
+          // Bounds check
+          if (keyAndValueByteSize === 0 || keyAndValueByteSize > bytesOfKeyValueData - bytesIntoKeyValueData) {
+              console.error('KTXLoader: keyAndValueByteSize out of bounds');
+              break;
+          }
+          // Note: keyNulByte can't be 0 otherwise the key is an empty string.
+          var keyNulByte = 0;
+          for (; keyNulByte < keyAndValueByteSize; keyNulByte++) {
+              if (dataView.getUint8(keyAndValueByteOffset + keyNulByte) === 0x00) {
+                  break;
+              }
+          }
+          if (keyNulByte === -1) {
+              console.error('KTXLoader: Failed to find null byte terminating kvData key');
+              break;
+          }
+          var key = new TextDecoder().decode(new Uint8Array(dataView.buffer, keyAndValueByteOffset, keyNulByte));
+          var value = new DataView(dataView.buffer, keyAndValueByteOffset + keyNulByte + 1, keyAndValueByteSize - keyNulByte - 1);
+          kvData.set(key, value);
+          // 4 = the keyAndValueByteSize field itself
+          // keyAndValueByteSize = the bytes taken by the key and value
+          // valuePadding = extra padding to align with 4 bytes
+          bytesIntoKeyValueData += 4 + keyAndValueByteSize + valuePadding;
+      }
+      return kvData;
+  }
 
-                if (queue.indexOf(baseTexture) === -1) {
-                    queue.push(baseTexture);
-                    result = true;
-                }
-            }
-        }
-    }
+  // Set DDS files to be loaded as an ArrayBuffer
+  exports.LoaderResource.setExtensionXhrType('dds', exports.LoaderResource.XHR_RESPONSE_TYPE.BUFFER);
+  /**
+   * @class
+   * @memberof PIXI
+   * @implements {PIXI.ILoaderPlugin}
+   * @see https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide
+   */
+  var DDSLoader = /** @class */ (function () {
+      function DDSLoader() {
+      }
+      /**
+       * Registers a DDS compressed texture
+       * @see PIXI.Loader.loaderMiddleware
+       * @param resource - loader resource that is checked to see if it is a DDS file
+       * @param next - callback Function to call when done
+       */
+      DDSLoader.use = function (resource, next) {
+          if (resource.extension === 'dds' && resource.data) {
+              try {
+                  Object.assign(resource, registerCompressedTextures(resource.name || resource.url, parseDDS(resource.data), resource.metadata));
+              }
+              catch (err) {
+                  next(err);
+                  return;
+              }
+          }
+          next();
+      };
+      /** @ignore */
+      DDSLoader.extension = exports.ExtensionType.Loader;
+      return DDSLoader;
+  }());
+
+  // Set KTX files to be loaded as an ArrayBuffer
+  exports.LoaderResource.setExtensionXhrType('ktx', exports.LoaderResource.XHR_RESPONSE_TYPE.BUFFER);
+  /**
+   * Loader plugin for handling KTX texture container files.
+   *
+   * This KTX loader does not currently support the following features:
+   * * cube textures
+   * * 3D textures
+   * * endianness conversion for big-endian machines
+   * * embedded *.basis files
+   *
+   * It does supports the following features:
+   * * multiple textures per file
+   * * mipmapping (only for compressed formats)
+   * * vendor-specific key/value data parsing (enable {@link PIXI.KTXLoader.loadKeyValueData})
+   * @class
+   * @memberof PIXI
+   * @implements {PIXI.ILoaderPlugin}
+   */
+  var KTXLoader = /** @class */ (function () {
+      function KTXLoader() {
+      }
+      /**
+       * Called after a KTX file is loaded.
+       *
+       * This will parse the KTX file header and add a {@code BaseTexture} to the texture
+       * cache.
+       * @see PIXI.Loader.loaderMiddleware
+       * @param resource - loader resource that is checked to see if it is a KTX file
+       * @param next - callback Function to call when done
+       */
+      KTXLoader.use = function (resource, next) {
+          if (resource.extension === 'ktx' && resource.data) {
+              try {
+                  var url_1 = resource.name || resource.url;
+                  var _a = parseKTX(url_1, resource.data, this.loadKeyValueData), compressed = _a.compressed, uncompressed = _a.uncompressed, kvData_1 = _a.kvData;
+                  if (compressed) {
+                      var result = registerCompressedTextures(url_1, compressed, resource.metadata);
+                      if (kvData_1 && result.textures) {
+                          for (var textureId in result.textures) {
+                              result.textures[textureId].baseTexture.ktxKeyValueData = kvData_1;
+                          }
+                      }
+                      Object.assign(resource, result);
+                  }
+                  else if (uncompressed) {
+                      var textures_1 = {};
+                      uncompressed.forEach(function (image, i) {
+                          var texture = new Texture(new BaseTexture(image.resource, {
+                              mipmap: exports.MIPMAP_MODES.OFF,
+                              alphaMode: exports.ALPHA_MODES.NO_PREMULTIPLIED_ALPHA,
+                              type: image.type,
+                              format: image.format,
+                          }));
+                          var cacheID = url_1 + "-" + (i + 1);
+                          if (kvData_1)
+                              { texture.baseTexture.ktxKeyValueData = kvData_1; }
+                          BaseTexture.addToCache(texture.baseTexture, cacheID);
+                          Texture.addToCache(texture, cacheID);
+                          if (i === 0) {
+                              textures_1[url_1] = texture;
+                              BaseTexture.addToCache(texture.baseTexture, url_1);
+                              Texture.addToCache(texture, url_1);
+                          }
+                          textures_1[cacheID] = texture;
+                      });
+                      Object.assign(resource, { textures: textures_1 });
+                  }
+              }
+              catch (err) {
+                  next(err);
+                  return;
+              }
+          }
+          next();
+      };
+      /** @ignore */
+      KTXLoader.extension = exports.ExtensionType.Loader;
+      /**
+       * If set to `true`, {@link PIXI.KTXLoader} will parse key-value data in KTX textures. This feature relies
+       * on the [Encoding Standard]{@link https://encoding.spec.whatwg.org}.
+       *
+       * The key-value data will be available on the base-textures as {@code PIXI.BaseTexture.ktxKeyValueData}. They
+       * will hold a reference to the texture data buffer, so make sure to delete key-value data once you are done
+       * using it.
+       */
+      KTXLoader.loadKeyValueData = false;
+      return KTXLoader;
+  }());
 
-    return result;
-}
+  /*!
+   * @pixi/particle-container - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/particle-container is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-/**
- * Built-in hook to find BaseTextures from Sprites.
- *
- * @private
- * @param {PIXI.DisplayObject} item - Display object to check
- * @param {Array<*>} queue - Collection of items to upload
- * @return {boolean} if a PIXI.Texture object was found.
- */
-function findBaseTexture(item, queue) {
-    // Objects with textures, like Sprites/Text
-    if (item instanceof core.BaseTexture) {
-        if (queue.indexOf(item) === -1) {
-            queue.push(item);
-        }
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$f = function(d, b) {
+      extendStatics$f = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$f(d, b);
+  };
 
-        return true;
-    }
+  function __extends$f(d, b) {
+      extendStatics$f(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-    return false;
-}
+  /**
+   * The ParticleContainer class is a really fast version of the Container built solely for speed,
+   * so use when you need a lot of sprites or particles.
+   *
+   * The tradeoff of the ParticleContainer is that most advanced functionality will not work.
+   * ParticleContainer implements the basic object transform (position, scale, rotation)
+   * and some advanced functionality like tint (as of v4.5.6).
+   *
+   * Other more advanced functionality like masking, children, filters, etc will not work on sprites in this batch.
+   *
+   * It's extremely easy to use:
+   * ```js
+   * let container = new ParticleContainer();
+   *
+   * for (let i = 0; i < 100; ++i)
+   * {
+   *     let sprite = PIXI.Sprite.from("myImage.png");
+   *     container.addChild(sprite);
+   * }
+   * ```
+   *
+   * And here you have a hundred sprites that will be rendered at the speed of light.
+   * @memberof PIXI
+   */
+  var ParticleContainer = /** @class */ (function (_super) {
+      __extends$f(ParticleContainer, _super);
+      /**
+       * @param maxSize - The maximum number of particles that can be rendered by the container.
+       *  Affects size of allocated buffers.
+       * @param properties - The properties of children that should be uploaded to the gpu and applied.
+       * @param {boolean} [properties.vertices=false] - When true, vertices be uploaded and applied.
+       *                  if sprite's ` scale/anchor/trim/frame/orig` is dynamic, please set `true`.
+       * @param {boolean} [properties.position=true] - When true, position be uploaded and applied.
+       * @param {boolean} [properties.rotation=false] - When true, rotation be uploaded and applied.
+       * @param {boolean} [properties.uvs=false] - When true, uvs be uploaded and applied.
+       * @param {boolean} [properties.tint=false] - When true, alpha and tint be uploaded and applied.
+       * @param {number} [batchSize=16384] - Number of particles per batch. If less than maxSize, it uses maxSize instead.
+       * @param {boolean} [autoResize=false] - If true, container allocates more batches in case
+       *  there are more than `maxSize` particles.
+       */
+      function ParticleContainer(maxSize, properties, batchSize, autoResize) {
+          if (maxSize === void 0) { maxSize = 1500; }
+          if (batchSize === void 0) { batchSize = 16384; }
+          if (autoResize === void 0) { autoResize = false; }
+          var _this = _super.call(this) || this;
+          // Making sure the batch size is valid
+          // 65535 is max vertex index in the index buffer (see ParticleRenderer)
+          // so max number of particles is 65536 / 4 = 16384
+          var maxBatchSize = 16384;
+          if (batchSize > maxBatchSize) {
+              batchSize = maxBatchSize;
+          }
+          _this._properties = [false, true, false, false, false];
+          _this._maxSize = maxSize;
+          _this._batchSize = batchSize;
+          _this._buffers = null;
+          _this._bufferUpdateIDs = [];
+          _this._updateID = 0;
+          _this.interactiveChildren = false;
+          _this.blendMode = exports.BLEND_MODES.NORMAL;
+          _this.autoResize = autoResize;
+          _this.roundPixels = true;
+          _this.baseTexture = null;
+          _this.setProperties(properties);
+          _this._tint = 0;
+          _this.tintRgb = new Float32Array(4);
+          _this.tint = 0xFFFFFF;
+          return _this;
+      }
+      /**
+       * Sets the private properties array to dynamic / static based on the passed properties object
+       * @param properties - The properties to be uploaded
+       */
+      ParticleContainer.prototype.setProperties = function (properties) {
+          if (properties) {
+              this._properties[0] = 'vertices' in properties || 'scale' in properties
+                  ? !!properties.vertices || !!properties.scale : this._properties[0];
+              this._properties[1] = 'position' in properties ? !!properties.position : this._properties[1];
+              this._properties[2] = 'rotation' in properties ? !!properties.rotation : this._properties[2];
+              this._properties[3] = 'uvs' in properties ? !!properties.uvs : this._properties[3];
+              this._properties[4] = 'tint' in properties || 'alpha' in properties
+                  ? !!properties.tint || !!properties.alpha : this._properties[4];
+          }
+      };
+      ParticleContainer.prototype.updateTransform = function () {
+          // TODO don't need to!
+          this.displayObjectUpdateTransform();
+      };
+      Object.defineProperty(ParticleContainer.prototype, "tint", {
+          /**
+           * The tint applied to the container. This is a hex value.
+           * A value of 0xFFFFFF will remove any tint effect.
+           * IMPORTANT: This is a WebGL only feature and will be ignored by the canvas renderer.
+           * @default 0xFFFFFF
+           */
+          get: function () {
+              return this._tint;
+          },
+          set: function (value) {
+              this._tint = value;
+              hex2rgb(value, this.tintRgb);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Renders the container using the WebGL renderer.
+       * @param renderer - The WebGL renderer.
+       */
+      ParticleContainer.prototype.render = function (renderer) {
+          var _this = this;
+          if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable) {
+              return;
+          }
+          if (!this.baseTexture) {
+              this.baseTexture = this.children[0]._texture.baseTexture;
+              if (!this.baseTexture.valid) {
+                  this.baseTexture.once('update', function () { return _this.onChildrenChange(0); });
+              }
+          }
+          renderer.batch.setObjectRenderer(renderer.plugins.particle);
+          renderer.plugins.particle.render(this);
+      };
+      /**
+       * Set the flag that static data should be updated to true
+       * @param smallestChildIndex - The smallest child index.
+       */
+      ParticleContainer.prototype.onChildrenChange = function (smallestChildIndex) {
+          var bufferIndex = Math.floor(smallestChildIndex / this._batchSize);
+          while (this._bufferUpdateIDs.length < bufferIndex) {
+              this._bufferUpdateIDs.push(0);
+          }
+          this._bufferUpdateIDs[bufferIndex] = ++this._updateID;
+      };
+      ParticleContainer.prototype.dispose = function () {
+          if (this._buffers) {
+              for (var i = 0; i < this._buffers.length; ++i) {
+                  this._buffers[i].destroy();
+              }
+              this._buffers = null;
+          }
+      };
+      /**
+       * Destroys the container
+       * @param options - Options parameter. A boolean will act as if all options
+       *  have been set to that value
+       * @param {boolean} [options.children=false] - if set to true, all the children will have their
+       *  destroy method called as well. 'options' will be passed on to those calls.
+       * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
+       *  Should it destroy the texture of the child sprite
+       * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
+       *  Should it destroy the base texture of the child sprite
+       */
+      ParticleContainer.prototype.destroy = function (options) {
+          _super.prototype.destroy.call(this, options);
+          this.dispose();
+          this._properties = null;
+          this._buffers = null;
+          this._bufferUpdateIDs = null;
+      };
+      return ParticleContainer;
+  }(Container));
+
+  /*
+   * @author Mat Groves
+   *
+   * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
+   * for creating the original PixiJS version!
+   * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that
+   * they now share 4 bytes on the vertex buffer
+   *
+   * Heavily inspired by LibGDX's ParticleBuffer:
+   * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleBuffer.java
+   */
+  /**
+   * The particle buffer manages the static and dynamic buffers for a particle container.
+   * @private
+   * @memberof PIXI
+   */
+  var ParticleBuffer = /** @class */ (function () {
+      /**
+       * @param {object} properties - The properties to upload.
+       * @param {boolean[]} dynamicPropertyFlags - Flags for which properties are dynamic.
+       * @param {number} size - The size of the batch.
+       */
+      function ParticleBuffer(properties, dynamicPropertyFlags, size) {
+          this.geometry = new Geometry();
+          this.indexBuffer = null;
+          this.size = size;
+          this.dynamicProperties = [];
+          this.staticProperties = [];
+          for (var i = 0; i < properties.length; ++i) {
+              var property = properties[i];
+              // Make copy of properties object so that when we edit the offset it doesn't
+              // change all other instances of the object literal
+              property = {
+                  attributeName: property.attributeName,
+                  size: property.size,
+                  uploadFunction: property.uploadFunction,
+                  type: property.type || exports.TYPES.FLOAT,
+                  offset: property.offset,
+              };
+              if (dynamicPropertyFlags[i]) {
+                  this.dynamicProperties.push(property);
+              }
+              else {
+                  this.staticProperties.push(property);
+              }
+          }
+          this.staticStride = 0;
+          this.staticBuffer = null;
+          this.staticData = null;
+          this.staticDataUint32 = null;
+          this.dynamicStride = 0;
+          this.dynamicBuffer = null;
+          this.dynamicData = null;
+          this.dynamicDataUint32 = null;
+          this._updateID = 0;
+          this.initBuffers();
+      }
+      /** Sets up the renderer context and necessary buffers. */
+      ParticleBuffer.prototype.initBuffers = function () {
+          var geometry = this.geometry;
+          var dynamicOffset = 0;
+          this.indexBuffer = new Buffer(createIndicesForQuads(this.size), true, true);
+          geometry.addIndex(this.indexBuffer);
+          this.dynamicStride = 0;
+          for (var i = 0; i < this.dynamicProperties.length; ++i) {
+              var property = this.dynamicProperties[i];
+              property.offset = dynamicOffset;
+              dynamicOffset += property.size;
+              this.dynamicStride += property.size;
+          }
+          var dynBuffer = new ArrayBuffer(this.size * this.dynamicStride * 4 * 4);
+          this.dynamicData = new Float32Array(dynBuffer);
+          this.dynamicDataUint32 = new Uint32Array(dynBuffer);
+          this.dynamicBuffer = new Buffer(this.dynamicData, false, false);
+          // static //
+          var staticOffset = 0;
+          this.staticStride = 0;
+          for (var i = 0; i < this.staticProperties.length; ++i) {
+              var property = this.staticProperties[i];
+              property.offset = staticOffset;
+              staticOffset += property.size;
+              this.staticStride += property.size;
+          }
+          var statBuffer = new ArrayBuffer(this.size * this.staticStride * 4 * 4);
+          this.staticData = new Float32Array(statBuffer);
+          this.staticDataUint32 = new Uint32Array(statBuffer);
+          this.staticBuffer = new Buffer(this.staticData, true, false);
+          for (var i = 0; i < this.dynamicProperties.length; ++i) {
+              var property = this.dynamicProperties[i];
+              geometry.addAttribute(property.attributeName, this.dynamicBuffer, 0, property.type === exports.TYPES.UNSIGNED_BYTE, property.type, this.dynamicStride * 4, property.offset * 4);
+          }
+          for (var i = 0; i < this.staticProperties.length; ++i) {
+              var property = this.staticProperties[i];
+              geometry.addAttribute(property.attributeName, this.staticBuffer, 0, property.type === exports.TYPES.UNSIGNED_BYTE, property.type, this.staticStride * 4, property.offset * 4);
+          }
+      };
+      /**
+       * Uploads the dynamic properties.
+       * @param children - The children to upload.
+       * @param startIndex - The index to start at.
+       * @param amount - The number to upload.
+       */
+      ParticleBuffer.prototype.uploadDynamic = function (children, startIndex, amount) {
+          for (var i = 0; i < this.dynamicProperties.length; i++) {
+              var property = this.dynamicProperties[i];
+              property.uploadFunction(children, startIndex, amount, property.type === exports.TYPES.UNSIGNED_BYTE ? this.dynamicDataUint32 : this.dynamicData, this.dynamicStride, property.offset);
+          }
+          this.dynamicBuffer._updateID++;
+      };
+      /**
+       * Uploads the static properties.
+       * @param children - The children to upload.
+       * @param startIndex - The index to start at.
+       * @param amount - The number to upload.
+       */
+      ParticleBuffer.prototype.uploadStatic = function (children, startIndex, amount) {
+          for (var i = 0; i < this.staticProperties.length; i++) {
+              var property = this.staticProperties[i];
+              property.uploadFunction(children, startIndex, amount, property.type === exports.TYPES.UNSIGNED_BYTE ? this.staticDataUint32 : this.staticData, this.staticStride, property.offset);
+          }
+          this.staticBuffer._updateID++;
+      };
+      /** Destroys the ParticleBuffer. */
+      ParticleBuffer.prototype.destroy = function () {
+          this.indexBuffer = null;
+          this.dynamicProperties = null;
+          this.dynamicBuffer = null;
+          this.dynamicData = null;
+          this.dynamicDataUint32 = null;
+          this.staticProperties = null;
+          this.staticBuffer = null;
+          this.staticData = null;
+          this.staticDataUint32 = null;
+          // all buffers are destroyed inside geometry
+          this.geometry.destroy();
+      };
+      return ParticleBuffer;
+  }());
+
+  var fragment$6 = "varying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n    vec4 color = texture2D(uSampler, vTextureCoord) * vColor;\n    gl_FragColor = color;\n}";
+
+  var vertex$3 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\n\nattribute vec2 aPositionCoord;\nattribute float aRotation;\n\nuniform mat3 translationMatrix;\nuniform vec4 uColor;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nvoid main(void){\n    float x = (aVertexPosition.x) * cos(aRotation) - (aVertexPosition.y) * sin(aRotation);\n    float y = (aVertexPosition.x) * sin(aRotation) + (aVertexPosition.y) * cos(aRotation);\n\n    vec2 v = vec2(x, y);\n    v = v + aPositionCoord;\n\n    gl_Position = vec4((translationMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vColor = aColor * uColor;\n}\n";
+
+  /*
+   * @author Mat Groves
+   *
+   * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
+   * for creating the original PixiJS version!
+   * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they now
+   * share 4 bytes on the vertex buffer
+   *
+   * Heavily inspired by LibGDX's ParticleRenderer:
+   * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleRenderer.java
+   */
+  /**
+   * Renderer for Particles that is designer for speed over feature set.
+   * @memberof PIXI
+   */
+  var ParticleRenderer = /** @class */ (function (_super) {
+      __extends$f(ParticleRenderer, _super);
+      /**
+       * @param renderer - The renderer this sprite batch works for.
+       */
+      function ParticleRenderer(renderer) {
+          var _this = _super.call(this, renderer) || this;
+          // 65535 is max vertex index in the index buffer (see ParticleRenderer)
+          // so max number of particles is 65536 / 4 = 16384
+          // and max number of element in the index buffer is 16384 * 6 = 98304
+          // Creating a full index buffer, overhead is 98304 * 2 = 196Ko
+          // let numIndices = 98304;
+          _this.shader = null;
+          _this.properties = null;
+          _this.tempMatrix = new Matrix();
+          _this.properties = [
+              // verticesData
+              {
+                  attributeName: 'aVertexPosition',
+                  size: 2,
+                  uploadFunction: _this.uploadVertices,
+                  offset: 0,
+              },
+              // positionData
+              {
+                  attributeName: 'aPositionCoord',
+                  size: 2,
+                  uploadFunction: _this.uploadPosition,
+                  offset: 0,
+              },
+              // rotationData
+              {
+                  attributeName: 'aRotation',
+                  size: 1,
+                  uploadFunction: _this.uploadRotation,
+                  offset: 0,
+              },
+              // uvsData
+              {
+                  attributeName: 'aTextureCoord',
+                  size: 2,
+                  uploadFunction: _this.uploadUvs,
+                  offset: 0,
+              },
+              // tintData
+              {
+                  attributeName: 'aColor',
+                  size: 1,
+                  type: exports.TYPES.UNSIGNED_BYTE,
+                  uploadFunction: _this.uploadTint,
+                  offset: 0,
+              } ];
+          _this.shader = Shader.from(vertex$3, fragment$6, {});
+          _this.state = State.for2d();
+          return _this;
+      }
+      /**
+       * Renders the particle container object.
+       * @param container - The container to render using this ParticleRenderer.
+       */
+      ParticleRenderer.prototype.render = function (container) {
+          var children = container.children;
+          var maxSize = container._maxSize;
+          var batchSize = container._batchSize;
+          var renderer = this.renderer;
+          var totalChildren = children.length;
+          if (totalChildren === 0) {
+              return;
+          }
+          else if (totalChildren > maxSize && !container.autoResize) {
+              totalChildren = maxSize;
+          }
+          var buffers = container._buffers;
+          if (!buffers) {
+              buffers = container._buffers = this.generateBuffers(container);
+          }
+          var baseTexture = children[0]._texture.baseTexture;
+          var premultiplied = baseTexture.alphaMode > 0;
+          // if the uvs have not updated then no point rendering just yet!
+          this.state.blendMode = correctBlendMode(container.blendMode, premultiplied);
+          renderer.state.set(this.state);
+          var gl = renderer.gl;
+          var m = container.worldTransform.copyTo(this.tempMatrix);
+          m.prepend(renderer.globalUniforms.uniforms.projectionMatrix);
+          this.shader.uniforms.translationMatrix = m.toArray(true);
+          this.shader.uniforms.uColor = premultiplyRgba(container.tintRgb, container.worldAlpha, this.shader.uniforms.uColor, premultiplied);
+          this.shader.uniforms.uSampler = baseTexture;
+          this.renderer.shader.bind(this.shader);
+          var updateStatic = false;
+          // now lets upload and render the buffers..
+          for (var i = 0, j = 0; i < totalChildren; i += batchSize, j += 1) {
+              var amount = (totalChildren - i);
+              if (amount > batchSize) {
+                  amount = batchSize;
+              }
+              if (j >= buffers.length) {
+                  buffers.push(this._generateOneMoreBuffer(container));
+              }
+              var buffer = buffers[j];
+              // we always upload the dynamic
+              buffer.uploadDynamic(children, i, amount);
+              var bid = container._bufferUpdateIDs[j] || 0;
+              updateStatic = updateStatic || (buffer._updateID < bid);
+              // we only upload the static content when we have to!
+              if (updateStatic) {
+                  buffer._updateID = container._updateID;
+                  buffer.uploadStatic(children, i, amount);
+              }
+              // bind the buffer
+              renderer.geometry.bind(buffer.geometry);
+              gl.drawElements(gl.TRIANGLES, amount * 6, gl.UNSIGNED_SHORT, 0);
+          }
+      };
+      /**
+       * Creates one particle buffer for each child in the container we want to render and updates internal properties.
+       * @param container - The container to render using this ParticleRenderer
+       * @returns - The buffers
+       */
+      ParticleRenderer.prototype.generateBuffers = function (container) {
+          var buffers = [];
+          var size = container._maxSize;
+          var batchSize = container._batchSize;
+          var dynamicPropertyFlags = container._properties;
+          for (var i = 0; i < size; i += batchSize) {
+              buffers.push(new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize));
+          }
+          return buffers;
+      };
+      /**
+       * Creates one more particle buffer, because container has autoResize feature.
+       * @param container - The container to render using this ParticleRenderer
+       * @returns - The generated buffer
+       */
+      ParticleRenderer.prototype._generateOneMoreBuffer = function (container) {
+          var batchSize = container._batchSize;
+          var dynamicPropertyFlags = container._properties;
+          return new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize);
+      };
+      /**
+       * Uploads the vertices.
+       * @param children - the array of sprites to render
+       * @param startIndex - the index to start from in the children array
+       * @param amount - the amount of children that will have their vertices uploaded
+       * @param array - The vertices to upload.
+       * @param stride - Stride to use for iteration.
+       * @param offset - Offset to start at.
+       */
+      ParticleRenderer.prototype.uploadVertices = function (children, startIndex, amount, array, stride, offset) {
+          var w0 = 0;
+          var w1 = 0;
+          var h0 = 0;
+          var h1 = 0;
+          for (var i = 0; i < amount; ++i) {
+              var sprite = children[startIndex + i];
+              var texture = sprite._texture;
+              var sx = sprite.scale.x;
+              var sy = sprite.scale.y;
+              var trim = texture.trim;
+              var orig = texture.orig;
+              if (trim) {
+                  // if the sprite is trimmed and is not a tilingsprite then we need to add the
+                  // extra space before transforming the sprite coords..
+                  w1 = trim.x - (sprite.anchor.x * orig.width);
+                  w0 = w1 + trim.width;
+                  h1 = trim.y - (sprite.anchor.y * orig.height);
+                  h0 = h1 + trim.height;
+              }
+              else {
+                  w0 = (orig.width) * (1 - sprite.anchor.x);
+                  w1 = (orig.width) * -sprite.anchor.x;
+                  h0 = orig.height * (1 - sprite.anchor.y);
+                  h1 = orig.height * -sprite.anchor.y;
+              }
+              array[offset] = w1 * sx;
+              array[offset + 1] = h1 * sy;
+              array[offset + stride] = w0 * sx;
+              array[offset + stride + 1] = h1 * sy;
+              array[offset + (stride * 2)] = w0 * sx;
+              array[offset + (stride * 2) + 1] = h0 * sy;
+              array[offset + (stride * 3)] = w1 * sx;
+              array[offset + (stride * 3) + 1] = h0 * sy;
+              offset += stride * 4;
+          }
+      };
+      /**
+       * Uploads the position.
+       * @param children - the array of sprites to render
+       * @param startIndex - the index to start from in the children array
+       * @param amount - the amount of children that will have their positions uploaded
+       * @param array - The vertices to upload.
+       * @param stride - Stride to use for iteration.
+       * @param offset - Offset to start at.
+       */
+      ParticleRenderer.prototype.uploadPosition = function (children, startIndex, amount, array, stride, offset) {
+          for (var i = 0; i < amount; i++) {
+              var spritePosition = children[startIndex + i].position;
+              array[offset] = spritePosition.x;
+              array[offset + 1] = spritePosition.y;
+              array[offset + stride] = spritePosition.x;
+              array[offset + stride + 1] = spritePosition.y;
+              array[offset + (stride * 2)] = spritePosition.x;
+              array[offset + (stride * 2) + 1] = spritePosition.y;
+              array[offset + (stride * 3)] = spritePosition.x;
+              array[offset + (stride * 3) + 1] = spritePosition.y;
+              offset += stride * 4;
+          }
+      };
+      /**
+       * Uploads the rotation.
+       * @param children - the array of sprites to render
+       * @param startIndex - the index to start from in the children array
+       * @param amount - the amount of children that will have their rotation uploaded
+       * @param array - The vertices to upload.
+       * @param stride - Stride to use for iteration.
+       * @param offset - Offset to start at.
+       */
+      ParticleRenderer.prototype.uploadRotation = function (children, startIndex, amount, array, stride, offset) {
+          for (var i = 0; i < amount; i++) {
+              var spriteRotation = children[startIndex + i].rotation;
+              array[offset] = spriteRotation;
+              array[offset + stride] = spriteRotation;
+              array[offset + (stride * 2)] = spriteRotation;
+              array[offset + (stride * 3)] = spriteRotation;
+              offset += stride * 4;
+          }
+      };
+      /**
+       * Uploads the UVs.
+       * @param children - the array of sprites to render
+       * @param startIndex - the index to start from in the children array
+       * @param amount - the amount of children that will have their rotation uploaded
+       * @param array - The vertices to upload.
+       * @param stride - Stride to use for iteration.
+       * @param offset - Offset to start at.
+       */
+      ParticleRenderer.prototype.uploadUvs = function (children, startIndex, amount, array, stride, offset) {
+          for (var i = 0; i < amount; ++i) {
+              var textureUvs = children[startIndex + i]._texture._uvs;
+              if (textureUvs) {
+                  array[offset] = textureUvs.x0;
+                  array[offset + 1] = textureUvs.y0;
+                  array[offset + stride] = textureUvs.x1;
+                  array[offset + stride + 1] = textureUvs.y1;
+                  array[offset + (stride * 2)] = textureUvs.x2;
+                  array[offset + (stride * 2) + 1] = textureUvs.y2;
+                  array[offset + (stride * 3)] = textureUvs.x3;
+                  array[offset + (stride * 3) + 1] = textureUvs.y3;
+                  offset += stride * 4;
+              }
+              else {
+                  // TODO you know this can be easier!
+                  array[offset] = 0;
+                  array[offset + 1] = 0;
+                  array[offset + stride] = 0;
+                  array[offset + stride + 1] = 0;
+                  array[offset + (stride * 2)] = 0;
+                  array[offset + (stride * 2) + 1] = 0;
+                  array[offset + (stride * 3)] = 0;
+                  array[offset + (stride * 3) + 1] = 0;
+                  offset += stride * 4;
+              }
+          }
+      };
+      /**
+       * Uploads the tint.
+       * @param children - the array of sprites to render
+       * @param startIndex - the index to start from in the children array
+       * @param amount - the amount of children that will have their rotation uploaded
+       * @param array - The vertices to upload.
+       * @param stride - Stride to use for iteration.
+       * @param offset - Offset to start at.
+       */
+      ParticleRenderer.prototype.uploadTint = function (children, startIndex, amount, array, stride, offset) {
+          for (var i = 0; i < amount; ++i) {
+              var sprite = children[startIndex + i];
+              var premultiplied = sprite._texture.baseTexture.alphaMode > 0;
+              var alpha = sprite.alpha;
+              // we dont call extra function if alpha is 1.0, that's faster
+              var argb = alpha < 1.0 && premultiplied
+                  ? premultiplyTint(sprite._tintRGB, alpha) : sprite._tintRGB + (alpha * 255 << 24);
+              array[offset] = argb;
+              array[offset + stride] = argb;
+              array[offset + (stride * 2)] = argb;
+              array[offset + (stride * 3)] = argb;
+              offset += stride * 4;
+          }
+      };
+      /** Destroys the ParticleRenderer. */
+      ParticleRenderer.prototype.destroy = function () {
+          _super.prototype.destroy.call(this);
+          if (this.shader) {
+              this.shader.destroy();
+              this.shader = null;
+          }
+          this.tempMatrix = null;
+      };
+      /** @ignore */
+      ParticleRenderer.extension = {
+          name: 'particle',
+          type: exports.ExtensionType.RendererPlugin,
+      };
+      return ParticleRenderer;
+  }(ObjectRenderer));
+
+  /*!
+   * @pixi/graphics - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/graphics is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-/**
- * Built-in hook to find textures from objects.
- *
- * @private
- * @param {PIXI.DisplayObject} item - Display object to check
- * @param {Array<*>} queue - Collection of items to upload
- * @return {boolean} if a PIXI.Texture object was found.
- */
-function findTexture(item, queue) {
-    if (item._texture && item._texture instanceof core.Texture) {
-        var texture = item._texture.baseTexture;
+  /**
+   * Supported line joints in `PIXI.LineStyle` for graphics.
+   * @see PIXI.Graphics#lineStyle
+   * @see https://graphicdesign.stackexchange.com/questions/59018/what-is-a-bevel-join-of-two-lines-exactly-illustrator
+   * @name LINE_JOIN
+   * @memberof PIXI
+   * @static
+   * @enum {string}
+   * @property {string} MITER - 'miter': make a sharp corner where outer part of lines meet
+   * @property {string} BEVEL - 'bevel': add a square butt at each end of line segment and fill the triangle at turn
+   * @property {string} ROUND - 'round': add an arc at the joint
+   */
+  exports.LINE_JOIN = void 0;
+  (function (LINE_JOIN) {
+      LINE_JOIN["MITER"] = "miter";
+      LINE_JOIN["BEVEL"] = "bevel";
+      LINE_JOIN["ROUND"] = "round";
+  })(exports.LINE_JOIN || (exports.LINE_JOIN = {}));
+  /**
+   * Support line caps in `PIXI.LineStyle` for graphics.
+   * @see PIXI.Graphics#lineStyle
+   * @name LINE_CAP
+   * @memberof PIXI
+   * @static
+   * @enum {string}
+   * @property {string} BUTT - 'butt': don't add any cap at line ends (leaves orthogonal edges)
+   * @property {string} ROUND - 'round': add semicircle at ends
+   * @property {string} SQUARE - 'square': add square at end (like `BUTT` except more length at end)
+   */
+  exports.LINE_CAP = void 0;
+  (function (LINE_CAP) {
+      LINE_CAP["BUTT"] = "butt";
+      LINE_CAP["ROUND"] = "round";
+      LINE_CAP["SQUARE"] = "square";
+  })(exports.LINE_CAP || (exports.LINE_CAP = {}));
+  /**
+   * Graphics curves resolution settings. If `adaptive` flag is set to `true`,
+   * the resolution is calculated based on the curve's length to ensure better visual quality.
+   * Adaptive draw works with `bezierCurveTo` and `quadraticCurveTo`.
+   * @static
+   * @constant
+   * @memberof PIXI
+   * @name GRAPHICS_CURVES
+   * @type {object}
+   * @property {boolean} [adaptive=true] - flag indicating if the resolution should be adaptive
+   * @property {number} [maxLength=10] - maximal length of a single segment of the curve (if adaptive = false, ignored)
+   * @property {number} [minSegments=8] - minimal number of segments in the curve (if adaptive = false, ignored)
+   * @property {number} [maxSegments=2048] - maximal number of segments in the curve (if adaptive = false, ignored)
+   */
+  var GRAPHICS_CURVES = {
+      adaptive: true,
+      maxLength: 10,
+      minSegments: 8,
+      maxSegments: 2048,
+      epsilon: 0.0001,
+      _segmentsCount: function (length, defaultSegments) {
+          if (defaultSegments === void 0) { defaultSegments = 20; }
+          if (!this.adaptive || !length || isNaN(length)) {
+              return defaultSegments;
+          }
+          var result = Math.ceil(length / this.maxLength);
+          if (result < this.minSegments) {
+              result = this.minSegments;
+          }
+          else if (result > this.maxSegments) {
+              result = this.maxSegments;
+          }
+          return result;
+      },
+  };
 
-        if (queue.indexOf(texture) === -1) {
-            queue.push(texture);
-        }
+  /**
+   * Fill style object for Graphics.
+   * @memberof PIXI
+   */
+  var FillStyle = /** @class */ (function () {
+      function FillStyle() {
+          /**
+           * The hex color value used when coloring the Graphics object.
+           * @default 0xFFFFFF
+           */
+          this.color = 0xFFFFFF;
+          /** The alpha value used when filling the Graphics object. */
+          this.alpha = 1.0;
+          /**
+           * The texture to be used for the fill.
+           * @default 0
+           */
+          this.texture = Texture.WHITE;
+          /**
+           * The transform applied to the texture.
+           * @default null
+           */
+          this.matrix = null;
+          /** If the current fill is visible. */
+          this.visible = false;
+          this.reset();
+      }
+      /** Clones the object */
+      FillStyle.prototype.clone = function () {
+          var obj = new FillStyle();
+          obj.color = this.color;
+          obj.alpha = this.alpha;
+          obj.texture = this.texture;
+          obj.matrix = this.matrix;
+          obj.visible = this.visible;
+          return obj;
+      };
+      /** Reset */
+      FillStyle.prototype.reset = function () {
+          this.color = 0xFFFFFF;
+          this.alpha = 1;
+          this.texture = Texture.WHITE;
+          this.matrix = null;
+          this.visible = false;
+      };
+      /** Destroy and don't use after this. */
+      FillStyle.prototype.destroy = function () {
+          this.texture = null;
+          this.matrix = null;
+      };
+      return FillStyle;
+  }());
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$e = function(d, b) {
+      extendStatics$e = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$e(d, b);
+  };
 
-        return true;
-    }
+  function __extends$e(d, b) {
+      extendStatics$e(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-    return false;
-}
+  function fixOrientation(points, hole) {
+      var _a, _b;
+      if (hole === void 0) { hole = false; }
+      var m = points.length;
+      if (m < 6) {
+          return;
+      }
+      var area = 0;
+      for (var i = 0, x1 = points[m - 2], y1 = points[m - 1]; i < m; i += 2) {
+          var x2 = points[i];
+          var y2 = points[i + 1];
+          area += (x2 - x1) * (y2 + y1);
+          x1 = x2;
+          y1 = y2;
+      }
+      if ((!hole && area > 0) || (hole && area <= 0)) {
+          var n = m / 2;
+          for (var i = n + (n % 2); i < m; i += 2) {
+              var i1 = m - i - 2;
+              var i2 = m - i - 1;
+              var i3 = i;
+              var i4 = i + 1;
+              _a = [points[i3], points[i1]], points[i1] = _a[0], points[i3] = _a[1];
+              _b = [points[i4], points[i2]], points[i2] = _b[0], points[i4] = _b[1];
+          }
+      }
+  }
+  /**
+   * Builds a polygon to draw
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
+   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
+   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
+   */
+  var buildPoly = {
+      build: function (graphicsData) {
+          graphicsData.points = graphicsData.shape.points.slice();
+      },
+      triangulate: function (graphicsData, graphicsGeometry) {
+          var points = graphicsData.points;
+          var holes = graphicsData.holes;
+          var verts = graphicsGeometry.points;
+          var indices = graphicsGeometry.indices;
+          if (points.length >= 6) {
+              fixOrientation(points, false);
+              var holeArray = [];
+              // Process holes..
+              for (var i = 0; i < holes.length; i++) {
+                  var hole = holes[i];
+                  fixOrientation(hole.points, true);
+                  holeArray.push(points.length / 2);
+                  points = points.concat(hole.points);
+              }
+              // sort color
+              var triangles = earcut_1(points, holeArray, 2);
+              if (!triangles) {
+                  return;
+              }
+              var vertPos = verts.length / 2;
+              for (var i = 0; i < triangles.length; i += 3) {
+                  indices.push(triangles[i] + vertPos);
+                  indices.push(triangles[i + 1] + vertPos);
+                  indices.push(triangles[i + 2] + vertPos);
+              }
+              for (var i = 0; i < points.length; i++) {
+                  verts.push(points[i]);
+              }
+          }
+      },
+  };
 
-/**
- * Built-in hook to draw PIXI.Text to its texture.
- *
- * @private
- * @param {PIXI.WebGLRenderer|PIXI.CanvasPrepare} helper - Not used by this upload handler
- * @param {PIXI.DisplayObject} item - Item to check
- * @return {boolean} If item was uploaded.
- */
-function drawText(helper, item) {
-    if (item instanceof core.Text) {
-        // updating text will return early if it is not dirty
-        item.updateText(true);
+  // for type only
+  /**
+   * Builds a circle to draw
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object to draw
+   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
+   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
+   */
+  var buildCircle = {
+      build: function (graphicsData) {
+          // need to convert points to a nice regular data
+          var points = graphicsData.points;
+          var x;
+          var y;
+          var dx;
+          var dy;
+          var rx;
+          var ry;
+          if (graphicsData.type === exports.SHAPES.CIRC) {
+              var circle = graphicsData.shape;
+              x = circle.x;
+              y = circle.y;
+              rx = ry = circle.radius;
+              dx = dy = 0;
+          }
+          else if (graphicsData.type === exports.SHAPES.ELIP) {
+              var ellipse = graphicsData.shape;
+              x = ellipse.x;
+              y = ellipse.y;
+              rx = ellipse.width;
+              ry = ellipse.height;
+              dx = dy = 0;
+          }
+          else {
+              var roundedRect = graphicsData.shape;
+              var halfWidth = roundedRect.width / 2;
+              var halfHeight = roundedRect.height / 2;
+              x = roundedRect.x + halfWidth;
+              y = roundedRect.y + halfHeight;
+              rx = ry = Math.max(0, Math.min(roundedRect.radius, Math.min(halfWidth, halfHeight)));
+              dx = halfWidth - rx;
+              dy = halfHeight - ry;
+          }
+          if (!(rx >= 0 && ry >= 0 && dx >= 0 && dy >= 0)) {
+              points.length = 0;
+              return;
+          }
+          // Choose a number of segments such that the maximum absolute deviation from the circle is approximately 0.029
+          var n = Math.ceil(2.3 * Math.sqrt(rx + ry));
+          var m = (n * 8) + (dx ? 4 : 0) + (dy ? 4 : 0);
+          points.length = m;
+          if (m === 0) {
+              return;
+          }
+          if (n === 0) {
+              points.length = 8;
+              points[0] = points[6] = x + dx;
+              points[1] = points[3] = y + dy;
+              points[2] = points[4] = x - dx;
+              points[5] = points[7] = y - dy;
+              return;
+          }
+          var j1 = 0;
+          var j2 = (n * 4) + (dx ? 2 : 0) + 2;
+          var j3 = j2;
+          var j4 = m;
+          {
+              var x0 = dx + rx;
+              var y0 = dy;
+              var x1 = x + x0;
+              var x2 = x - x0;
+              var y1 = y + y0;
+              points[j1++] = x1;
+              points[j1++] = y1;
+              points[--j2] = y1;
+              points[--j2] = x2;
+              if (dy) {
+                  var y2 = y - y0;
+                  points[j3++] = x2;
+                  points[j3++] = y2;
+                  points[--j4] = y2;
+                  points[--j4] = x1;
+              }
+          }
+          for (var i = 1; i < n; i++) {
+              var a = Math.PI / 2 * (i / n);
+              var x0 = dx + (Math.cos(a) * rx);
+              var y0 = dy + (Math.sin(a) * ry);
+              var x1 = x + x0;
+              var x2 = x - x0;
+              var y1 = y + y0;
+              var y2 = y - y0;
+              points[j1++] = x1;
+              points[j1++] = y1;
+              points[--j2] = y1;
+              points[--j2] = x2;
+              points[j3++] = x2;
+              points[j3++] = y2;
+              points[--j4] = y2;
+              points[--j4] = x1;
+          }
+          {
+              var x0 = dx;
+              var y0 = dy + ry;
+              var x1 = x + x0;
+              var x2 = x - x0;
+              var y1 = y + y0;
+              var y2 = y - y0;
+              points[j1++] = x1;
+              points[j1++] = y1;
+              points[--j4] = y2;
+              points[--j4] = x1;
+              if (dx) {
+                  points[j1++] = x2;
+                  points[j1++] = y1;
+                  points[--j4] = y2;
+                  points[--j4] = x2;
+              }
+          }
+      },
+      triangulate: function (graphicsData, graphicsGeometry) {
+          var points = graphicsData.points;
+          var verts = graphicsGeometry.points;
+          var indices = graphicsGeometry.indices;
+          if (points.length === 0) {
+              return;
+          }
+          var vertPos = verts.length / 2;
+          var center = vertPos;
+          var x;
+          var y;
+          if (graphicsData.type !== exports.SHAPES.RREC) {
+              var circle = graphicsData.shape;
+              x = circle.x;
+              y = circle.y;
+          }
+          else {
+              var roundedRect = graphicsData.shape;
+              x = roundedRect.x + (roundedRect.width / 2);
+              y = roundedRect.y + (roundedRect.height / 2);
+          }
+          var matrix = graphicsData.matrix;
+          // Push center (special point)
+          verts.push(graphicsData.matrix ? (matrix.a * x) + (matrix.c * y) + matrix.tx : x, graphicsData.matrix ? (matrix.b * x) + (matrix.d * y) + matrix.ty : y);
+          vertPos++;
+          verts.push(points[0], points[1]);
+          for (var i = 2; i < points.length; i += 2) {
+              verts.push(points[i], points[i + 1]);
+              // add some uvs
+              indices.push(vertPos++, center, vertPos);
+          }
+          indices.push(center + 1, center, vertPos);
+      },
+  };
 
-        return true;
-    }
+  /**
+   * Builds a rectangle to draw
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
+   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
+   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
+   */
+  var buildRectangle = {
+      build: function (graphicsData) {
+          // --- //
+          // need to convert points to a nice regular data
+          //
+          var rectData = graphicsData.shape;
+          var x = rectData.x;
+          var y = rectData.y;
+          var width = rectData.width;
+          var height = rectData.height;
+          var points = graphicsData.points;
+          points.length = 0;
+          points.push(x, y, x + width, y, x + width, y + height, x, y + height);
+      },
+      triangulate: function (graphicsData, graphicsGeometry) {
+          var points = graphicsData.points;
+          var verts = graphicsGeometry.points;
+          var vertPos = verts.length / 2;
+          verts.push(points[0], points[1], points[2], points[3], points[6], points[7], points[4], points[5]);
+          graphicsGeometry.indices.push(vertPos, vertPos + 1, vertPos + 2, vertPos + 1, vertPos + 2, vertPos + 3);
+      },
+  };
 
-    return false;
-}
+  /**
+   * Calculate a single point for a quadratic bezier curve.
+   * Utility function used by quadraticBezierCurve.
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {number} n1 - first number
+   * @param {number} n2 - second number
+   * @param {number} perc - percentage
+   * @returns {number} the result
+   */
+  function getPt(n1, n2, perc) {
+      var diff = n2 - n1;
+      return n1 + (diff * perc);
+  }
+  /**
+   * Calculate the points for a quadratic bezier curve. (helper function..)
+   * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {number} fromX - Origin point x
+   * @param {number} fromY - Origin point x
+   * @param {number} cpX - Control point x
+   * @param {number} cpY - Control point y
+   * @param {number} toX - Destination point x
+   * @param {number} toY - Destination point y
+   * @param {number[]} [out=[]] - The output array to add points into. If not passed, a new array is created.
+   * @returns {number[]} an array of points
+   */
+  function quadraticBezierCurve(fromX, fromY, cpX, cpY, toX, toY, out) {
+      if (out === void 0) { out = []; }
+      var n = 20;
+      var points = out;
+      var xa = 0;
+      var ya = 0;
+      var xb = 0;
+      var yb = 0;
+      var x = 0;
+      var y = 0;
+      for (var i = 0, j = 0; i <= n; ++i) {
+          j = i / n;
+          // The Green Line
+          xa = getPt(fromX, cpX, j);
+          ya = getPt(fromY, cpY, j);
+          xb = getPt(cpX, toX, j);
+          yb = getPt(cpY, toY, j);
+          // The Black Dot
+          x = getPt(xa, xb, j);
+          y = getPt(ya, yb, j);
+          // Handle case when first curve points overlaps and earcut fails to triangulate
+          if (i === 0 && points[points.length - 2] === x && points[points.length - 1] === y) {
+              continue;
+          }
+          points.push(x, y);
+      }
+      return points;
+  }
+  /**
+   * Builds a rounded rectangle to draw
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
+   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
+   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
+   */
+  var buildRoundedRectangle = {
+      build: function (graphicsData) {
+          if (Graphics.nextRoundedRectBehavior) {
+              buildCircle.build(graphicsData);
+              return;
+          }
+          var rrectData = graphicsData.shape;
+          var points = graphicsData.points;
+          var x = rrectData.x;
+          var y = rrectData.y;
+          var width = rrectData.width;
+          var height = rrectData.height;
+          // Don't allow negative radius or greater than half the smallest width
+          var radius = Math.max(0, Math.min(rrectData.radius, Math.min(width, height) / 2));
+          points.length = 0;
+          // No radius, do a simple rectangle
+          if (!radius) {
+              points.push(x, y, x + width, y, x + width, y + height, x, y + height);
+          }
+          else {
+              quadraticBezierCurve(x, y + radius, x, y, x + radius, y, points);
+              quadraticBezierCurve(x + width - radius, y, x + width, y, x + width, y + radius, points);
+              quadraticBezierCurve(x + width, y + height - radius, x + width, y + height, x + width - radius, y + height, points);
+              quadraticBezierCurve(x + radius, y + height, x, y + height, x, y + height - radius, points);
+          }
+      },
+      triangulate: function (graphicsData, graphicsGeometry) {
+          if (Graphics.nextRoundedRectBehavior) {
+              buildCircle.triangulate(graphicsData, graphicsGeometry);
+              return;
+          }
+          var points = graphicsData.points;
+          var verts = graphicsGeometry.points;
+          var indices = graphicsGeometry.indices;
+          var vecPos = verts.length / 2;
+          var triangles = earcut_1(points, null, 2);
+          for (var i = 0, j = triangles.length; i < j; i += 3) {
+              indices.push(triangles[i] + vecPos);
+              //     indices.push(triangles[i] + vecPos);
+              indices.push(triangles[i + 1] + vecPos);
+              //   indices.push(triangles[i + 2] + vecPos);
+              indices.push(triangles[i + 2] + vecPos);
+          }
+          for (var i = 0, j = points.length; i < j; i++) {
+              verts.push(points[i], points[++i]);
+          }
+      },
+  };
 
-/**
- * Built-in hook to calculate a text style for a PIXI.Text object.
- *
- * @private
- * @param {PIXI.WebGLRenderer|PIXI.CanvasPrepare} helper - Not used by this upload handler
- * @param {PIXI.DisplayObject} item - Item to check
- * @return {boolean} If item was uploaded.
- */
-function calculateTextStyle(helper, item) {
-    if (item instanceof core.TextStyle) {
-        var font = item.toFontString();
+  /**
+   * Buffers vertices to draw a square cap.
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {number} x - X-coord of end point
+   * @param {number} y - Y-coord of end point
+   * @param {number} nx - X-coord of line normal pointing inside
+   * @param {number} ny - Y-coord of line normal pointing inside
+   * @param {number} innerWeight - Weight of inner points
+   * @param {number} outerWeight - Weight of outer points
+   * @param {boolean} clockwise - Whether the cap is drawn clockwise
+   * @param {Array<number>} verts - vertex buffer
+   * @returns {number} - no. of vertices pushed
+   */
+  function square(x, y, nx, ny, innerWeight, outerWeight, clockwise, /* rotation for square (true at left end, false at right end) */ verts) {
+      var ix = x - (nx * innerWeight);
+      var iy = y - (ny * innerWeight);
+      var ox = x + (nx * outerWeight);
+      var oy = y + (ny * outerWeight);
+      /* Rotate nx,ny for extension vector */
+      var exx;
+      var eyy;
+      if (clockwise) {
+          exx = ny;
+          eyy = -nx;
+      }
+      else {
+          exx = -ny;
+          eyy = nx;
+      }
+      /* [i|0]x,y extended at cap */
+      var eix = ix + exx;
+      var eiy = iy + eyy;
+      var eox = ox + exx;
+      var eoy = oy + eyy;
+      /* Square itself must be inserted clockwise*/
+      verts.push(eix, eiy);
+      verts.push(eox, eoy);
+      return 2;
+  }
+  /**
+   * Buffers vertices to draw an arc at the line joint or cap.
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {number} cx - X-coord of center
+   * @param {number} cy - Y-coord of center
+   * @param {number} sx - X-coord of arc start
+   * @param {number} sy - Y-coord of arc start
+   * @param {number} ex - X-coord of arc end
+   * @param {number} ey - Y-coord of arc end
+   * @param {Array<number>} verts - buffer of vertices
+   * @param {boolean} clockwise - orientation of vertices
+   * @returns {number} - no. of vertices pushed
+   */
+  function round(cx, cy, sx, sy, ex, ey, verts, clockwise) {
+      var cx2p0x = sx - cx;
+      var cy2p0y = sy - cy;
+      var angle0 = Math.atan2(cx2p0x, cy2p0y);
+      var angle1 = Math.atan2(ex - cx, ey - cy);
+      if (clockwise && angle0 < angle1) {
+          angle0 += Math.PI * 2;
+      }
+      else if (!clockwise && angle0 > angle1) {
+          angle1 += Math.PI * 2;
+      }
+      var startAngle = angle0;
+      var angleDiff = angle1 - angle0;
+      var absAngleDiff = Math.abs(angleDiff);
+      /* if (absAngleDiff >= PI_LBOUND && absAngleDiff <= PI_UBOUND)
+      {
+          const r1x = cx - nxtPx;
+          const r1y = cy - nxtPy;
+
+          if (r1x === 0)
+          {
+              if (r1y > 0)
+              {
+                  angleDiff = -angleDiff;
+              }
+          }
+          else if (r1x >= -GRAPHICS_CURVES.epsilon)
+          {
+              angleDiff = -angleDiff;
+          }
+      }*/
+      var radius = Math.sqrt((cx2p0x * cx2p0x) + (cy2p0y * cy2p0y));
+      var segCount = ((15 * absAngleDiff * Math.sqrt(radius) / Math.PI) >> 0) + 1;
+      var angleInc = angleDiff / segCount;
+      startAngle += angleInc;
+      if (clockwise) {
+          verts.push(cx, cy);
+          verts.push(sx, sy);
+          for (var i = 1, angle = startAngle; i < segCount; i++, angle += angleInc) {
+              verts.push(cx, cy);
+              verts.push(cx + ((Math.sin(angle) * radius)), cy + ((Math.cos(angle) * radius)));
+          }
+          verts.push(cx, cy);
+          verts.push(ex, ey);
+      }
+      else {
+          verts.push(sx, sy);
+          verts.push(cx, cy);
+          for (var i = 1, angle = startAngle; i < segCount; i++, angle += angleInc) {
+              verts.push(cx + ((Math.sin(angle) * radius)), cy + ((Math.cos(angle) * radius)));
+              verts.push(cx, cy);
+          }
+          verts.push(ex, ey);
+          verts.push(cx, cy);
+      }
+      return segCount * 2;
+  }
+  /**
+   * Builds a line to draw using the polygon method.
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {PIXI.GraphicsData} graphicsData - The graphics object containing all the necessary properties
+   * @param {PIXI.GraphicsGeometry} graphicsGeometry - Geometry where to append output
+   */
+  function buildNonNativeLine(graphicsData, graphicsGeometry) {
+      var shape = graphicsData.shape;
+      var points = graphicsData.points || shape.points.slice();
+      var eps = graphicsGeometry.closePointEps;
+      if (points.length === 0) {
+          return;
+      }
+      // if the line width is an odd number add 0.5 to align to a whole pixel
+      // commenting this out fixes #711 and #1620
+      // if (graphicsData.lineWidth%2)
+      // {
+      //     for (i = 0; i < points.length; i++)
+      //     {
+      //         points[i] += 0.5;
+      //     }
+      // }
+      var style = graphicsData.lineStyle;
+      // get first and last point.. figure out the middle!
+      var firstPoint = new Point(points[0], points[1]);
+      var lastPoint = new Point(points[points.length - 2], points[points.length - 1]);
+      var closedShape = shape.type !== exports.SHAPES.POLY || shape.closeStroke;
+      var closedPath = Math.abs(firstPoint.x - lastPoint.x) < eps
+          && Math.abs(firstPoint.y - lastPoint.y) < eps;
+      // if the first point is the last point - gonna have issues :)
+      if (closedShape) {
+          // need to clone as we are going to slightly modify the shape..
+          points = points.slice();
+          if (closedPath) {
+              points.pop();
+              points.pop();
+              lastPoint.set(points[points.length - 2], points[points.length - 1]);
+          }
+          var midPointX = (firstPoint.x + lastPoint.x) * 0.5;
+          var midPointY = (lastPoint.y + firstPoint.y) * 0.5;
+          points.unshift(midPointX, midPointY);
+          points.push(midPointX, midPointY);
+      }
+      var verts = graphicsGeometry.points;
+      var length = points.length / 2;
+      var indexCount = points.length;
+      var indexStart = verts.length / 2;
+      // Max. inner and outer width
+      var width = style.width / 2;
+      var widthSquared = width * width;
+      var miterLimitSquared = style.miterLimit * style.miterLimit;
+      /* Line segments of interest where (x1,y1) forms the corner. */
+      var x0 = points[0];
+      var y0 = points[1];
+      var x1 = points[2];
+      var y1 = points[3];
+      var x2 = 0;
+      var y2 = 0;
+      /* perp[?](x|y) = the line normal with magnitude lineWidth. */
+      var perpx = -(y0 - y1);
+      var perpy = x0 - x1;
+      var perp1x = 0;
+      var perp1y = 0;
+      var dist = Math.sqrt((perpx * perpx) + (perpy * perpy));
+      perpx /= dist;
+      perpy /= dist;
+      perpx *= width;
+      perpy *= width;
+      var ratio = style.alignment; // 0.5;
+      var innerWeight = (1 - ratio) * 2;
+      var outerWeight = ratio * 2;
+      if (!closedShape) {
+          if (style.cap === exports.LINE_CAP.ROUND) {
+              indexCount += round(x0 - (perpx * (innerWeight - outerWeight) * 0.5), y0 - (perpy * (innerWeight - outerWeight) * 0.5), x0 - (perpx * innerWeight), y0 - (perpy * innerWeight), x0 + (perpx * outerWeight), y0 + (perpy * outerWeight), verts, true) + 2;
+          }
+          else if (style.cap === exports.LINE_CAP.SQUARE) {
+              indexCount += square(x0, y0, perpx, perpy, innerWeight, outerWeight, true, verts);
+          }
+      }
+      // Push first point (below & above vertices)
+      verts.push(x0 - (perpx * innerWeight), y0 - (perpy * innerWeight));
+      verts.push(x0 + (perpx * outerWeight), y0 + (perpy * outerWeight));
+      for (var i = 1; i < length - 1; ++i) {
+          x0 = points[(i - 1) * 2];
+          y0 = points[((i - 1) * 2) + 1];
+          x1 = points[i * 2];
+          y1 = points[(i * 2) + 1];
+          x2 = points[(i + 1) * 2];
+          y2 = points[((i + 1) * 2) + 1];
+          perpx = -(y0 - y1);
+          perpy = x0 - x1;
+          dist = Math.sqrt((perpx * perpx) + (perpy * perpy));
+          perpx /= dist;
+          perpy /= dist;
+          perpx *= width;
+          perpy *= width;
+          perp1x = -(y1 - y2);
+          perp1y = x1 - x2;
+          dist = Math.sqrt((perp1x * perp1x) + (perp1y * perp1y));
+          perp1x /= dist;
+          perp1y /= dist;
+          perp1x *= width;
+          perp1y *= width;
+          /* d[x|y](0|1) = the component displacement between points p(0,1|1,2) */
+          var dx0 = x1 - x0;
+          var dy0 = y0 - y1;
+          var dx1 = x1 - x2;
+          var dy1 = y2 - y1;
+          /* +ve if internal angle < 90 degree, -ve if internal angle > 90 degree. */
+          var dot = (dx0 * dx1) + (dy0 * dy1);
+          /* +ve if internal angle counterclockwise, -ve if internal angle clockwise. */
+          var cross = (dy0 * dx1) - (dy1 * dx0);
+          var clockwise = (cross < 0);
+          /* Going nearly parallel? */
+          /* atan(0.001) ~= 0.001 rad ~= 0.057 degree */
+          if (Math.abs(cross) < 0.001 * Math.abs(dot)) {
+              verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight));
+              verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight));
+              /* 180 degree corner? */
+              if (dot >= 0) {
+                  if (style.join === exports.LINE_JOIN.ROUND) {
+                      indexCount += round(x1, y1, x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight), verts, false) + 4;
+                  }
+                  else {
+                      indexCount += 2;
+                  }
+                  verts.push(x1 - (perp1x * outerWeight), y1 - (perp1y * outerWeight));
+                  verts.push(x1 + (perp1x * innerWeight), y1 + (perp1y * innerWeight));
+              }
+              continue;
+          }
+          /* p[x|y] is the miter point. pdist is the distance between miter point and p1. */
+          var c1 = ((-perpx + x0) * (-perpy + y1)) - ((-perpx + x1) * (-perpy + y0));
+          var c2 = ((-perp1x + x2) * (-perp1y + y1)) - ((-perp1x + x1) * (-perp1y + y2));
+          var px = ((dx0 * c2) - (dx1 * c1)) / cross;
+          var py = ((dy1 * c1) - (dy0 * c2)) / cross;
+          var pdist = ((px - x1) * (px - x1)) + ((py - y1) * (py - y1));
+          /* Inner miter point */
+          var imx = x1 + ((px - x1) * innerWeight);
+          var imy = y1 + ((py - y1) * innerWeight);
+          /* Outer miter point */
+          var omx = x1 - ((px - x1) * outerWeight);
+          var omy = y1 - ((py - y1) * outerWeight);
+          /* Is the inside miter point too far away, creating a spike? */
+          var smallerInsideSegmentSq = Math.min((dx0 * dx0) + (dy0 * dy0), (dx1 * dx1) + (dy1 * dy1));
+          var insideWeight = clockwise ? innerWeight : outerWeight;
+          var smallerInsideDiagonalSq = smallerInsideSegmentSq + (insideWeight * insideWeight * widthSquared);
+          var insideMiterOk = pdist <= smallerInsideDiagonalSq;
+          if (insideMiterOk) {
+              if (style.join === exports.LINE_JOIN.BEVEL || pdist / widthSquared > miterLimitSquared) {
+                  if (clockwise) /* rotating at inner angle */ {
+                      verts.push(imx, imy); // inner miter point
+                      verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight)); // first segment's outer vertex
+                      verts.push(imx, imy); // inner miter point
+                      verts.push(x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight)); // second segment's outer vertex
+                  }
+                  else /* rotating at outer angle */ {
+                      verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight)); // first segment's inner vertex
+                      verts.push(omx, omy); // outer miter point
+                      verts.push(x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight)); // second segment's outer vertex
+                      verts.push(omx, omy); // outer miter point
+                  }
+                  indexCount += 2;
+              }
+              else if (style.join === exports.LINE_JOIN.ROUND) {
+                  if (clockwise) /* arc is outside */ {
+                      verts.push(imx, imy);
+                      verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight));
+                      indexCount += round(x1, y1, x1 + (perpx * outerWeight), y1 + (perpy * outerWeight), x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight), verts, true) + 4;
+                      verts.push(imx, imy);
+                      verts.push(x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight));
+                  }
+                  else /* arc is inside */ {
+                      verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight));
+                      verts.push(omx, omy);
+                      indexCount += round(x1, y1, x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight), verts, false) + 4;
+                      verts.push(x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight));
+                      verts.push(omx, omy);
+                  }
+              }
+              else {
+                  verts.push(imx, imy);
+                  verts.push(omx, omy);
+              }
+          }
+          else // inside miter is NOT ok
+           {
+              verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight)); // first segment's inner vertex
+              verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight)); // first segment's outer vertex
+              if (style.join === exports.LINE_JOIN.ROUND) {
+                  if (clockwise) /* arc is outside */ {
+                      indexCount += round(x1, y1, x1 + (perpx * outerWeight), y1 + (perpy * outerWeight), x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight), verts, true) + 2;
+                  }
+                  else /* arc is inside */ {
+                      indexCount += round(x1, y1, x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight), verts, false) + 2;
+                  }
+              }
+              else if (style.join === exports.LINE_JOIN.MITER && pdist / widthSquared <= miterLimitSquared) {
+                  if (clockwise) {
+                      verts.push(omx, omy); // inner miter point
+                      verts.push(omx, omy); // inner miter point
+                  }
+                  else {
+                      verts.push(imx, imy); // outer miter point
+                      verts.push(imx, imy); // outer miter point
+                  }
+                  indexCount += 2;
+              }
+              verts.push(x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight)); // second segment's inner vertex
+              verts.push(x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight)); // second segment's outer vertex
+              indexCount += 2;
+          }
+      }
+      x0 = points[(length - 2) * 2];
+      y0 = points[((length - 2) * 2) + 1];
+      x1 = points[(length - 1) * 2];
+      y1 = points[((length - 1) * 2) + 1];
+      perpx = -(y0 - y1);
+      perpy = x0 - x1;
+      dist = Math.sqrt((perpx * perpx) + (perpy * perpy));
+      perpx /= dist;
+      perpy /= dist;
+      perpx *= width;
+      perpy *= width;
+      verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight));
+      verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight));
+      if (!closedShape) {
+          if (style.cap === exports.LINE_CAP.ROUND) {
+              indexCount += round(x1 - (perpx * (innerWeight - outerWeight) * 0.5), y1 - (perpy * (innerWeight - outerWeight) * 0.5), x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 + (perpx * outerWeight), y1 + (perpy * outerWeight), verts, false) + 2;
+          }
+          else if (style.cap === exports.LINE_CAP.SQUARE) {
+              indexCount += square(x1, y1, perpx, perpy, innerWeight, outerWeight, false, verts);
+          }
+      }
+      var indices = graphicsGeometry.indices;
+      var eps2 = GRAPHICS_CURVES.epsilon * GRAPHICS_CURVES.epsilon;
+      // indices.push(indexStart);
+      for (var i = indexStart; i < indexCount + indexStart - 2; ++i) {
+          x0 = verts[(i * 2)];
+          y0 = verts[(i * 2) + 1];
+          x1 = verts[(i + 1) * 2];
+          y1 = verts[((i + 1) * 2) + 1];
+          x2 = verts[(i + 2) * 2];
+          y2 = verts[((i + 2) * 2) + 1];
+          /* Skip zero area triangles */
+          if (Math.abs((x0 * (y1 - y2)) + (x1 * (y2 - y0)) + (x2 * (y0 - y1))) < eps2) {
+              continue;
+          }
+          indices.push(i, i + 1, i + 2);
+      }
+  }
+  /**
+   * Builds a line to draw using the gl.drawArrays(gl.LINES) method
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {PIXI.GraphicsData} graphicsData - The graphics object containing all the necessary properties
+   * @param {PIXI.GraphicsGeometry} graphicsGeometry - Geometry where to append output
+   */
+  function buildNativeLine(graphicsData, graphicsGeometry) {
+      var i = 0;
+      var shape = graphicsData.shape;
+      var points = graphicsData.points || shape.points;
+      var closedShape = shape.type !== exports.SHAPES.POLY || shape.closeStroke;
+      if (points.length === 0)
+          { return; }
+      var verts = graphicsGeometry.points;
+      var indices = graphicsGeometry.indices;
+      var length = points.length / 2;
+      var startIndex = verts.length / 2;
+      var currentIndex = startIndex;
+      verts.push(points[0], points[1]);
+      for (i = 1; i < length; i++) {
+          verts.push(points[i * 2], points[(i * 2) + 1]);
+          indices.push(currentIndex, currentIndex + 1);
+          currentIndex++;
+      }
+      if (closedShape) {
+          indices.push(currentIndex, startIndex);
+      }
+  }
+  /**
+   * Builds a line to draw
+   *
+   * Ignored from docs since it is not directly exposed.
+   * @ignore
+   * @private
+   * @param {PIXI.GraphicsData} graphicsData - The graphics object containing all the necessary properties
+   * @param {PIXI.GraphicsGeometry} graphicsGeometry - Geometry where to append output
+   */
+  function buildLine(graphicsData, graphicsGeometry) {
+      if (graphicsData.lineStyle.native) {
+          buildNativeLine(graphicsData, graphicsGeometry);
+      }
+      else {
+          buildNonNativeLine(graphicsData, graphicsGeometry);
+      }
+  }
 
-        core.TextMetrics.measureFont(font);
+  /**
+   * Utilities for arc curves.
+   * @private
+   */
+  var ArcUtils = /** @class */ (function () {
+      function ArcUtils() {
+      }
+      /**
+       * The arcTo() method creates an arc/curve between two tangents on the canvas.
+       *
+       * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
+       * @private
+       * @param x1 - The x-coordinate of the beginning of the arc
+       * @param y1 - The y-coordinate of the beginning of the arc
+       * @param x2 - The x-coordinate of the end of the arc
+       * @param y2 - The y-coordinate of the end of the arc
+       * @param radius - The radius of the arc
+       * @param points -
+       * @returns - If the arc length is valid, return center of circle, radius and other info otherwise `null`.
+       */
+      ArcUtils.curveTo = function (x1, y1, x2, y2, radius, points) {
+          var fromX = points[points.length - 2];
+          var fromY = points[points.length - 1];
+          var a1 = fromY - y1;
+          var b1 = fromX - x1;
+          var a2 = y2 - y1;
+          var b2 = x2 - x1;
+          var mm = Math.abs((a1 * b2) - (b1 * a2));
+          if (mm < 1.0e-8 || radius === 0) {
+              if (points[points.length - 2] !== x1 || points[points.length - 1] !== y1) {
+                  points.push(x1, y1);
+              }
+              return null;
+          }
+          var dd = (a1 * a1) + (b1 * b1);
+          var cc = (a2 * a2) + (b2 * b2);
+          var tt = (a1 * a2) + (b1 * b2);
+          var k1 = radius * Math.sqrt(dd) / mm;
+          var k2 = radius * Math.sqrt(cc) / mm;
+          var j1 = k1 * tt / dd;
+          var j2 = k2 * tt / cc;
+          var cx = (k1 * b2) + (k2 * b1);
+          var cy = (k1 * a2) + (k2 * a1);
+          var px = b1 * (k2 + j1);
+          var py = a1 * (k2 + j1);
+          var qx = b2 * (k1 + j2);
+          var qy = a2 * (k1 + j2);
+          var startAngle = Math.atan2(py - cy, px - cx);
+          var endAngle = Math.atan2(qy - cy, qx - cx);
+          return {
+              cx: (cx + x1),
+              cy: (cy + y1),
+              radius: radius,
+              startAngle: startAngle,
+              endAngle: endAngle,
+              anticlockwise: (b1 * a2 > b2 * a1),
+          };
+      };
+      /* eslint-disable max-len */
+      /**
+       * The arc method creates an arc/curve (used to create circles, or parts of circles).
+       * @private
+       * @param _startX - Start x location of arc
+       * @param _startY - Start y location of arc
+       * @param cx - The x-coordinate of the center of the circle
+       * @param cy - The y-coordinate of the center of the circle
+       * @param radius - The radius of the circle
+       * @param startAngle - The starting angle, in radians (0 is at the 3 o'clock position
+       *  of the arc's circle)
+       * @param endAngle - The ending angle, in radians
+       * @param _anticlockwise - Specifies whether the drawing should be
+       *  counter-clockwise or clockwise. False is default, and indicates clockwise, while true
+       *  indicates counter-clockwise.
+       * @param points - Collection of points to add to
+       */
+      ArcUtils.arc = function (_startX, _startY, cx, cy, radius, startAngle, endAngle, _anticlockwise, points) {
+          var sweep = endAngle - startAngle;
+          var n = GRAPHICS_CURVES._segmentsCount(Math.abs(sweep) * radius, Math.ceil(Math.abs(sweep) / PI_2) * 40);
+          var theta = (sweep) / (n * 2);
+          var theta2 = theta * 2;
+          var cTheta = Math.cos(theta);
+          var sTheta = Math.sin(theta);
+          var segMinus = n - 1;
+          var remainder = (segMinus % 1) / segMinus;
+          for (var i = 0; i <= segMinus; ++i) {
+              var real = i + (remainder * i);
+              var angle = ((theta) + startAngle + (theta2 * real));
+              var c = Math.cos(angle);
+              var s = -Math.sin(angle);
+              points.push((((cTheta * c) + (sTheta * s)) * radius) + cx, (((cTheta * -s) + (sTheta * c)) * radius) + cy);
+          }
+      };
+      return ArcUtils;
+  }());
 
-        return true;
-    }
+  /**
+   * Utilities for bezier curves
+   * @private
+   */
+  var BezierUtils = /** @class */ (function () {
+      function BezierUtils() {
+      }
+      /**
+       * Calculate length of bezier curve.
+       * Analytical solution is impossible, since it involves an integral that does not integrate in general.
+       * Therefore numerical solution is used.
+       * @private
+       * @param fromX - Starting point x
+       * @param fromY - Starting point y
+       * @param cpX - Control point x
+       * @param cpY - Control point y
+       * @param cpX2 - Second Control point x
+       * @param cpY2 - Second Control point y
+       * @param toX - Destination point x
+       * @param toY - Destination point y
+       * @returns - Length of bezier curve
+       */
+      BezierUtils.curveLength = function (fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
+          var n = 10;
+          var result = 0.0;
+          var t = 0.0;
+          var t2 = 0.0;
+          var t3 = 0.0;
+          var nt = 0.0;
+          var nt2 = 0.0;
+          var nt3 = 0.0;
+          var x = 0.0;
+          var y = 0.0;
+          var dx = 0.0;
+          var dy = 0.0;
+          var prevX = fromX;
+          var prevY = fromY;
+          for (var i = 1; i <= n; ++i) {
+              t = i / n;
+              t2 = t * t;
+              t3 = t2 * t;
+              nt = (1.0 - t);
+              nt2 = nt * nt;
+              nt3 = nt2 * nt;
+              x = (nt3 * fromX) + (3.0 * nt2 * t * cpX) + (3.0 * nt * t2 * cpX2) + (t3 * toX);
+              y = (nt3 * fromY) + (3.0 * nt2 * t * cpY) + (3 * nt * t2 * cpY2) + (t3 * toY);
+              dx = prevX - x;
+              dy = prevY - y;
+              prevX = x;
+              prevY = y;
+              result += Math.sqrt((dx * dx) + (dy * dy));
+          }
+          return result;
+      };
+      /**
+       * Calculate the points for a bezier curve and then draws it.
+       *
+       * Ignored from docs since it is not directly exposed.
+       * @ignore
+       * @param cpX - Control point x
+       * @param cpY - Control point y
+       * @param cpX2 - Second Control point x
+       * @param cpY2 - Second Control point y
+       * @param toX - Destination point x
+       * @param toY - Destination point y
+       * @param points - Path array to push points into
+       */
+      BezierUtils.curveTo = function (cpX, cpY, cpX2, cpY2, toX, toY, points) {
+          var fromX = points[points.length - 2];
+          var fromY = points[points.length - 1];
+          points.length -= 2;
+          var n = GRAPHICS_CURVES._segmentsCount(BezierUtils.curveLength(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY));
+          var dt = 0;
+          var dt2 = 0;
+          var dt3 = 0;
+          var t2 = 0;
+          var t3 = 0;
+          points.push(fromX, fromY);
+          for (var i = 1, j = 0; i <= n; ++i) {
+              j = i / n;
+              dt = (1 - j);
+              dt2 = dt * dt;
+              dt3 = dt2 * dt;
+              t2 = j * j;
+              t3 = t2 * j;
+              points.push((dt3 * fromX) + (3 * dt2 * j * cpX) + (3 * dt * t2 * cpX2) + (t3 * toX), (dt3 * fromY) + (3 * dt2 * j * cpY) + (3 * dt * t2 * cpY2) + (t3 * toY));
+          }
+      };
+      return BezierUtils;
+  }());
 
-    return false;
-}
+  /**
+   * Utilities for quadratic curves.
+   * @private
+   */
+  var QuadraticUtils = /** @class */ (function () {
+      function QuadraticUtils() {
+      }
+      /**
+       * Calculate length of quadratic curve
+       * @see {@link http://www.malczak.linuxpl.com/blog/quadratic-bezier-curve-length/}
+       * for the detailed explanation of math behind this.
+       * @private
+       * @param fromX - x-coordinate of curve start point
+       * @param fromY - y-coordinate of curve start point
+       * @param cpX - x-coordinate of curve control point
+       * @param cpY - y-coordinate of curve control point
+       * @param toX - x-coordinate of curve end point
+       * @param toY - y-coordinate of curve end point
+       * @returns - Length of quadratic curve
+       */
+      QuadraticUtils.curveLength = function (fromX, fromY, cpX, cpY, toX, toY) {
+          var ax = fromX - (2.0 * cpX) + toX;
+          var ay = fromY - (2.0 * cpY) + toY;
+          var bx = (2.0 * cpX) - (2.0 * fromX);
+          var by = (2.0 * cpY) - (2.0 * fromY);
+          var a = 4.0 * ((ax * ax) + (ay * ay));
+          var b = 4.0 * ((ax * bx) + (ay * by));
+          var c = (bx * bx) + (by * by);
+          var s = 2.0 * Math.sqrt(a + b + c);
+          var a2 = Math.sqrt(a);
+          var a32 = 2.0 * a * a2;
+          var c2 = 2.0 * Math.sqrt(c);
+          var ba = b / a2;
+          return ((a32 * s)
+              + (a2 * b * (s - c2))
+              + (((4.0 * c * a) - (b * b))
+                  * Math.log(((2.0 * a2) + ba + s) / (ba + c2)))) / (4.0 * a32);
+      };
+      /**
+       * Calculate the points for a quadratic bezier curve and then draws it.
+       * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
+       * @private
+       * @param cpX - Control point x
+       * @param cpY - Control point y
+       * @param toX - Destination point x
+       * @param toY - Destination point y
+       * @param points - Points to add segments to.
+       */
+      QuadraticUtils.curveTo = function (cpX, cpY, toX, toY, points) {
+          var fromX = points[points.length - 2];
+          var fromY = points[points.length - 1];
+          var n = GRAPHICS_CURVES._segmentsCount(QuadraticUtils.curveLength(fromX, fromY, cpX, cpY, toX, toY));
+          var xa = 0;
+          var ya = 0;
+          for (var i = 1; i <= n; ++i) {
+              var j = i / n;
+              xa = fromX + ((cpX - fromX) * j);
+              ya = fromY + ((cpY - fromY) * j);
+              points.push(xa + (((cpX + ((toX - cpX) * j)) - xa) * j), ya + (((cpY + ((toY - cpY) * j)) - ya) * j));
+          }
+      };
+      return QuadraticUtils;
+  }());
 
-/**
- * Built-in hook to find Text objects.
- *
- * @private
- * @param {PIXI.DisplayObject} item - Display object to check
- * @param {Array<*>} queue - Collection of items to upload
- * @return {boolean} if a PIXI.Text object was found.
- */
-function findText(item, queue) {
-    if (item instanceof core.Text) {
-        // push the text style to prepare it - this can be really expensive
-        if (queue.indexOf(item.style) === -1) {
-            queue.push(item.style);
-        }
-        // also push the text object so that we can render it (to canvas/texture) if needed
-        if (queue.indexOf(item) === -1) {
-            queue.push(item);
-        }
-        // also push the Text's texture for upload to GPU
-        var texture = item._texture.baseTexture;
+  /**
+   * A structure to hold interim batch objects for Graphics.
+   * @memberof PIXI.graphicsUtils
+   */
+  var BatchPart = /** @class */ (function () {
+      function BatchPart() {
+          this.reset();
+      }
+      /**
+       * Begin batch part.
+       * @param style
+       * @param startIndex
+       * @param attribStart
+       */
+      BatchPart.prototype.begin = function (style, startIndex, attribStart) {
+          this.reset();
+          this.style = style;
+          this.start = startIndex;
+          this.attribStart = attribStart;
+      };
+      /**
+       * End batch part.
+       * @param endIndex
+       * @param endAttrib
+       */
+      BatchPart.prototype.end = function (endIndex, endAttrib) {
+          this.attribSize = endAttrib - this.attribStart;
+          this.size = endIndex - this.start;
+      };
+      BatchPart.prototype.reset = function () {
+          this.style = null;
+          this.size = 0;
+          this.start = 0;
+          this.attribStart = 0;
+          this.attribSize = 0;
+      };
+      return BatchPart;
+  }());
 
-        if (queue.indexOf(texture) === -1) {
-            queue.push(texture);
-        }
+  /**
+   * Generalized convenience utilities for Graphics.
+   * @namespace graphicsUtils
+   * @memberof PIXI
+   */
+  var _a;
+  /**
+   * Map of fill commands for each shape type.
+   * @memberof PIXI.graphicsUtils
+   * @member {object} FILL_COMMANDS
+   */
+  var FILL_COMMANDS = (_a = {},
+      _a[exports.SHAPES.POLY] = buildPoly,
+      _a[exports.SHAPES.CIRC] = buildCircle,
+      _a[exports.SHAPES.ELIP] = buildCircle,
+      _a[exports.SHAPES.RECT] = buildRectangle,
+      _a[exports.SHAPES.RREC] = buildRoundedRectangle,
+      _a);
+  /**
+   * Batch pool, stores unused batches for preventing allocations.
+   * @memberof PIXI.graphicsUtils
+   * @member {Array<PIXI.graphicsUtils.BatchPart>} BATCH_POOL
+   */
+  var BATCH_POOL = [];
+  /**
+   * Draw call pool, stores unused draw calls for preventing allocations.
+   * @memberof PIXI.graphicsUtils
+   * @member {Array<PIXI.BatchDrawCall>} DRAW_CALL_POOL
+   */
+  var DRAW_CALL_POOL = [];
 
-        return true;
-    }
+  /**
+   * A class to contain data useful for Graphics objects
+   * @memberof PIXI
+   */
+  var GraphicsData = /** @class */ (function () {
+      /**
+       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - The shape object to draw.
+       * @param fillStyle - the width of the line to draw
+       * @param lineStyle - the color of the line to draw
+       * @param matrix - Transform matrix
+       */
+      function GraphicsData(shape, fillStyle, lineStyle, matrix) {
+          if (fillStyle === void 0) { fillStyle = null; }
+          if (lineStyle === void 0) { lineStyle = null; }
+          if (matrix === void 0) { matrix = null; }
+          /** The collection of points. */
+          this.points = [];
+          /** The collection of holes. */
+          this.holes = [];
+          this.shape = shape;
+          this.lineStyle = lineStyle;
+          this.fillStyle = fillStyle;
+          this.matrix = matrix;
+          this.type = shape.type;
+      }
+      /**
+       * Creates a new GraphicsData object with the same values as this one.
+       * @returns - Cloned GraphicsData object
+       */
+      GraphicsData.prototype.clone = function () {
+          return new GraphicsData(this.shape, this.fillStyle, this.lineStyle, this.matrix);
+      };
+      /** Destroys the Graphics data. */
+      GraphicsData.prototype.destroy = function () {
+          this.shape = null;
+          this.holes.length = 0;
+          this.holes = null;
+          this.points.length = 0;
+          this.points = null;
+          this.lineStyle = null;
+          this.fillStyle = null;
+      };
+      return GraphicsData;
+  }());
+
+  var tmpPoint = new Point();
+  /**
+   * The Graphics class contains methods used to draw primitive shapes such as lines, circles and
+   * rectangles to the display, and to color and fill them.
+   *
+   * GraphicsGeometry is designed to not be continually updating the geometry since it's expensive
+   * to re-tesselate using **earcut**. Consider using {@link PIXI.Mesh} for this use-case, it's much faster.
+   * @memberof PIXI
+   */
+  var GraphicsGeometry = /** @class */ (function (_super) {
+      __extends$e(GraphicsGeometry, _super);
+      // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+      function GraphicsGeometry() {
+          var _this = _super.call(this) || this;
+          /** Minimal distance between points that are considered different. Affects line tesselation. */
+          _this.closePointEps = 1e-4;
+          /** Padding to add to the bounds. */
+          _this.boundsPadding = 0;
+          _this.uvsFloat32 = null;
+          _this.indicesUint16 = null;
+          _this.batchable = false;
+          /** An array of points to draw, 2 numbers per point */
+          _this.points = [];
+          /** The collection of colors */
+          _this.colors = [];
+          /** The UVs collection */
+          _this.uvs = [];
+          /** The indices of the vertices */
+          _this.indices = [];
+          /** Reference to the texture IDs. */
+          _this.textureIds = [];
+          /**
+           * The collection of drawn shapes.
+           * @member {PIXI.GraphicsData[]}
+           */
+          _this.graphicsData = [];
+          /**
+           * List of current draw calls drived from the batches.
+           * @member {PIXI.BatchDrawCall[]}
+           */
+          _this.drawCalls = [];
+          /** Batches need to regenerated if the geometry is updated. */
+          _this.batchDirty = -1;
+          /**
+           * Intermediate abstract format sent to batch system.
+           * Can be converted to drawCalls or to batchable objects.
+           * @member {PIXI.graphicsUtils.BatchPart[]}
+           */
+          _this.batches = [];
+          /** Used to detect if the graphics object has changed. */
+          _this.dirty = 0;
+          /** Used to check if the cache is dirty. */
+          _this.cacheDirty = -1;
+          /** Used to detect if we cleared the graphicsData. */
+          _this.clearDirty = 0;
+          /** Index of the last batched shape in the stack of calls. */
+          _this.shapeIndex = 0;
+          /** Cached bounds. */
+          _this._bounds = new Bounds();
+          /** The bounds dirty flag. */
+          _this.boundsDirty = -1;
+          return _this;
+      }
+      Object.defineProperty(GraphicsGeometry.prototype, "bounds", {
+          /**
+           * Get the current bounds of the graphic geometry.
+           * @readonly
+           */
+          get: function () {
+              this.updateBatches();
+              if (this.boundsDirty !== this.dirty) {
+                  this.boundsDirty = this.dirty;
+                  this.calculateBounds();
+              }
+              return this._bounds;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Call if you changed graphicsData manually. Empties all batch buffers. */
+      GraphicsGeometry.prototype.invalidate = function () {
+          this.boundsDirty = -1;
+          this.dirty++;
+          this.batchDirty++;
+          this.shapeIndex = 0;
+          this.points.length = 0;
+          this.colors.length = 0;
+          this.uvs.length = 0;
+          this.indices.length = 0;
+          this.textureIds.length = 0;
+          for (var i = 0; i < this.drawCalls.length; i++) {
+              this.drawCalls[i].texArray.clear();
+              DRAW_CALL_POOL.push(this.drawCalls[i]);
+          }
+          this.drawCalls.length = 0;
+          for (var i = 0; i < this.batches.length; i++) {
+              var batchPart = this.batches[i];
+              batchPart.reset();
+              BATCH_POOL.push(batchPart);
+          }
+          this.batches.length = 0;
+      };
+      /**
+       * Clears the graphics that were drawn to this Graphics object, and resets fill and line style settings.
+       * @returns - This GraphicsGeometry object. Good for chaining method calls
+       */
+      GraphicsGeometry.prototype.clear = function () {
+          if (this.graphicsData.length > 0) {
+              this.invalidate();
+              this.clearDirty++;
+              this.graphicsData.length = 0;
+          }
+          return this;
+      };
+      /**
+       * Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
+       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - The shape object to draw.
+       * @param fillStyle - Defines style of the fill.
+       * @param lineStyle - Defines style of the lines.
+       * @param matrix - Transform applied to the points of the shape.
+       * @returns - Returns geometry for chaining.
+       */
+      GraphicsGeometry.prototype.drawShape = function (shape, fillStyle, lineStyle, matrix) {
+          if (fillStyle === void 0) { fillStyle = null; }
+          if (lineStyle === void 0) { lineStyle = null; }
+          if (matrix === void 0) { matrix = null; }
+          var data = new GraphicsData(shape, fillStyle, lineStyle, matrix);
+          this.graphicsData.push(data);
+          this.dirty++;
+          return this;
+      };
+      /**
+       * Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
+       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - The shape object to draw.
+       * @param matrix - Transform applied to the points of the shape.
+       * @returns - Returns geometry for chaining.
+       */
+      GraphicsGeometry.prototype.drawHole = function (shape, matrix) {
+          if (matrix === void 0) { matrix = null; }
+          if (!this.graphicsData.length) {
+              return null;
+          }
+          var data = new GraphicsData(shape, null, null, matrix);
+          var lastShape = this.graphicsData[this.graphicsData.length - 1];
+          data.lineStyle = lastShape.lineStyle;
+          lastShape.holes.push(data);
+          this.dirty++;
+          return this;
+      };
+      /** Destroys the GraphicsGeometry object. */
+      GraphicsGeometry.prototype.destroy = function () {
+          _super.prototype.destroy.call(this);
+          // destroy each of the GraphicsData objects
+          for (var i = 0; i < this.graphicsData.length; ++i) {
+              this.graphicsData[i].destroy();
+          }
+          this.points.length = 0;
+          this.points = null;
+          this.colors.length = 0;
+          this.colors = null;
+          this.uvs.length = 0;
+          this.uvs = null;
+          this.indices.length = 0;
+          this.indices = null;
+          this.indexBuffer.destroy();
+          this.indexBuffer = null;
+          this.graphicsData.length = 0;
+          this.graphicsData = null;
+          this.drawCalls.length = 0;
+          this.drawCalls = null;
+          this.batches.length = 0;
+          this.batches = null;
+          this._bounds = null;
+      };
+      /**
+       * Check to see if a point is contained within this geometry.
+       * @param point - Point to check if it's contained.
+       * @returns {boolean} `true` if the point is contained within geometry.
+       */
+      GraphicsGeometry.prototype.containsPoint = function (point) {
+          var graphicsData = this.graphicsData;
+          for (var i = 0; i < graphicsData.length; ++i) {
+              var data = graphicsData[i];
+              if (!data.fillStyle.visible) {
+                  continue;
+              }
+              // only deal with fills..
+              if (data.shape) {
+                  if (data.matrix) {
+                      data.matrix.applyInverse(point, tmpPoint);
+                  }
+                  else {
+                      tmpPoint.copyFrom(point);
+                  }
+                  if (data.shape.contains(tmpPoint.x, tmpPoint.y)) {
+                      var hitHole = false;
+                      if (data.holes) {
+                          for (var i_1 = 0; i_1 < data.holes.length; i_1++) {
+                              var hole = data.holes[i_1];
+                              if (hole.shape.contains(tmpPoint.x, tmpPoint.y)) {
+                                  hitHole = true;
+                                  break;
+                              }
+                          }
+                      }
+                      if (!hitHole) {
+                          return true;
+                      }
+                  }
+              }
+          }
+          return false;
+      };
+      /**
+       * Generates intermediate batch data. Either gets converted to drawCalls
+       * or used to convert to batch objects directly by the Graphics object.
+       */
+      GraphicsGeometry.prototype.updateBatches = function () {
+          if (!this.graphicsData.length) {
+              this.batchable = true;
+              return;
+          }
+          if (!this.validateBatching()) {
+              return;
+          }
+          this.cacheDirty = this.dirty;
+          var uvs = this.uvs;
+          var graphicsData = this.graphicsData;
+          var batchPart = null;
+          var currentStyle = null;
+          if (this.batches.length > 0) {
+              batchPart = this.batches[this.batches.length - 1];
+              currentStyle = batchPart.style;
+          }
+          for (var i = this.shapeIndex; i < graphicsData.length; i++) {
+              this.shapeIndex++;
+              var data = graphicsData[i];
+              var fillStyle = data.fillStyle;
+              var lineStyle = data.lineStyle;
+              var command = FILL_COMMANDS[data.type];
+              // build out the shapes points..
+              command.build(data);
+              if (data.matrix) {
+                  this.transformPoints(data.points, data.matrix);
+              }
+              if (fillStyle.visible || lineStyle.visible) {
+                  this.processHoles(data.holes);
+              }
+              for (var j = 0; j < 2; j++) {
+                  var style = (j === 0) ? fillStyle : lineStyle;
+                  if (!style.visible)
+                      { continue; }
+                  var nextTexture = style.texture.baseTexture;
+                  var index_1 = this.indices.length;
+                  var attribIndex = this.points.length / 2;
+                  nextTexture.wrapMode = exports.WRAP_MODES.REPEAT;
+                  if (j === 0) {
+                      this.processFill(data);
+                  }
+                  else {
+                      this.processLine(data);
+                  }
+                  var size = (this.points.length / 2) - attribIndex;
+                  if (size === 0)
+                      { continue; }
+                  // close batch if style is different
+                  if (batchPart && !this._compareStyles(currentStyle, style)) {
+                      batchPart.end(index_1, attribIndex);
+                      batchPart = null;
+                  }
+                  // spawn new batch if its first batch or previous was closed
+                  if (!batchPart) {
+                      batchPart = BATCH_POOL.pop() || new BatchPart();
+                      batchPart.begin(style, index_1, attribIndex);
+                      this.batches.push(batchPart);
+                      currentStyle = style;
+                  }
+                  this.addUvs(this.points, uvs, style.texture, attribIndex, size, style.matrix);
+              }
+          }
+          var index = this.indices.length;
+          var attrib = this.points.length / 2;
+          if (batchPart) {
+              batchPart.end(index, attrib);
+          }
+          if (this.batches.length === 0) {
+              // there are no visible styles in GraphicsData
+              // its possible that someone wants Graphics just for the bounds
+              this.batchable = true;
+              return;
+          }
+          var need32 = attrib > 0xffff;
+          // prevent allocation when length is same as buffer
+          if (this.indicesUint16 && this.indices.length === this.indicesUint16.length
+              && need32 === (this.indicesUint16.BYTES_PER_ELEMENT > 2)) {
+              this.indicesUint16.set(this.indices);
+          }
+          else {
+              this.indicesUint16 = need32 ? new Uint32Array(this.indices) : new Uint16Array(this.indices);
+          }
+          // TODO make this a const..
+          this.batchable = this.isBatchable();
+          if (this.batchable) {
+              this.packBatches();
+          }
+          else {
+              this.buildDrawCalls();
+          }
+      };
+      /**
+       * Affinity check
+       * @param styleA
+       * @param styleB
+       */
+      GraphicsGeometry.prototype._compareStyles = function (styleA, styleB) {
+          if (!styleA || !styleB) {
+              return false;
+          }
+          if (styleA.texture.baseTexture !== styleB.texture.baseTexture) {
+              return false;
+          }
+          if (styleA.color + styleA.alpha !== styleB.color + styleB.alpha) {
+              return false;
+          }
+          if (!!styleA.native !== !!styleB.native) {
+              return false;
+          }
+          return true;
+      };
+      /** Test geometry for batching process. */
+      GraphicsGeometry.prototype.validateBatching = function () {
+          if (this.dirty === this.cacheDirty || !this.graphicsData.length) {
+              return false;
+          }
+          for (var i = 0, l = this.graphicsData.length; i < l; i++) {
+              var data = this.graphicsData[i];
+              var fill = data.fillStyle;
+              var line = data.lineStyle;
+              if (fill && !fill.texture.baseTexture.valid)
+                  { return false; }
+              if (line && !line.texture.baseTexture.valid)
+                  { return false; }
+          }
+          return true;
+      };
+      /** Offset the indices so that it works with the batcher. */
+      GraphicsGeometry.prototype.packBatches = function () {
+          this.batchDirty++;
+          this.uvsFloat32 = new Float32Array(this.uvs);
+          var batches = this.batches;
+          for (var i = 0, l = batches.length; i < l; i++) {
+              var batch = batches[i];
+              for (var j = 0; j < batch.size; j++) {
+                  var index = batch.start + j;
+                  this.indicesUint16[index] = this.indicesUint16[index] - batch.attribStart;
+              }
+          }
+      };
+      /**
+       * Checks to see if this graphics geometry can be batched.
+       * Currently it needs to be small enough and not contain any native lines.
+       */
+      GraphicsGeometry.prototype.isBatchable = function () {
+          // prevent heavy mesh batching
+          if (this.points.length > 0xffff * 2) {
+              return false;
+          }
+          var batches = this.batches;
+          for (var i = 0; i < batches.length; i++) {
+              if (batches[i].style.native) {
+                  return false;
+              }
+          }
+          return (this.points.length < GraphicsGeometry.BATCHABLE_SIZE * 2);
+      };
+      /** Converts intermediate batches data to drawCalls. */
+      GraphicsGeometry.prototype.buildDrawCalls = function () {
+          var TICK = ++BaseTexture._globalBatch;
+          for (var i = 0; i < this.drawCalls.length; i++) {
+              this.drawCalls[i].texArray.clear();
+              DRAW_CALL_POOL.push(this.drawCalls[i]);
+          }
+          this.drawCalls.length = 0;
+          var colors = this.colors;
+          var textureIds = this.textureIds;
+          var currentGroup = DRAW_CALL_POOL.pop();
+          if (!currentGroup) {
+              currentGroup = new BatchDrawCall();
+              currentGroup.texArray = new BatchTextureArray();
+          }
+          currentGroup.texArray.count = 0;
+          currentGroup.start = 0;
+          currentGroup.size = 0;
+          currentGroup.type = exports.DRAW_MODES.TRIANGLES;
+          var textureCount = 0;
+          var currentTexture = null;
+          var textureId = 0;
+          var native = false;
+          var drawMode = exports.DRAW_MODES.TRIANGLES;
+          var index = 0;
+          this.drawCalls.push(currentGroup);
+          // TODO - this can be simplified
+          for (var i = 0; i < this.batches.length; i++) {
+              var data = this.batches[i];
+              // TODO add some full on MAX_TEXTURE CODE..
+              var MAX_TEXTURES = 8;
+              // Forced cast for checking `native` without errors
+              var style = data.style;
+              var nextTexture = style.texture.baseTexture;
+              if (native !== !!style.native) {
+                  native = !!style.native;
+                  drawMode = native ? exports.DRAW_MODES.LINES : exports.DRAW_MODES.TRIANGLES;
+                  // force the batch to break!
+                  currentTexture = null;
+                  textureCount = MAX_TEXTURES;
+                  TICK++;
+              }
+              if (currentTexture !== nextTexture) {
+                  currentTexture = nextTexture;
+                  if (nextTexture._batchEnabled !== TICK) {
+                      if (textureCount === MAX_TEXTURES) {
+                          TICK++;
+                          textureCount = 0;
+                          if (currentGroup.size > 0) {
+                              currentGroup = DRAW_CALL_POOL.pop();
+                              if (!currentGroup) {
+                                  currentGroup = new BatchDrawCall();
+                                  currentGroup.texArray = new BatchTextureArray();
+                              }
+                              this.drawCalls.push(currentGroup);
+                          }
+                          currentGroup.start = index;
+                          currentGroup.size = 0;
+                          currentGroup.texArray.count = 0;
+                          currentGroup.type = drawMode;
+                      }
+                      // TODO add this to the render part..
+                      // Hack! Because texture has protected `touched`
+                      nextTexture.touched = 1; // touch;
+                      nextTexture._batchEnabled = TICK;
+                      nextTexture._batchLocation = textureCount;
+                      nextTexture.wrapMode = exports.WRAP_MODES.REPEAT;
+                      currentGroup.texArray.elements[currentGroup.texArray.count++] = nextTexture;
+                      textureCount++;
+                  }
+              }
+              currentGroup.size += data.size;
+              index += data.size;
+              textureId = nextTexture._batchLocation;
+              this.addColors(colors, style.color, style.alpha, data.attribSize, data.attribStart);
+              this.addTextureIds(textureIds, textureId, data.attribSize, data.attribStart);
+          }
+          BaseTexture._globalBatch = TICK;
+          // upload..
+          // merge for now!
+          this.packAttributes();
+      };
+      /** Packs attributes to single buffer. */
+      GraphicsGeometry.prototype.packAttributes = function () {
+          var verts = this.points;
+          var uvs = this.uvs;
+          var colors = this.colors;
+          var textureIds = this.textureIds;
+          // verts are 2 positions.. so we * by 3 as there are 6 properties.. then 4 cos its bytes
+          var glPoints = new ArrayBuffer(verts.length * 3 * 4);
+          var f32 = new Float32Array(glPoints);
+          var u32 = new Uint32Array(glPoints);
+          var p = 0;
+          for (var i = 0; i < verts.length / 2; i++) {
+              f32[p++] = verts[i * 2];
+              f32[p++] = verts[(i * 2) + 1];
+              f32[p++] = uvs[i * 2];
+              f32[p++] = uvs[(i * 2) + 1];
+              u32[p++] = colors[i];
+              f32[p++] = textureIds[i];
+          }
+          this._buffer.update(glPoints);
+          this._indexBuffer.update(this.indicesUint16);
+      };
+      /**
+       * Process fill part of Graphics.
+       * @param data
+       */
+      GraphicsGeometry.prototype.processFill = function (data) {
+          if (data.holes.length) {
+              buildPoly.triangulate(data, this);
+          }
+          else {
+              var command = FILL_COMMANDS[data.type];
+              command.triangulate(data, this);
+          }
+      };
+      /**
+       * Process line part of Graphics.
+       * @param data
+       */
+      GraphicsGeometry.prototype.processLine = function (data) {
+          buildLine(data, this);
+          for (var i = 0; i < data.holes.length; i++) {
+              buildLine(data.holes[i], this);
+          }
+      };
+      /**
+       * Process the holes data.
+       * @param holes
+       */
+      GraphicsGeometry.prototype.processHoles = function (holes) {
+          for (var i = 0; i < holes.length; i++) {
+              var hole = holes[i];
+              var command = FILL_COMMANDS[hole.type];
+              command.build(hole);
+              if (hole.matrix) {
+                  this.transformPoints(hole.points, hole.matrix);
+              }
+          }
+      };
+      /** Update the local bounds of the object. Expensive to use performance-wise. */
+      GraphicsGeometry.prototype.calculateBounds = function () {
+          var bounds = this._bounds;
+          bounds.clear();
+          bounds.addVertexData(this.points, 0, this.points.length);
+          bounds.pad(this.boundsPadding, this.boundsPadding);
+      };
+      /**
+       * Transform points using matrix.
+       * @param points - Points to transform
+       * @param matrix - Transform matrix
+       */
+      GraphicsGeometry.prototype.transformPoints = function (points, matrix) {
+          for (var i = 0; i < points.length / 2; i++) {
+              var x = points[(i * 2)];
+              var y = points[(i * 2) + 1];
+              points[(i * 2)] = (matrix.a * x) + (matrix.c * y) + matrix.tx;
+              points[(i * 2) + 1] = (matrix.b * x) + (matrix.d * y) + matrix.ty;
+          }
+      };
+      /**
+       * Add colors.
+       * @param colors - List of colors to add to
+       * @param color - Color to add
+       * @param alpha - Alpha to use
+       * @param size - Number of colors to add
+       * @param offset
+       */
+      GraphicsGeometry.prototype.addColors = function (colors, color, alpha, size, offset) {
+          if (offset === void 0) { offset = 0; }
+          // TODO use the premultiply bits Ivan added
+          var rgb = (color >> 16) + (color & 0xff00) + ((color & 0xff) << 16);
+          var rgba = premultiplyTint(rgb, alpha);
+          colors.length = Math.max(colors.length, offset + size);
+          for (var i = 0; i < size; i++) {
+              colors[offset + i] = rgba;
+          }
+      };
+      /**
+       * Add texture id that the shader/fragment wants to use.
+       * @param textureIds
+       * @param id
+       * @param size
+       * @param offset
+       */
+      GraphicsGeometry.prototype.addTextureIds = function (textureIds, id, size, offset) {
+          if (offset === void 0) { offset = 0; }
+          textureIds.length = Math.max(textureIds.length, offset + size);
+          for (var i = 0; i < size; i++) {
+              textureIds[offset + i] = id;
+          }
+      };
+      /**
+       * Generates the UVs for a shape.
+       * @param verts - Vertices
+       * @param uvs - UVs
+       * @param texture - Reference to Texture
+       * @param start - Index buffer start index.
+       * @param size - The size/length for index buffer.
+       * @param matrix - Optional transform for all points.
+       */
+      GraphicsGeometry.prototype.addUvs = function (verts, uvs, texture, start, size, matrix) {
+          if (matrix === void 0) { matrix = null; }
+          var index = 0;
+          var uvsStart = uvs.length;
+          var frame = texture.frame;
+          while (index < size) {
+              var x = verts[(start + index) * 2];
+              var y = verts[((start + index) * 2) + 1];
+              if (matrix) {
+                  var nx = (matrix.a * x) + (matrix.c * y) + matrix.tx;
+                  y = (matrix.b * x) + (matrix.d * y) + matrix.ty;
+                  x = nx;
+              }
+              index++;
+              uvs.push(x / frame.width, y / frame.height);
+          }
+          var baseTexture = texture.baseTexture;
+          if (frame.width < baseTexture.width
+              || frame.height < baseTexture.height) {
+              this.adjustUvs(uvs, texture, uvsStart, size);
+          }
+      };
+      /**
+       * Modify uvs array according to position of texture region
+       * Does not work with rotated or trimmed textures
+       * @param uvs - array
+       * @param texture - region
+       * @param start - starting index for uvs
+       * @param size - how many points to adjust
+       */
+      GraphicsGeometry.prototype.adjustUvs = function (uvs, texture, start, size) {
+          var baseTexture = texture.baseTexture;
+          var eps = 1e-6;
+          var finish = start + (size * 2);
+          var frame = texture.frame;
+          var scaleX = frame.width / baseTexture.width;
+          var scaleY = frame.height / baseTexture.height;
+          var offsetX = frame.x / frame.width;
+          var offsetY = frame.y / frame.height;
+          var minX = Math.floor(uvs[start] + eps);
+          var minY = Math.floor(uvs[start + 1] + eps);
+          for (var i = start + 2; i < finish; i += 2) {
+              minX = Math.min(minX, Math.floor(uvs[i] + eps));
+              minY = Math.min(minY, Math.floor(uvs[i + 1] + eps));
+          }
+          offsetX -= minX;
+          offsetY -= minY;
+          for (var i = start; i < finish; i += 2) {
+              uvs[i] = (uvs[i] + offsetX) * scaleX;
+              uvs[i + 1] = (uvs[i + 1] + offsetY) * scaleY;
+          }
+      };
+      /**
+       * The maximum number of points to consider an object "batchable",
+       * able to be batched by the renderer's batch system.
+  \
+       */
+      GraphicsGeometry.BATCHABLE_SIZE = 100;
+      return GraphicsGeometry;
+  }(BatchGeometry));
 
-    return false;
-}
+  /**
+   * Represents the line style for Graphics.
+   * @memberof PIXI
+   */
+  var LineStyle = /** @class */ (function (_super) {
+      __extends$e(LineStyle, _super);
+      function LineStyle() {
+          var _this = _super !== null && _super.apply(this, arguments) || this;
+          /** The width (thickness) of any lines drawn. */
+          _this.width = 0;
+          /** The alignment of any lines drawn (0.5 = middle, 1 = outer, 0 = inner). WebGL only. */
+          _this.alignment = 0.5;
+          /** If true the lines will be draw using LINES instead of TRIANGLE_STRIP. */
+          _this.native = false;
+          /**
+           * Line cap style.
+           * @member {PIXI.LINE_CAP}
+           * @default PIXI.LINE_CAP.BUTT
+           */
+          _this.cap = exports.LINE_CAP.BUTT;
+          /**
+           * Line join style.
+           * @member {PIXI.LINE_JOIN}
+           * @default PIXI.LINE_JOIN.MITER
+           */
+          _this.join = exports.LINE_JOIN.MITER;
+          /** Miter limit. */
+          _this.miterLimit = 10;
+          return _this;
+      }
+      /** Clones the object. */
+      LineStyle.prototype.clone = function () {
+          var obj = new LineStyle();
+          obj.color = this.color;
+          obj.alpha = this.alpha;
+          obj.texture = this.texture;
+          obj.matrix = this.matrix;
+          obj.visible = this.visible;
+          obj.width = this.width;
+          obj.alignment = this.alignment;
+          obj.native = this.native;
+          obj.cap = this.cap;
+          obj.join = this.join;
+          obj.miterLimit = this.miterLimit;
+          return obj;
+      };
+      /** Reset the line style to default. */
+      LineStyle.prototype.reset = function () {
+          _super.prototype.reset.call(this);
+          // Override default line style color
+          this.color = 0x0;
+          this.alignment = 0.5;
+          this.width = 0;
+          this.native = false;
+      };
+      return LineStyle;
+  }(FillStyle));
+
+  var temp = new Float32Array(3);
+  // a default shaders map used by graphics..
+  var DEFAULT_SHADERS = {};
+  /**
+   * The Graphics class is primarily used to render primitive shapes such as lines, circles and
+   * rectangles to the display, and to color and fill them.  However, you can also use a Graphics
+   * object to build a list of primitives to use as a mask, or as a complex hitArea.
+   *
+   * Please note that due to legacy naming conventions, the behavior of some functions in this class
+   * can be confusing.  Each call to `drawRect()`, `drawPolygon()`, etc. actually stores that primitive
+   * in the Geometry class's GraphicsGeometry object for later use in rendering or hit testing - the
+   * functions do not directly draw anything to the screen.  Similarly, the `clear()` function doesn't
+   * change the screen, it simply resets the list of primitives, which can be useful if you want to
+   * rebuild the contents of an existing Graphics object.
+   *
+   * Once a GraphicsGeometry list is built, you can re-use it in other Geometry objects as
+   * an optimization, by passing it into a new Geometry object's constructor.  Because of this
+   * ability, it's important to call `destroy()` on Geometry objects once you are done with them, to
+   * properly dereference each GraphicsGeometry and prevent memory leaks.
+   * @memberof PIXI
+   */
+  var Graphics = /** @class */ (function (_super) {
+      __extends$e(Graphics, _super);
+      /**
+       * @param geometry - Geometry to use, if omitted will create a new GraphicsGeometry instance.
+       */
+      function Graphics(geometry) {
+          if (geometry === void 0) { geometry = null; }
+          var _this = _super.call(this) || this;
+          /**
+           * Represents the vertex and fragment shaders that processes the geometry and runs on the GPU.
+           * Can be shared between multiple Graphics objects.
+           */
+          _this.shader = null;
+          /** Renderer plugin for batching */
+          _this.pluginName = 'batch';
+          /**
+           * Current path
+           * @readonly
+           */
+          _this.currentPath = null;
+          /** A collections of batches! These can be drawn by the renderer batch system. */
+          _this.batches = [];
+          /** Update dirty for limiting calculating tints for batches. */
+          _this.batchTint = -1;
+          /** Update dirty for limiting calculating batches.*/
+          _this.batchDirty = -1;
+          /** Copy of the object vertex data. */
+          _this.vertexData = null;
+          /** Current fill style. */
+          _this._fillStyle = new FillStyle();
+          /** Current line style. */
+          _this._lineStyle = new LineStyle();
+          /** Current shape transform matrix. */
+          _this._matrix = null;
+          /** Current hole mode is enabled. */
+          _this._holeMode = false;
+          /**
+           * Represents the WebGL state the Graphics required to render, excludes shader and geometry. E.g.,
+           * blend mode, culling, depth testing, direction of rendering triangles, backface, etc.
+           */
+          _this.state = State.for2d();
+          _this._geometry = geometry || new GraphicsGeometry();
+          _this._geometry.refCount++;
+          /**
+           * When cacheAsBitmap is set to true the graphics object will be rendered as if it was a sprite.
+           * This is useful if your graphics element does not change often, as it will speed up the rendering
+           * of the object in exchange for taking up texture memory. It is also useful if you need the graphics
+           * object to be anti-aliased, because it will be rendered using canvas. This is not recommended if
+           * you are constantly redrawing the graphics element.
+           * @name cacheAsBitmap
+           * @member {boolean}
+           * @memberof PIXI.Graphics#
+           * @default false
+           */
+          _this._transformID = -1;
+          // Set default
+          _this.tint = 0xFFFFFF;
+          _this.blendMode = exports.BLEND_MODES.NORMAL;
+          return _this;
+      }
+      Object.defineProperty(Graphics.prototype, "geometry", {
+          /**
+           * Includes vertex positions, face indices, normals, colors, UVs, and
+           * custom attributes within buffers, reducing the cost of passing all
+           * this data to the GPU. Can be shared between multiple Mesh or Graphics objects.
+           * @readonly
+           */
+          get: function () {
+              return this._geometry;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Creates a new Graphics object with the same values as this one.
+       * Note that only the geometry of the object is cloned, not its transform (position,scale,etc)
+       * @returns - A clone of the graphics object
+       */
+      Graphics.prototype.clone = function () {
+          this.finishPoly();
+          return new Graphics(this._geometry);
+      };
+      Object.defineProperty(Graphics.prototype, "blendMode", {
+          get: function () {
+              return this.state.blendMode;
+          },
+          /**
+           * The blend mode to be applied to the graphic shape. Apply a value of
+           * `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.  Note that, since each
+           * primitive in the GraphicsGeometry list is rendered sequentially, modes
+           * such as `PIXI.BLEND_MODES.ADD` and `PIXI.BLEND_MODES.MULTIPLY` will
+           * be applied per-primitive.
+           * @default PIXI.BLEND_MODES.NORMAL
+           */
+          set: function (value) {
+              this.state.blendMode = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Graphics.prototype, "tint", {
+          /**
+           * The tint applied to each graphic shape. This is a hex value. A value of
+           * 0xFFFFFF will remove any tint effect.
+           * @default 0xFFFFFF
+           */
+          get: function () {
+              return this._tint;
+          },
+          set: function (value) {
+              this._tint = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Graphics.prototype, "fill", {
+          /**
+           * The current fill style.
+           * @readonly
+           */
+          get: function () {
+              return this._fillStyle;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Graphics.prototype, "line", {
+          /**
+           * The current line style.
+           * @readonly
+           */
+          get: function () {
+              return this._lineStyle;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Graphics.prototype.lineStyle = function (options, color, alpha, alignment, native) {
+          if (options === void 0) { options = null; }
+          if (color === void 0) { color = 0x0; }
+          if (alpha === void 0) { alpha = 1; }
+          if (alignment === void 0) { alignment = 0.5; }
+          if (native === void 0) { native = false; }
+          // Support non-object params: (width, color, alpha, alignment, native)
+          if (typeof options === 'number') {
+              options = { width: options, color: color, alpha: alpha, alignment: alignment, native: native };
+          }
+          return this.lineTextureStyle(options);
+      };
+      /**
+       * Like line style but support texture for line fill.
+       * @param [options] - Collection of options for setting line style.
+       * @param {number} [options.width=0] - width of the line to draw, will update the objects stored style
+       * @param {PIXI.Texture} [options.texture=PIXI.Texture.WHITE] - Texture to use
+       * @param {number} [options.color=0x0] - color of the line to draw, will update the objects stored style.
+       *  Default 0xFFFFFF if texture present.
+       * @param {number} [options.alpha=1] - alpha of the line to draw, will update the objects stored style
+       * @param {PIXI.Matrix} [options.matrix=null] - Texture matrix to transform texture
+       * @param {number} [options.alignment=0.5] - alignment of the line to draw, (0 = inner, 0.5 = middle, 1 = outer).
+       *        WebGL only.
+       * @param {boolean} [options.native=false] - If true the lines will be draw using LINES instead of TRIANGLE_STRIP
+       * @param {PIXI.LINE_CAP}[options.cap=PIXI.LINE_CAP.BUTT] - line cap style
+       * @param {PIXI.LINE_JOIN}[options.join=PIXI.LINE_JOIN.MITER] - line join style
+       * @param {number}[options.miterLimit=10] - miter limit ratio
+       * @returns {PIXI.Graphics} This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.lineTextureStyle = function (options) {
+          // Apply defaults
+          options = Object.assign({
+              width: 0,
+              texture: Texture.WHITE,
+              color: (options && options.texture) ? 0xFFFFFF : 0x0,
+              alpha: 1,
+              matrix: null,
+              alignment: 0.5,
+              native: false,
+              cap: exports.LINE_CAP.BUTT,
+              join: exports.LINE_JOIN.MITER,
+              miterLimit: 10,
+          }, options);
+          if (this.currentPath) {
+              this.startPoly();
+          }
+          var visible = options.width > 0 && options.alpha > 0;
+          if (!visible) {
+              this._lineStyle.reset();
+          }
+          else {
+              if (options.matrix) {
+                  options.matrix = options.matrix.clone();
+                  options.matrix.invert();
+              }
+              Object.assign(this._lineStyle, { visible: visible }, options);
+          }
+          return this;
+      };
+      /**
+       * Start a polygon object internally.
+       * @protected
+       */
+      Graphics.prototype.startPoly = function () {
+          if (this.currentPath) {
+              var points = this.currentPath.points;
+              var len = this.currentPath.points.length;
+              if (len > 2) {
+                  this.drawShape(this.currentPath);
+                  this.currentPath = new Polygon();
+                  this.currentPath.closeStroke = false;
+                  this.currentPath.points.push(points[len - 2], points[len - 1]);
+              }
+          }
+          else {
+              this.currentPath = new Polygon();
+              this.currentPath.closeStroke = false;
+          }
+      };
+      /**
+       * Finish the polygon object.
+       * @protected
+       */
+      Graphics.prototype.finishPoly = function () {
+          if (this.currentPath) {
+              if (this.currentPath.points.length > 2) {
+                  this.drawShape(this.currentPath);
+                  this.currentPath = null;
+              }
+              else {
+                  this.currentPath.points.length = 0;
+              }
+          }
+      };
+      /**
+       * Moves the current drawing position to x, y.
+       * @param x - the X coordinate to move to
+       * @param y - the Y coordinate to move to
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.moveTo = function (x, y) {
+          this.startPoly();
+          this.currentPath.points[0] = x;
+          this.currentPath.points[1] = y;
+          return this;
+      };
+      /**
+       * Draws a line using the current line style from the current drawing position to (x, y);
+       * The current drawing position is then set to (x, y).
+       * @param x - the X coordinate to draw to
+       * @param y - the Y coordinate to draw to
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.lineTo = function (x, y) {
+          if (!this.currentPath) {
+              this.moveTo(0, 0);
+          }
+          // remove duplicates..
+          var points = this.currentPath.points;
+          var fromX = points[points.length - 2];
+          var fromY = points[points.length - 1];
+          if (fromX !== x || fromY !== y) {
+              points.push(x, y);
+          }
+          return this;
+      };
+      /**
+       * Initialize the curve
+       * @param x
+       * @param y
+       */
+      Graphics.prototype._initCurve = function (x, y) {
+          if (x === void 0) { x = 0; }
+          if (y === void 0) { y = 0; }
+          if (this.currentPath) {
+              if (this.currentPath.points.length === 0) {
+                  this.currentPath.points = [x, y];
+              }
+          }
+          else {
+              this.moveTo(x, y);
+          }
+      };
+      /**
+       * Calculate the points for a quadratic bezier curve and then draws it.
+       * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
+       * @param cpX - Control point x
+       * @param cpY - Control point y
+       * @param toX - Destination point x
+       * @param toY - Destination point y
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.quadraticCurveTo = function (cpX, cpY, toX, toY) {
+          this._initCurve();
+          var points = this.currentPath.points;
+          if (points.length === 0) {
+              this.moveTo(0, 0);
+          }
+          QuadraticUtils.curveTo(cpX, cpY, toX, toY, points);
+          return this;
+      };
+      /**
+       * Calculate the points for a bezier curve and then draws it.
+       * @param cpX - Control point x
+       * @param cpY - Control point y
+       * @param cpX2 - Second Control point x
+       * @param cpY2 - Second Control point y
+       * @param toX - Destination point x
+       * @param toY - Destination point y
+       * @returns This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.bezierCurveTo = function (cpX, cpY, cpX2, cpY2, toX, toY) {
+          this._initCurve();
+          BezierUtils.curveTo(cpX, cpY, cpX2, cpY2, toX, toY, this.currentPath.points);
+          return this;
+      };
+      /**
+       * The arcTo() method creates an arc/curve between two tangents on the canvas.
+       *
+       * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
+       * @param x1 - The x-coordinate of the first tangent point of the arc
+       * @param y1 - The y-coordinate of the first tangent point of the arc
+       * @param x2 - The x-coordinate of the end of the arc
+       * @param y2 - The y-coordinate of the end of the arc
+       * @param radius - The radius of the arc
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.arcTo = function (x1, y1, x2, y2, radius) {
+          this._initCurve(x1, y1);
+          var points = this.currentPath.points;
+          var result = ArcUtils.curveTo(x1, y1, x2, y2, radius, points);
+          if (result) {
+              var cx = result.cx, cy = result.cy, radius_1 = result.radius, startAngle = result.startAngle, endAngle = result.endAngle, anticlockwise = result.anticlockwise;
+              this.arc(cx, cy, radius_1, startAngle, endAngle, anticlockwise);
+          }
+          return this;
+      };
+      /**
+       * The arc method creates an arc/curve (used to create circles, or parts of circles).
+       * @param cx - The x-coordinate of the center of the circle
+       * @param cy - The y-coordinate of the center of the circle
+       * @param radius - The radius of the circle
+       * @param startAngle - The starting angle, in radians (0 is at the 3 o'clock position
+       *  of the arc's circle)
+       * @param endAngle - The ending angle, in radians
+       * @param anticlockwise - Specifies whether the drawing should be
+       *  counter-clockwise or clockwise. False is default, and indicates clockwise, while true
+       *  indicates counter-clockwise.
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.arc = function (cx, cy, radius, startAngle, endAngle, anticlockwise) {
+          if (anticlockwise === void 0) { anticlockwise = false; }
+          if (startAngle === endAngle) {
+              return this;
+          }
+          if (!anticlockwise && endAngle <= startAngle) {
+              endAngle += PI_2;
+          }
+          else if (anticlockwise && startAngle <= endAngle) {
+              startAngle += PI_2;
+          }
+          var sweep = endAngle - startAngle;
+          if (sweep === 0) {
+              return this;
+          }
+          var startX = cx + (Math.cos(startAngle) * radius);
+          var startY = cy + (Math.sin(startAngle) * radius);
+          var eps = this._geometry.closePointEps;
+          // If the currentPath exists, take its points. Otherwise call `moveTo` to start a path.
+          var points = this.currentPath ? this.currentPath.points : null;
+          if (points) {
+              // TODO: make a better fix.
+              // We check how far our start is from the last existing point
+              var xDiff = Math.abs(points[points.length - 2] - startX);
+              var yDiff = Math.abs(points[points.length - 1] - startY);
+              if (xDiff < eps && yDiff < eps) { ; }
+              else {
+                  points.push(startX, startY);
+              }
+          }
+          else {
+              this.moveTo(startX, startY);
+              points = this.currentPath.points;
+          }
+          ArcUtils.arc(startX, startY, cx, cy, radius, startAngle, endAngle, anticlockwise, points);
+          return this;
+      };
+      /**
+       * Specifies a simple one-color fill that subsequent calls to other Graphics methods
+       * (such as lineTo() or drawCircle()) use when drawing.
+       * @param color - the color of the fill
+       * @param alpha - the alpha of the fill
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.beginFill = function (color, alpha) {
+          if (color === void 0) { color = 0; }
+          if (alpha === void 0) { alpha = 1; }
+          return this.beginTextureFill({ texture: Texture.WHITE, color: color, alpha: alpha });
+      };
+      /**
+       * Begin the texture fill
+       * @param options - Object object.
+       * @param {PIXI.Texture} [options.texture=PIXI.Texture.WHITE] - Texture to fill
+       * @param {number} [options.color=0xffffff] - Background to fill behind texture
+       * @param {number} [options.alpha=1] - Alpha of fill
+       * @param {PIXI.Matrix} [options.matrix=null] - Transform matrix
+       * @returns {PIXI.Graphics} This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.beginTextureFill = function (options) {
+          // Apply defaults
+          options = Object.assign({
+              texture: Texture.WHITE,
+              color: 0xFFFFFF,
+              alpha: 1,
+              matrix: null,
+          }, options);
+          if (this.currentPath) {
+              this.startPoly();
+          }
+          var visible = options.alpha > 0;
+          if (!visible) {
+              this._fillStyle.reset();
+          }
+          else {
+              if (options.matrix) {
+                  options.matrix = options.matrix.clone();
+                  options.matrix.invert();
+              }
+              Object.assign(this._fillStyle, { visible: visible }, options);
+          }
+          return this;
+      };
+      /**
+       * Applies a fill to the lines and shapes that were added since the last call to the beginFill() method.
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.endFill = function () {
+          this.finishPoly();
+          this._fillStyle.reset();
+          return this;
+      };
+      /**
+       * Draws a rectangle shape.
+       * @param x - The X coord of the top-left of the rectangle
+       * @param y - The Y coord of the top-left of the rectangle
+       * @param width - The width of the rectangle
+       * @param height - The height of the rectangle
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.drawRect = function (x, y, width, height) {
+          return this.drawShape(new Rectangle(x, y, width, height));
+      };
+      /**
+       * Draw a rectangle shape with rounded/beveled corners.
+       * @param x - The X coord of the top-left of the rectangle
+       * @param y - The Y coord of the top-left of the rectangle
+       * @param width - The width of the rectangle
+       * @param height - The height of the rectangle
+       * @param radius - Radius of the rectangle corners
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.drawRoundedRect = function (x, y, width, height, radius) {
+          return this.drawShape(new RoundedRectangle(x, y, width, height, radius));
+      };
+      /**
+       * Draws a circle.
+       * @param x - The X coordinate of the center of the circle
+       * @param y - The Y coordinate of the center of the circle
+       * @param radius - The radius of the circle
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.drawCircle = function (x, y, radius) {
+          return this.drawShape(new Circle(x, y, radius));
+      };
+      /**
+       * Draws an ellipse.
+       * @param x - The X coordinate of the center of the ellipse
+       * @param y - The Y coordinate of the center of the ellipse
+       * @param width - The half width of the ellipse
+       * @param height - The half height of the ellipse
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.drawEllipse = function (x, y, width, height) {
+          return this.drawShape(new Ellipse(x, y, width, height));
+      };
+      /**
+       * Draws a polygon using the given path.
+       * @param {number[]|PIXI.IPointData[]|PIXI.Polygon} path - The path data used to construct the polygon.
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.drawPolygon = function () {
+          var arguments$1 = arguments;
 
-/**
- * Built-in hook to find TextStyle objects.
- *
- * @private
- * @param {PIXI.TextStyle} item - Display object to check
- * @param {Array<*>} queue - Collection of items to upload
- * @return {boolean} if a PIXI.TextStyle object was found.
- */
-function findTextStyle(item, queue) {
-    if (item instanceof core.TextStyle) {
-        if (queue.indexOf(item) === -1) {
-            queue.push(item);
-        }
+          var path = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              path[_i] = arguments$1[_i];
+          }
+          var points;
+          var closeStroke = true; // !!this._fillStyle;
+          var poly = path[0];
+          // check if data has points..
+          if (poly.points) {
+              closeStroke = poly.closeStroke;
+              points = poly.points;
+          }
+          else if (Array.isArray(path[0])) {
+              points = path[0];
+          }
+          else {
+              points = path;
+          }
+          var shape = new Polygon(points);
+          shape.closeStroke = closeStroke;
+          this.drawShape(shape);
+          return this;
+      };
+      /**
+       * Draw any shape.
+       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - Shape to draw
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.drawShape = function (shape) {
+          if (!this._holeMode) {
+              this._geometry.drawShape(shape, this._fillStyle.clone(), this._lineStyle.clone(), this._matrix);
+          }
+          else {
+              this._geometry.drawHole(shape, this._matrix);
+          }
+          return this;
+      };
+      /**
+       * Clears the graphics that were drawn to this Graphics object, and resets fill and line style settings.
+       * @returns - This Graphics object. Good for chaining method calls
+       */
+      Graphics.prototype.clear = function () {
+          this._geometry.clear();
+          this._lineStyle.reset();
+          this._fillStyle.reset();
+          this._boundsID++;
+          this._matrix = null;
+          this._holeMode = false;
+          this.currentPath = null;
+          return this;
+      };
+      /**
+       * True if graphics consists of one rectangle, and thus, can be drawn like a Sprite and
+       * masked with gl.scissor.
+       * @returns - True if only 1 rect.
+       */
+      Graphics.prototype.isFastRect = function () {
+          var data = this._geometry.graphicsData;
+          return data.length === 1
+              && data[0].shape.type === exports.SHAPES.RECT
+              && !data[0].matrix
+              && !data[0].holes.length
+              && !(data[0].lineStyle.visible && data[0].lineStyle.width);
+      };
+      /**
+       * Renders the object using the WebGL renderer
+       * @param renderer - The renderer
+       */
+      Graphics.prototype._render = function (renderer) {
+          this.finishPoly();
+          var geometry = this._geometry;
+          // batch part..
+          // batch it!
+          geometry.updateBatches();
+          if (geometry.batchable) {
+              if (this.batchDirty !== geometry.batchDirty) {
+                  this._populateBatches();
+              }
+              this._renderBatched(renderer);
+          }
+          else {
+              // no batching...
+              renderer.batch.flush();
+              this._renderDirect(renderer);
+          }
+      };
+      /** Populating batches for rendering. */
+      Graphics.prototype._populateBatches = function () {
+          var geometry = this._geometry;
+          var blendMode = this.blendMode;
+          var len = geometry.batches.length;
+          this.batchTint = -1;
+          this._transformID = -1;
+          this.batchDirty = geometry.batchDirty;
+          this.batches.length = len;
+          this.vertexData = new Float32Array(geometry.points);
+          for (var i = 0; i < len; i++) {
+              var gI = geometry.batches[i];
+              var color = gI.style.color;
+              var vertexData = new Float32Array(this.vertexData.buffer, gI.attribStart * 4 * 2, gI.attribSize * 2);
+              var uvs = new Float32Array(geometry.uvsFloat32.buffer, gI.attribStart * 4 * 2, gI.attribSize * 2);
+              var indices = new Uint16Array(geometry.indicesUint16.buffer, gI.start * 2, gI.size);
+              var batch = {
+                  vertexData: vertexData,
+                  blendMode: blendMode,
+                  indices: indices,
+                  uvs: uvs,
+                  _batchRGB: hex2rgb(color),
+                  _tintRGB: color,
+                  _texture: gI.style.texture,
+                  alpha: gI.style.alpha,
+                  worldAlpha: 1
+              };
+              this.batches[i] = batch;
+          }
+      };
+      /**
+       * Renders the batches using the BathedRenderer plugin
+       * @param renderer - The renderer
+       */
+      Graphics.prototype._renderBatched = function (renderer) {
+          if (!this.batches.length) {
+              return;
+          }
+          renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
+          this.calculateVertices();
+          this.calculateTints();
+          for (var i = 0, l = this.batches.length; i < l; i++) {
+              var batch = this.batches[i];
+              batch.worldAlpha = this.worldAlpha * batch.alpha;
+              renderer.plugins[this.pluginName].render(batch);
+          }
+      };
+      /**
+       * Renders the graphics direct
+       * @param renderer - The renderer
+       */
+      Graphics.prototype._renderDirect = function (renderer) {
+          var shader = this._resolveDirectShader(renderer);
+          var geometry = this._geometry;
+          var tint = this.tint;
+          var worldAlpha = this.worldAlpha;
+          var uniforms = shader.uniforms;
+          var drawCalls = geometry.drawCalls;
+          // lets set the transfomr
+          uniforms.translationMatrix = this.transform.worldTransform;
+          // and then lets set the tint..
+          uniforms.tint[0] = (((tint >> 16) & 0xFF) / 255) * worldAlpha;
+          uniforms.tint[1] = (((tint >> 8) & 0xFF) / 255) * worldAlpha;
+          uniforms.tint[2] = ((tint & 0xFF) / 255) * worldAlpha;
+          uniforms.tint[3] = worldAlpha;
+          // the first draw call, we can set the uniforms of the shader directly here.
+          // this means that we can tack advantage of the sync function of pixi!
+          // bind and sync uniforms..
+          // there is a way to optimise this..
+          renderer.shader.bind(shader);
+          renderer.geometry.bind(geometry, shader);
+          // set state..
+          renderer.state.set(this.state);
+          // then render the rest of them...
+          for (var i = 0, l = drawCalls.length; i < l; i++) {
+              this._renderDrawCallDirect(renderer, geometry.drawCalls[i]);
+          }
+      };
+      /**
+       * Renders specific DrawCall
+       * @param renderer
+       * @param drawCall
+       */
+      Graphics.prototype._renderDrawCallDirect = function (renderer, drawCall) {
+          var texArray = drawCall.texArray, type = drawCall.type, size = drawCall.size, start = drawCall.start;
+          var groupTextureCount = texArray.count;
+          for (var j = 0; j < groupTextureCount; j++) {
+              renderer.texture.bind(texArray.elements[j], j);
+          }
+          renderer.geometry.draw(type, size, start);
+      };
+      /**
+       * Resolves shader for direct rendering
+       * @param renderer - The renderer
+       */
+      Graphics.prototype._resolveDirectShader = function (renderer) {
+          var shader = this.shader;
+          var pluginName = this.pluginName;
+          if (!shader) {
+              // if there is no shader here, we can use the default shader.
+              // and that only gets created if we actually need it..
+              // but may be more than one plugins for graphics
+              if (!DEFAULT_SHADERS[pluginName]) {
+                  var MAX_TEXTURES = renderer.plugins[pluginName].MAX_TEXTURES;
+                  var sampleValues = new Int32Array(MAX_TEXTURES);
+                  for (var i = 0; i < MAX_TEXTURES; i++) {
+                      sampleValues[i] = i;
+                  }
+                  var uniforms = {
+                      tint: new Float32Array([1, 1, 1, 1]),
+                      translationMatrix: new Matrix(),
+                      default: UniformGroup.from({ uSamplers: sampleValues }, true),
+                  };
+                  var program = renderer.plugins[pluginName]._shader.program;
+                  DEFAULT_SHADERS[pluginName] = new Shader(program, uniforms);
+              }
+              shader = DEFAULT_SHADERS[pluginName];
+          }
+          return shader;
+      };
+      /** Retrieves the bounds of the graphic shape as a rectangle object. */
+      Graphics.prototype._calculateBounds = function () {
+          this.finishPoly();
+          var geometry = this._geometry;
+          // skipping when graphics is empty, like a container
+          if (!geometry.graphicsData.length) {
+              return;
+          }
+          var _a = geometry.bounds, minX = _a.minX, minY = _a.minY, maxX = _a.maxX, maxY = _a.maxY;
+          this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);
+      };
+      /**
+       * Tests if a point is inside this graphics object
+       * @param point - the point to test
+       * @returns - the result of the test
+       */
+      Graphics.prototype.containsPoint = function (point) {
+          this.worldTransform.applyInverse(point, Graphics._TEMP_POINT);
+          return this._geometry.containsPoint(Graphics._TEMP_POINT);
+      };
+      /** Recalculate the tint by applying tint to batches using Graphics tint. */
+      Graphics.prototype.calculateTints = function () {
+          if (this.batchTint !== this.tint) {
+              this.batchTint = this.tint;
+              var tintRGB = hex2rgb(this.tint, temp);
+              for (var i = 0; i < this.batches.length; i++) {
+                  var batch = this.batches[i];
+                  var batchTint = batch._batchRGB;
+                  var r = (tintRGB[0] * batchTint[0]) * 255;
+                  var g = (tintRGB[1] * batchTint[1]) * 255;
+                  var b = (tintRGB[2] * batchTint[2]) * 255;
+                  // TODO Ivan, can this be done in one go?
+                  var color = (r << 16) + (g << 8) + (b | 0);
+                  batch._tintRGB = (color >> 16)
+                      + (color & 0xff00)
+                      + ((color & 0xff) << 16);
+              }
+          }
+      };
+      /** If there's a transform update or a change to the shape of the geometry, recalculate the vertices. */
+      Graphics.prototype.calculateVertices = function () {
+          var wtID = this.transform._worldID;
+          if (this._transformID === wtID) {
+              return;
+          }
+          this._transformID = wtID;
+          var wt = this.transform.worldTransform;
+          var a = wt.a;
+          var b = wt.b;
+          var c = wt.c;
+          var d = wt.d;
+          var tx = wt.tx;
+          var ty = wt.ty;
+          var data = this._geometry.points; // batch.vertexDataOriginal;
+          var vertexData = this.vertexData;
+          var count = 0;
+          for (var i = 0; i < data.length; i += 2) {
+              var x = data[i];
+              var y = data[i + 1];
+              vertexData[count++] = (a * x) + (c * y) + tx;
+              vertexData[count++] = (d * y) + (b * x) + ty;
+          }
+      };
+      /**
+       * Closes the current path.
+       * @returns - Returns itself.
+       */
+      Graphics.prototype.closePath = function () {
+          var currentPath = this.currentPath;
+          if (currentPath) {
+              // we don't need to add extra point in the end because buildLine will take care of that
+              currentPath.closeStroke = true;
+              // ensure that the polygon is completed, and is available for hit detection
+              // (even if the graphics is not rendered yet)
+              this.finishPoly();
+          }
+          return this;
+      };
+      /**
+       * Apply a matrix to the positional data.
+       * @param matrix - Matrix to use for transform current shape.
+       * @returns - Returns itself.
+       */
+      Graphics.prototype.setMatrix = function (matrix) {
+          this._matrix = matrix;
+          return this;
+      };
+      /**
+       * Begin adding holes to the last draw shape
+       * IMPORTANT: holes must be fully inside a shape to work
+       * Also weirdness ensues if holes overlap!
+       * Ellipses, Circles, Rectangles and Rounded Rectangles cannot be holes or host for holes in CanvasRenderer,
+       * please use `moveTo` `lineTo`, `quadraticCurveTo` if you rely on pixi-legacy bundle.
+       * @returns - Returns itself.
+       */
+      Graphics.prototype.beginHole = function () {
+          this.finishPoly();
+          this._holeMode = true;
+          return this;
+      };
+      /**
+       * End adding holes to the last draw shape.
+       * @returns - Returns itself.
+       */
+      Graphics.prototype.endHole = function () {
+          this.finishPoly();
+          this._holeMode = false;
+          return this;
+      };
+      /**
+       * Destroys the Graphics object.
+       * @param options - Options parameter. A boolean will act as if all
+       *  options have been set to that value
+       * @param {boolean} [options.children=false] - if set to true, all the children will have
+       *  their destroy method called as well. 'options' will be passed on to those calls.
+       * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
+       *  Should it destroy the texture of the child sprite
+       * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
+       *  Should it destroy the base texture of the child sprite
+       */
+      Graphics.prototype.destroy = function (options) {
+          this._geometry.refCount--;
+          if (this._geometry.refCount === 0) {
+              this._geometry.dispose();
+          }
+          this._matrix = null;
+          this.currentPath = null;
+          this._lineStyle.destroy();
+          this._lineStyle = null;
+          this._fillStyle.destroy();
+          this._fillStyle = null;
+          this._geometry = null;
+          this.shader = null;
+          this.vertexData = null;
+          this.batches.length = 0;
+          this.batches = null;
+          _super.prototype.destroy.call(this, options);
+      };
+      /**
+       * New rendering behavior for rounded rectangles: circular arcs instead of quadratic bezier curves.
+       * In the next major release, we'll enable this by default.
+       */
+      Graphics.nextRoundedRectBehavior = false;
+      /**
+       * Temporary point to use for containsPoint.
+       * @private
+       */
+      Graphics._TEMP_POINT = new Point();
+      return Graphics;
+  }(Container));
+
+  var graphicsUtils = {
+      buildPoly: buildPoly,
+      buildCircle: buildCircle,
+      buildRectangle: buildRectangle,
+      buildRoundedRectangle: buildRoundedRectangle,
+      buildLine: buildLine,
+      ArcUtils: ArcUtils,
+      BezierUtils: BezierUtils,
+      QuadraticUtils: QuadraticUtils,
+      BatchPart: BatchPart,
+      FILL_COMMANDS: FILL_COMMANDS,
+      BATCH_POOL: BATCH_POOL,
+      DRAW_CALL_POOL: DRAW_CALL_POOL
+  };
 
-        return true;
-    }
+  /*!
+   * @pixi/sprite - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/sprite is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-    return false;
-}
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$d = function(d, b) {
+      extendStatics$d = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$d(d, b);
+  };
 
-},{"../core":65,"./limiters/CountLimiter":185}],183:[function(require,module,exports){
-'use strict';
+  function __extends$d(d, b) {
+      extendStatics$d(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-exports.__esModule = true;
+  var tempPoint$2 = new Point();
+  var indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+  /**
+   * The Sprite object is the base for all textured objects that are rendered to the screen
+   *
+   * A sprite can be created directly from an image like this:
+   *
+   * ```js
+   * let sprite = PIXI.Sprite.from('assets/image.png');
+   * ```
+   *
+   * The more efficient way to create sprites is using a {@link PIXI.Spritesheet},
+   * as swapping base textures when rendering to the screen is inefficient.
+   *
+   * ```js
+   * PIXI.Loader.shared.add("assets/spritesheet.json").load(setup);
+   *
+   * function setup() {
+   *   let sheet = PIXI.Loader.shared.resources["assets/spritesheet.json"].spritesheet;
+   *   let sprite = new PIXI.Sprite(sheet.textures["image.png"]);
+   *   ...
+   * }
+   * ```
+   * @memberof PIXI
+   */
+  var Sprite = /** @class */ (function (_super) {
+      __extends$d(Sprite, _super);
+      /** @param texture - The texture for this sprite. */
+      function Sprite(texture) {
+          var _this = _super.call(this) || this;
+          _this._anchor = new ObservablePoint(_this._onAnchorUpdate, _this, (texture ? texture.defaultAnchor.x : 0), (texture ? texture.defaultAnchor.y : 0));
+          _this._texture = null;
+          _this._width = 0;
+          _this._height = 0;
+          _this._tint = null;
+          _this._tintRGB = null;
+          _this.tint = 0xFFFFFF;
+          _this.blendMode = exports.BLEND_MODES.NORMAL;
+          _this._cachedTint = 0xFFFFFF;
+          _this.uvs = null;
+          // call texture setter
+          _this.texture = texture || Texture.EMPTY;
+          _this.vertexData = new Float32Array(8);
+          _this.vertexTrimmedData = null;
+          _this._transformID = -1;
+          _this._textureID = -1;
+          _this._transformTrimmedID = -1;
+          _this._textureTrimmedID = -1;
+          // Batchable stuff..
+          // TODO could make this a mixin?
+          _this.indices = indices;
+          _this.pluginName = 'batch';
+          /**
+           * Used to fast check if a sprite is.. a sprite!
+           * @member {boolean}
+           */
+          _this.isSprite = true;
+          _this._roundPixels = settings.ROUND_PIXELS;
+          return _this;
+      }
+      /** When the texture is updated, this event will fire to update the scale and frame. */
+      Sprite.prototype._onTextureUpdate = function () {
+          this._textureID = -1;
+          this._textureTrimmedID = -1;
+          this._cachedTint = 0xFFFFFF;
+          // so if _width is 0 then width was not set..
+          if (this._width) {
+              this.scale.x = sign(this.scale.x) * this._width / this._texture.orig.width;
+          }
+          if (this._height) {
+              this.scale.y = sign(this.scale.y) * this._height / this._texture.orig.height;
+          }
+      };
+      /** Called when the anchor position updates. */
+      Sprite.prototype._onAnchorUpdate = function () {
+          this._transformID = -1;
+          this._transformTrimmedID = -1;
+      };
+      /** Calculates worldTransform * vertices, store it in vertexData. */
+      Sprite.prototype.calculateVertices = function () {
+          var texture = this._texture;
+          if (this._transformID === this.transform._worldID && this._textureID === texture._updateID) {
+              return;
+          }
+          // update texture UV here, because base texture can be changed without calling `_onTextureUpdate`
+          if (this._textureID !== texture._updateID) {
+              this.uvs = this._texture._uvs.uvsFloat32;
+          }
+          this._transformID = this.transform._worldID;
+          this._textureID = texture._updateID;
+          // set the vertex data
+          var wt = this.transform.worldTransform;
+          var a = wt.a;
+          var b = wt.b;
+          var c = wt.c;
+          var d = wt.d;
+          var tx = wt.tx;
+          var ty = wt.ty;
+          var vertexData = this.vertexData;
+          var trim = texture.trim;
+          var orig = texture.orig;
+          var anchor = this._anchor;
+          var w0 = 0;
+          var w1 = 0;
+          var h0 = 0;
+          var h1 = 0;
+          if (trim) {
+              // if the sprite is trimmed and is not a tilingsprite then we need to add the extra
+              // space before transforming the sprite coords.
+              w1 = trim.x - (anchor._x * orig.width);
+              w0 = w1 + trim.width;
+              h1 = trim.y - (anchor._y * orig.height);
+              h0 = h1 + trim.height;
+          }
+          else {
+              w1 = -anchor._x * orig.width;
+              w0 = w1 + orig.width;
+              h1 = -anchor._y * orig.height;
+              h0 = h1 + orig.height;
+          }
+          // xy
+          vertexData[0] = (a * w1) + (c * h1) + tx;
+          vertexData[1] = (d * h1) + (b * w1) + ty;
+          // xy
+          vertexData[2] = (a * w0) + (c * h1) + tx;
+          vertexData[3] = (d * h1) + (b * w0) + ty;
+          // xy
+          vertexData[4] = (a * w0) + (c * h0) + tx;
+          vertexData[5] = (d * h0) + (b * w0) + ty;
+          // xy
+          vertexData[6] = (a * w1) + (c * h0) + tx;
+          vertexData[7] = (d * h0) + (b * w1) + ty;
+          if (this._roundPixels) {
+              var resolution = settings.RESOLUTION;
+              for (var i = 0; i < vertexData.length; ++i) {
+                  vertexData[i] = Math.round((vertexData[i] * resolution | 0) / resolution);
+              }
+          }
+      };
+      /**
+       * Calculates worldTransform * vertices for a non texture with a trim. store it in vertexTrimmedData.
+       *
+       * This is used to ensure that the true width and height of a trimmed texture is respected.
+       */
+      Sprite.prototype.calculateTrimmedVertices = function () {
+          if (!this.vertexTrimmedData) {
+              this.vertexTrimmedData = new Float32Array(8);
+          }
+          else if (this._transformTrimmedID === this.transform._worldID && this._textureTrimmedID === this._texture._updateID) {
+              return;
+          }
+          this._transformTrimmedID = this.transform._worldID;
+          this._textureTrimmedID = this._texture._updateID;
+          // lets do some special trim code!
+          var texture = this._texture;
+          var vertexData = this.vertexTrimmedData;
+          var orig = texture.orig;
+          var anchor = this._anchor;
+          // lets calculate the new untrimmed bounds..
+          var wt = this.transform.worldTransform;
+          var a = wt.a;
+          var b = wt.b;
+          var c = wt.c;
+          var d = wt.d;
+          var tx = wt.tx;
+          var ty = wt.ty;
+          var w1 = -anchor._x * orig.width;
+          var w0 = w1 + orig.width;
+          var h1 = -anchor._y * orig.height;
+          var h0 = h1 + orig.height;
+          // xy
+          vertexData[0] = (a * w1) + (c * h1) + tx;
+          vertexData[1] = (d * h1) + (b * w1) + ty;
+          // xy
+          vertexData[2] = (a * w0) + (c * h1) + tx;
+          vertexData[3] = (d * h1) + (b * w0) + ty;
+          // xy
+          vertexData[4] = (a * w0) + (c * h0) + tx;
+          vertexData[5] = (d * h0) + (b * w0) + ty;
+          // xy
+          vertexData[6] = (a * w1) + (c * h0) + tx;
+          vertexData[7] = (d * h0) + (b * w1) + ty;
+      };
+      /**
+       *
+       * Renders the object using the WebGL renderer
+       * @param renderer - The webgl renderer to use.
+       */
+      Sprite.prototype._render = function (renderer) {
+          this.calculateVertices();
+          renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
+          renderer.plugins[this.pluginName].render(this);
+      };
+      /** Updates the bounds of the sprite. */
+      Sprite.prototype._calculateBounds = function () {
+          var trim = this._texture.trim;
+          var orig = this._texture.orig;
+          // First lets check to see if the current texture has a trim..
+          if (!trim || (trim.width === orig.width && trim.height === orig.height)) {
+              // no trim! lets use the usual calculations..
+              this.calculateVertices();
+              this._bounds.addQuad(this.vertexData);
+          }
+          else {
+              // lets calculate a special trimmed bounds...
+              this.calculateTrimmedVertices();
+              this._bounds.addQuad(this.vertexTrimmedData);
+          }
+      };
+      /**
+       * Gets the local bounds of the sprite object.
+       * @param rect - Optional output rectangle.
+       * @returns The bounds.
+       */
+      Sprite.prototype.getLocalBounds = function (rect) {
+          // we can do a fast local bounds if the sprite has no children!
+          if (this.children.length === 0) {
+              if (!this._localBounds) {
+                  this._localBounds = new Bounds();
+              }
+              this._localBounds.minX = this._texture.orig.width * -this._anchor._x;
+              this._localBounds.minY = this._texture.orig.height * -this._anchor._y;
+              this._localBounds.maxX = this._texture.orig.width * (1 - this._anchor._x);
+              this._localBounds.maxY = this._texture.orig.height * (1 - this._anchor._y);
+              if (!rect) {
+                  if (!this._localBoundsRect) {
+                      this._localBoundsRect = new Rectangle();
+                  }
+                  rect = this._localBoundsRect;
+              }
+              return this._localBounds.getRectangle(rect);
+          }
+          return _super.prototype.getLocalBounds.call(this, rect);
+      };
+      /**
+       * Tests if a point is inside this sprite
+       * @param point - the point to test
+       * @returns The result of the test
+       */
+      Sprite.prototype.containsPoint = function (point) {
+          this.worldTransform.applyInverse(point, tempPoint$2);
+          var width = this._texture.orig.width;
+          var height = this._texture.orig.height;
+          var x1 = -width * this.anchor.x;
+          var y1 = 0;
+          if (tempPoint$2.x >= x1 && tempPoint$2.x < x1 + width) {
+              y1 = -height * this.anchor.y;
+              if (tempPoint$2.y >= y1 && tempPoint$2.y < y1 + height) {
+                  return true;
+              }
+          }
+          return false;
+      };
+      /**
+       * Destroys this sprite and optionally its texture and children.
+       * @param options - Options parameter. A boolean will act as if all options
+       *  have been set to that value
+       * @param [options.children=false] - if set to true, all the children will have their destroy
+       *      method called as well. 'options' will be passed on to those calls.
+       * @param [options.texture=false] - Should it destroy the current texture of the sprite as well
+       * @param [options.baseTexture=false] - Should it destroy the base texture of the sprite as well
+       */
+      Sprite.prototype.destroy = function (options) {
+          _super.prototype.destroy.call(this, options);
+          this._texture.off('update', this._onTextureUpdate, this);
+          this._anchor = null;
+          var destroyTexture = typeof options === 'boolean' ? options : options && options.texture;
+          if (destroyTexture) {
+              var destroyBaseTexture = typeof options === 'boolean' ? options : options && options.baseTexture;
+              this._texture.destroy(!!destroyBaseTexture);
+          }
+          this._texture = null;
+      };
+      // some helper functions..
+      /**
+       * Helper function that creates a new sprite based on the source you provide.
+       * The source can be - frame id, image url, video url, canvas element, video element, base texture
+       * @param {string|PIXI.Texture|HTMLCanvasElement|HTMLVideoElement} source - Source to create texture from
+       * @param {object} [options] - See {@link PIXI.BaseTexture}'s constructor for options.
+       * @returns The newly created sprite
+       */
+      Sprite.from = function (source, options) {
+          var texture = (source instanceof Texture)
+              ? source
+              : Texture.from(source, options);
+          return new Sprite(texture);
+      };
+      Object.defineProperty(Sprite.prototype, "roundPixels", {
+          get: function () {
+              return this._roundPixels;
+          },
+          /**
+           * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
+           *
+           * Advantages can include sharper image quality (like text) and faster rendering on canvas.
+           * The main disadvantage is movement of objects may appear less smooth.
+           *
+           * To set the global default, change {@link PIXI.settings.ROUND_PIXELS}.
+           * @default false
+           */
+          set: function (value) {
+              if (this._roundPixels !== value) {
+                  this._transformID = -1;
+              }
+              this._roundPixels = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Sprite.prototype, "width", {
+          /** The width of the sprite, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              return Math.abs(this.scale.x) * this._texture.orig.width;
+          },
+          set: function (value) {
+              var s = sign(this.scale.x) || 1;
+              this.scale.x = s * value / this._texture.orig.width;
+              this._width = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Sprite.prototype, "height", {
+          /** The height of the sprite, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              return Math.abs(this.scale.y) * this._texture.orig.height;
+          },
+          set: function (value) {
+              var s = sign(this.scale.y) || 1;
+              this.scale.y = s * value / this._texture.orig.height;
+              this._height = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Sprite.prototype, "anchor", {
+          /**
+           * The anchor sets the origin point of the sprite. The default value is taken from the {@link PIXI.Texture|Texture}
+           * and passed to the constructor.
+           *
+           * The default is `(0,0)`, this means the sprite's origin is the top left.
+           *
+           * Setting the anchor to `(0.5,0.5)` means the sprite's origin is centered.
+           *
+           * Setting the anchor to `(1,1)` would mean the sprite's origin point will be the bottom right corner.
+           *
+           * If you pass only single parameter, it will set both x and y to the same value as shown in the example below.
+           * @example
+           * const sprite = new PIXI.Sprite(texture);
+           * sprite.anchor.set(0.5); // This will set the origin to center. (0.5) is same as (0.5, 0.5).
+           */
+          get: function () {
+              return this._anchor;
+          },
+          set: function (value) {
+              this._anchor.copyFrom(value);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Sprite.prototype, "tint", {
+          /**
+           * The tint applied to the sprite. This is a hex value.
+           *
+           * A value of 0xFFFFFF will remove any tint effect.
+           * @default 0xFFFFFF
+           */
+          get: function () {
+              return this._tint;
+          },
+          set: function (value) {
+              this._tint = value;
+              this._tintRGB = (value >> 16) + (value & 0xff00) + ((value & 0xff) << 16);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Sprite.prototype, "texture", {
+          /** The texture that the sprite is using. */
+          get: function () {
+              return this._texture;
+          },
+          set: function (value) {
+              if (this._texture === value) {
+                  return;
+              }
+              if (this._texture) {
+                  this._texture.off('update', this._onTextureUpdate, this);
+              }
+              this._texture = value || Texture.EMPTY;
+              this._cachedTint = 0xFFFFFF;
+              this._textureID = -1;
+              this._textureTrimmedID = -1;
+              if (value) {
+                  // wait for the texture to load
+                  if (value.baseTexture.valid) {
+                      this._onTextureUpdate();
+                  }
+                  else {
+                      value.once('update', this._onTextureUpdate, this);
+                  }
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return Sprite;
+  }(Container));
+
+  /*!
+   * @pixi/text - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/text is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-var _core = require('../../core');
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$c = function(d, b) {
+      extendStatics$c = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$c(d, b);
+  };
 
-var core = _interopRequireWildcard(_core);
+  function __extends$c(d, b) {
+      extendStatics$c(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-var _BasePrepare2 = require('../BasePrepare');
+  /**
+   * Constants that define the type of gradient on text.
+   * @static
+   * @constant
+   * @name TEXT_GRADIENT
+   * @memberof PIXI
+   * @type {object}
+   * @property {number} LINEAR_VERTICAL Vertical gradient
+   * @property {number} LINEAR_HORIZONTAL Linear gradient
+   */
+  exports.TEXT_GRADIENT = void 0;
+  (function (TEXT_GRADIENT) {
+      TEXT_GRADIENT[TEXT_GRADIENT["LINEAR_VERTICAL"] = 0] = "LINEAR_VERTICAL";
+      TEXT_GRADIENT[TEXT_GRADIENT["LINEAR_HORIZONTAL"] = 1] = "LINEAR_HORIZONTAL";
+  })(exports.TEXT_GRADIENT || (exports.TEXT_GRADIENT = {}));
+
+  // disabling eslint for now, going to rewrite this in v5
+  var defaultStyle = {
+      align: 'left',
+      breakWords: false,
+      dropShadow: false,
+      dropShadowAlpha: 1,
+      dropShadowAngle: Math.PI / 6,
+      dropShadowBlur: 0,
+      dropShadowColor: 'black',
+      dropShadowDistance: 5,
+      fill: 'black',
+      fillGradientType: exports.TEXT_GRADIENT.LINEAR_VERTICAL,
+      fillGradientStops: [],
+      fontFamily: 'Arial',
+      fontSize: 26,
+      fontStyle: 'normal',
+      fontVariant: 'normal',
+      fontWeight: 'normal',
+      letterSpacing: 0,
+      lineHeight: 0,
+      lineJoin: 'miter',
+      miterLimit: 10,
+      padding: 0,
+      stroke: 'black',
+      strokeThickness: 0,
+      textBaseline: 'alphabetic',
+      trim: false,
+      whiteSpace: 'pre',
+      wordWrap: false,
+      wordWrapWidth: 100,
+      leading: 0,
+  };
+  var genericFontFamilies = [
+      'serif',
+      'sans-serif',
+      'monospace',
+      'cursive',
+      'fantasy',
+      'system-ui' ];
+  /**
+   * A TextStyle Object contains information to decorate a Text objects.
+   *
+   * An instance can be shared between multiple Text objects; then changing the style will update all text objects using it.
+   *
+   * A tool can be used to generate a text style [here](https://pixijs.io/pixi-text-style).
+   *
+   * @memberof PIXI
+   */
+  var TextStyle = /** @class */ (function () {
+      /**
+       * @param {object} [style] - The style parameters
+       * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center' or 'right'),
+       *  does not affect single line text
+       * @param {boolean} [style.breakWords=false] - Indicates if lines can be wrapped within words, it
+       *  needs wordWrap to be set to true
+       * @param {boolean} [style.dropShadow=false] - Set a drop shadow for the text
+       * @param {number} [style.dropShadowAlpha=1] - Set alpha for the drop shadow
+       * @param {number} [style.dropShadowAngle=Math.PI/6] - Set a angle of the drop shadow
+       * @param {number} [style.dropShadowBlur=0] - Set a shadow blur radius
+       * @param {string|number} [style.dropShadowColor='black'] - A fill style to be used on the dropshadow e.g 'red', '#00FF00'
+       * @param {number} [style.dropShadowDistance=5] - Set a distance of the drop shadow
+       * @param {string|string[]|number|number[]|CanvasGradient|CanvasPattern} [style.fill='black'] - A canvas
+       *  fillstyle that will be used on the text e.g 'red', '#00FF00'. Can be an array to create a gradient
+       *  eg ['#000000','#FFFFFF']
+       * {@link https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillStyle|MDN}
+       * @param {number} [style.fillGradientType=PIXI.TEXT_GRADIENT.LINEAR_VERTICAL] - If fill is an array of colours
+       *  to create a gradient, this can change the type/direction of the gradient. See {@link PIXI.TEXT_GRADIENT}
+       * @param {number[]} [style.fillGradientStops] - If fill is an array of colours to create a gradient, this array can set
+       * the stop points (numbers between 0 and 1) for the color, overriding the default behaviour of evenly spacing them.
+       * @param {string|string[]} [style.fontFamily='Arial'] - The font family
+       * @param {number|string} [style.fontSize=26] - The font size (as a number it converts to px, but as a string,
+       *  equivalents are '26px','20pt','160%' or '1.6em')
+       * @param {string} [style.fontStyle='normal'] - The font style ('normal', 'italic' or 'oblique')
+       * @param {string} [style.fontVariant='normal'] - The font variant ('normal' or 'small-caps')
+       * @param {string} [style.fontWeight='normal'] - The font weight ('normal', 'bold', 'bolder', 'lighter' and '100',
+       *  '200', '300', '400', '500', '600', '700', '800' or '900')
+       * @param {number} [style.leading=0] - The space between lines
+       * @param {number} [style.letterSpacing=0] - The amount of spacing between letters, default is 0
+       * @param {number} [style.lineHeight] - The line height, a number that represents the vertical space that a letter uses
+       * @param {string} [style.lineJoin='miter'] - The lineJoin property sets the type of corner created, it can resolve
+       *      spiked text issues. Possible values "miter" (creates a sharp corner), "round" (creates a round corner) or "bevel"
+       *      (creates a squared corner).
+       * @param {number} [style.miterLimit=10] - The miter limit to use when using the 'miter' lineJoin mode. This can reduce
+       *      or increase the spikiness of rendered text.
+       * @param {number} [style.padding=0] - Occasionally some fonts are cropped. Adding some padding will prevent this from
+       *     happening by adding padding to all sides of the text.
+       * @param {string|number} [style.stroke='black'] - A canvas fillstyle that will be used on the text stroke
+       *  e.g 'blue', '#FCFF00'
+       * @param {number} [style.strokeThickness=0] - A number that represents the thickness of the stroke.
+       *  Default is 0 (no stroke)
+       * @param {boolean} [style.trim=false] - Trim transparent borders
+       * @param {string} [style.textBaseline='alphabetic'] - The baseline of the text that is rendered.
+       * @param {string} [style.whiteSpace='pre'] - Determines whether newlines & spaces are collapsed or preserved "normal"
+       *      (collapse, collapse), "pre" (preserve, preserve) | "pre-line" (preserve, collapse). It needs wordWrap to be set to true
+       * @param {boolean} [style.wordWrap=false] - Indicates if word wrap should be used
+       * @param {number} [style.wordWrapWidth=100] - The width at which text will wrap, it needs wordWrap to be set to true
+       */
+      function TextStyle(style) {
+          this.styleID = 0;
+          this.reset();
+          deepCopyProperties(this, style, style);
+      }
+      /**
+       * Creates a new TextStyle object with the same values as this one.
+       * Note that the only the properties of the object are cloned.
+       *
+       * @return New cloned TextStyle object
+       */
+      TextStyle.prototype.clone = function () {
+          var clonedProperties = {};
+          deepCopyProperties(clonedProperties, this, defaultStyle);
+          return new TextStyle(clonedProperties);
+      };
+      /** Resets all properties to the defaults specified in TextStyle.prototype._default */
+      TextStyle.prototype.reset = function () {
+          deepCopyProperties(this, defaultStyle, defaultStyle);
+      };
+      Object.defineProperty(TextStyle.prototype, "align", {
+          /**
+           * Alignment for multiline text ('left', 'center' or 'right'), does not affect single line text
+           *
+           * @member {string}
+           */
+          get: function () {
+              return this._align;
+          },
+          set: function (align) {
+              if (this._align !== align) {
+                  this._align = align;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "breakWords", {
+          /** Indicates if lines can be wrapped within words, it needs wordWrap to be set to true. */
+          get: function () {
+              return this._breakWords;
+          },
+          set: function (breakWords) {
+              if (this._breakWords !== breakWords) {
+                  this._breakWords = breakWords;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "dropShadow", {
+          /** Set a drop shadow for the text. */
+          get: function () {
+              return this._dropShadow;
+          },
+          set: function (dropShadow) {
+              if (this._dropShadow !== dropShadow) {
+                  this._dropShadow = dropShadow;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "dropShadowAlpha", {
+          /** Set alpha for the drop shadow. */
+          get: function () {
+              return this._dropShadowAlpha;
+          },
+          set: function (dropShadowAlpha) {
+              if (this._dropShadowAlpha !== dropShadowAlpha) {
+                  this._dropShadowAlpha = dropShadowAlpha;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "dropShadowAngle", {
+          /** Set a angle of the drop shadow. */
+          get: function () {
+              return this._dropShadowAngle;
+          },
+          set: function (dropShadowAngle) {
+              if (this._dropShadowAngle !== dropShadowAngle) {
+                  this._dropShadowAngle = dropShadowAngle;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "dropShadowBlur", {
+          /** Set a shadow blur radius. */
+          get: function () {
+              return this._dropShadowBlur;
+          },
+          set: function (dropShadowBlur) {
+              if (this._dropShadowBlur !== dropShadowBlur) {
+                  this._dropShadowBlur = dropShadowBlur;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "dropShadowColor", {
+          /** A fill style to be used on the dropshadow e.g 'red', '#00FF00'. */
+          get: function () {
+              return this._dropShadowColor;
+          },
+          set: function (dropShadowColor) {
+              var outputColor = getColor(dropShadowColor);
+              if (this._dropShadowColor !== outputColor) {
+                  this._dropShadowColor = outputColor;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "dropShadowDistance", {
+          /** Set a distance of the drop shadow. */
+          get: function () {
+              return this._dropShadowDistance;
+          },
+          set: function (dropShadowDistance) {
+              if (this._dropShadowDistance !== dropShadowDistance) {
+                  this._dropShadowDistance = dropShadowDistance;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fill", {
+          /**
+           * A canvas fillstyle that will be used on the text e.g 'red', '#00FF00'.
+           *
+           * Can be an array to create a gradient eg ['#000000','#FFFFFF']
+           * {@link https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillStyle|MDN}
+           *
+           * @member {string|string[]|number|number[]|CanvasGradient|CanvasPattern}
+           */
+          get: function () {
+              return this._fill;
+          },
+          set: function (fill) {
+              // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
+              //       the setter converts to string. See this thread for more details:
+              //       https://github.com/microsoft/TypeScript/issues/2521
+              // TODO: Not sure if getColor works properly with CanvasGradient and/or CanvasPattern, can't pass in
+              //       without casting here.
+              var outputColor = getColor(fill);
+              if (this._fill !== outputColor) {
+                  this._fill = outputColor;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fillGradientType", {
+          /**
+           * If fill is an array of colours to create a gradient, this can change the type/direction of the gradient.
+           *
+           * @see PIXI.TEXT_GRADIENT
+           */
+          get: function () {
+              return this._fillGradientType;
+          },
+          set: function (fillGradientType) {
+              if (this._fillGradientType !== fillGradientType) {
+                  this._fillGradientType = fillGradientType;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fillGradientStops", {
+          /**
+           * If fill is an array of colours to create a gradient, this array can set the stop points
+           * (numbers between 0 and 1) for the color, overriding the default behaviour of evenly spacing them.
+           */
+          get: function () {
+              return this._fillGradientStops;
+          },
+          set: function (fillGradientStops) {
+              if (!areArraysEqual(this._fillGradientStops, fillGradientStops)) {
+                  this._fillGradientStops = fillGradientStops;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fontFamily", {
+          /** The font family. */
+          get: function () {
+              return this._fontFamily;
+          },
+          set: function (fontFamily) {
+              if (this.fontFamily !== fontFamily) {
+                  this._fontFamily = fontFamily;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fontSize", {
+          /**
+           * The font size
+           * (as a number it converts to px, but as a string, equivalents are '26px','20pt','160%' or '1.6em')
+           */
+          get: function () {
+              return this._fontSize;
+          },
+          set: function (fontSize) {
+              if (this._fontSize !== fontSize) {
+                  this._fontSize = fontSize;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fontStyle", {
+          /**
+           * The font style
+           * ('normal', 'italic' or 'oblique')
+           *
+           * @member {string}
+           */
+          get: function () {
+              return this._fontStyle;
+          },
+          set: function (fontStyle) {
+              if (this._fontStyle !== fontStyle) {
+                  this._fontStyle = fontStyle;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fontVariant", {
+          /**
+           * The font variant
+           * ('normal' or 'small-caps')
+           *
+           * @member {string}
+           */
+          get: function () {
+              return this._fontVariant;
+          },
+          set: function (fontVariant) {
+              if (this._fontVariant !== fontVariant) {
+                  this._fontVariant = fontVariant;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "fontWeight", {
+          /**
+           * The font weight
+           * ('normal', 'bold', 'bolder', 'lighter' and '100', '200', '300', '400', '500', '600', '700', 800' or '900')
+           *
+           * @member {string}
+           */
+          get: function () {
+              return this._fontWeight;
+          },
+          set: function (fontWeight) {
+              if (this._fontWeight !== fontWeight) {
+                  this._fontWeight = fontWeight;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "letterSpacing", {
+          /** The amount of spacing between letters, default is 0. */
+          get: function () {
+              return this._letterSpacing;
+          },
+          set: function (letterSpacing) {
+              if (this._letterSpacing !== letterSpacing) {
+                  this._letterSpacing = letterSpacing;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "lineHeight", {
+          /** The line height, a number that represents the vertical space that a letter uses. */
+          get: function () {
+              return this._lineHeight;
+          },
+          set: function (lineHeight) {
+              if (this._lineHeight !== lineHeight) {
+                  this._lineHeight = lineHeight;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "leading", {
+          /** The space between lines. */
+          get: function () {
+              return this._leading;
+          },
+          set: function (leading) {
+              if (this._leading !== leading) {
+                  this._leading = leading;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "lineJoin", {
+          /**
+           * The lineJoin property sets the type of corner created, it can resolve spiked text issues.
+           * Default is 'miter' (creates a sharp corner).
+           *
+           * @member {string}
+           */
+          get: function () {
+              return this._lineJoin;
+          },
+          set: function (lineJoin) {
+              if (this._lineJoin !== lineJoin) {
+                  this._lineJoin = lineJoin;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "miterLimit", {
+          /**
+           * The miter limit to use when using the 'miter' lineJoin mode.
+           *
+           * This can reduce or increase the spikiness of rendered text.
+           */
+          get: function () {
+              return this._miterLimit;
+          },
+          set: function (miterLimit) {
+              if (this._miterLimit !== miterLimit) {
+                  this._miterLimit = miterLimit;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "padding", {
+          /**
+           * Occasionally some fonts are cropped. Adding some padding will prevent this from happening
+           * by adding padding to all sides of the text.
+           */
+          get: function () {
+              return this._padding;
+          },
+          set: function (padding) {
+              if (this._padding !== padding) {
+                  this._padding = padding;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "stroke", {
+          /**
+           * A canvas fillstyle that will be used on the text stroke
+           * e.g 'blue', '#FCFF00'
+           */
+          get: function () {
+              return this._stroke;
+          },
+          set: function (stroke) {
+              // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
+              //       the setter converts to string. See this thread for more details:
+              //       https://github.com/microsoft/TypeScript/issues/2521
+              var outputColor = getColor(stroke);
+              if (this._stroke !== outputColor) {
+                  this._stroke = outputColor;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "strokeThickness", {
+          /**
+           * A number that represents the thickness of the stroke.
+           *
+           * @default 0
+           */
+          get: function () {
+              return this._strokeThickness;
+          },
+          set: function (strokeThickness) {
+              if (this._strokeThickness !== strokeThickness) {
+                  this._strokeThickness = strokeThickness;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "textBaseline", {
+          /**
+           * The baseline of the text that is rendered.
+           *
+           * @member {string}
+           */
+          get: function () {
+              return this._textBaseline;
+          },
+          set: function (textBaseline) {
+              if (this._textBaseline !== textBaseline) {
+                  this._textBaseline = textBaseline;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "trim", {
+          /** Trim transparent borders. */
+          get: function () {
+              return this._trim;
+          },
+          set: function (trim) {
+              if (this._trim !== trim) {
+                  this._trim = trim;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "whiteSpace", {
+          /**
+           * How newlines and spaces should be handled.
+           * Default is 'pre' (preserve, preserve).
+           *
+           *  value       | New lines     |   Spaces
+           *  ---         | ---           |   ---
+           * 'normal'     | Collapse      |   Collapse
+           * 'pre'        | Preserve      |   Preserve
+           * 'pre-line'   | Preserve      |   Collapse
+           *
+           * @member {string}
+           */
+          get: function () {
+              return this._whiteSpace;
+          },
+          set: function (whiteSpace) {
+              if (this._whiteSpace !== whiteSpace) {
+                  this._whiteSpace = whiteSpace;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "wordWrap", {
+          /** Indicates if word wrap should be used. */
+          get: function () {
+              return this._wordWrap;
+          },
+          set: function (wordWrap) {
+              if (this._wordWrap !== wordWrap) {
+                  this._wordWrap = wordWrap;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextStyle.prototype, "wordWrapWidth", {
+          /** The width at which text will wrap, it needs wordWrap to be set to true. */
+          get: function () {
+              return this._wordWrapWidth;
+          },
+          set: function (wordWrapWidth) {
+              if (this._wordWrapWidth !== wordWrapWidth) {
+                  this._wordWrapWidth = wordWrapWidth;
+                  this.styleID++;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Generates a font style string to use for `TextMetrics.measureFont()`.
+       *
+       * @return Font style string, for passing to `TextMetrics.measureFont()`
+       */
+      TextStyle.prototype.toFontString = function () {
+          // build canvas api font setting from individual components. Convert a numeric this.fontSize to px
+          var fontSizeString = (typeof this.fontSize === 'number') ? this.fontSize + "px" : this.fontSize;
+          // Clean-up fontFamily property by quoting each font name
+          // this will support font names with spaces
+          var fontFamilies = this.fontFamily;
+          if (!Array.isArray(this.fontFamily)) {
+              fontFamilies = this.fontFamily.split(',');
+          }
+          for (var i = fontFamilies.length - 1; i >= 0; i--) {
+              // Trim any extra white-space
+              var fontFamily = fontFamilies[i].trim();
+              // Check if font already contains strings
+              if (!(/([\"\'])[^\'\"]+\1/).test(fontFamily) && genericFontFamilies.indexOf(fontFamily) < 0) {
+                  fontFamily = "\"" + fontFamily + "\"";
+              }
+              fontFamilies[i] = fontFamily;
+          }
+          return this.fontStyle + " " + this.fontVariant + " " + this.fontWeight + " " + fontSizeString + " " + fontFamilies.join(',');
+      };
+      return TextStyle;
+  }());
+  /**
+   * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.
+   * @private
+   * @param color
+   * @return The color as a string.
+   */
+  function getSingleColor(color) {
+      if (typeof color === 'number') {
+          return hex2string(color);
+      }
+      else if (typeof color === 'string') {
+          if (color.indexOf('0x') === 0) {
+              color = color.replace('0x', '#');
+          }
+      }
+      return color;
+  }
+  function getColor(color) {
+      if (!Array.isArray(color)) {
+          return getSingleColor(color);
+      }
+      else {
+          for (var i = 0; i < color.length; ++i) {
+              color[i] = getSingleColor(color[i]);
+          }
+          return color;
+      }
+  }
+  /**
+   * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.
+   * This version can also convert array of colors
+   * @private
+   * @param array1 - First array to compare
+   * @param array2 - Second array to compare
+   * @return Do the arrays contain the same values in the same order
+   */
+  function areArraysEqual(array1, array2) {
+      if (!Array.isArray(array1) || !Array.isArray(array2)) {
+          return false;
+      }
+      if (array1.length !== array2.length) {
+          return false;
+      }
+      for (var i = 0; i < array1.length; ++i) {
+          if (array1[i] !== array2[i]) {
+              return false;
+          }
+      }
+      return true;
+  }
+  /**
+   * Utility function to ensure that object properties are copied by value, and not by reference
+   * @private
+   * @param target - Target object to copy properties into
+   * @param source - Source object for the properties to copy
+   * @param propertyObj - Object containing properties names we want to loop over
+   */
+  function deepCopyProperties(target, source, propertyObj) {
+      for (var prop in propertyObj) {
+          if (Array.isArray(source[prop])) {
+              target[prop] = source[prop].slice();
+          }
+          else {
+              target[prop] = source[prop];
+          }
+      }
+  }
 
-var _BasePrepare3 = _interopRequireDefault(_BasePrepare2);
+  // Default settings used for all getContext calls
+  var contextSettings = {
+      // TextMetrics requires getImageData readback for measuring fonts.
+      willReadFrequently: true,
+  };
+  /**
+   * The TextMetrics object represents the measurement of a block of text with a specified style.
+   *
+   * ```js
+   * let style = new PIXI.TextStyle({fontFamily : 'Arial', fontSize: 24, fill : 0xff1010, align : 'center'})
+   * let textMetrics = PIXI.TextMetrics.measureText('Your text', style)
+   * ```
+   * @memberof PIXI
+   */
+  var TextMetrics = /** @class */ (function () {
+      /**
+       * @param text - the text that was measured
+       * @param style - the style that was measured
+       * @param width - the measured width of the text
+       * @param height - the measured height of the text
+       * @param lines - an array of the lines of text broken by new lines and wrapping if specified in style
+       * @param lineWidths - an array of the line widths for each line matched to `lines`
+       * @param lineHeight - the measured line height for this style
+       * @param maxLineWidth - the maximum line width for all measured lines
+       * @param {PIXI.IFontMetrics} fontProperties - the font properties object from TextMetrics.measureFont
+       */
+      function TextMetrics(text, style, width, height, lines, lineWidths, lineHeight, maxLineWidth, fontProperties) {
+          this.text = text;
+          this.style = style;
+          this.width = width;
+          this.height = height;
+          this.lines = lines;
+          this.lineWidths = lineWidths;
+          this.lineHeight = lineHeight;
+          this.maxLineWidth = maxLineWidth;
+          this.fontProperties = fontProperties;
+      }
+      /**
+       * Measures the supplied string of text and returns a Rectangle.
+       * @param text - The text to measure.
+       * @param style - The text style to use for measuring
+       * @param wordWrap - Override for if word-wrap should be applied to the text.
+       * @param canvas - optional specification of the canvas to use for measuring.
+       * @returns Measured width and height of the text.
+       */
+      TextMetrics.measureText = function (text, style, wordWrap, canvas) {
+          if (canvas === void 0) { canvas = TextMetrics._canvas; }
+          wordWrap = (wordWrap === undefined || wordWrap === null) ? style.wordWrap : wordWrap;
+          var font = style.toFontString();
+          var fontProperties = TextMetrics.measureFont(font);
+          // fallback in case UA disallow canvas data extraction
+          // (toDataURI, getImageData functions)
+          if (fontProperties.fontSize === 0) {
+              fontProperties.fontSize = style.fontSize;
+              fontProperties.ascent = style.fontSize;
+          }
+          var context = canvas.getContext('2d', contextSettings);
+          context.font = font;
+          var outputText = wordWrap ? TextMetrics.wordWrap(text, style, canvas) : text;
+          var lines = outputText.split(/(?:\r\n|\r|\n)/);
+          var lineWidths = new Array(lines.length);
+          var maxLineWidth = 0;
+          for (var i = 0; i < lines.length; i++) {
+              var lineWidth = context.measureText(lines[i]).width + ((lines[i].length - 1) * style.letterSpacing);
+              lineWidths[i] = lineWidth;
+              maxLineWidth = Math.max(maxLineWidth, lineWidth);
+          }
+          var width = maxLineWidth + style.strokeThickness;
+          if (style.dropShadow) {
+              width += style.dropShadowDistance;
+          }
+          var lineHeight = style.lineHeight || fontProperties.fontSize + style.strokeThickness;
+          var height = Math.max(lineHeight, fontProperties.fontSize + style.strokeThickness)
+              + ((lines.length - 1) * (lineHeight + style.leading));
+          if (style.dropShadow) {
+              height += style.dropShadowDistance;
+          }
+          return new TextMetrics(text, style, width, height, lines, lineWidths, lineHeight + style.leading, maxLineWidth, fontProperties);
+      };
+      /**
+       * Applies newlines to a string to have it optimally fit into the horizontal
+       * bounds set by the Text object's wordWrapWidth property.
+       * @param text - String to apply word wrapping to
+       * @param style - the style to use when wrapping
+       * @param canvas - optional specification of the canvas to use for measuring.
+       * @returns New string with new lines applied where required
+       */
+      TextMetrics.wordWrap = function (text, style, canvas) {
+          if (canvas === void 0) { canvas = TextMetrics._canvas; }
+          var context = canvas.getContext('2d', contextSettings);
+          var width = 0;
+          var line = '';
+          var lines = '';
+          var cache = Object.create(null);
+          var letterSpacing = style.letterSpacing, whiteSpace = style.whiteSpace;
+          // How to handle whitespaces
+          var collapseSpaces = TextMetrics.collapseSpaces(whiteSpace);
+          var collapseNewlines = TextMetrics.collapseNewlines(whiteSpace);
+          // whether or not spaces may be added to the beginning of lines
+          var canPrependSpaces = !collapseSpaces;
+          // There is letterSpacing after every char except the last one
+          // t_h_i_s_' '_i_s_' '_a_n_' '_e_x_a_m_p_l_e_' '_!
+          // so for convenience the above needs to be compared to width + 1 extra letterSpace
+          // t_h_i_s_' '_i_s_' '_a_n_' '_e_x_a_m_p_l_e_' '_!_
+          // ________________________________________________
+          // And then the final space is simply no appended to each line
+          var wordWrapWidth = style.wordWrapWidth + letterSpacing;
+          // break text into words, spaces and newline chars
+          var tokens = TextMetrics.tokenize(text);
+          for (var i = 0; i < tokens.length; i++) {
+              // get the word, space or newlineChar
+              var token = tokens[i];
+              // if word is a new line
+              if (TextMetrics.isNewline(token)) {
+                  // keep the new line
+                  if (!collapseNewlines) {
+                      lines += TextMetrics.addLine(line);
+                      canPrependSpaces = !collapseSpaces;
+                      line = '';
+                      width = 0;
+                      continue;
+                  }
+                  // if we should collapse new lines
+                  // we simply convert it into a space
+                  token = ' ';
+              }
+              // if we should collapse repeated whitespaces
+              if (collapseSpaces) {
+                  // check both this and the last tokens for spaces
+                  var currIsBreakingSpace = TextMetrics.isBreakingSpace(token);
+                  var lastIsBreakingSpace = TextMetrics.isBreakingSpace(line[line.length - 1]);
+                  if (currIsBreakingSpace && lastIsBreakingSpace) {
+                      continue;
+                  }
+              }
+              // get word width from cache if possible
+              var tokenWidth = TextMetrics.getFromCache(token, letterSpacing, cache, context);
+              // word is longer than desired bounds
+              if (tokenWidth > wordWrapWidth) {
+                  // if we are not already at the beginning of a line
+                  if (line !== '') {
+                      // start newlines for overflow words
+                      lines += TextMetrics.addLine(line);
+                      line = '';
+                      width = 0;
+                  }
+                  // break large word over multiple lines
+                  if (TextMetrics.canBreakWords(token, style.breakWords)) {
+                      // break word into characters
+                      var characters = TextMetrics.wordWrapSplit(token);
+                      // loop the characters
+                      for (var j = 0; j < characters.length; j++) {
+                          var char = characters[j];
+                          var k = 1;
+                          // we are not at the end of the token
+                          while (characters[j + k]) {
+                              var nextChar = characters[j + k];
+                              var lastChar = char[char.length - 1];
+                              // should not split chars
+                              if (!TextMetrics.canBreakChars(lastChar, nextChar, token, j, style.breakWords)) {
+                                  // combine chars & move forward one
+                                  char += nextChar;
+                              }
+                              else {
+                                  break;
+                              }
+                              k++;
+                          }
+                          j += char.length - 1;
+                          var characterWidth = TextMetrics.getFromCache(char, letterSpacing, cache, context);
+                          if (characterWidth + width > wordWrapWidth) {
+                              lines += TextMetrics.addLine(line);
+                              canPrependSpaces = false;
+                              line = '';
+                              width = 0;
+                          }
+                          line += char;
+                          width += characterWidth;
+                      }
+                  }
+                  // run word out of the bounds
+                  else {
+                      // if there are words in this line already
+                      // finish that line and start a new one
+                      if (line.length > 0) {
+                          lines += TextMetrics.addLine(line);
+                          line = '';
+                          width = 0;
+                      }
+                      var isLastToken = i === tokens.length - 1;
+                      // give it its own line if it's not the end
+                      lines += TextMetrics.addLine(token, !isLastToken);
+                      canPrependSpaces = false;
+                      line = '';
+                      width = 0;
+                  }
+              }
+              // word could fit
+              else {
+                  // word won't fit because of existing words
+                  // start a new line
+                  if (tokenWidth + width > wordWrapWidth) {
+                      // if its a space we don't want it
+                      canPrependSpaces = false;
+                      // add a new line
+                      lines += TextMetrics.addLine(line);
+                      // start a new line
+                      line = '';
+                      width = 0;
+                  }
+                  // don't add spaces to the beginning of lines
+                  if (line.length > 0 || !TextMetrics.isBreakingSpace(token) || canPrependSpaces) {
+                      // add the word to the current line
+                      line += token;
+                      // update width counter
+                      width += tokenWidth;
+                  }
+              }
+          }
+          lines += TextMetrics.addLine(line, false);
+          return lines;
+      };
+      /**
+       * Convienience function for logging each line added during the wordWrap method.
+       * @param line    - The line of text to add
+       * @param newLine - Add new line character to end
+       * @returns A formatted line
+       */
+      TextMetrics.addLine = function (line, newLine) {
+          if (newLine === void 0) { newLine = true; }
+          line = TextMetrics.trimRight(line);
+          line = (newLine) ? line + "\n" : line;
+          return line;
+      };
+      /**
+       * Gets & sets the widths of calculated characters in a cache object
+       * @param key            - The key
+       * @param letterSpacing  - The letter spacing
+       * @param cache          - The cache
+       * @param context        - The canvas context
+       * @returns The from cache.
+       */
+      TextMetrics.getFromCache = function (key, letterSpacing, cache, context) {
+          var width = cache[key];
+          if (typeof width !== 'number') {
+              var spacing = ((key.length) * letterSpacing);
+              width = context.measureText(key).width + spacing;
+              cache[key] = width;
+          }
+          return width;
+      };
+      /**
+       * Determines whether we should collapse breaking spaces.
+       * @param whiteSpace - The TextStyle property whiteSpace
+       * @returns Should collapse
+       */
+      TextMetrics.collapseSpaces = function (whiteSpace) {
+          return (whiteSpace === 'normal' || whiteSpace === 'pre-line');
+      };
+      /**
+       * Determines whether we should collapse newLine chars.
+       * @param whiteSpace - The white space
+       * @returns  should collapse
+       */
+      TextMetrics.collapseNewlines = function (whiteSpace) {
+          return (whiteSpace === 'normal');
+      };
+      /**
+       * Trims breaking whitespaces from string.
+       * @param  text - The text
+       * @returns Trimmed string
+       */
+      TextMetrics.trimRight = function (text) {
+          if (typeof text !== 'string') {
+              return '';
+          }
+          for (var i = text.length - 1; i >= 0; i--) {
+              var char = text[i];
+              if (!TextMetrics.isBreakingSpace(char)) {
+                  break;
+              }
+              text = text.slice(0, -1);
+          }
+          return text;
+      };
+      /**
+       * Determines if char is a newline.
+       * @param  char - The character
+       * @returns True if newline, False otherwise.
+       */
+      TextMetrics.isNewline = function (char) {
+          if (typeof char !== 'string') {
+              return false;
+          }
+          return (TextMetrics._newlines.indexOf(char.charCodeAt(0)) >= 0);
+      };
+      /**
+       * Determines if char is a breaking whitespace.
+       *
+       * It allows one to determine whether char should be a breaking whitespace
+       * For example certain characters in CJK langs or numbers.
+       * It must return a boolean.
+       * @param char - The character
+       * @param [_nextChar] - The next character
+       * @returns True if whitespace, False otherwise.
+       */
+      TextMetrics.isBreakingSpace = function (char, _nextChar) {
+          if (typeof char !== 'string') {
+              return false;
+          }
+          return (TextMetrics._breakingSpaces.indexOf(char.charCodeAt(0)) >= 0);
+      };
+      /**
+       * Splits a string into words, breaking-spaces and newLine characters
+       * @param  text - The text
+       * @returns  A tokenized array
+       */
+      TextMetrics.tokenize = function (text) {
+          var tokens = [];
+          var token = '';
+          if (typeof text !== 'string') {
+              return tokens;
+          }
+          for (var i = 0; i < text.length; i++) {
+              var char = text[i];
+              var nextChar = text[i + 1];
+              if (TextMetrics.isBreakingSpace(char, nextChar) || TextMetrics.isNewline(char)) {
+                  if (token !== '') {
+                      tokens.push(token);
+                      token = '';
+                  }
+                  tokens.push(char);
+                  continue;
+              }
+              token += char;
+          }
+          if (token !== '') {
+              tokens.push(token);
+          }
+          return tokens;
+      };
+      /**
+       * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
+       *
+       * It allows one to customise which words should break
+       * Examples are if the token is CJK or numbers.
+       * It must return a boolean.
+       * @param _token - The token
+       * @param  breakWords - The style attr break words
+       * @returns Whether to break word or not
+       */
+      TextMetrics.canBreakWords = function (_token, breakWords) {
+          return breakWords;
+      };
+      /**
+       * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
+       *
+       * It allows one to determine whether a pair of characters
+       * should be broken by newlines
+       * For example certain characters in CJK langs or numbers.
+       * It must return a boolean.
+       * @param _char - The character
+       * @param _nextChar - The next character
+       * @param _token - The token/word the characters are from
+       * @param _index - The index in the token of the char
+       * @param _breakWords - The style attr break words
+       * @returns whether to break word or not
+       */
+      TextMetrics.canBreakChars = function (_char, _nextChar, _token, _index, _breakWords) {
+          return true;
+      };
+      /**
+       * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
+       *
+       * It is called when a token (usually a word) has to be split into separate pieces
+       * in order to determine the point to break a word.
+       * It must return an array of characters.
+       * @example
+       * // Correctly splits emojis, eg "🤪🤪" will result in two element array, each with one emoji.
+       * TextMetrics.wordWrapSplit = (token) => [...token];
+       * @param  token - The token to split
+       * @returns The characters of the token
+       */
+      TextMetrics.wordWrapSplit = function (token) {
+          return token.split('');
+      };
+      /**
+       * Calculates the ascent, descent and fontSize of a given font-style
+       * @param font - String representing the style of the font
+       * @returns Font properties object
+       */
+      TextMetrics.measureFont = function (font) {
+          // as this method is used for preparing assets, don't recalculate things if we don't need to
+          if (TextMetrics._fonts[font]) {
+              return TextMetrics._fonts[font];
+          }
+          var properties = {
+              ascent: 0,
+              descent: 0,
+              fontSize: 0,
+          };
+          var canvas = TextMetrics._canvas;
+          var context = TextMetrics._context;
+          context.font = font;
+          var metricsString = TextMetrics.METRICS_STRING + TextMetrics.BASELINE_SYMBOL;
+          var width = Math.ceil(context.measureText(metricsString).width);
+          var baseline = Math.ceil(context.measureText(TextMetrics.BASELINE_SYMBOL).width);
+          var height = Math.ceil(TextMetrics.HEIGHT_MULTIPLIER * baseline);
+          baseline = baseline * TextMetrics.BASELINE_MULTIPLIER | 0;
+          canvas.width = width;
+          canvas.height = height;
+          context.fillStyle = '#f00';
+          context.fillRect(0, 0, width, height);
+          context.font = font;
+          context.textBaseline = 'alphabetic';
+          context.fillStyle = '#000';
+          context.fillText(metricsString, 0, baseline);
+          var imagedata = context.getImageData(0, 0, width, height).data;
+          var pixels = imagedata.length;
+          var line = width * 4;
+          var i = 0;
+          var idx = 0;
+          var stop = false;
+          // ascent. scan from top to bottom until we find a non red pixel
+          for (i = 0; i < baseline; ++i) {
+              for (var j = 0; j < line; j += 4) {
+                  if (imagedata[idx + j] !== 255) {
+                      stop = true;
+                      break;
+                  }
+              }
+              if (!stop) {
+                  idx += line;
+              }
+              else {
+                  break;
+              }
+          }
+          properties.ascent = baseline - i;
+          idx = pixels - line;
+          stop = false;
+          // descent. scan from bottom to top until we find a non red pixel
+          for (i = height; i > baseline; --i) {
+              for (var j = 0; j < line; j += 4) {
+                  if (imagedata[idx + j] !== 255) {
+                      stop = true;
+                      break;
+                  }
+              }
+              if (!stop) {
+                  idx -= line;
+              }
+              else {
+                  break;
+              }
+          }
+          properties.descent = i - baseline;
+          properties.fontSize = properties.ascent + properties.descent;
+          TextMetrics._fonts[font] = properties;
+          return properties;
+      };
+      /**
+       * Clear font metrics in metrics cache.
+       * @param {string} [font] - font name. If font name not set then clear cache for all fonts.
+       */
+      TextMetrics.clearMetrics = function (font) {
+          if (font === void 0) { font = ''; }
+          if (font) {
+              delete TextMetrics._fonts[font];
+          }
+          else {
+              TextMetrics._fonts = {};
+          }
+      };
+      Object.defineProperty(TextMetrics, "_canvas", {
+          /**
+           * Cached canvas element for measuring text
+           * TODO: this should be private, but isn't because of backward compat, will fix later.
+           * @ignore
+           */
+          get: function () {
+              if (!TextMetrics.__canvas) {
+                  var canvas = void 0;
+                  try {
+                      // OffscreenCanvas2D measureText can be up to 40% faster.
+                      var c = new OffscreenCanvas(0, 0);
+                      var context = c.getContext('2d', contextSettings);
+                      if (context && context.measureText) {
+                          TextMetrics.__canvas = c;
+                          return c;
+                      }
+                      canvas = settings.ADAPTER.createCanvas();
+                  }
+                  catch (ex) {
+                      canvas = settings.ADAPTER.createCanvas();
+                  }
+                  canvas.width = canvas.height = 10;
+                  TextMetrics.__canvas = canvas;
+              }
+              return TextMetrics.__canvas;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TextMetrics, "_context", {
+          /**
+           * TODO: this should be private, but isn't because of backward compat, will fix later.
+           * @ignore
+           */
+          get: function () {
+              if (!TextMetrics.__context) {
+                  TextMetrics.__context = TextMetrics._canvas.getContext('2d', contextSettings);
+              }
+              return TextMetrics.__context;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return TextMetrics;
+  }());
+  /**
+   * Internal return object for {@link PIXI.TextMetrics.measureFont `TextMetrics.measureFont`}.
+   * @typedef {object} FontMetrics
+   * @property {number} ascent - The ascent distance
+   * @property {number} descent - The descent distance
+   * @property {number} fontSize - Font size from ascent to descent
+   * @memberof PIXI.TextMetrics
+   * @private
+   */
+  /**
+   * Cache of {@see PIXI.TextMetrics.FontMetrics} objects.
+   * @memberof PIXI.TextMetrics
+   * @type {object}
+   * @private
+   */
+  TextMetrics._fonts = {};
+  /**
+   * String used for calculate font metrics.
+   * These characters are all tall to help calculate the height required for text.
+   * @static
+   * @memberof PIXI.TextMetrics
+   * @name METRICS_STRING
+   * @type {string}
+   * @default |ÉqÅ
+   */
+  TextMetrics.METRICS_STRING = '|ÉqÅ';
+  /**
+   * Baseline symbol for calculate font metrics.
+   * @static
+   * @memberof PIXI.TextMetrics
+   * @name BASELINE_SYMBOL
+   * @type {string}
+   * @default M
+   */
+  TextMetrics.BASELINE_SYMBOL = 'M';
+  /**
+   * Baseline multiplier for calculate font metrics.
+   * @static
+   * @memberof PIXI.TextMetrics
+   * @name BASELINE_MULTIPLIER
+   * @type {number}
+   * @default 1.4
+   */
+  TextMetrics.BASELINE_MULTIPLIER = 1.4;
+  /**
+   * Height multiplier for setting height of canvas to calculate font metrics.
+   * @static
+   * @memberof PIXI.TextMetrics
+   * @name HEIGHT_MULTIPLIER
+   * @type {number}
+   * @default 2.00
+   */
+  TextMetrics.HEIGHT_MULTIPLIER = 2.0;
+  /**
+   * Cache of new line chars.
+   * @memberof PIXI.TextMetrics
+   * @type {number[]}
+   * @private
+   */
+  TextMetrics._newlines = [
+      0x000A,
+      0x000D ];
+  /**
+   * Cache of breaking spaces.
+   * @memberof PIXI.TextMetrics
+   * @type {number[]}
+   * @private
+   */
+  TextMetrics._breakingSpaces = [
+      0x0009,
+      0x0020,
+      0x2000,
+      0x2001,
+      0x2002,
+      0x2003,
+      0x2004,
+      0x2005,
+      0x2006,
+      0x2008,
+      0x2009,
+      0x200A,
+      0x205F,
+      0x3000 ];
+  /**
+   * A number, or a string containing a number.
+   * @memberof PIXI
+   * @typedef {object} IFontMetrics
+   * @property {number} ascent - Font ascent
+   * @property {number} descent - Font descent
+   * @property {number} fontSize - Font size
+   */
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  var defaultDestroyOptions = {
+      texture: true,
+      children: false,
+      baseTexture: true,
+  };
+  /**
+   * A Text Object will create a line or multiple lines of text.
+   *
+   * The text is created using the [Canvas API](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API).
+   *
+   * The primary advantage of this class over BitmapText is that you have great control over the style of the text,
+   * which you can change at runtime.
+   *
+   * The primary disadvantages is that each piece of text has it's own texture, which can use more memory.
+   * When text changes, this texture has to be re-generated and re-uploaded to the GPU, taking up time.
+   *
+   * To split a line you can use '\n' in your text string, or, on the `style` object,
+   * change its `wordWrap` property to true and and give the `wordWrapWidth` property a value.
+   *
+   * A Text can be created directly from a string and a style object,
+   * which can be generated [here](https://pixijs.io/pixi-text-style).
+   *
+   * ```js
+   * let text = new PIXI.Text('This is a PixiJS text',{fontFamily : 'Arial', fontSize: 24, fill : 0xff1010, align : 'center'});
+   * ```
+   * @memberof PIXI
+   */
+  var Text = /** @class */ (function (_super) {
+      __extends$c(Text, _super);
+      /**
+       * @param text - The string that you would like the text to display
+       * @param {object|PIXI.TextStyle} [style] - The style parameters
+       * @param canvas - The canvas element for drawing text
+       */
+      function Text(text, style, canvas) {
+          var _this = this;
+          var ownCanvas = false;
+          if (!canvas) {
+              canvas = settings.ADAPTER.createCanvas();
+              ownCanvas = true;
+          }
+          canvas.width = 3;
+          canvas.height = 3;
+          var texture = Texture.from(canvas);
+          texture.orig = new Rectangle();
+          texture.trim = new Rectangle();
+          _this = _super.call(this, texture) || this;
+          _this._ownCanvas = ownCanvas;
+          _this.canvas = canvas;
+          _this.context = canvas.getContext('2d', {
+              // required for trimming to work without warnings
+              willReadFrequently: true,
+          });
+          _this._resolution = settings.RESOLUTION;
+          _this._autoResolution = true;
+          _this._text = null;
+          _this._style = null;
+          _this._styleListener = null;
+          _this._font = '';
+          _this.text = text;
+          _this.style = style;
+          _this.localStyleID = -1;
+          return _this;
+      }
+      /**
+       * Renders text to its canvas, and updates its texture.
+       *
+       * By default this is used internally to ensure the texture is correct before rendering,
+       * but it can be used called externally, for example from this class to 'pre-generate' the texture from a piece of text,
+       * and then shared across multiple Sprites.
+       * @param respectDirty - Whether to abort updating the text if the Text isn't dirty and the function is called.
+       */
+      Text.prototype.updateText = function (respectDirty) {
+          var style = this._style;
+          // check if style has changed..
+          if (this.localStyleID !== style.styleID) {
+              this.dirty = true;
+              this.localStyleID = style.styleID;
+          }
+          if (!this.dirty && respectDirty) {
+              return;
+          }
+          this._font = this._style.toFontString();
+          var context = this.context;
+          var measured = TextMetrics.measureText(this._text || ' ', this._style, this._style.wordWrap, this.canvas);
+          var width = measured.width;
+          var height = measured.height;
+          var lines = measured.lines;
+          var lineHeight = measured.lineHeight;
+          var lineWidths = measured.lineWidths;
+          var maxLineWidth = measured.maxLineWidth;
+          var fontProperties = measured.fontProperties;
+          this.canvas.width = Math.ceil(Math.ceil((Math.max(1, width) + (style.padding * 2))) * this._resolution);
+          this.canvas.height = Math.ceil(Math.ceil((Math.max(1, height) + (style.padding * 2))) * this._resolution);
+          context.scale(this._resolution, this._resolution);
+          context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+          context.font = this._font;
+          context.lineWidth = style.strokeThickness;
+          context.textBaseline = style.textBaseline;
+          context.lineJoin = style.lineJoin;
+          context.miterLimit = style.miterLimit;
+          var linePositionX;
+          var linePositionY;
+          // require 2 passes if a shadow; the first to draw the drop shadow, the second to draw the text
+          var passesCount = style.dropShadow ? 2 : 1;
+          // For v4, we drew text at the colours of the drop shadow underneath the normal text. This gave the correct zIndex,
+          // but features such as alpha and shadowblur did not look right at all, since we were using actual text as a shadow.
+          //
+          // For v5.0.0, we moved over to just use the canvas API for drop shadows, which made them look much nicer and more
+          // visually please, but now because the stroke is drawn and then the fill, drop shadows would appear on both the fill
+          // and the stroke; and fill drop shadows would appear over the top of the stroke.
+          //
+          // For v5.1.1, the new route is to revert to v4 style of drawing text first to get the drop shadows underneath normal
+          // text, but instead drawing text in the correct location, we'll draw it off screen (-paddingY), and then adjust the
+          // drop shadow so only that appears on screen (+paddingY). Now we'll have the correct draw order of the shadow
+          // beneath the text, whilst also having the proper text shadow styling.
+          for (var i = 0; i < passesCount; ++i) {
+              var isShadowPass = style.dropShadow && i === 0;
+              // we only want the drop shadow, so put text way off-screen
+              var dsOffsetText = isShadowPass ? Math.ceil(Math.max(1, height) + (style.padding * 2)) : 0;
+              var dsOffsetShadow = dsOffsetText * this._resolution;
+              if (isShadowPass) {
+                  // On Safari, text with gradient and drop shadows together do not position correctly
+                  // if the scale of the canvas is not 1: https://bugs.webkit.org/show_bug.cgi?id=197689
+                  // Therefore we'll set the styles to be a plain black whilst generating this drop shadow
+                  context.fillStyle = 'black';
+                  context.strokeStyle = 'black';
+                  var dropShadowColor = style.dropShadowColor;
+                  var rgb = hex2rgb(typeof dropShadowColor === 'number' ? dropShadowColor : string2hex(dropShadowColor));
+                  var dropShadowBlur = style.dropShadowBlur * this._resolution;
+                  var dropShadowDistance = style.dropShadowDistance * this._resolution;
+                  context.shadowColor = "rgba(" + rgb[0] * 255 + "," + rgb[1] * 255 + "," + rgb[2] * 255 + "," + style.dropShadowAlpha + ")";
+                  context.shadowBlur = dropShadowBlur;
+                  context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;
+                  context.shadowOffsetY = (Math.sin(style.dropShadowAngle) * dropShadowDistance) + dsOffsetShadow;
+              }
+              else {
+                  // set canvas text styles
+                  context.fillStyle = this._generateFillStyle(style, lines, measured);
+                  // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
+                  //       the setter converts to string. See this thread for more details:
+                  //       https://github.com/microsoft/TypeScript/issues/2521
+                  context.strokeStyle = style.stroke;
+                  context.shadowColor = 'black';
+                  context.shadowBlur = 0;
+                  context.shadowOffsetX = 0;
+                  context.shadowOffsetY = 0;
+              }
+              var linePositionYShift = (lineHeight - fontProperties.fontSize) / 2;
+              if (!Text.nextLineHeightBehavior || lineHeight - fontProperties.fontSize < 0) {
+                  linePositionYShift = 0;
+              }
+              // draw lines line by line
+              for (var i_1 = 0; i_1 < lines.length; i_1++) {
+                  linePositionX = style.strokeThickness / 2;
+                  linePositionY = ((style.strokeThickness / 2) + (i_1 * lineHeight)) + fontProperties.ascent
+                      + linePositionYShift;
+                  if (style.align === 'right') {
+                      linePositionX += maxLineWidth - lineWidths[i_1];
+                  }
+                  else if (style.align === 'center') {
+                      linePositionX += (maxLineWidth - lineWidths[i_1]) / 2;
+                  }
+                  if (style.stroke && style.strokeThickness) {
+                      this.drawLetterSpacing(lines[i_1], linePositionX + style.padding, linePositionY + style.padding - dsOffsetText, true);
+                  }
+                  if (style.fill) {
+                      this.drawLetterSpacing(lines[i_1], linePositionX + style.padding, linePositionY + style.padding - dsOffsetText);
+                  }
+              }
+          }
+          this.updateTexture();
+      };
+      /**
+       * Render the text with letter-spacing.
+       * @param text - The text to draw
+       * @param x - Horizontal position to draw the text
+       * @param y - Vertical position to draw the text
+       * @param isStroke - Is this drawing for the outside stroke of the
+       *  text? If not, it's for the inside fill
+       */
+      Text.prototype.drawLetterSpacing = function (text, x, y, isStroke) {
+          if (isStroke === void 0) { isStroke = false; }
+          var style = this._style;
+          // letterSpacing of 0 means normal
+          var letterSpacing = style.letterSpacing;
+          // Checking that we can use moddern canvas2D api
+          // https://developer.chrome.com/origintrials/#/view_trial/3585991203293757441
+          // note: this is unstable API, Chrome less 94 use a `textLetterSpacing`, newest use a letterSpacing
+          // eslint-disable-next-line max-len
+          var supportLetterSpacing = Text.experimentalLetterSpacing
+              && ('letterSpacing' in CanvasRenderingContext2D.prototype
+                  || 'textLetterSpacing' in CanvasRenderingContext2D.prototype);
+          if (letterSpacing === 0 || supportLetterSpacing) {
+              if (supportLetterSpacing) {
+                  this.context.letterSpacing = letterSpacing;
+                  this.context.textLetterSpacing = letterSpacing;
+              }
+              if (isStroke) {
+                  this.context.strokeText(text, x, y);
+              }
+              else {
+                  this.context.fillText(text, x, y);
+              }
+              return;
+          }
+          var currentPosition = x;
+          // Using Array.from correctly splits characters whilst keeping emoji together.
+          // This is not supported on IE as it requires ES6, so regular text splitting occurs.
+          // This also doesn't account for emoji that are multiple emoji put together to make something else.
+          // Handling all of this would require a big library itself.
+          // https://medium.com/@giltayar/iterating-over-emoji-characters-the-es6-way-f06e4589516
+          // https://github.com/orling/grapheme-splitter
+          var stringArray = Array.from ? Array.from(text) : text.split('');
+          var previousWidth = this.context.measureText(text).width;
+          var currentWidth = 0;
+          for (var i = 0; i < stringArray.length; ++i) {
+              var currentChar = stringArray[i];
+              if (isStroke) {
+                  this.context.strokeText(currentChar, currentPosition, y);
+              }
+              else {
+                  this.context.fillText(currentChar, currentPosition, y);
+              }
+              var textStr = '';
+              for (var j = i + 1; j < stringArray.length; ++j) {
+                  textStr += stringArray[j];
+              }
+              currentWidth = this.context.measureText(textStr).width;
+              currentPosition += previousWidth - currentWidth + letterSpacing;
+              previousWidth = currentWidth;
+          }
+      };
+      /** Updates texture size based on canvas size. */
+      Text.prototype.updateTexture = function () {
+          var canvas = this.canvas;
+          if (this._style.trim) {
+              var trimmed = trimCanvas(canvas);
+              if (trimmed.data) {
+                  canvas.width = trimmed.width;
+                  canvas.height = trimmed.height;
+                  this.context.putImageData(trimmed.data, 0, 0);
+              }
+          }
+          var texture = this._texture;
+          var style = this._style;
+          var padding = style.trim ? 0 : style.padding;
+          var baseTexture = texture.baseTexture;
+          texture.trim.width = texture._frame.width = canvas.width / this._resolution;
+          texture.trim.height = texture._frame.height = canvas.height / this._resolution;
+          texture.trim.x = -padding;
+          texture.trim.y = -padding;
+          texture.orig.width = texture._frame.width - (padding * 2);
+          texture.orig.height = texture._frame.height - (padding * 2);
+          // call sprite onTextureUpdate to update scale if _width or _height were set
+          this._onTextureUpdate();
+          baseTexture.setRealSize(canvas.width, canvas.height, this._resolution);
+          texture.updateUvs();
+          this.dirty = false;
+      };
+      /**
+       * Renders the object using the WebGL renderer
+       * @param renderer - The renderer
+       */
+      Text.prototype._render = function (renderer) {
+          if (this._autoResolution && this._resolution !== renderer.resolution) {
+              this._resolution = renderer.resolution;
+              this.dirty = true;
+          }
+          this.updateText(true);
+          _super.prototype._render.call(this, renderer);
+      };
+      /** Updates the transform on all children of this container for rendering. */
+      Text.prototype.updateTransform = function () {
+          this.updateText(true);
+          _super.prototype.updateTransform.call(this);
+      };
+      Text.prototype.getBounds = function (skipUpdate, rect) {
+          this.updateText(true);
+          if (this._textureID === -1) {
+              // texture was updated: recalculate transforms
+              skipUpdate = false;
+          }
+          return _super.prototype.getBounds.call(this, skipUpdate, rect);
+      };
+      /**
+       * Gets the local bounds of the text object.
+       * @param rect - The output rectangle.
+       * @returns The bounds.
+       */
+      Text.prototype.getLocalBounds = function (rect) {
+          this.updateText(true);
+          return _super.prototype.getLocalBounds.call(this, rect);
+      };
+      /** Calculates the bounds of the Text as a rectangle. The bounds calculation takes the worldTransform into account. */
+      Text.prototype._calculateBounds = function () {
+          this.calculateVertices();
+          // if we have already done this on THIS frame.
+          this._bounds.addQuad(this.vertexData);
+      };
+      /**
+       * Generates the fill style. Can automatically generate a gradient based on the fill style being an array
+       * @param style - The style.
+       * @param lines - The lines of text.
+       * @param metrics
+       * @returns The fill style
+       */
+      Text.prototype._generateFillStyle = function (style, lines, metrics) {
+          // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
+          //       the setter converts to string. See this thread for more details:
+          //       https://github.com/microsoft/TypeScript/issues/2521
+          var fillStyle = style.fill;
+          if (!Array.isArray(fillStyle)) {
+              return fillStyle;
+          }
+          else if (fillStyle.length === 1) {
+              return fillStyle[0];
+          }
+          // the gradient will be evenly spaced out according to how large the array is.
+          // ['#FF0000', '#00FF00', '#0000FF'] would created stops at 0.25, 0.5 and 0.75
+          var gradient;
+          // a dropshadow will enlarge the canvas and result in the gradient being
+          // generated with the incorrect dimensions
+          var dropShadowCorrection = (style.dropShadow) ? style.dropShadowDistance : 0;
+          // should also take padding into account, padding can offset the gradient
+          var padding = style.padding || 0;
+          var width = (this.canvas.width / this._resolution) - dropShadowCorrection - (padding * 2);
+          var height = (this.canvas.height / this._resolution) - dropShadowCorrection - (padding * 2);
+          // make a copy of the style settings, so we can manipulate them later
+          var fill = fillStyle.slice();
+          var fillGradientStops = style.fillGradientStops.slice();
+          // wanting to evenly distribute the fills. So an array of 4 colours should give fills of 0.25, 0.5 and 0.75
+          if (!fillGradientStops.length) {
+              var lengthPlus1 = fill.length + 1;
+              for (var i = 1; i < lengthPlus1; ++i) {
+                  fillGradientStops.push(i / lengthPlus1);
+              }
+          }
+          // stop the bleeding of the last gradient on the line above to the top gradient of the this line
+          // by hard defining the first gradient colour at point 0, and last gradient colour at point 1
+          fill.unshift(fillStyle[0]);
+          fillGradientStops.unshift(0);
+          fill.push(fillStyle[fillStyle.length - 1]);
+          fillGradientStops.push(1);
+          if (style.fillGradientType === exports.TEXT_GRADIENT.LINEAR_VERTICAL) {
+              // start the gradient at the top center of the canvas, and end at the bottom middle of the canvas
+              gradient = this.context.createLinearGradient(width / 2, padding, width / 2, height + padding);
+              // we need to repeat the gradient so that each individual line of text has the same vertical gradient effect
+              // ['#FF0000', '#00FF00', '#0000FF'] over 2 lines would create stops at 0.125, 0.25, 0.375, 0.625, 0.75, 0.875
+              // Actual height of the text itself, not counting spacing for lineHeight/leading/dropShadow etc
+              var textHeight = metrics.fontProperties.fontSize + style.strokeThickness;
+              for (var i = 0; i < lines.length; i++) {
+                  var lastLineBottom = (metrics.lineHeight * (i - 1)) + textHeight;
+                  var thisLineTop = metrics.lineHeight * i;
+                  var thisLineGradientStart = thisLineTop;
+                  // Handle case where last & this line overlap
+                  if (i > 0 && lastLineBottom > thisLineTop) {
+                      thisLineGradientStart = (thisLineTop + lastLineBottom) / 2;
+                  }
+                  var thisLineBottom = thisLineTop + textHeight;
+                  var nextLineTop = metrics.lineHeight * (i + 1);
+                  var thisLineGradientEnd = thisLineBottom;
+                  // Handle case where this & next line overlap
+                  if (i + 1 < lines.length && nextLineTop < thisLineBottom) {
+                      thisLineGradientEnd = (thisLineBottom + nextLineTop) / 2;
+                  }
+                  // textHeight, but as a 0-1 size in global gradient stop space
+                  var gradStopLineHeight = (thisLineGradientEnd - thisLineGradientStart) / height;
+                  for (var j = 0; j < fill.length; j++) {
+                      // 0-1 stop point for the current line, multiplied to global space afterwards
+                      var lineStop = 0;
+                      if (typeof fillGradientStops[j] === 'number') {
+                          lineStop = fillGradientStops[j];
+                      }
+                      else {
+                          lineStop = j / fill.length;
+                      }
+                      var globalStop = Math.min(1, Math.max(0, (thisLineGradientStart / height) + (lineStop * gradStopLineHeight)));
+                      // There's potential for floating point precision issues at the seams between gradient repeats.
+                      globalStop = Number(globalStop.toFixed(5));
+                      gradient.addColorStop(globalStop, fill[j]);
+                  }
+              }
+          }
+          else {
+              // start the gradient at the center left of the canvas, and end at the center right of the canvas
+              gradient = this.context.createLinearGradient(padding, height / 2, width + padding, height / 2);
+              // can just evenly space out the gradients in this case, as multiple lines makes no difference
+              // to an even left to right gradient
+              var totalIterations = fill.length + 1;
+              var currentIteration = 1;
+              for (var i = 0; i < fill.length; i++) {
+                  var stop = void 0;
+                  if (typeof fillGradientStops[i] === 'number') {
+                      stop = fillGradientStops[i];
+                  }
+                  else {
+                      stop = currentIteration / totalIterations;
+                  }
+                  gradient.addColorStop(stop, fill[i]);
+                  currentIteration++;
+              }
+          }
+          return gradient;
+      };
+      /**
+       * Destroys this text object.
+       *
+       * Note* Unlike a Sprite, a Text object will automatically destroy its baseTexture and texture as
+       * the majority of the time the texture will not be shared with any other Sprites.
+       * @param options - Options parameter. A boolean will act as if all options
+       *  have been set to that value
+       * @param {boolean} [options.children=false] - if set to true, all the children will have their
+       *  destroy method called as well. 'options' will be passed on to those calls.
+       * @param {boolean} [options.texture=true] - Should it destroy the current texture of the sprite as well
+       * @param {boolean} [options.baseTexture=true] - Should it destroy the base texture of the sprite as well
+       */
+      Text.prototype.destroy = function (options) {
+          if (typeof options === 'boolean') {
+              options = { children: options };
+          }
+          options = Object.assign({}, defaultDestroyOptions, options);
+          _super.prototype.destroy.call(this, options);
+          // set canvas width and height to 0 to workaround memory leak in Safari < 13
+          // https://stackoverflow.com/questions/52532614/total-canvas-memory-use-exceeds-the-maximum-limit-safari-12
+          if (this._ownCanvas) {
+              this.canvas.height = this.canvas.width = 0;
+          }
+          // make sure to reset the context and canvas.. dont want this hanging around in memory!
+          this.context = null;
+          this.canvas = null;
+          this._style = null;
+      };
+      Object.defineProperty(Text.prototype, "width", {
+          /** The width of the Text, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              this.updateText(true);
+              return Math.abs(this.scale.x) * this._texture.orig.width;
+          },
+          set: function (value) {
+              this.updateText(true);
+              var s = sign(this.scale.x) || 1;
+              this.scale.x = s * value / this._texture.orig.width;
+              this._width = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Text.prototype, "height", {
+          /** The height of the Text, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              this.updateText(true);
+              return Math.abs(this.scale.y) * this._texture.orig.height;
+          },
+          set: function (value) {
+              this.updateText(true);
+              var s = sign(this.scale.y) || 1;
+              this.scale.y = s * value / this._texture.orig.height;
+              this._height = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Text.prototype, "style", {
+          /**
+           * Set the style of the text.
+           *
+           * Set up an event listener to listen for changes on the style object and mark the text as dirty.
+           */
+          get: function () {
+              // TODO: Can't have different types for getter and setter. The getter shouldn't have the ITextStyle
+              //       since the setter creates the TextStyle. See this thread for more details:
+              //       https://github.com/microsoft/TypeScript/issues/2521
+              return this._style;
+          },
+          set: function (style) {
+              style = style || {};
+              if (style instanceof TextStyle) {
+                  this._style = style;
+              }
+              else {
+                  this._style = new TextStyle(style);
+              }
+              this.localStyleID = -1;
+              this.dirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Text.prototype, "text", {
+          /** Set the copy for the text object. To split a line you can use '\n'. */
+          get: function () {
+              return this._text;
+          },
+          set: function (text) {
+              text = String(text === null || text === undefined ? '' : text);
+              if (this._text === text) {
+                  return;
+              }
+              this._text = text;
+              this.dirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Text.prototype, "resolution", {
+          /**
+           * The resolution / device pixel ratio of the canvas.
+           *
+           * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.
+           * @default 1
+           */
+          get: function () {
+              return this._resolution;
+          },
+          set: function (value) {
+              this._autoResolution = false;
+              if (this._resolution === value) {
+                  return;
+              }
+              this._resolution = value;
+              this.dirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * New behavior for `lineHeight` that's meant to mimic HTML text. A value of `true` will
+       * make sure the first baseline is offset by the `lineHeight` value if it is greater than `fontSize`.
+       * A value of `false` will use the legacy behavior and not change the baseline of the first line.
+       * In the next major release, we'll enable this by default.
+       */
+      Text.nextLineHeightBehavior = false;
+      /**
+       * New rendering behavior for letter-spacing which uses Chrome's new native API. This will
+       * lead to more accurate letter-spacing results because it does not try to manually draw
+       * each character. However, this Chrome API is experimental and may not serve all cases yet.
+       */
+      Text.experimentalLetterSpacing = false;
+      return Text;
+  }(Sprite));
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+  /*!
+   * @pixi/prepare - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/prepare is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  /**
+   * Default number of uploads per frame using prepare plugin.
+   * @static
+   * @memberof PIXI.settings
+   * @name UPLOADS_PER_FRAME
+   * @type {number}
+   * @default 4
+   */
+  settings.UPLOADS_PER_FRAME = 4;
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$b = function(d, b) {
+      extendStatics$b = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$b(d, b);
+  };
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+  function __extends$b(d, b) {
+      extendStatics$b(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  /**
+   * CountLimiter limits the number of items handled by a {@link PIXI.BasePrepare} to a specified
+   * number of items per frame.
+   * @memberof PIXI
+   */
+  var CountLimiter = /** @class */ (function () {
+      /**
+       * @param maxItemsPerFrame - The maximum number of items that can be prepared each frame.
+       */
+      function CountLimiter(maxItemsPerFrame) {
+          this.maxItemsPerFrame = maxItemsPerFrame;
+          this.itemsLeft = 0;
+      }
+      /** Resets any counting properties to start fresh on a new frame. */
+      CountLimiter.prototype.beginFrame = function () {
+          this.itemsLeft = this.maxItemsPerFrame;
+      };
+      /**
+       * Checks to see if another item can be uploaded. This should only be called once per item.
+       * @returns If the item is allowed to be uploaded.
+       */
+      CountLimiter.prototype.allowedToUpload = function () {
+          return this.itemsLeft-- > 0;
+      };
+      return CountLimiter;
+  }());
 
-var CANVAS_START_SIZE = 16;
+  /**
+   * Built-in hook to find multiple textures from objects like AnimatedSprites.
+   * @private
+   * @param item - Display object to check
+   * @param queue - Collection of items to upload
+   * @returns If a PIXI.Texture object was found.
+   */
+  function findMultipleBaseTextures(item, queue) {
+      var result = false;
+      // Objects with multiple textures
+      if (item && item._textures && item._textures.length) {
+          for (var i = 0; i < item._textures.length; i++) {
+              if (item._textures[i] instanceof Texture) {
+                  var baseTexture = item._textures[i].baseTexture;
+                  if (queue.indexOf(baseTexture) === -1) {
+                      queue.push(baseTexture);
+                      result = true;
+                  }
+              }
+          }
+      }
+      return result;
+  }
+  /**
+   * Built-in hook to find BaseTextures from Texture.
+   * @private
+   * @param item - Display object to check
+   * @param queue - Collection of items to upload
+   * @returns If a PIXI.Texture object was found.
+   */
+  function findBaseTexture(item, queue) {
+      if (item.baseTexture instanceof BaseTexture) {
+          var texture = item.baseTexture;
+          if (queue.indexOf(texture) === -1) {
+              queue.push(texture);
+          }
+          return true;
+      }
+      return false;
+  }
+  /**
+   * Built-in hook to find textures from objects.
+   * @private
+   * @param item - Display object to check
+   * @param queue - Collection of items to upload
+   * @returns If a PIXI.Texture object was found.
+   */
+  function findTexture(item, queue) {
+      if (item._texture && item._texture instanceof Texture) {
+          var texture = item._texture.baseTexture;
+          if (queue.indexOf(texture) === -1) {
+              queue.push(texture);
+          }
+          return true;
+      }
+      return false;
+  }
+  /**
+   * Built-in hook to draw PIXI.Text to its texture.
+   * @private
+   * @param _helper - Not used by this upload handler
+   * @param item - Item to check
+   * @returns If item was uploaded.
+   */
+  function drawText(_helper, item) {
+      if (item instanceof Text) {
+          // updating text will return early if it is not dirty
+          item.updateText(true);
+          return true;
+      }
+      return false;
+  }
+  /**
+   * Built-in hook to calculate a text style for a PIXI.Text object.
+   * @private
+   * @param _helper - Not used by this upload handler
+   * @param item - Item to check
+   * @returns If item was uploaded.
+   */
+  function calculateTextStyle(_helper, item) {
+      if (item instanceof TextStyle) {
+          var font = item.toFontString();
+          TextMetrics.measureFont(font);
+          return true;
+      }
+      return false;
+  }
+  /**
+   * Built-in hook to find Text objects.
+   * @private
+   * @param item - Display object to check
+   * @param queue - Collection of items to upload
+   * @returns if a PIXI.Text object was found.
+   */
+  function findText(item, queue) {
+      if (item instanceof Text) {
+          // push the text style to prepare it - this can be really expensive
+          if (queue.indexOf(item.style) === -1) {
+              queue.push(item.style);
+          }
+          // also push the text object so that we can render it (to canvas/texture) if needed
+          if (queue.indexOf(item) === -1) {
+              queue.push(item);
+          }
+          // also push the Text's texture for upload to GPU
+          var texture = item._texture.baseTexture;
+          if (queue.indexOf(texture) === -1) {
+              queue.push(texture);
+          }
+          return true;
+      }
+      return false;
+  }
+  /**
+   * Built-in hook to find TextStyle objects.
+   * @private
+   * @param item - Display object to check
+   * @param queue - Collection of items to upload
+   * @returns If a PIXI.TextStyle object was found.
+   */
+  function findTextStyle(item, queue) {
+      if (item instanceof TextStyle) {
+          if (queue.indexOf(item) === -1) {
+              queue.push(item);
+          }
+          return true;
+      }
+      return false;
+  }
+  /**
+   * The prepare manager provides functionality to upload content to the GPU.
+   *
+   * BasePrepare handles basic queuing functionality and is extended by
+   * {@link PIXI.Prepare} and {@link PIXI.CanvasPrepare}
+   * to provide preparation capabilities specific to their respective renderers.
+   * @example
+   * // Create a sprite
+   * const sprite = PIXI.Sprite.from('something.png');
+   *
+   * // Load object into GPU
+   * app.renderer.plugins.prepare.upload(sprite, () => {
+   *
+   *     //Texture(s) has been uploaded to GPU
+   *     app.stage.addChild(sprite);
+   *
+   * })
+   * @abstract
+   * @memberof PIXI
+   */
+  var BasePrepare = /** @class */ (function () {
+      /**
+       * @param {PIXI.AbstractRenderer} renderer - A reference to the current renderer
+       */
+      function BasePrepare(renderer) {
+          var _this = this;
+          this.limiter = new CountLimiter(settings.UPLOADS_PER_FRAME);
+          this.renderer = renderer;
+          this.uploadHookHelper = null;
+          this.queue = [];
+          this.addHooks = [];
+          this.uploadHooks = [];
+          this.completes = [];
+          this.ticking = false;
+          this.delayedTick = function () {
+              // unlikely, but in case we were destroyed between tick() and delayedTick()
+              if (!_this.queue) {
+                  return;
+              }
+              _this.prepareItems();
+          };
+          // hooks to find the correct texture
+          this.registerFindHook(findText);
+          this.registerFindHook(findTextStyle);
+          this.registerFindHook(findMultipleBaseTextures);
+          this.registerFindHook(findBaseTexture);
+          this.registerFindHook(findTexture);
+          // upload hooks
+          this.registerUploadHook(drawText);
+          this.registerUploadHook(calculateTextStyle);
+      }
+      /** @ignore */
+      BasePrepare.prototype.upload = function (item, done) {
+          var _this = this;
+          if (typeof item === 'function') {
+              done = item;
+              item = null;
+          }
+          if (done) {
+              deprecation('6.5.0', 'BasePrepare.upload callback is deprecated, use the return Promise instead.');
+          }
+          return new Promise(function (resolve) {
+              // If a display object, search for items
+              // that we could upload
+              if (item) {
+                  _this.add(item);
+              }
+              // TODO: remove done callback and just use resolve
+              var complete = function () {
+                  done === null || done === void 0 ? void 0 : done();
+                  resolve();
+              };
+              // Get the items for upload from the display
+              if (_this.queue.length) {
+                  _this.completes.push(complete);
+                  if (!_this.ticking) {
+                      _this.ticking = true;
+                      Ticker.system.addOnce(_this.tick, _this, exports.UPDATE_PRIORITY.UTILITY);
+                  }
+              }
+              else {
+                  complete();
+              }
+          });
+      };
+      /**
+       * Handle tick update
+       * @private
+       */
+      BasePrepare.prototype.tick = function () {
+          setTimeout(this.delayedTick, 0);
+      };
+      /**
+       * Actually prepare items. This is handled outside of the tick because it will take a while
+       * and we do NOT want to block the current animation frame from rendering.
+       * @private
+       */
+      BasePrepare.prototype.prepareItems = function () {
+          this.limiter.beginFrame();
+          // Upload the graphics
+          while (this.queue.length && this.limiter.allowedToUpload()) {
+              var item = this.queue[0];
+              var uploaded = false;
+              if (item && !item._destroyed) {
+                  for (var i = 0, len = this.uploadHooks.length; i < len; i++) {
+                      if (this.uploadHooks[i](this.uploadHookHelper, item)) {
+                          this.queue.shift();
+                          uploaded = true;
+                          break;
+                      }
+                  }
+              }
+              if (!uploaded) {
+                  this.queue.shift();
+              }
+          }
+          // We're finished
+          if (!this.queue.length) {
+              this.ticking = false;
+              var completes = this.completes.slice(0);
+              this.completes.length = 0;
+              for (var i = 0, len = completes.length; i < len; i++) {
+                  completes[i]();
+              }
+          }
+          else {
+              // if we are not finished, on the next rAF do this again
+              Ticker.system.addOnce(this.tick, this, exports.UPDATE_PRIORITY.UTILITY);
+          }
+      };
+      /**
+       * Adds hooks for finding items.
+       * @param {Function} addHook - Function call that takes two parameters: `item:*, queue:Array`
+       *          function must return `true` if it was able to add item to the queue.
+       * @returns Instance of plugin for chaining.
+       */
+      BasePrepare.prototype.registerFindHook = function (addHook) {
+          if (addHook) {
+              this.addHooks.push(addHook);
+          }
+          return this;
+      };
+      /**
+       * Adds hooks for uploading items.
+       * @param {Function} uploadHook - Function call that takes two parameters: `prepare:CanvasPrepare, item:*` and
+       *          function must return `true` if it was able to handle upload of item.
+       * @returns Instance of plugin for chaining.
+       */
+      BasePrepare.prototype.registerUploadHook = function (uploadHook) {
+          if (uploadHook) {
+              this.uploadHooks.push(uploadHook);
+          }
+          return this;
+      };
+      /**
+       * Manually add an item to the uploading queue.
+       * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text|*} item - Object to
+       *        add to the queue
+       * @returns Instance of plugin for chaining.
+       */
+      BasePrepare.prototype.add = function (item) {
+          // Add additional hooks for finding elements on special
+          // types of objects that
+          for (var i = 0, len = this.addHooks.length; i < len; i++) {
+              if (this.addHooks[i](item, this.queue)) {
+                  break;
+              }
+          }
+          // Get children recursively
+          if (item instanceof Container) {
+              for (var i = item.children.length - 1; i >= 0; i--) {
+                  this.add(item.children[i]);
+              }
+          }
+          return this;
+      };
+      /** Destroys the plugin, don't use after this. */
+      BasePrepare.prototype.destroy = function () {
+          if (this.ticking) {
+              Ticker.system.remove(this.tick, this);
+          }
+          this.ticking = false;
+          this.addHooks = null;
+          this.uploadHooks = null;
+          this.renderer = null;
+          this.completes = null;
+          this.queue = null;
+          this.limiter = null;
+          this.uploadHookHelper = null;
+      };
+      return BasePrepare;
+  }());
 
-/**
- * The prepare manager provides functionality to upload content to the GPU
- * This cannot be done directly for Canvas like in WebGL, but the effect can be achieved by drawing
- * textures to an offline canvas.
- * This draw call will force the texture to be moved onto the GPU.
- *
- * An instance of this class is automatically created by default, and can be found at renderer.plugins.prepare
- *
- * @class
- * @extends PIXI.prepare.BasePrepare
- * @memberof PIXI.prepare
- */
+  /**
+   * Built-in hook to upload PIXI.Texture objects to the GPU.
+   * @private
+   * @param renderer - instance of the webgl renderer
+   * @param item - Item to check
+   * @returns If item was uploaded.
+   */
+  function uploadBaseTextures(renderer, item) {
+      if (item instanceof BaseTexture) {
+          // if the texture already has a GL texture, then the texture has been prepared or rendered
+          // before now. If the texture changed, then the changer should be calling texture.update() which
+          // reuploads the texture without need for preparing it again
+          if (!item._glTextures[renderer.CONTEXT_UID]) {
+              renderer.texture.bind(item);
+          }
+          return true;
+      }
+      return false;
+  }
+  /**
+   * Built-in hook to upload PIXI.Graphics to the GPU.
+   * @private
+   * @param renderer - instance of the webgl renderer
+   * @param item - Item to check
+   * @returns If item was uploaded.
+   */
+  function uploadGraphics(renderer, item) {
+      if (!(item instanceof Graphics)) {
+          return false;
+      }
+      var geometry = item.geometry;
+      // update dirty graphics to get batches
+      item.finishPoly();
+      geometry.updateBatches();
+      var batches = geometry.batches;
+      // upload all textures found in styles
+      for (var i = 0; i < batches.length; i++) {
+          var texture = batches[i].style.texture;
+          if (texture) {
+              uploadBaseTextures(renderer, texture.baseTexture);
+          }
+      }
+      // if its not batchable - update vao for particular shader
+      if (!geometry.batchable) {
+          renderer.geometry.bind(geometry, item._resolveDirectShader(renderer));
+      }
+      return true;
+  }
+  /**
+   * Built-in hook to find graphics.
+   * @private
+   * @param item - Display object to check
+   * @param queue - Collection of items to upload
+   * @returns if a PIXI.Graphics object was found.
+   */
+  function findGraphics(item, queue) {
+      if (item instanceof Graphics) {
+          queue.push(item);
+          return true;
+      }
+      return false;
+  }
+  /**
+   * The prepare plugin provides renderer-specific plugins for pre-rendering DisplayObjects. These plugins are useful for
+   * asynchronously preparing and uploading to the GPU assets, textures, graphics waiting to be displayed.
+   *
+   * Do not instantiate this plugin directly. It is available from the `renderer.plugins` property.
+   * See {@link PIXI.CanvasRenderer#plugins} or {@link PIXI.Renderer#plugins}.
+   * @example
+   * // Create a new application
+   * const app = new PIXI.Application();
+   * document.body.appendChild(app.view);
+   *
+   * // Don't start rendering right away
+   * app.stop();
+   *
+   * // create a display object
+   * const rect = new PIXI.Graphics()
+   *     .beginFill(0x00ff00)
+   *     .drawRect(40, 40, 200, 200);
+   *
+   * // Add to the stage
+   * app.stage.addChild(rect);
+   *
+   * // Don't start rendering until the graphic is uploaded to the GPU
+   * app.renderer.plugins.prepare.upload(app.stage, () => {
+   *     app.start();
+   * });
+   * @memberof PIXI
+   */
+  var Prepare = /** @class */ (function (_super) {
+      __extends$b(Prepare, _super);
+      /**
+       * @param {PIXI.Renderer} renderer - A reference to the current renderer
+       */
+      function Prepare(renderer) {
+          var _this = _super.call(this, renderer) || this;
+          _this.uploadHookHelper = _this.renderer;
+          // Add textures and graphics to upload
+          _this.registerFindHook(findGraphics);
+          _this.registerUploadHook(uploadBaseTextures);
+          _this.registerUploadHook(uploadGraphics);
+          return _this;
+      }
+      /** @ignore */
+      Prepare.extension = {
+          name: 'prepare',
+          type: exports.ExtensionType.RendererPlugin,
+      };
+      return Prepare;
+  }(BasePrepare));
 
-var CanvasPrepare = function (_BasePrepare) {
-    _inherits(CanvasPrepare, _BasePrepare);
-
-    /**
-     * @param {PIXI.CanvasRenderer} renderer - A reference to the current renderer
-     */
-    function CanvasPrepare(renderer) {
-        _classCallCheck(this, CanvasPrepare);
-
-        var _this = _possibleConstructorReturn(this, _BasePrepare.call(this, renderer));
-
-        _this.uploadHookHelper = _this;
-
-        /**
-        * An offline canvas to render textures to
-        * @type {HTMLCanvasElement}
-        * @private
-        */
-        _this.canvas = document.createElement('canvas');
-        _this.canvas.width = CANVAS_START_SIZE;
-        _this.canvas.height = CANVAS_START_SIZE;
-
-        /**
-         * The context to the canvas
-        * @type {CanvasRenderingContext2D}
-        * @private
-        */
-        _this.ctx = _this.canvas.getContext('2d');
-
-        // Add textures to upload
-        _this.registerUploadHook(uploadBaseTextures);
-        return _this;
-    }
+  /**
+   * TimeLimiter limits the number of items handled by a {@link PIXI.BasePrepare} to a specified
+   * number of milliseconds per frame.
+   * @memberof PIXI
+   */
+  var TimeLimiter = /** @class */ (function () {
+      /** @param maxMilliseconds - The maximum milliseconds that can be spent preparing items each frame. */
+      function TimeLimiter(maxMilliseconds) {
+          this.maxMilliseconds = maxMilliseconds;
+          this.frameStart = 0;
+      }
+      /** Resets any counting properties to start fresh on a new frame. */
+      TimeLimiter.prototype.beginFrame = function () {
+          this.frameStart = Date.now();
+      };
+      /**
+       * Checks to see if another item can be uploaded. This should only be called once per item.
+       * @returns - If the item is allowed to be uploaded.
+       */
+      TimeLimiter.prototype.allowedToUpload = function () {
+          return Date.now() - this.frameStart < this.maxMilliseconds;
+      };
+      return TimeLimiter;
+  }());
+
+  /*!
+   * @pixi/spritesheet - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/spritesheet is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-    /**
-     * Destroys the plugin, don't use after this.
-     *
-     */
+  /**
+   * Utility class for maintaining reference to a collection
+   * of Textures on a single Spritesheet.
+   *
+   * To access a sprite sheet from your code you may pass its JSON data file to Pixi's loader:
+   *
+   * ```js
+   * PIXI.Loader.shared.add("images/spritesheet.json").load(setup);
+   *
+   * function setup() {
+   *   let sheet = PIXI.Loader.shared.resources["images/spritesheet.json"].spritesheet;
+   *   ...
+   * }
+   * ```
+   *
+   * Alternately, you may circumvent the loader by instantiating the Spritesheet directly:
+   * ```js
+   * const sheet = new PIXI.Spritesheet(texture, spritesheetData);
+   * await sheet.parse();
+   * console.log('Spritesheet ready to use!');
+   * ```
+   *
+   * With the `sheet.textures` you can create Sprite objects,`sheet.animations` can be used to create an AnimatedSprite.
+   *
+   * Sprite sheets can be packed using tools like {@link https://codeandweb.com/texturepacker|TexturePacker},
+   * {@link https://renderhjs.net/shoebox/|Shoebox} or {@link https://github.com/krzysztof-o/spritesheet.js|Spritesheet.js}.
+   * Default anchor points (see {@link PIXI.Texture#defaultAnchor}) and grouping of animation sprites are currently only
+   * supported by TexturePacker.
+   * @memberof PIXI
+   */
+  var Spritesheet = /** @class */ (function () {
+      /**
+       * @param texture - Reference to the source BaseTexture object.
+       * @param {object} data - Spritesheet image data.
+       * @param resolutionFilename - The filename to consider when determining
+       *        the resolution of the spritesheet. If not provided, the imageUrl will
+       *        be used on the BaseTexture.
+       */
+      function Spritesheet(texture, data, resolutionFilename) {
+          if (resolutionFilename === void 0) { resolutionFilename = null; }
+          /** For multi-packed spritesheets, this contains a reference to all the other spritesheets it depends on. */
+          this.linkedSheets = [];
+          this._texture = texture instanceof Texture ? texture : null;
+          this.baseTexture = texture instanceof BaseTexture ? texture : this._texture.baseTexture;
+          this.textures = {};
+          this.animations = {};
+          this.data = data;
+          var resource = this.baseTexture.resource;
+          this.resolution = this._updateResolution(resolutionFilename || (resource ? resource.url : null));
+          this._frames = this.data.frames;
+          this._frameKeys = Object.keys(this._frames);
+          this._batchIndex = 0;
+          this._callback = null;
+      }
+      /**
+       * Generate the resolution from the filename or fallback
+       * to the meta.scale field of the JSON data.
+       * @param resolutionFilename - The filename to use for resolving
+       *        the default resolution.
+       * @returns Resolution to use for spritesheet.
+       */
+      Spritesheet.prototype._updateResolution = function (resolutionFilename) {
+          if (resolutionFilename === void 0) { resolutionFilename = null; }
+          var scale = this.data.meta.scale;
+          // Use a defaultValue of `null` to check if a url-based resolution is set
+          var resolution = getResolutionOfUrl(resolutionFilename, null);
+          // No resolution found via URL
+          if (resolution === null) {
+              // Use the scale value or default to 1
+              resolution = scale !== undefined ? parseFloat(scale) : 1;
+          }
+          // For non-1 resolutions, update baseTexture
+          if (resolution !== 1) {
+              this.baseTexture.setResolution(resolution);
+          }
+          return resolution;
+      };
+      /** @ignore */
+      Spritesheet.prototype.parse = function (callback) {
+          var _this = this;
+          if (callback) {
+              deprecation('6.5.0', 'Spritesheet.parse callback is deprecated, use the return Promise instead.');
+          }
+          return new Promise(function (resolve) {
+              _this._callback = function (textures) {
+                  callback === null || callback === void 0 ? void 0 : callback(textures);
+                  resolve(textures);
+              };
+              _this._batchIndex = 0;
+              if (_this._frameKeys.length <= Spritesheet.BATCH_SIZE) {
+                  _this._processFrames(0);
+                  _this._processAnimations();
+                  _this._parseComplete();
+              }
+              else {
+                  _this._nextBatch();
+              }
+          });
+      };
+      /**
+       * Process a batch of frames
+       * @param initialFrameIndex - The index of frame to start.
+       */
+      Spritesheet.prototype._processFrames = function (initialFrameIndex) {
+          var frameIndex = initialFrameIndex;
+          var maxFrames = Spritesheet.BATCH_SIZE;
+          while (frameIndex - initialFrameIndex < maxFrames && frameIndex < this._frameKeys.length) {
+              var i = this._frameKeys[frameIndex];
+              var data = this._frames[i];
+              var rect = data.frame;
+              if (rect) {
+                  var frame = null;
+                  var trim = null;
+                  var sourceSize = data.trimmed !== false && data.sourceSize
+                      ? data.sourceSize : data.frame;
+                  var orig = new Rectangle(0, 0, Math.floor(sourceSize.w) / this.resolution, Math.floor(sourceSize.h) / this.resolution);
+                  if (data.rotated) {
+                      frame = new Rectangle(Math.floor(rect.x) / this.resolution, Math.floor(rect.y) / this.resolution, Math.floor(rect.h) / this.resolution, Math.floor(rect.w) / this.resolution);
+                  }
+                  else {
+                      frame = new Rectangle(Math.floor(rect.x) / this.resolution, Math.floor(rect.y) / this.resolution, Math.floor(rect.w) / this.resolution, Math.floor(rect.h) / this.resolution);
+                  }
+                  //  Check to see if the sprite is trimmed
+                  if (data.trimmed !== false && data.spriteSourceSize) {
+                      trim = new Rectangle(Math.floor(data.spriteSourceSize.x) / this.resolution, Math.floor(data.spriteSourceSize.y) / this.resolution, Math.floor(rect.w) / this.resolution, Math.floor(rect.h) / this.resolution);
+                  }
+                  this.textures[i] = new Texture(this.baseTexture, frame, orig, trim, data.rotated ? 2 : 0, data.anchor);
+                  // lets also add the frame to pixi's global cache for 'from' and 'fromLoader' functions
+                  Texture.addToCache(this.textures[i], i);
+              }
+              frameIndex++;
+          }
+      };
+      /** Parse animations config. */
+      Spritesheet.prototype._processAnimations = function () {
+          var animations = this.data.animations || {};
+          for (var animName in animations) {
+              this.animations[animName] = [];
+              for (var i = 0; i < animations[animName].length; i++) {
+                  var frameName = animations[animName][i];
+                  this.animations[animName].push(this.textures[frameName]);
+              }
+          }
+      };
+      /** The parse has completed. */
+      Spritesheet.prototype._parseComplete = function () {
+          var callback = this._callback;
+          this._callback = null;
+          this._batchIndex = 0;
+          callback.call(this, this.textures);
+      };
+      /** Begin the next batch of textures. */
+      Spritesheet.prototype._nextBatch = function () {
+          var _this = this;
+          this._processFrames(this._batchIndex * Spritesheet.BATCH_SIZE);
+          this._batchIndex++;
+          setTimeout(function () {
+              if (_this._batchIndex * Spritesheet.BATCH_SIZE < _this._frameKeys.length) {
+                  _this._nextBatch();
+              }
+              else {
+                  _this._processAnimations();
+                  _this._parseComplete();
+              }
+          }, 0);
+      };
+      /**
+       * Destroy Spritesheet and don't use after this.
+       * @param {boolean} [destroyBase=false] - Whether to destroy the base texture as well
+       */
+      Spritesheet.prototype.destroy = function (destroyBase) {
+          var _a;
+          if (destroyBase === void 0) { destroyBase = false; }
+          for (var i in this.textures) {
+              this.textures[i].destroy();
+          }
+          this._frames = null;
+          this._frameKeys = null;
+          this.data = null;
+          this.textures = null;
+          if (destroyBase) {
+              (_a = this._texture) === null || _a === void 0 ? void 0 : _a.destroy();
+              this.baseTexture.destroy();
+          }
+          this._texture = null;
+          this.baseTexture = null;
+          this.linkedSheets = [];
+      };
+      /** The maximum number of Textures to build per process. */
+      Spritesheet.BATCH_SIZE = 1000;
+      return Spritesheet;
+  }());
+  /**
+   * Reference to Spritesheet object created.
+   * @member {PIXI.Spritesheet} spritesheet
+   * @memberof PIXI.LoaderResource
+   * @instance
+   */
+  /**
+   * Dictionary of textures from Spritesheet.
+   * @member {Object<string, PIXI.Texture>} textures
+   * @memberof PIXI.LoaderResource
+   * @instance
+   */
 
+  /**
+   * {@link PIXI.Loader} middleware for loading texture atlases that have been created with
+   * TexturePacker or similar JSON-based spritesheet.
+   *
+   * This middleware automatically generates Texture resources.
+   *
+   * If you're using Webpack or other bundlers and plan on bundling the atlas' JSON,
+   * use the {@link PIXI.Spritesheet} class to directly parse the JSON.
+   *
+   * The Loader's image Resource name is automatically appended with `"_image"`.
+   * If a Resource with this name is already loaded, the Loader will skip parsing the
+   * Spritesheet. The code below will generate an internal Loader Resource called `"myatlas_image"`.
+   * @example
+   * loader.add('myatlas', 'path/to/myatlas.json');
+   * loader.load(() => {
+   *   loader.resources.myatlas; // atlas JSON resource
+   *   loader.resources.myatlas_image; // atlas Image resource
+   * });
+   * @memberof PIXI
+   */
+  var SpritesheetLoader = /** @class */ (function () {
+      function SpritesheetLoader() {
+      }
+      /**
+       * Called after a resource is loaded.
+       * @see PIXI.Loader.loaderMiddleware
+       * @param resource
+       * @param next
+       */
+      SpritesheetLoader.use = function (resource, next) {
+          var _a, _b;
+          // because this is middleware, it execute in loader context. `this` = loader
+          var loader = this;
+          var imageResourceName = resource.name + "_image";
+          // skip if no data, its not json, it isn't spritesheet data, or the image resource already exists
+          if (!resource.data
+              || resource.type !== exports.LoaderResource.TYPE.JSON
+              || !resource.data.frames
+              || loader.resources[imageResourceName]) {
+              next();
+              return;
+          }
+          // Check and add the multi atlas
+          // Heavily influenced and based on https://github.com/rocket-ua/pixi-tps-loader/blob/master/src/ResourceLoader.js
+          // eslint-disable-next-line camelcase
+          var multiPacks = (_b = (_a = resource.data) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.related_multi_packs;
+          if (Array.isArray(multiPacks)) {
+              var _loop_1 = function (item) {
+                  if (typeof item !== 'string') {
+                      return "continue";
+                  }
+                  var itemName = item.replace('.json', '');
+                  var itemUrl = url.resolve(resource.url.replace(loader.baseUrl, ''), item);
+                  // Check if the file wasn't already added as multipacks are redundant
+                  if (loader.resources[itemName]
+                      || Object.values(loader.resources).some(function (r) { return url.format(url.parse(r.url)) === itemUrl; })) {
+                      return "continue";
+                  }
+                  var options = {
+                      crossOrigin: resource.crossOrigin,
+                      loadType: exports.LoaderResource.LOAD_TYPE.XHR,
+                      xhrType: exports.LoaderResource.XHR_RESPONSE_TYPE.JSON,
+                      parentResource: resource,
+                      metadata: resource.metadata
+                  };
+                  loader.add(itemName, itemUrl, options);
+              };
+              for (var _i = 0, multiPacks_1 = multiPacks; _i < multiPacks_1.length; _i++) {
+                  var item = multiPacks_1[_i];
+                  _loop_1(item);
+              }
+          }
+          var loadOptions = {
+              crossOrigin: resource.crossOrigin,
+              metadata: resource.metadata.imageMetadata,
+              parentResource: resource,
+          };
+          var resourcePath = SpritesheetLoader.getResourcePath(resource, loader.baseUrl);
+          // load the image for this sheet
+          loader.add(imageResourceName, resourcePath, loadOptions, function onImageLoad(res) {
+              if (res.error) {
+                  next(res.error);
+                  return;
+              }
+              var spritesheet = new Spritesheet(res.texture, resource.data, resource.url);
+              spritesheet.parse().then(function () {
+                  resource.spritesheet = spritesheet;
+                  resource.textures = spritesheet.textures;
+                  next();
+              });
+          });
+      };
+      /**
+       * Get the spritesheets root path
+       * @param resource - Resource to check path
+       * @param baseUrl - Base root url
+       */
+      SpritesheetLoader.getResourcePath = function (resource, baseUrl) {
+          // Prepend url path unless the resource image is a data url
+          if (resource.isDataUrl) {
+              return resource.data.meta.image;
+          }
+          return url.resolve(resource.url.replace(baseUrl, ''), resource.data.meta.image);
+      };
+      /** @ignore */
+      SpritesheetLoader.extension = exports.ExtensionType.Loader;
+      return SpritesheetLoader;
+  }());
+
+  /*!
+   * @pixi/sprite-tiling - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/sprite-tiling is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-    CanvasPrepare.prototype.destroy = function destroy() {
-        _BasePrepare.prototype.destroy.call(this);
-        this.ctx = null;
-        this.canvas = null;
-    };
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$a = function(d, b) {
+      extendStatics$a = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$a(d, b);
+  };
 
-    return CanvasPrepare;
-}(_BasePrepare3.default);
+  function __extends$a(d, b) {
+      extendStatics$a(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-/**
- * Built-in hook to upload PIXI.Texture objects to the GPU.
- *
- * @private
- * @param {*} prepare - Instance of CanvasPrepare
- * @param {*} item - Item to check
- * @return {boolean} If item was uploaded.
- */
+  var tempPoint$1 = new Point();
+  /**
+   * A tiling sprite is a fast way of rendering a tiling image.
+   * @memberof PIXI
+   */
+  var TilingSprite = /** @class */ (function (_super) {
+      __extends$a(TilingSprite, _super);
+      /**
+       * @param texture - The texture of the tiling sprite.
+       * @param width - The width of the tiling sprite.
+       * @param height - The height of the tiling sprite.
+       */
+      function TilingSprite(texture, width, height) {
+          if (width === void 0) { width = 100; }
+          if (height === void 0) { height = 100; }
+          var _this = _super.call(this, texture) || this;
+          _this.tileTransform = new Transform();
+          // The width of the tiling sprite
+          _this._width = width;
+          // The height of the tiling sprite
+          _this._height = height;
+          _this.uvMatrix = _this.texture.uvMatrix || new TextureMatrix(texture);
+          /**
+           * Plugin that is responsible for rendering this element.
+           * Allows to customize the rendering process without overriding '_render' method.
+           * @default 'tilingSprite'
+           */
+          _this.pluginName = 'tilingSprite';
+          _this.uvRespectAnchor = false;
+          return _this;
+      }
+      Object.defineProperty(TilingSprite.prototype, "clampMargin", {
+          /**
+           * Changes frame clamping in corresponding textureTransform, shortcut
+           * Change to -0.5 to add a pixel to the edge, recommended for transparent trimmed textures in atlas
+           * @default 0.5
+           * @member {number}
+           */
+          get: function () {
+              return this.uvMatrix.clampMargin;
+          },
+          set: function (value) {
+              this.uvMatrix.clampMargin = value;
+              this.uvMatrix.update(true);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TilingSprite.prototype, "tileScale", {
+          /** The scaling of the image that is being tiled. */
+          get: function () {
+              return this.tileTransform.scale;
+          },
+          set: function (value) {
+              this.tileTransform.scale.copyFrom(value);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TilingSprite.prototype, "tilePosition", {
+          /** The offset of the image that is being tiled. */
+          get: function () {
+              return this.tileTransform.position;
+          },
+          set: function (value) {
+              this.tileTransform.position.copyFrom(value);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * @protected
+       */
+      TilingSprite.prototype._onTextureUpdate = function () {
+          if (this.uvMatrix) {
+              this.uvMatrix.texture = this._texture;
+          }
+          this._cachedTint = 0xFFFFFF;
+      };
+      /**
+       * Renders the object using the WebGL renderer
+       * @param renderer - The renderer
+       */
+      TilingSprite.prototype._render = function (renderer) {
+          // tweak our texture temporarily..
+          var texture = this._texture;
+          if (!texture || !texture.valid) {
+              return;
+          }
+          this.tileTransform.updateLocalTransform();
+          this.uvMatrix.update();
+          renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
+          renderer.plugins[this.pluginName].render(this);
+      };
+      /** Updates the bounds of the tiling sprite. */
+      TilingSprite.prototype._calculateBounds = function () {
+          var minX = this._width * -this._anchor._x;
+          var minY = this._height * -this._anchor._y;
+          var maxX = this._width * (1 - this._anchor._x);
+          var maxY = this._height * (1 - this._anchor._y);
+          this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);
+      };
+      /**
+       * Gets the local bounds of the sprite object.
+       * @param rect - Optional output rectangle.
+       * @returns The bounds.
+       */
+      TilingSprite.prototype.getLocalBounds = function (rect) {
+          // we can do a fast local bounds if the sprite has no children!
+          if (this.children.length === 0) {
+              this._bounds.minX = this._width * -this._anchor._x;
+              this._bounds.minY = this._height * -this._anchor._y;
+              this._bounds.maxX = this._width * (1 - this._anchor._x);
+              this._bounds.maxY = this._height * (1 - this._anchor._y);
+              if (!rect) {
+                  if (!this._localBoundsRect) {
+                      this._localBoundsRect = new Rectangle();
+                  }
+                  rect = this._localBoundsRect;
+              }
+              return this._bounds.getRectangle(rect);
+          }
+          return _super.prototype.getLocalBounds.call(this, rect);
+      };
+      /**
+       * Checks if a point is inside this tiling sprite.
+       * @param point - The point to check.
+       * @returns Whether or not the sprite contains the point.
+       */
+      TilingSprite.prototype.containsPoint = function (point) {
+          this.worldTransform.applyInverse(point, tempPoint$1);
+          var width = this._width;
+          var height = this._height;
+          var x1 = -width * this.anchor._x;
+          if (tempPoint$1.x >= x1 && tempPoint$1.x < x1 + width) {
+              var y1 = -height * this.anchor._y;
+              if (tempPoint$1.y >= y1 && tempPoint$1.y < y1 + height) {
+                  return true;
+              }
+          }
+          return false;
+      };
+      /**
+       * Destroys this sprite and optionally its texture and children
+       * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
+       *  have been set to that value
+       * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
+       *      method called as well. 'options' will be passed on to those calls.
+       * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well
+       * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well
+       */
+      TilingSprite.prototype.destroy = function (options) {
+          _super.prototype.destroy.call(this, options);
+          this.tileTransform = null;
+          this.uvMatrix = null;
+      };
+      /**
+       * Helper function that creates a new tiling sprite based on the source you provide.
+       * The source can be - frame id, image url, video url, canvas element, video element, base texture
+       * @static
+       * @param {string|PIXI.Texture|HTMLCanvasElement|HTMLVideoElement} source - Source to create texture from
+       * @param {object} options - See {@link PIXI.BaseTexture}'s constructor for options.
+       * @param {number} options.width - required width of the tiling sprite
+       * @param {number} options.height - required height of the tiling sprite
+       * @returns {PIXI.TilingSprite} The newly created texture
+       */
+      TilingSprite.from = function (source, options) {
+          var texture = (source instanceof Texture)
+              ? source
+              : Texture.from(source, options);
+          return new TilingSprite(texture, options.width, options.height);
+      };
+      Object.defineProperty(TilingSprite.prototype, "width", {
+          /** The width of the sprite, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              return this._width;
+          },
+          set: function (value) {
+              this._width = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(TilingSprite.prototype, "height", {
+          /** The height of the TilingSprite, setting this will actually modify the scale to achieve the value set. */
+          get: function () {
+              return this._height;
+          },
+          set: function (value) {
+              this._height = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return TilingSprite;
+  }(Sprite));
+
+  var fragmentSimpleSrc = "#version 100\n#define SHADER_NAME Tiling-Sprite-Simple-100\n\nprecision lowp float;\n\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\n\nvoid main(void)\n{\n    vec4 texSample = texture2D(uSampler, vTextureCoord);\n    gl_FragColor = texSample * uColor;\n}\n";
+
+  var gl1VertexSrc = "#version 100\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n";
+
+  var gl1FragmentSrc = "#version 100\n#ifdef GL_EXT_shader_texture_lod\n    #extension GL_EXT_shader_texture_lod : enable\n#endif\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\nuniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;\n\nvoid main(void)\n{\n    vec2 coord = vTextureCoord + ceil(uClampOffset - vTextureCoord);\n    coord = (uMapCoord * vec3(coord, 1.0)).xy;\n    vec2 unclamped = coord;\n    coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);\n\n    #ifdef GL_EXT_shader_texture_lod\n        vec4 texSample = unclamped == coord\n            ? texture2D(uSampler, coord) \n            : texture2DLodEXT(uSampler, coord, 0);\n    #else\n        vec4 texSample = texture2D(uSampler, coord);\n    #endif\n\n    gl_FragColor = texSample * uColor;\n}\n";
+
+  var gl2VertexSrc = "#version 300 es\n#define SHADER_NAME Tiling-Sprite-300\n\nprecision lowp float;\n\nin vec2 aVertexPosition;\nin vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nout vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n";
+
+  var gl2FragmentSrc = "#version 300 es\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nin vec2 vTextureCoord;\n\nout vec4 fragmentColor;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\nuniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;\n\nvoid main(void)\n{\n    vec2 coord = vTextureCoord + ceil(uClampOffset - vTextureCoord);\n    coord = (uMapCoord * vec3(coord, 1.0)).xy;\n    vec2 unclamped = coord;\n    coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);\n\n    vec4 texSample = texture(uSampler, coord, unclamped == coord ? 0.0f : -32.0f);// lod-bias very negative to force lod 0\n\n    fragmentColor = texSample * uColor;\n}\n";
+
+  var tempMat = new Matrix();
+  /**
+   * WebGL renderer plugin for tiling sprites
+   * @class
+   * @memberof PIXI
+   * @extends PIXI.ObjectRenderer
+   */
+  var TilingSpriteRenderer = /** @class */ (function (_super) {
+      __extends$a(TilingSpriteRenderer, _super);
+      /**
+       * constructor for renderer
+       * @param {PIXI.Renderer} renderer - The renderer this tiling awesomeness works for.
+       */
+      function TilingSpriteRenderer(renderer) {
+          var _this = _super.call(this, renderer) || this;
+          // WebGL version is not available during initialization!
+          renderer.runners.contextChange.add(_this);
+          _this.quad = new QuadUv();
+          /**
+           * The WebGL state in which this renderer will work.
+           * @member {PIXI.State}
+           * @readonly
+           */
+          _this.state = State.for2d();
+          return _this;
+      }
+      /** Creates shaders when context is initialized. */
+      TilingSpriteRenderer.prototype.contextChange = function () {
+          var renderer = this.renderer;
+          var uniforms = { globals: renderer.globalUniforms };
+          this.simpleShader = Shader.from(gl1VertexSrc, fragmentSimpleSrc, uniforms);
+          this.shader = renderer.context.webGLVersion > 1
+              ? Shader.from(gl2VertexSrc, gl2FragmentSrc, uniforms)
+              : Shader.from(gl1VertexSrc, gl1FragmentSrc, uniforms);
+      };
+      /**
+       * @param {PIXI.TilingSprite} ts - tilingSprite to be rendered
+       */
+      TilingSpriteRenderer.prototype.render = function (ts) {
+          var renderer = this.renderer;
+          var quad = this.quad;
+          var vertices = quad.vertices;
+          vertices[0] = vertices[6] = (ts._width) * -ts.anchor.x;
+          vertices[1] = vertices[3] = ts._height * -ts.anchor.y;
+          vertices[2] = vertices[4] = (ts._width) * (1.0 - ts.anchor.x);
+          vertices[5] = vertices[7] = ts._height * (1.0 - ts.anchor.y);
+          var anchorX = ts.uvRespectAnchor ? ts.anchor.x : 0;
+          var anchorY = ts.uvRespectAnchor ? ts.anchor.y : 0;
+          vertices = quad.uvs;
+          vertices[0] = vertices[6] = -anchorX;
+          vertices[1] = vertices[3] = -anchorY;
+          vertices[2] = vertices[4] = 1.0 - anchorX;
+          vertices[5] = vertices[7] = 1.0 - anchorY;
+          quad.invalidate();
+          var tex = ts._texture;
+          var baseTex = tex.baseTexture;
+          var premultiplied = baseTex.alphaMode > 0;
+          var lt = ts.tileTransform.localTransform;
+          var uv = ts.uvMatrix;
+          var isSimple = baseTex.isPowerOfTwo
+              && tex.frame.width === baseTex.width && tex.frame.height === baseTex.height;
+          // auto, force repeat wrapMode for big tiling textures
+          if (isSimple) {
+              if (!baseTex._glTextures[renderer.CONTEXT_UID]) {
+                  if (baseTex.wrapMode === exports.WRAP_MODES.CLAMP) {
+                      baseTex.wrapMode = exports.WRAP_MODES.REPEAT;
+                  }
+              }
+              else {
+                  isSimple = baseTex.wrapMode !== exports.WRAP_MODES.CLAMP;
+              }
+          }
+          var shader = isSimple ? this.simpleShader : this.shader;
+          var w = tex.width;
+          var h = tex.height;
+          var W = ts._width;
+          var H = ts._height;
+          tempMat.set(lt.a * w / W, lt.b * w / H, lt.c * h / W, lt.d * h / H, lt.tx / W, lt.ty / H);
+          // that part is the same as above:
+          // tempMat.identity();
+          // tempMat.scale(tex.width, tex.height);
+          // tempMat.prepend(lt);
+          // tempMat.scale(1.0 / ts._width, 1.0 / ts._height);
+          tempMat.invert();
+          if (isSimple) {
+              tempMat.prepend(uv.mapCoord);
+          }
+          else {
+              shader.uniforms.uMapCoord = uv.mapCoord.toArray(true);
+              shader.uniforms.uClampFrame = uv.uClampFrame;
+              shader.uniforms.uClampOffset = uv.uClampOffset;
+          }
+          shader.uniforms.uTransform = tempMat.toArray(true);
+          shader.uniforms.uColor = premultiplyTintToRgba(ts.tint, ts.worldAlpha, shader.uniforms.uColor, premultiplied);
+          shader.uniforms.translationMatrix = ts.transform.worldTransform.toArray(true);
+          shader.uniforms.uSampler = tex;
+          renderer.shader.bind(shader);
+          renderer.geometry.bind(quad);
+          this.state.blendMode = correctBlendMode(ts.blendMode, premultiplied);
+          renderer.state.set(this.state);
+          renderer.geometry.draw(this.renderer.gl.TRIANGLES, 6, 0);
+      };
+      /** @ignore */
+      TilingSpriteRenderer.extension = {
+          name: 'tilingSprite',
+          type: exports.ExtensionType.RendererPlugin,
+      };
+      return TilingSpriteRenderer;
+  }(ObjectRenderer));
+
+  /*!
+   * @pixi/mesh - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/mesh is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$9 = function(d, b) {
+      extendStatics$9 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$9(d, b);
+  };
 
-exports.default = CanvasPrepare;
-function uploadBaseTextures(prepare, item) {
-    if (item instanceof core.BaseTexture) {
-        var image = item.source;
+  function __extends$9(d, b) {
+      extendStatics$9(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-        // Sometimes images (like atlas images) report a size of zero, causing errors on windows phone.
-        // So if the width or height is equal to zero then use the canvas size
-        // Otherwise use whatever is smaller, the image dimensions or the canvas dimensions.
-        var imageWidth = image.width === 0 ? prepare.canvas.width : Math.min(prepare.canvas.width, image.width);
-        var imageHeight = image.height === 0 ? prepare.canvas.height : Math.min(prepare.canvas.height, image.height);
+  /**
+   * Class controls cache for UV mapping from Texture normal space to BaseTexture normal space.
+   * @memberof PIXI
+   */
+  var MeshBatchUvs = /** @class */ (function () {
+      /**
+       * @param uvBuffer - Buffer with normalized uv's
+       * @param uvMatrix - Material UV matrix
+       */
+      function MeshBatchUvs(uvBuffer, uvMatrix) {
+          this.uvBuffer = uvBuffer;
+          this.uvMatrix = uvMatrix;
+          this.data = null;
+          this._bufferUpdateId = -1;
+          this._textureUpdateId = -1;
+          this._updateID = 0;
+      }
+      /**
+       * Updates
+       * @param forceUpdate - force the update
+       */
+      MeshBatchUvs.prototype.update = function (forceUpdate) {
+          if (!forceUpdate
+              && this._bufferUpdateId === this.uvBuffer._updateID
+              && this._textureUpdateId === this.uvMatrix._updateID) {
+              return;
+          }
+          this._bufferUpdateId = this.uvBuffer._updateID;
+          this._textureUpdateId = this.uvMatrix._updateID;
+          var data = this.uvBuffer.data;
+          if (!this.data || this.data.length !== data.length) {
+              this.data = new Float32Array(data.length);
+          }
+          this.uvMatrix.multiplyUvs(data, this.data);
+          this._updateID++;
+      };
+      return MeshBatchUvs;
+  }());
+
+  var tempPoint = new Point();
+  var tempPolygon = new Polygon();
+  /**
+   * Base mesh class.
+   *
+   * This class empowers you to have maximum flexibility to render any kind of WebGL visuals you can think of.
+   * This class assumes a certain level of WebGL knowledge.
+   * If you know a bit this should abstract enough away to make your life easier!
+   *
+   * Pretty much ALL WebGL can be broken down into the following:
+   * - Geometry - The structure and data for the mesh. This can include anything from positions, uvs, normals, colors etc..
+   * - Shader - This is the shader that PixiJS will render the geometry with (attributes in the shader must match the geometry)
+   * - State - This is the state of WebGL required to render the mesh.
+   *
+   * Through a combination of the above elements you can render anything you want, 2D or 3D!
+   * @memberof PIXI
+   */
+  var Mesh = /** @class */ (function (_super) {
+      __extends$9(Mesh, _super);
+      /**
+       * @param geometry - The geometry the mesh will use.
+       * @param {PIXI.MeshMaterial} shader - The shader the mesh will use.
+       * @param state - The state that the WebGL context is required to be in to render the mesh
+       *        if no state is provided, uses {@link PIXI.State.for2d} to create a 2D state for PixiJS.
+       * @param drawMode - The drawMode, can be any of the {@link PIXI.DRAW_MODES} constants.
+       */
+      function Mesh(geometry, shader, state, drawMode) {
+          if (drawMode === void 0) { drawMode = exports.DRAW_MODES.TRIANGLES; }
+          var _this = _super.call(this) || this;
+          _this.geometry = geometry;
+          _this.shader = shader;
+          _this.state = state || State.for2d();
+          _this.drawMode = drawMode;
+          _this.start = 0;
+          _this.size = 0;
+          _this.uvs = null;
+          _this.indices = null;
+          _this.vertexData = new Float32Array(1);
+          _this.vertexDirty = -1;
+          _this._transformID = -1;
+          _this._roundPixels = settings.ROUND_PIXELS;
+          _this.batchUvs = null;
+          return _this;
+      }
+      Object.defineProperty(Mesh.prototype, "geometry", {
+          /**
+           * Includes vertex positions, face indices, normals, colors, UVs, and
+           * custom attributes within buffers, reducing the cost of passing all
+           * this data to the GPU. Can be shared between multiple Mesh objects.
+           */
+          get: function () {
+              return this._geometry;
+          },
+          set: function (value) {
+              if (this._geometry === value) {
+                  return;
+              }
+              if (this._geometry) {
+                  this._geometry.refCount--;
+                  if (this._geometry.refCount === 0) {
+                      this._geometry.dispose();
+                  }
+              }
+              this._geometry = value;
+              if (this._geometry) {
+                  this._geometry.refCount++;
+              }
+              this.vertexDirty = -1;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Mesh.prototype, "uvBuffer", {
+          /**
+           * To change mesh uv's, change its uvBuffer data and increment its _updateID.
+           * @readonly
+           */
+          get: function () {
+              return this.geometry.buffers[1];
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Mesh.prototype, "verticesBuffer", {
+          /**
+           * To change mesh vertices, change its uvBuffer data and increment its _updateID.
+           * Incrementing _updateID is optional because most of Mesh objects do it anyway.
+           * @readonly
+           */
+          get: function () {
+              return this.geometry.buffers[0];
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Mesh.prototype, "material", {
+          get: function () {
+              return this.shader;
+          },
+          /** Alias for {@link PIXI.Mesh#shader}. */
+          set: function (value) {
+              this.shader = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Mesh.prototype, "blendMode", {
+          get: function () {
+              return this.state.blendMode;
+          },
+          /**
+           * The blend mode to be applied to the Mesh. Apply a value of
+           * `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.
+           * @default PIXI.BLEND_MODES.NORMAL;
+           */
+          set: function (value) {
+              this.state.blendMode = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Mesh.prototype, "roundPixels", {
+          get: function () {
+              return this._roundPixels;
+          },
+          /**
+           * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
+           * Advantages can include sharper image quality (like text) and faster rendering on canvas.
+           * The main disadvantage is movement of objects may appear less smooth.
+           * To set the global default, change {@link PIXI.settings.ROUND_PIXELS}
+           * @default false
+           */
+          set: function (value) {
+              if (this._roundPixels !== value) {
+                  this._transformID = -1;
+              }
+              this._roundPixels = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Mesh.prototype, "tint", {
+          /**
+           * The multiply tint applied to the Mesh. This is a hex value. A value of
+           * `0xFFFFFF` will remove any tint effect.
+           *
+           * Null for non-MeshMaterial shaders
+           * @default 0xFFFFFF
+           */
+          get: function () {
+              return 'tint' in this.shader ? this.shader.tint : null;
+          },
+          set: function (value) {
+              this.shader.tint = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Mesh.prototype, "texture", {
+          /** The texture that the Mesh uses. Null for non-MeshMaterial shaders */
+          get: function () {
+              return 'texture' in this.shader ? this.shader.texture : null;
+          },
+          set: function (value) {
+              this.shader.texture = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Standard renderer draw.
+       * @param renderer - Instance to renderer.
+       */
+      Mesh.prototype._render = function (renderer) {
+          // set properties for batching..
+          // TODO could use a different way to grab verts?
+          var vertices = this.geometry.buffers[0].data;
+          var shader = this.shader;
+          // TODO benchmark check for attribute size..
+          if (shader.batchable
+              && this.drawMode === exports.DRAW_MODES.TRIANGLES
+              && vertices.length < Mesh.BATCHABLE_SIZE * 2) {
+              this._renderToBatch(renderer);
+          }
+          else {
+              this._renderDefault(renderer);
+          }
+      };
+      /**
+       * Standard non-batching way of rendering.
+       * @param renderer - Instance to renderer.
+       */
+      Mesh.prototype._renderDefault = function (renderer) {
+          var shader = this.shader;
+          shader.alpha = this.worldAlpha;
+          if (shader.update) {
+              shader.update();
+          }
+          renderer.batch.flush();
+          // bind and sync uniforms..
+          shader.uniforms.translationMatrix = this.transform.worldTransform.toArray(true);
+          renderer.shader.bind(shader);
+          // set state..
+          renderer.state.set(this.state);
+          // bind the geometry...
+          renderer.geometry.bind(this.geometry, shader);
+          // then render it
+          renderer.geometry.draw(this.drawMode, this.size, this.start, this.geometry.instanceCount);
+      };
+      /**
+       * Rendering by using the Batch system.
+       * @param renderer - Instance to renderer.
+       */
+      Mesh.prototype._renderToBatch = function (renderer) {
+          var geometry = this.geometry;
+          var shader = this.shader;
+          if (shader.uvMatrix) {
+              shader.uvMatrix.update();
+              this.calculateUvs();
+          }
+          // set properties for batching..
+          this.calculateVertices();
+          this.indices = geometry.indexBuffer.data;
+          this._tintRGB = shader._tintRGB;
+          this._texture = shader.texture;
+          var pluginName = this.material.pluginName;
+          renderer.batch.setObjectRenderer(renderer.plugins[pluginName]);
+          renderer.plugins[pluginName].render(this);
+      };
+      /** Updates vertexData field based on transform and vertices. */
+      Mesh.prototype.calculateVertices = function () {
+          var geometry = this.geometry;
+          var verticesBuffer = geometry.buffers[0];
+          var vertices = verticesBuffer.data;
+          var vertexDirtyId = verticesBuffer._updateID;
+          if (vertexDirtyId === this.vertexDirty && this._transformID === this.transform._worldID) {
+              return;
+          }
+          this._transformID = this.transform._worldID;
+          if (this.vertexData.length !== vertices.length) {
+              this.vertexData = new Float32Array(vertices.length);
+          }
+          var wt = this.transform.worldTransform;
+          var a = wt.a;
+          var b = wt.b;
+          var c = wt.c;
+          var d = wt.d;
+          var tx = wt.tx;
+          var ty = wt.ty;
+          var vertexData = this.vertexData;
+          for (var i = 0; i < vertexData.length / 2; i++) {
+              var x = vertices[(i * 2)];
+              var y = vertices[(i * 2) + 1];
+              vertexData[(i * 2)] = (a * x) + (c * y) + tx;
+              vertexData[(i * 2) + 1] = (b * x) + (d * y) + ty;
+          }
+          if (this._roundPixels) {
+              var resolution = settings.RESOLUTION;
+              for (var i = 0; i < vertexData.length; ++i) {
+                  vertexData[i] = Math.round((vertexData[i] * resolution | 0) / resolution);
+              }
+          }
+          this.vertexDirty = vertexDirtyId;
+      };
+      /** Updates uv field based on from geometry uv's or batchUvs. */
+      Mesh.prototype.calculateUvs = function () {
+          var geomUvs = this.geometry.buffers[1];
+          var shader = this.shader;
+          if (!shader.uvMatrix.isSimple) {
+              if (!this.batchUvs) {
+                  this.batchUvs = new MeshBatchUvs(geomUvs, shader.uvMatrix);
+              }
+              this.batchUvs.update();
+              this.uvs = this.batchUvs.data;
+          }
+          else {
+              this.uvs = geomUvs.data;
+          }
+      };
+      /**
+       * Updates the bounds of the mesh as a rectangle. The bounds calculation takes the worldTransform into account.
+       * there must be a aVertexPosition attribute present in the geometry for bounds to be calculated correctly.
+       */
+      Mesh.prototype._calculateBounds = function () {
+          this.calculateVertices();
+          this._bounds.addVertexData(this.vertexData, 0, this.vertexData.length);
+      };
+      /**
+       * Tests if a point is inside this mesh. Works only for PIXI.DRAW_MODES.TRIANGLES.
+       * @param point - The point to test.
+       * @returns - The result of the test.
+       */
+      Mesh.prototype.containsPoint = function (point) {
+          if (!this.getBounds().contains(point.x, point.y)) {
+              return false;
+          }
+          this.worldTransform.applyInverse(point, tempPoint);
+          var vertices = this.geometry.getBuffer('aVertexPosition').data;
+          var points = tempPolygon.points;
+          var indices = this.geometry.getIndex().data;
+          var len = indices.length;
+          var step = this.drawMode === 4 ? 3 : 1;
+          for (var i = 0; i + 2 < len; i += step) {
+              var ind0 = indices[i] * 2;
+              var ind1 = indices[i + 1] * 2;
+              var ind2 = indices[i + 2] * 2;
+              points[0] = vertices[ind0];
+              points[1] = vertices[ind0 + 1];
+              points[2] = vertices[ind1];
+              points[3] = vertices[ind1 + 1];
+              points[4] = vertices[ind2];
+              points[5] = vertices[ind2 + 1];
+              if (tempPolygon.contains(tempPoint.x, tempPoint.y)) {
+                  return true;
+              }
+          }
+          return false;
+      };
+      Mesh.prototype.destroy = function (options) {
+          _super.prototype.destroy.call(this, options);
+          if (this._cachedTexture) {
+              this._cachedTexture.destroy();
+              this._cachedTexture = null;
+          }
+          this.geometry = null;
+          this.shader = null;
+          this.state = null;
+          this.uvs = null;
+          this.indices = null;
+          this.vertexData = null;
+      };
+      /** The maximum number of vertices to consider batchable. Generally, the complexity of the geometry. */
+      Mesh.BATCHABLE_SIZE = 100;
+      return Mesh;
+  }(Container));
+
+  var fragment$5 = "varying vec2 vTextureCoord;\nuniform vec4 uColor;\n\nuniform sampler2D uSampler;\n\nvoid main(void)\n{\n    gl_FragColor = texture2D(uSampler, vTextureCoord) * uColor;\n}\n";
+
+  var vertex$2 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTextureMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTextureMatrix * vec3(aTextureCoord, 1.0)).xy;\n}\n";
 
-        // Only a small subsections is required to be drawn to have the whole texture uploaded to the GPU
-        // A smaller draw can be faster.
-        prepare.ctx.drawImage(image, 0, 0, imageWidth, imageHeight, 0, 0, prepare.canvas.width, prepare.canvas.height);
+  /**
+   * Slightly opinionated default shader for PixiJS 2D objects.
+   * @memberof PIXI
+   */
+  var MeshMaterial = /** @class */ (function (_super) {
+      __extends$9(MeshMaterial, _super);
+      /**
+       * @param uSampler - Texture that material uses to render.
+       * @param options - Additional options
+       * @param {number} [options.alpha=1] - Default alpha.
+       * @param {number} [options.tint=0xFFFFFF] - Default tint.
+       * @param {string} [options.pluginName='batch'] - Renderer plugin for batching.
+       * @param {PIXI.Program} [options.program=0xFFFFFF] - Custom program.
+       * @param {object} [options.uniforms] - Custom uniforms.
+       */
+      function MeshMaterial(uSampler, options) {
+          var _this = this;
+          var uniforms = {
+              uSampler: uSampler,
+              alpha: 1,
+              uTextureMatrix: Matrix.IDENTITY,
+              uColor: new Float32Array([1, 1, 1, 1]),
+          };
+          // Set defaults
+          options = Object.assign({
+              tint: 0xFFFFFF,
+              alpha: 1,
+              pluginName: 'batch',
+          }, options);
+          if (options.uniforms) {
+              Object.assign(uniforms, options.uniforms);
+          }
+          _this = _super.call(this, options.program || Program.from(vertex$2, fragment$5), uniforms) || this;
+          _this._colorDirty = false;
+          _this.uvMatrix = new TextureMatrix(uSampler);
+          _this.batchable = options.program === undefined;
+          _this.pluginName = options.pluginName;
+          _this.tint = options.tint;
+          _this.alpha = options.alpha;
+          return _this;
+      }
+      Object.defineProperty(MeshMaterial.prototype, "texture", {
+          /** Reference to the texture being rendered. */
+          get: function () {
+              return this.uniforms.uSampler;
+          },
+          set: function (value) {
+              if (this.uniforms.uSampler !== value) {
+                  if (!this.uniforms.uSampler.baseTexture.alphaMode !== !value.baseTexture.alphaMode) {
+                      this._colorDirty = true;
+                  }
+                  this.uniforms.uSampler = value;
+                  this.uvMatrix.texture = value;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(MeshMaterial.prototype, "alpha", {
+          get: function () {
+              return this._alpha;
+          },
+          /**
+           * This gets automatically set by the object using this.
+           * @default 1
+           */
+          set: function (value) {
+              if (value === this._alpha)
+                  { return; }
+              this._alpha = value;
+              this._colorDirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(MeshMaterial.prototype, "tint", {
+          get: function () {
+              return this._tint;
+          },
+          /**
+           * Multiply tint for the material.
+           * @default 0xFFFFFF
+           */
+          set: function (value) {
+              if (value === this._tint)
+                  { return; }
+              this._tint = value;
+              this._tintRGB = (value >> 16) + (value & 0xff00) + ((value & 0xff) << 16);
+              this._colorDirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Gets called automatically by the Mesh. Intended to be overridden for custom {@link MeshMaterial} objects. */
+      MeshMaterial.prototype.update = function () {
+          if (this._colorDirty) {
+              this._colorDirty = false;
+              var baseTexture = this.texture.baseTexture;
+              premultiplyTintToRgba(this._tint, this._alpha, this.uniforms.uColor, baseTexture.alphaMode);
+          }
+          if (this.uvMatrix.update()) {
+              this.uniforms.uTextureMatrix = this.uvMatrix.mapCoord;
+          }
+      };
+      return MeshMaterial;
+  }(Shader));
 
-        return true;
-    }
+  /**
+   * Standard 2D geometry used in PixiJS.
+   *
+   * Geometry can be defined without passing in a style or data if required.
+   *
+   * ```js
+   * const geometry = new PIXI.Geometry();
+   *
+   * geometry.addAttribute('positions', [0, 0, 100, 0, 100, 100, 0, 100], 2);
+   * geometry.addAttribute('uvs', [0,0,1,0,1,1,0,1], 2);
+   * geometry.addIndex([0,1,2,1,3,2]);
+   *
+   * ```
+   * @memberof PIXI
+   */
+  var MeshGeometry = /** @class */ (function (_super) {
+      __extends$9(MeshGeometry, _super);
+      /**
+       * @param {Float32Array|number[]} [vertices] - Positional data on geometry.
+       * @param {Float32Array|number[]} [uvs] - Texture UVs.
+       * @param {Uint16Array|number[]} [index] - IndexBuffer
+       */
+      function MeshGeometry(vertices, uvs, index) {
+          var _this = _super.call(this) || this;
+          var verticesBuffer = new Buffer(vertices);
+          var uvsBuffer = new Buffer(uvs, true);
+          var indexBuffer = new Buffer(index, true, true);
+          _this.addAttribute('aVertexPosition', verticesBuffer, 2, false, exports.TYPES.FLOAT)
+              .addAttribute('aTextureCoord', uvsBuffer, 2, false, exports.TYPES.FLOAT)
+              .addIndex(indexBuffer);
+          _this._updateId = -1;
+          return _this;
+      }
+      Object.defineProperty(MeshGeometry.prototype, "vertexDirtyId", {
+          /**
+           * If the vertex position is updated.
+           * @readonly
+           * @private
+           */
+          get: function () {
+              return this.buffers[0]._updateID;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return MeshGeometry;
+  }(Geometry));
+
+  /*!
+   * @pixi/text-bitmap - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/text-bitmap is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-    return false;
-}
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$8 = function(d, b) {
+      extendStatics$8 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$8(d, b);
+  };
 
-core.CanvasRenderer.registerPlugin('prepare', CanvasPrepare);
+  function __extends$8(d, b) {
+      extendStatics$8(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-},{"../../core":65,"../BasePrepare":182}],184:[function(require,module,exports){
-'use strict';
+  /* eslint-disable max-len */
+  /**
+   * Normalized parsed data from .fnt files.
+   * @memberof PIXI
+   */
+  var BitmapFontData = /** @class */ (function () {
+      function BitmapFontData() {
+          this.info = [];
+          this.common = [];
+          this.page = [];
+          this.char = [];
+          this.kerning = [];
+          this.distanceField = [];
+      }
+      return BitmapFontData;
+  }());
 
-exports.__esModule = true;
+  /**
+   * BitmapFont format that's Text-based.
+   * @private
+   */
+  var TextFormat = /** @class */ (function () {
+      function TextFormat() {
+      }
+      /**
+       * Check if resource refers to txt font data.
+       * @param data
+       * @returns - True if resource could be treated as font data, false otherwise.
+       */
+      TextFormat.test = function (data) {
+          return typeof data === 'string' && data.indexOf('info face=') === 0;
+      };
+      /**
+       * Convert text font data to a javascript object.
+       * @param txt - Raw string data to be converted
+       * @returns - Parsed font data
+       */
+      TextFormat.parse = function (txt) {
+          // Retrieve data item
+          var items = txt.match(/^[a-z]+\s+.+$/gm);
+          var rawData = {
+              info: [],
+              common: [],
+              page: [],
+              char: [],
+              chars: [],
+              kerning: [],
+              kernings: [],
+              distanceField: [],
+          };
+          for (var i in items) {
+              // Extract item name
+              var name = items[i].match(/^[a-z]+/gm)[0];
+              // Extract item attribute list as string ex.: "width=10"
+              var attributeList = items[i].match(/[a-zA-Z]+=([^\s"']+|"([^"]*)")/gm);
+              // Convert attribute list into an object
+              var itemData = {};
+              for (var i_1 in attributeList) {
+                  // Split key-value pairs
+                  var split = attributeList[i_1].split('=');
+                  var key = split[0];
+                  // Remove eventual quotes from value
+                  var strValue = split[1].replace(/"/gm, '');
+                  // Try to convert value into float
+                  var floatValue = parseFloat(strValue);
+                  // Use string value case float value is NaN
+                  var value = isNaN(floatValue) ? strValue : floatValue;
+                  itemData[key] = value;
+              }
+              // Push current item to the resulting data
+              rawData[name].push(itemData);
+          }
+          var font = new BitmapFontData();
+          rawData.info.forEach(function (info) { return font.info.push({
+              face: info.face,
+              size: parseInt(info.size, 10),
+          }); });
+          rawData.common.forEach(function (common) { return font.common.push({
+              lineHeight: parseInt(common.lineHeight, 10),
+          }); });
+          rawData.page.forEach(function (page) { return font.page.push({
+              id: parseInt(page.id, 10),
+              file: page.file,
+          }); });
+          rawData.char.forEach(function (char) { return font.char.push({
+              id: parseInt(char.id, 10),
+              page: parseInt(char.page, 10),
+              x: parseInt(char.x, 10),
+              y: parseInt(char.y, 10),
+              width: parseInt(char.width, 10),
+              height: parseInt(char.height, 10),
+              xoffset: parseInt(char.xoffset, 10),
+              yoffset: parseInt(char.yoffset, 10),
+              xadvance: parseInt(char.xadvance, 10),
+          }); });
+          rawData.kerning.forEach(function (kerning) { return font.kerning.push({
+              first: parseInt(kerning.first, 10),
+              second: parseInt(kerning.second, 10),
+              amount: parseInt(kerning.amount, 10),
+          }); });
+          rawData.distanceField.forEach(function (df) { return font.distanceField.push({
+              distanceRange: parseInt(df.distanceRange, 10),
+              fieldType: df.fieldType,
+          }); });
+          return font;
+      };
+      return TextFormat;
+  }());
 
-var _WebGLPrepare = require('./webgl/WebGLPrepare');
+  /**
+   * BitmapFont format that's XML-based.
+   * @private
+   */
+  var XMLFormat = /** @class */ (function () {
+      function XMLFormat() {
+      }
+      /**
+       * Check if resource refers to xml font data.
+       * @param data
+       * @returns - True if resource could be treated as font data, false otherwise.
+       */
+      XMLFormat.test = function (data) {
+          return data instanceof XMLDocument
+              && data.getElementsByTagName('page').length
+              && data.getElementsByTagName('info')[0].getAttribute('face') !== null;
+      };
+      /**
+       * Convert the XML into BitmapFontData that we can use.
+       * @param xml
+       * @returns - Data to use for BitmapFont
+       */
+      XMLFormat.parse = function (xml) {
+          var data = new BitmapFontData();
+          var info = xml.getElementsByTagName('info');
+          var common = xml.getElementsByTagName('common');
+          var page = xml.getElementsByTagName('page');
+          var char = xml.getElementsByTagName('char');
+          var kerning = xml.getElementsByTagName('kerning');
+          var distanceField = xml.getElementsByTagName('distanceField');
+          for (var i = 0; i < info.length; i++) {
+              data.info.push({
+                  face: info[i].getAttribute('face'),
+                  size: parseInt(info[i].getAttribute('size'), 10),
+              });
+          }
+          for (var i = 0; i < common.length; i++) {
+              data.common.push({
+                  lineHeight: parseInt(common[i].getAttribute('lineHeight'), 10),
+              });
+          }
+          for (var i = 0; i < page.length; i++) {
+              data.page.push({
+                  id: parseInt(page[i].getAttribute('id'), 10) || 0,
+                  file: page[i].getAttribute('file'),
+              });
+          }
+          for (var i = 0; i < char.length; i++) {
+              var letter = char[i];
+              data.char.push({
+                  id: parseInt(letter.getAttribute('id'), 10),
+                  page: parseInt(letter.getAttribute('page'), 10) || 0,
+                  x: parseInt(letter.getAttribute('x'), 10),
+                  y: parseInt(letter.getAttribute('y'), 10),
+                  width: parseInt(letter.getAttribute('width'), 10),
+                  height: parseInt(letter.getAttribute('height'), 10),
+                  xoffset: parseInt(letter.getAttribute('xoffset'), 10),
+                  yoffset: parseInt(letter.getAttribute('yoffset'), 10),
+                  xadvance: parseInt(letter.getAttribute('xadvance'), 10),
+              });
+          }
+          for (var i = 0; i < kerning.length; i++) {
+              data.kerning.push({
+                  first: parseInt(kerning[i].getAttribute('first'), 10),
+                  second: parseInt(kerning[i].getAttribute('second'), 10),
+                  amount: parseInt(kerning[i].getAttribute('amount'), 10),
+              });
+          }
+          for (var i = 0; i < distanceField.length; i++) {
+              data.distanceField.push({
+                  fieldType: distanceField[i].getAttribute('fieldType'),
+                  distanceRange: parseInt(distanceField[i].getAttribute('distanceRange'), 10),
+              });
+          }
+          return data;
+      };
+      return XMLFormat;
+  }());
 
-Object.defineProperty(exports, 'webgl', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_WebGLPrepare).default;
+  /**
+   * BitmapFont format that's XML-based.
+   * @private
+   */
+  var XMLStringFormat = /** @class */ (function () {
+      function XMLStringFormat() {
+      }
+      /**
+       * Check if resource refers to text xml font data.
+       * @param data
+       * @returns - True if resource could be treated as font data, false otherwise.
+       */
+      XMLStringFormat.test = function (data) {
+          if (typeof data === 'string' && data.indexOf('<font>') > -1) {
+              var xml = new globalThis.DOMParser().parseFromString(data, 'text/xml');
+              return XMLFormat.test(xml);
+          }
+          return false;
+      };
+      /**
+       * Convert the text XML into BitmapFontData that we can use.
+       * @param xmlTxt
+       * @returns - Data to use for BitmapFont
+       */
+      XMLStringFormat.parse = function (xmlTxt) {
+          var xml = new globalThis.DOMParser().parseFromString(xmlTxt, 'text/xml');
+          return XMLFormat.parse(xml);
+      };
+      return XMLStringFormat;
+  }());
+
+  // Registered formats, maybe make this extensible in the future?
+  var formats = [
+      TextFormat,
+      XMLFormat,
+      XMLStringFormat ];
+  /**
+   * Auto-detect BitmapFont parsing format based on data.
+   * @private
+   * @param {any} data - Data to detect format
+   * @returns {any} Format or null
+   */
+  function autoDetectFormat(data) {
+      for (var i = 0; i < formats.length; i++) {
+          if (formats[i].test(data)) {
+              return formats[i];
+          }
+      }
+      return null;
   }
-});
-
-var _CanvasPrepare = require('./canvas/CanvasPrepare');
 
-Object.defineProperty(exports, 'canvas', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CanvasPrepare).default;
+  // TODO: Prevent code duplication b/w generateFillStyle & Text#generateFillStyle
+  /**
+   * Generates the fill style. Can automatically generate a gradient based on the fill style being an array
+   * @private
+   * @param canvas
+   * @param context
+   * @param {object} style - The style.
+   * @param resolution
+   * @param {string[]} lines - The lines of text.
+   * @param metrics
+   * @returns {string|number|CanvasGradient} The fill style
+   */
+  function generateFillStyle(canvas, context, style, resolution, lines, metrics) {
+      // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
+      //       the setter converts to string. See this thread for more details:
+      //       https://github.com/microsoft/TypeScript/issues/2521
+      var fillStyle = style.fill;
+      if (!Array.isArray(fillStyle)) {
+          return fillStyle;
+      }
+      else if (fillStyle.length === 1) {
+          return fillStyle[0];
+      }
+      // the gradient will be evenly spaced out according to how large the array is.
+      // ['#FF0000', '#00FF00', '#0000FF'] would created stops at 0.25, 0.5 and 0.75
+      var gradient;
+      // a dropshadow will enlarge the canvas and result in the gradient being
+      // generated with the incorrect dimensions
+      var dropShadowCorrection = (style.dropShadow) ? style.dropShadowDistance : 0;
+      // should also take padding into account, padding can offset the gradient
+      var padding = style.padding || 0;
+      var width = (canvas.width / resolution) - dropShadowCorrection - (padding * 2);
+      var height = (canvas.height / resolution) - dropShadowCorrection - (padding * 2);
+      // make a copy of the style settings, so we can manipulate them later
+      var fill = fillStyle.slice();
+      var fillGradientStops = style.fillGradientStops.slice();
+      // wanting to evenly distribute the fills. So an array of 4 colours should give fills of 0.25, 0.5 and 0.75
+      if (!fillGradientStops.length) {
+          var lengthPlus1 = fill.length + 1;
+          for (var i = 1; i < lengthPlus1; ++i) {
+              fillGradientStops.push(i / lengthPlus1);
+          }
+      }
+      // stop the bleeding of the last gradient on the line above to the top gradient of the this line
+      // by hard defining the first gradient colour at point 0, and last gradient colour at point 1
+      fill.unshift(fillStyle[0]);
+      fillGradientStops.unshift(0);
+      fill.push(fillStyle[fillStyle.length - 1]);
+      fillGradientStops.push(1);
+      if (style.fillGradientType === exports.TEXT_GRADIENT.LINEAR_VERTICAL) {
+          // start the gradient at the top center of the canvas, and end at the bottom middle of the canvas
+          gradient = context.createLinearGradient(width / 2, padding, width / 2, height + padding);
+          // we need to repeat the gradient so that each individual line of text has the same vertical gradient effect
+          // ['#FF0000', '#00FF00', '#0000FF'] over 2 lines would create stops at 0.125, 0.25, 0.375, 0.625, 0.75, 0.875
+          // There's potential for floating point precision issues at the seams between gradient repeats.
+          // The loop below generates the stops in order, so track the last generated one to prevent
+          // floating point precision from making us go the teeniest bit backwards, resulting in
+          // the first and last colors getting swapped.
+          var lastIterationStop = 0;
+          // Actual height of the text itself, not counting spacing for lineHeight/leading/dropShadow etc
+          var textHeight = metrics.fontProperties.fontSize + style.strokeThickness;
+          // textHeight, but as a 0-1 size in global gradient stop space
+          var gradStopLineHeight = textHeight / height;
+          for (var i = 0; i < lines.length; i++) {
+              var thisLineTop = metrics.lineHeight * i;
+              for (var j = 0; j < fill.length; j++) {
+                  // 0-1 stop point for the current line, multiplied to global space afterwards
+                  var lineStop = 0;
+                  if (typeof fillGradientStops[j] === 'number') {
+                      lineStop = fillGradientStops[j];
+                  }
+                  else {
+                      lineStop = j / fill.length;
+                  }
+                  var globalStop = (thisLineTop / height) + (lineStop * gradStopLineHeight);
+                  // Prevent color stop generation going backwards from floating point imprecision
+                  var clampedStop = Math.max(lastIterationStop, globalStop);
+                  clampedStop = Math.min(clampedStop, 1); // Cap at 1 as well for safety's sake to avoid a possible throw.
+                  gradient.addColorStop(clampedStop, fill[j]);
+                  lastIterationStop = clampedStop;
+              }
+          }
+      }
+      else {
+          // start the gradient at the center left of the canvas, and end at the center right of the canvas
+          gradient = context.createLinearGradient(padding, height / 2, width + padding, height / 2);
+          // can just evenly space out the gradients in this case, as multiple lines makes no difference
+          // to an even left to right gradient
+          var totalIterations = fill.length + 1;
+          var currentIteration = 1;
+          for (var i = 0; i < fill.length; i++) {
+              var stop = void 0;
+              if (typeof fillGradientStops[i] === 'number') {
+                  stop = fillGradientStops[i];
+              }
+              else {
+                  stop = currentIteration / totalIterations;
+              }
+              gradient.addColorStop(stop, fill[i]);
+              currentIteration++;
+          }
+      }
+      return gradient;
   }
-});
-
-var _BasePrepare = require('./BasePrepare');
 
-Object.defineProperty(exports, 'BasePrepare', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_BasePrepare).default;
+  // TODO: Prevent code duplication b/w drawGlyph & Text#updateText
+  /**
+   * Draws the glyph `metrics.text` on the given canvas.
+   *
+   * Ignored because not directly exposed.
+   * @ignore
+   * @param {HTMLCanvasElement} canvas
+   * @param {CanvasRenderingContext2D} context
+   * @param {TextMetrics} metrics
+   * @param {number} x
+   * @param {number} y
+   * @param {number} resolution
+   * @param {TextStyle} style
+   */
+  function drawGlyph(canvas, context, metrics, x, y, resolution, style) {
+      var char = metrics.text;
+      var fontProperties = metrics.fontProperties;
+      context.translate(x, y);
+      context.scale(resolution, resolution);
+      var tx = style.strokeThickness / 2;
+      var ty = -(style.strokeThickness / 2);
+      context.font = style.toFontString();
+      context.lineWidth = style.strokeThickness;
+      context.textBaseline = style.textBaseline;
+      context.lineJoin = style.lineJoin;
+      context.miterLimit = style.miterLimit;
+      // set canvas text styles
+      context.fillStyle = generateFillStyle(canvas, context, style, resolution, [char], metrics);
+      context.strokeStyle = style.stroke;
+      if (style.dropShadow) {
+          var dropShadowColor = style.dropShadowColor;
+          var rgb = hex2rgb(typeof dropShadowColor === 'number' ? dropShadowColor : string2hex(dropShadowColor));
+          var dropShadowBlur = style.dropShadowBlur * resolution;
+          var dropShadowDistance = style.dropShadowDistance * resolution;
+          context.shadowColor = "rgba(" + rgb[0] * 255 + "," + rgb[1] * 255 + "," + rgb[2] * 255 + "," + style.dropShadowAlpha + ")";
+          context.shadowBlur = dropShadowBlur;
+          context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;
+          context.shadowOffsetY = Math.sin(style.dropShadowAngle) * dropShadowDistance;
+      }
+      else {
+          context.shadowColor = 'black';
+          context.shadowBlur = 0;
+          context.shadowOffsetX = 0;
+          context.shadowOffsetY = 0;
+      }
+      if (style.stroke && style.strokeThickness) {
+          context.strokeText(char, tx, ty + metrics.lineHeight - fontProperties.descent);
+      }
+      if (style.fill) {
+          context.fillText(char, tx, ty + metrics.lineHeight - fontProperties.descent);
+      }
+      context.setTransform(1, 0, 0, 1, 0, 0); // defaults needed for older browsers (e.g. Opera 29)
+      context.fillStyle = 'rgba(0, 0, 0, 0)';
   }
-});
-
-var _CountLimiter = require('./limiters/CountLimiter');
 
-Object.defineProperty(exports, 'CountLimiter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_CountLimiter).default;
+  /**
+   * Ponyfill for IE because it doesn't support `Array.from`
+   * @param text
+   * @private
+   */
+  function splitTextToCharacters(text) {
+      return Array.from ? Array.from(text) : text.split('');
   }
-});
-
-var _TimeLimiter = require('./limiters/TimeLimiter');
 
-Object.defineProperty(exports, 'TimeLimiter', {
-  enumerable: true,
-  get: function get() {
-    return _interopRequireDefault(_TimeLimiter).default;
+  /**
+   * Processes the passed character set data and returns a flattened array of all the characters.
+   *
+   * Ignored because not directly exposed.
+   * @ignore
+   * @param {string | string[] | string[][] } chars
+   * @returns {string[]} the flattened array of characters
+   */
+  function resolveCharacters(chars) {
+      // Split the chars string into individual characters
+      if (typeof chars === 'string') {
+          chars = [chars];
+      }
+      // Handle an array of characters+ranges
+      var result = [];
+      for (var i = 0, j = chars.length; i < j; i++) {
+          var item = chars[i];
+          // Handle range delimited by start/end chars
+          if (Array.isArray(item)) {
+              if (item.length !== 2) {
+                  throw new Error("[BitmapFont]: Invalid character range length, expecting 2 got " + item.length + ".");
+              }
+              var startCode = item[0].charCodeAt(0);
+              var endCode = item[1].charCodeAt(0);
+              if (endCode < startCode) {
+                  throw new Error('[BitmapFont]: Invalid character range.');
+              }
+              for (var i_1 = startCode, j_1 = endCode; i_1 <= j_1; i_1++) {
+                  result.push(String.fromCharCode(i_1));
+              }
+          }
+          // Handle a character set string
+          else {
+              result.push.apply(result, splitTextToCharacters(item));
+          }
+      }
+      if (result.length === 0) {
+          throw new Error('[BitmapFont]: Empty set when resolving characters.');
+      }
+      return result;
   }
-});
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-},{"./BasePrepare":182,"./canvas/CanvasPrepare":183,"./limiters/CountLimiter":185,"./limiters/TimeLimiter":186,"./webgl/WebGLPrepare":187}],185:[function(require,module,exports){
-"use strict";
-
-exports.__esModule = true;
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-/**
- * CountLimiter limits the number of items handled by a {@link PIXI.prepare.BasePrepare} to a specified
- * number of items per frame.
- *
- * @class
- * @memberof PIXI
- */
-var CountLimiter = function () {
-  /**
-   * @param {number} maxItemsPerFrame - The maximum number of items that can be prepared each frame.
-   */
-  function CountLimiter(maxItemsPerFrame) {
-    _classCallCheck(this, CountLimiter);
-
-    /**
-     * The maximum number of items that can be prepared each frame.
-     * @private
-     */
-    this.maxItemsPerFrame = maxItemsPerFrame;
-    /**
-     * The number of items that can be prepared in the current frame.
-     * @type {number}
-     * @private
-     */
-    this.itemsLeft = 0;
+  /**
+   * Ponyfill for IE because it doesn't support `codePointAt`
+   * @param str
+   * @private
+   */
+  function extractCharCode(str) {
+      return str.codePointAt ? str.codePointAt(0) : str.charCodeAt(0);
   }
 
   /**
-   * Resets any counting properties to start fresh on a new frame.
+   * BitmapFont represents a typeface available for use with the BitmapText class. Use the `install`
+   * method for adding a font to be used.
+   * @memberof PIXI
    */
-
-
-  CountLimiter.prototype.beginFrame = function beginFrame() {
-    this.itemsLeft = this.maxItemsPerFrame;
-  };
-
+  var BitmapFont = /** @class */ (function () {
+      /**
+       * @param data
+       * @param textures
+       * @param ownsTextures - Setting to `true` will destroy page textures
+       *        when the font is uninstalled.
+       */
+      function BitmapFont(data, textures, ownsTextures) {
+          var _a, _b;
+          var info = data.info[0];
+          var common = data.common[0];
+          var page = data.page[0];
+          var distanceField = data.distanceField[0];
+          var res = getResolutionOfUrl(page.file);
+          var pageTextures = {};
+          this._ownsTextures = ownsTextures;
+          this.font = info.face;
+          this.size = info.size;
+          this.lineHeight = common.lineHeight / res;
+          this.chars = {};
+          this.pageTextures = pageTextures;
+          // Convert the input Texture, Textures or object
+          // into a page Texture lookup by "id"
+          for (var i = 0; i < data.page.length; i++) {
+              var _c = data.page[i], id = _c.id, file = _c.file;
+              pageTextures[id] = textures instanceof Array
+                  ? textures[i] : textures[file];
+              // only MSDF and SDF fonts need no-premultiplied-alpha
+              if ((distanceField === null || distanceField === void 0 ? void 0 : distanceField.fieldType) && distanceField.fieldType !== 'none') {
+                  pageTextures[id].baseTexture.alphaMode = exports.ALPHA_MODES.NO_PREMULTIPLIED_ALPHA;
+                  pageTextures[id].baseTexture.mipmap = exports.MIPMAP_MODES.OFF;
+              }
+          }
+          // parse letters
+          for (var i = 0; i < data.char.length; i++) {
+              var _d = data.char[i], id = _d.id, page_1 = _d.page;
+              var _e = data.char[i], x = _e.x, y = _e.y, width = _e.width, height = _e.height, xoffset = _e.xoffset, yoffset = _e.yoffset, xadvance = _e.xadvance;
+              x /= res;
+              y /= res;
+              width /= res;
+              height /= res;
+              xoffset /= res;
+              yoffset /= res;
+              xadvance /= res;
+              var rect = new Rectangle(x + (pageTextures[page_1].frame.x / res), y + (pageTextures[page_1].frame.y / res), width, height);
+              this.chars[id] = {
+                  xOffset: xoffset,
+                  yOffset: yoffset,
+                  xAdvance: xadvance,
+                  kerning: {},
+                  texture: new Texture(pageTextures[page_1].baseTexture, rect),
+                  page: page_1,
+              };
+          }
+          // parse kernings
+          for (var i = 0; i < data.kerning.length; i++) {
+              var _f = data.kerning[i], first = _f.first, second = _f.second, amount = _f.amount;
+              first /= res;
+              second /= res;
+              amount /= res;
+              if (this.chars[second]) {
+                  this.chars[second].kerning[first] = amount;
+              }
+          }
+          // Store distance field information
+          this.distanceFieldRange = distanceField === null || distanceField === void 0 ? void 0 : distanceField.distanceRange;
+          this.distanceFieldType = (_b = (_a = distanceField === null || distanceField === void 0 ? void 0 : distanceField.fieldType) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : 'none';
+      }
+      /** Remove references to created glyph textures. */
+      BitmapFont.prototype.destroy = function () {
+          for (var id in this.chars) {
+              this.chars[id].texture.destroy();
+              this.chars[id].texture = null;
+          }
+          for (var id in this.pageTextures) {
+              if (this._ownsTextures) {
+                  this.pageTextures[id].destroy(true);
+              }
+              this.pageTextures[id] = null;
+          }
+          // Set readonly null.
+          this.chars = null;
+          this.pageTextures = null;
+      };
+      /**
+       * Register a new bitmap font.
+       * @param data - The
+       *        characters map that could be provided as xml or raw string.
+       * @param textures - List of textures for each page.
+       * @param ownsTextures - Set to `true` to destroy page textures
+       *        when the font is uninstalled. By default fonts created with
+       *        `BitmapFont.from` or from the `BitmapFontLoader` are `true`.
+       * @returns {PIXI.BitmapFont} Result font object with font, size, lineHeight
+       *         and char fields.
+       */
+      BitmapFont.install = function (data, textures, ownsTextures) {
+          var fontData;
+          if (data instanceof BitmapFontData) {
+              fontData = data;
+          }
+          else {
+              var format = autoDetectFormat(data);
+              if (!format) {
+                  throw new Error('Unrecognized data format for font.');
+              }
+              fontData = format.parse(data);
+          }
+          // Single texture, convert to list
+          if (textures instanceof Texture) {
+              textures = [textures];
+          }
+          var font = new BitmapFont(fontData, textures, ownsTextures);
+          BitmapFont.available[font.font] = font;
+          return font;
+      };
+      /**
+       * Remove bitmap font by name.
+       * @param name - Name of the font to uninstall.
+       */
+      BitmapFont.uninstall = function (name) {
+          var font = BitmapFont.available[name];
+          if (!font) {
+              throw new Error("No font found named '" + name + "'");
+          }
+          font.destroy();
+          delete BitmapFont.available[name];
+      };
+      /**
+       * Generates a bitmap-font for the given style and character set. This does not support
+       * kernings yet. With `style` properties, only the following non-layout properties are used:
+       *
+       * - {@link PIXI.TextStyle#dropShadow|dropShadow}
+       * - {@link PIXI.TextStyle#dropShadowDistance|dropShadowDistance}
+       * - {@link PIXI.TextStyle#dropShadowColor|dropShadowColor}
+       * - {@link PIXI.TextStyle#dropShadowBlur|dropShadowBlur}
+       * - {@link PIXI.TextStyle#dropShadowAngle|dropShadowAngle}
+       * - {@link PIXI.TextStyle#fill|fill}
+       * - {@link PIXI.TextStyle#fillGradientStops|fillGradientStops}
+       * - {@link PIXI.TextStyle#fillGradientType|fillGradientType}
+       * - {@link PIXI.TextStyle#fontFamily|fontFamily}
+       * - {@link PIXI.TextStyle#fontSize|fontSize}
+       * - {@link PIXI.TextStyle#fontVariant|fontVariant}
+       * - {@link PIXI.TextStyle#fontWeight|fontWeight}
+       * - {@link PIXI.TextStyle#lineJoin|lineJoin}
+       * - {@link PIXI.TextStyle#miterLimit|miterLimit}
+       * - {@link PIXI.TextStyle#stroke|stroke}
+       * - {@link PIXI.TextStyle#strokeThickness|strokeThickness}
+       * - {@link PIXI.TextStyle#textBaseline|textBaseline}
+       * @param name - The name of the custom font to use with BitmapText.
+       * @param textStyle - Style options to render with BitmapFont.
+       * @param options - Setup options for font or name of the font.
+       * @param {string|string[]|string[][]} [options.chars=PIXI.BitmapFont.ALPHANUMERIC] - characters included
+       *      in the font set. You can also use ranges. For example, `[['a', 'z'], ['A', 'Z'], "!@#$%^&*()~{}[] "]`.
+       *      Don't forget to include spaces ' ' in your character set!
+       * @param {number} [options.resolution=1] - Render resolution for glyphs.
+       * @param {number} [options.textureWidth=512] - Optional width of atlas, smaller values to reduce memory.
+       * @param {number} [options.textureHeight=512] - Optional height of atlas, smaller values to reduce memory.
+       * @param {number} [options.padding=4] - Padding between glyphs on texture atlas.
+       * @returns Font generated by style options.
+       * @example
+       * PIXI.BitmapFont.from("TitleFont", {
+       *     fontFamily: "Arial",
+       *     fontSize: 12,
+       *     strokeThickness: 2,
+       *     fill: "purple"
+       * });
+       *
+       * const title = new PIXI.BitmapText("This is the title", { fontName: "TitleFont" });
+       */
+      BitmapFont.from = function (name, textStyle, options) {
+          if (!name) {
+              throw new Error('[BitmapFont] Property `name` is required.');
+          }
+          var _a = Object.assign({}, BitmapFont.defaultOptions, options), chars = _a.chars, padding = _a.padding, resolution = _a.resolution, textureWidth = _a.textureWidth, textureHeight = _a.textureHeight;
+          var charsList = resolveCharacters(chars);
+          var style = textStyle instanceof TextStyle ? textStyle : new TextStyle(textStyle);
+          var lineWidth = textureWidth;
+          var fontData = new BitmapFontData();
+          fontData.info[0] = {
+              face: style.fontFamily,
+              size: style.fontSize,
+          };
+          fontData.common[0] = {
+              lineHeight: style.fontSize,
+          };
+          var positionX = 0;
+          var positionY = 0;
+          var canvas;
+          var context;
+          var baseTexture;
+          var maxCharHeight = 0;
+          var textures = [];
+          for (var i = 0; i < charsList.length; i++) {
+              if (!canvas) {
+                  canvas = settings.ADAPTER.createCanvas();
+                  canvas.width = textureWidth;
+                  canvas.height = textureHeight;
+                  context = canvas.getContext('2d');
+                  baseTexture = new BaseTexture(canvas, { resolution: resolution });
+                  textures.push(new Texture(baseTexture));
+                  fontData.page.push({
+                      id: textures.length - 1,
+                      file: '',
+                  });
+              }
+              // Measure glyph dimensions
+              var character = charsList[i];
+              var metrics = TextMetrics.measureText(character, style, false, canvas);
+              var width = metrics.width;
+              var height = Math.ceil(metrics.height);
+              // This is ugly - but italics are given more space so they don't overlap
+              var textureGlyphWidth = Math.ceil((style.fontStyle === 'italic' ? 2 : 1) * width);
+              // Can't fit char anymore: next canvas please!
+              if (positionY >= textureHeight - (height * resolution)) {
+                  if (positionY === 0) {
+                      // We don't want user debugging an infinite loop (or do we? :)
+                      throw new Error("[BitmapFont] textureHeight " + textureHeight + "px is too small "
+                          + ("(fontFamily: '" + style.fontFamily + "', fontSize: " + style.fontSize + "px, char: '" + character + "')"));
+                  }
+                  --i;
+                  // Create new atlas once current has filled up
+                  canvas = null;
+                  context = null;
+                  baseTexture = null;
+                  positionY = 0;
+                  positionX = 0;
+                  maxCharHeight = 0;
+                  continue;
+              }
+              maxCharHeight = Math.max(height + metrics.fontProperties.descent, maxCharHeight);
+              // Wrap line once full row has been rendered
+              if ((textureGlyphWidth * resolution) + positionX >= lineWidth) {
+                  if (positionX === 0) {
+                      // Avoid infinite loop (There can be some very wide char like '\uFDFD'!)
+                      throw new Error("[BitmapFont] textureWidth " + textureWidth + "px is too small "
+                          + ("(fontFamily: '" + style.fontFamily + "', fontSize: " + style.fontSize + "px, char: '" + character + "')"));
+                  }
+                  --i;
+                  positionY += maxCharHeight * resolution;
+                  positionY = Math.ceil(positionY);
+                  positionX = 0;
+                  maxCharHeight = 0;
+                  continue;
+              }
+              drawGlyph(canvas, context, metrics, positionX, positionY, resolution, style);
+              // Unique (numeric) ID mapping to this glyph
+              var id = extractCharCode(metrics.text);
+              // Create a texture holding just the glyph
+              fontData.char.push({
+                  id: id,
+                  page: textures.length - 1,
+                  x: positionX / resolution,
+                  y: positionY / resolution,
+                  width: textureGlyphWidth,
+                  height: height,
+                  xoffset: 0,
+                  yoffset: 0,
+                  xadvance: Math.ceil(width
+                      - (style.dropShadow ? style.dropShadowDistance : 0)
+                      - (style.stroke ? style.strokeThickness : 0)),
+              });
+              positionX += (textureGlyphWidth + (2 * padding)) * resolution;
+              positionX = Math.ceil(positionX);
+          }
+          if (!(options === null || options === void 0 ? void 0 : options.skipKerning)) {
+              // Brute-force kerning info, this can be expensive b/c it's an O(n²),
+              // but we're using measureText which is native and fast.
+              for (var i = 0, len = charsList.length; i < len; i++) {
+                  var first = charsList[i];
+                  for (var j = 0; j < len; j++) {
+                      var second = charsList[j];
+                      var c1 = context.measureText(first).width;
+                      var c2 = context.measureText(second).width;
+                      var total = context.measureText(first + second).width;
+                      var amount = total - (c1 + c2);
+                      if (amount) {
+                          fontData.kerning.push({
+                              first: extractCharCode(first),
+                              second: extractCharCode(second),
+                              amount: amount,
+                          });
+                      }
+                  }
+              }
+          }
+          var font = new BitmapFont(fontData, textures, true);
+          // Make it easier to replace a font
+          if (BitmapFont.available[name] !== undefined) {
+              BitmapFont.uninstall(name);
+          }
+          BitmapFont.available[name] = font;
+          return font;
+      };
+      /**
+       * This character set includes all the letters in the alphabet (both lower- and upper- case).
+       * @type {string[][]}
+       * @example
+       * BitmapFont.from("ExampleFont", style, { chars: BitmapFont.ALPHA })
+       */
+      BitmapFont.ALPHA = [['a', 'z'], ['A', 'Z'], ' '];
+      /**
+       * This character set includes all decimal digits (from 0 to 9).
+       * @type {string[][]}
+       * @example
+       * BitmapFont.from("ExampleFont", style, { chars: BitmapFont.NUMERIC })
+       */
+      BitmapFont.NUMERIC = [['0', '9']];
+      /**
+       * This character set is the union of `BitmapFont.ALPHA` and `BitmapFont.NUMERIC`.
+       * @type {string[][]}
+       */
+      BitmapFont.ALPHANUMERIC = [['a', 'z'], ['A', 'Z'], ['0', '9'], ' '];
+      /**
+       * This character set consists of all the ASCII table.
+       * @member {string[][]}
+       * @see http://www.asciitable.com/
+       */
+      BitmapFont.ASCII = [[' ', '~']];
+      /**
+       * Collection of default options when using `BitmapFont.from`.
+       * @property {number} [resolution=1] -
+       * @property {number} [textureWidth=512] -
+       * @property {number} [textureHeight=512] -
+       * @property {number} [padding=4] -
+       * @property {string|string[]|string[][]} chars = PIXI.BitmapFont.ALPHANUMERIC
+       */
+      BitmapFont.defaultOptions = {
+          resolution: 1,
+          textureWidth: 512,
+          textureHeight: 512,
+          padding: 4,
+          chars: BitmapFont.ALPHANUMERIC,
+      };
+      /** Collection of available/installed fonts. */
+      BitmapFont.available = {};
+      return BitmapFont;
+  }());
+
+  var msdfFrag = "// Pixi texture info\r\nvarying vec2 vTextureCoord;\r\nuniform sampler2D uSampler;\r\n\r\n// Tint\r\nuniform vec4 uColor;\r\n\r\n// on 2D applications fwidth is screenScale / glyphAtlasScale * distanceFieldRange\r\nuniform float uFWidth;\r\n\r\nvoid main(void) {\r\n\r\n  // To stack MSDF and SDF we need a non-pre-multiplied-alpha texture.\r\n  vec4 texColor = texture2D(uSampler, vTextureCoord);\r\n\r\n  // MSDF\r\n  float median = texColor.r + texColor.g + texColor.b -\r\n                  min(texColor.r, min(texColor.g, texColor.b)) -\r\n                  max(texColor.r, max(texColor.g, texColor.b));\r\n  // SDF\r\n  median = min(median, texColor.a);\r\n\r\n  float screenPxDistance = uFWidth * (median - 0.5);\r\n  float alpha = clamp(screenPxDistance + 0.5, 0.0, 1.0);\r\n  if (median < 0.01) {\r\n    alpha = 0.0;\r\n  } else if (median > 0.99) {\r\n    alpha = 1.0;\r\n  }\r\n\r\n  // NPM Textures, NPM outputs\r\n  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);\r\n\r\n}\r\n";
+
+  var msdfVert = "// Mesh material default fragment\r\nattribute vec2 aVertexPosition;\r\nattribute vec2 aTextureCoord;\r\n\r\nuniform mat3 projectionMatrix;\r\nuniform mat3 translationMatrix;\r\nuniform mat3 uTextureMatrix;\r\n\r\nvarying vec2 vTextureCoord;\r\n\r\nvoid main(void)\r\n{\r\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\r\n\r\n    vTextureCoord = (uTextureMatrix * vec3(aTextureCoord, 1.0)).xy;\r\n}\r\n";
+
+  // If we ever need more than two pools, please make a Dict or something better.
+  var pageMeshDataDefaultPageMeshData = [];
+  var pageMeshDataMSDFPageMeshData = [];
+  var charRenderDataPool = [];
   /**
-   * Checks to see if another item can be uploaded. This should only be called once per item.
-   * @return {boolean} If the item is allowed to be uploaded.
+   * A BitmapText object will create a line or multiple lines of text using bitmap font.
+   *
+   * The primary advantage of this class over Text is that all of your textures are pre-generated and loading,
+   * meaning that rendering is fast, and changing text has no performance implications.
+   *
+   * Supporting character sets other than latin, such as CJK languages, may be impractical due to the number of characters.
+   *
+   * To split a line you can use '\n', '\r' or '\r\n' in your string.
+   *
+   * PixiJS can auto-generate fonts on-the-fly using BitmapFont or use fnt files provided by:
+   * http://www.angelcode.com/products/bmfont/ for Windows or
+   * http://www.bmglyph.com/ for Mac.
+   *
+   * You can also use SDF, MSDF and MTSDF BitmapFonts for vector-like scaling appearance provided by:
+   * https://github.com/soimy/msdf-bmfont-xml for SDF and MSDF fnt files or
+   * https://github.com/Chlumsky/msdf-atlas-gen for SDF, MSDF and MTSDF json files
+   *
+   * A BitmapText can only be created when the font is loaded.
+   *
+   * ```js
+   * // in this case the font is in a file called 'desyrel.fnt'
+   * let bitmapText = new PIXI.BitmapText("text using a fancy font!", {
+   *   fontName: "Desyrel",
+   *   fontSize: 35,
+   *   align: "right"
+   * });
+   * ```
+   * @memberof PIXI
    */
+  var BitmapText = /** @class */ (function (_super) {
+      __extends$8(BitmapText, _super);
+      /**
+       * @param text - A string that you would like the text to display.
+       * @param style - The style parameters.
+       * @param {string} style.fontName - The installed BitmapFont name.
+       * @param {number} [style.fontSize] - The size of the font in pixels, e.g. 24. If undefined,
+       *.     this will default to the BitmapFont size.
+       * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center', 'right' or 'justify'),
+       *      does not affect single line text.
+       * @param {number} [style.tint=0xFFFFFF] - The tint color.
+       * @param {number} [style.letterSpacing=0] - The amount of spacing between letters.
+       * @param {number} [style.maxWidth=0] - The max width of the text before line wrapping.
+       */
+      function BitmapText(text, style) {
+          if (style === void 0) { style = {}; }
+          var _this = _super.call(this) || this;
+          /**
+           * Private tracker for the current tint.
+           * @private
+           */
+          _this._tint = 0xFFFFFF;
+          // Apply the defaults
+          var _a = Object.assign({}, BitmapText.styleDefaults, style), align = _a.align, tint = _a.tint, maxWidth = _a.maxWidth, letterSpacing = _a.letterSpacing, fontName = _a.fontName, fontSize = _a.fontSize;
+          if (!BitmapFont.available[fontName]) {
+              throw new Error("Missing BitmapFont \"" + fontName + "\"");
+          }
+          _this._activePagesMeshData = [];
+          _this._textWidth = 0;
+          _this._textHeight = 0;
+          _this._align = align;
+          _this._tint = tint;
+          _this._font = undefined;
+          _this._fontName = fontName;
+          _this._fontSize = fontSize;
+          _this.text = text;
+          _this._maxWidth = maxWidth;
+          _this._maxLineHeight = 0;
+          _this._letterSpacing = letterSpacing;
+          _this._anchor = new ObservablePoint(function () { _this.dirty = true; }, _this, 0, 0);
+          _this._roundPixels = settings.ROUND_PIXELS;
+          _this.dirty = true;
+          _this._resolution = settings.RESOLUTION;
+          _this._autoResolution = true;
+          _this._textureCache = {};
+          return _this;
+      }
+      /** Renders text and updates it when needed. This should only be called if the BitmapFont is regenerated. */
+      BitmapText.prototype.updateText = function () {
+          var _a;
+          var data = BitmapFont.available[this._fontName];
+          var fontSize = this.fontSize;
+          var scale = fontSize / data.size;
+          var pos = new Point();
+          var chars = [];
+          var lineWidths = [];
+          var lineSpaces = [];
+          var text = this._text.replace(/(?:\r\n|\r)/g, '\n') || ' ';
+          var charsInput = splitTextToCharacters(text);
+          var maxWidth = this._maxWidth * data.size / fontSize;
+          var pageMeshDataPool = data.distanceFieldType === 'none'
+              ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;
+          var prevCharCode = null;
+          var lastLineWidth = 0;
+          var maxLineWidth = 0;
+          var line = 0;
+          var lastBreakPos = -1;
+          var lastBreakWidth = 0;
+          var spacesRemoved = 0;
+          var maxLineHeight = 0;
+          var spaceCount = 0;
+          for (var i = 0; i < charsInput.length; i++) {
+              var char = charsInput[i];
+              var charCode = extractCharCode(char);
+              if ((/(?:\s)/).test(char)) {
+                  lastBreakPos = i;
+                  lastBreakWidth = lastLineWidth;
+                  spaceCount++;
+              }
+              if (char === '\r' || char === '\n') {
+                  lineWidths.push(lastLineWidth);
+                  lineSpaces.push(-1);
+                  maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
+                  ++line;
+                  ++spacesRemoved;
+                  pos.x = 0;
+                  pos.y += data.lineHeight;
+                  prevCharCode = null;
+                  spaceCount = 0;
+                  continue;
+              }
+              var charData = data.chars[charCode];
+              if (!charData) {
+                  continue;
+              }
+              if (prevCharCode && charData.kerning[prevCharCode]) {
+                  pos.x += charData.kerning[prevCharCode];
+              }
+              var charRenderData = charRenderDataPool.pop() || {
+                  texture: Texture.EMPTY,
+                  line: 0,
+                  charCode: 0,
+                  prevSpaces: 0,
+                  position: new Point(),
+              };
+              charRenderData.texture = charData.texture;
+              charRenderData.line = line;
+              charRenderData.charCode = charCode;
+              charRenderData.position.x = pos.x + charData.xOffset + (this._letterSpacing / 2);
+              charRenderData.position.y = pos.y + charData.yOffset;
+              charRenderData.prevSpaces = spaceCount;
+              chars.push(charRenderData);
+              lastLineWidth = charRenderData.position.x
+                  + Math.max(charData.xAdvance - charData.xOffset, charData.texture.orig.width);
+              pos.x += charData.xAdvance + this._letterSpacing;
+              maxLineHeight = Math.max(maxLineHeight, (charData.yOffset + charData.texture.height));
+              prevCharCode = charCode;
+              if (lastBreakPos !== -1 && maxWidth > 0 && pos.x > maxWidth) {
+                  ++spacesRemoved;
+                  removeItems(chars, 1 + lastBreakPos - spacesRemoved, 1 + i - lastBreakPos);
+                  i = lastBreakPos;
+                  lastBreakPos = -1;
+                  lineWidths.push(lastBreakWidth);
+                  lineSpaces.push(chars.length > 0 ? chars[chars.length - 1].prevSpaces : 0);
+                  maxLineWidth = Math.max(maxLineWidth, lastBreakWidth);
+                  line++;
+                  pos.x = 0;
+                  pos.y += data.lineHeight;
+                  prevCharCode = null;
+                  spaceCount = 0;
+              }
+          }
+          var lastChar = charsInput[charsInput.length - 1];
+          if (lastChar !== '\r' && lastChar !== '\n') {
+              if ((/(?:\s)/).test(lastChar)) {
+                  lastLineWidth = lastBreakWidth;
+              }
+              lineWidths.push(lastLineWidth);
+              maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
+              lineSpaces.push(-1);
+          }
+          var lineAlignOffsets = [];
+          for (var i = 0; i <= line; i++) {
+              var alignOffset = 0;
+              if (this._align === 'right') {
+                  alignOffset = maxLineWidth - lineWidths[i];
+              }
+              else if (this._align === 'center') {
+                  alignOffset = (maxLineWidth - lineWidths[i]) / 2;
+              }
+              else if (this._align === 'justify') {
+                  alignOffset = lineSpaces[i] < 0 ? 0 : (maxLineWidth - lineWidths[i]) / lineSpaces[i];
+              }
+              lineAlignOffsets.push(alignOffset);
+          }
+          var lenChars = chars.length;
+          var pagesMeshData = {};
+          var newPagesMeshData = [];
+          var activePagesMeshData = this._activePagesMeshData;
+          pageMeshDataPool.push.apply(pageMeshDataPool, activePagesMeshData);
+          for (var i = 0; i < lenChars; i++) {
+              var texture = chars[i].texture;
+              var baseTextureUid = texture.baseTexture.uid;
+              if (!pagesMeshData[baseTextureUid]) {
+                  var pageMeshData = pageMeshDataPool.pop();
+                  if (!pageMeshData) {
+                      var geometry = new MeshGeometry();
+                      var material = void 0;
+                      var meshBlendMode = void 0;
+                      if (data.distanceFieldType === 'none') {
+                          material = new MeshMaterial(Texture.EMPTY);
+                          meshBlendMode = exports.BLEND_MODES.NORMAL;
+                      }
+                      else {
+                          material = new MeshMaterial(Texture.EMPTY, { program: Program.from(msdfVert, msdfFrag), uniforms: { uFWidth: 0 } });
+                          meshBlendMode = exports.BLEND_MODES.NORMAL_NPM;
+                      }
+                      var mesh = new Mesh(geometry, material);
+                      mesh.blendMode = meshBlendMode;
+                      pageMeshData = {
+                          index: 0,
+                          indexCount: 0,
+                          vertexCount: 0,
+                          uvsCount: 0,
+                          total: 0,
+                          mesh: mesh,
+                          vertices: null,
+                          uvs: null,
+                          indices: null,
+                      };
+                  }
+                  // reset data..
+                  pageMeshData.index = 0;
+                  pageMeshData.indexCount = 0;
+                  pageMeshData.vertexCount = 0;
+                  pageMeshData.uvsCount = 0;
+                  pageMeshData.total = 0;
+                  // TODO need to get page texture here somehow..
+                  var _textureCache = this._textureCache;
+                  _textureCache[baseTextureUid] = _textureCache[baseTextureUid] || new Texture(texture.baseTexture);
+                  pageMeshData.mesh.texture = _textureCache[baseTextureUid];
+                  pageMeshData.mesh.tint = this._tint;
+                  newPagesMeshData.push(pageMeshData);
+                  pagesMeshData[baseTextureUid] = pageMeshData;
+              }
+              pagesMeshData[baseTextureUid].total++;
+          }
+          // lets find any previously active pageMeshDatas that are no longer required for
+          // the updated text (if any), removed and return them to the pool.
+          for (var i = 0; i < activePagesMeshData.length; i++) {
+              if (newPagesMeshData.indexOf(activePagesMeshData[i]) === -1) {
+                  this.removeChild(activePagesMeshData[i].mesh);
+              }
+          }
+          // next lets add any new meshes, that have not yet been added to this BitmapText
+          // we only add if its not already a child of this BitmapObject
+          for (var i = 0; i < newPagesMeshData.length; i++) {
+              if (newPagesMeshData[i].mesh.parent !== this) {
+                  this.addChild(newPagesMeshData[i].mesh);
+              }
+          }
+          // active page mesh datas are set to be the new pages added.
+          this._activePagesMeshData = newPagesMeshData;
+          for (var i in pagesMeshData) {
+              var pageMeshData = pagesMeshData[i];
+              var total = pageMeshData.total;
+              // lets only allocate new buffers if we can fit the new text in the current ones..
+              // unless that is, we will be batching. Currently batching dose not respect the size property of mesh
+              if (!(((_a = pageMeshData.indices) === null || _a === void 0 ? void 0 : _a.length) > 6 * total) || pageMeshData.vertices.length < Mesh.BATCHABLE_SIZE * 2) {
+                  pageMeshData.vertices = new Float32Array(4 * 2 * total);
+                  pageMeshData.uvs = new Float32Array(4 * 2 * total);
+                  pageMeshData.indices = new Uint16Array(6 * total);
+              }
+              else {
+                  var total_1 = pageMeshData.total;
+                  var vertices = pageMeshData.vertices;
+                  // Clear the garbage at the end of the vertices buffer. This will prevent the bounds miscalculation.
+                  for (var i_1 = total_1 * 4 * 2; i_1 < vertices.length; i_1++) {
+                      vertices[i_1] = 0;
+                  }
+              }
+              // as a buffer maybe bigger than the current word, we set the size of the meshMaterial
+              // to match the number of letters needed
+              pageMeshData.mesh.size = 6 * total;
+          }
+          for (var i = 0; i < lenChars; i++) {
+              var char = chars[i];
+              var offset = char.position.x + (lineAlignOffsets[char.line] * (this._align === 'justify' ? char.prevSpaces : 1));
+              if (this._roundPixels) {
+                  offset = Math.round(offset);
+              }
+              var xPos = offset * scale;
+              var yPos = char.position.y * scale;
+              var texture = char.texture;
+              var pageMesh = pagesMeshData[texture.baseTexture.uid];
+              var textureFrame = texture.frame;
+              var textureUvs = texture._uvs;
+              var index = pageMesh.index++;
+              pageMesh.indices[(index * 6) + 0] = 0 + (index * 4);
+              pageMesh.indices[(index * 6) + 1] = 1 + (index * 4);
+              pageMesh.indices[(index * 6) + 2] = 2 + (index * 4);
+              pageMesh.indices[(index * 6) + 3] = 0 + (index * 4);
+              pageMesh.indices[(index * 6) + 4] = 2 + (index * 4);
+              pageMesh.indices[(index * 6) + 5] = 3 + (index * 4);
+              pageMesh.vertices[(index * 8) + 0] = xPos;
+              pageMesh.vertices[(index * 8) + 1] = yPos;
+              pageMesh.vertices[(index * 8) + 2] = xPos + (textureFrame.width * scale);
+              pageMesh.vertices[(index * 8) + 3] = yPos;
+              pageMesh.vertices[(index * 8) + 4] = xPos + (textureFrame.width * scale);
+              pageMesh.vertices[(index * 8) + 5] = yPos + (textureFrame.height * scale);
+              pageMesh.vertices[(index * 8) + 6] = xPos;
+              pageMesh.vertices[(index * 8) + 7] = yPos + (textureFrame.height * scale);
+              pageMesh.uvs[(index * 8) + 0] = textureUvs.x0;
+              pageMesh.uvs[(index * 8) + 1] = textureUvs.y0;
+              pageMesh.uvs[(index * 8) + 2] = textureUvs.x1;
+              pageMesh.uvs[(index * 8) + 3] = textureUvs.y1;
+              pageMesh.uvs[(index * 8) + 4] = textureUvs.x2;
+              pageMesh.uvs[(index * 8) + 5] = textureUvs.y2;
+              pageMesh.uvs[(index * 8) + 6] = textureUvs.x3;
+              pageMesh.uvs[(index * 8) + 7] = textureUvs.y3;
+          }
+          this._textWidth = maxLineWidth * scale;
+          this._textHeight = (pos.y + data.lineHeight) * scale;
+          for (var i in pagesMeshData) {
+              var pageMeshData = pagesMeshData[i];
+              // apply anchor
+              if (this.anchor.x !== 0 || this.anchor.y !== 0) {
+                  var vertexCount = 0;
+                  var anchorOffsetX = this._textWidth * this.anchor.x;
+                  var anchorOffsetY = this._textHeight * this.anchor.y;
+                  for (var i_2 = 0; i_2 < pageMeshData.total; i_2++) {
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+                  }
+              }
+              this._maxLineHeight = maxLineHeight * scale;
+              var vertexBuffer = pageMeshData.mesh.geometry.getBuffer('aVertexPosition');
+              var textureBuffer = pageMeshData.mesh.geometry.getBuffer('aTextureCoord');
+              var indexBuffer = pageMeshData.mesh.geometry.getIndex();
+              vertexBuffer.data = pageMeshData.vertices;
+              textureBuffer.data = pageMeshData.uvs;
+              indexBuffer.data = pageMeshData.indices;
+              vertexBuffer.update();
+              textureBuffer.update();
+              indexBuffer.update();
+          }
+          for (var i = 0; i < chars.length; i++) {
+              charRenderDataPool.push(chars[i]);
+          }
+          this._font = data;
+          this.dirty = false;
+      };
+      BitmapText.prototype.updateTransform = function () {
+          this.validate();
+          this.containerUpdateTransform();
+      };
+      BitmapText.prototype._render = function (renderer) {
+          if (this._autoResolution && this._resolution !== renderer.resolution) {
+              this._resolution = renderer.resolution;
+              this.dirty = true;
+          }
+          // Update the uniform
+          var _a = BitmapFont.available[this._fontName], distanceFieldRange = _a.distanceFieldRange, distanceFieldType = _a.distanceFieldType, size = _a.size;
+          if (distanceFieldType !== 'none') {
+              // Inject the shader code with the correct value
+              var _b = this.worldTransform, a = _b.a, b = _b.b, c = _b.c, d = _b.d;
+              var dx = Math.sqrt((a * a) + (b * b));
+              var dy = Math.sqrt((c * c) + (d * d));
+              var worldScale = (Math.abs(dx) + Math.abs(dy)) / 2;
+              var fontScale = this.fontSize / size;
+              for (var _i = 0, _c = this._activePagesMeshData; _i < _c.length; _i++) {
+                  var mesh = _c[_i];
+                  mesh.mesh.shader.uniforms.uFWidth = worldScale * distanceFieldRange * fontScale * this._resolution;
+              }
+          }
+          _super.prototype._render.call(this, renderer);
+      };
+      /**
+       * Validates text before calling parent's getLocalBounds
+       * @returns - The rectangular bounding area
+       */
+      BitmapText.prototype.getLocalBounds = function () {
+          this.validate();
+          return _super.prototype.getLocalBounds.call(this);
+      };
+      /**
+       * Updates text when needed
+       * @private
+       */
+      BitmapText.prototype.validate = function () {
+          var font = BitmapFont.available[this._fontName];
+          if (!font) {
+              throw new Error("Missing BitmapFont \"" + this._fontName + "\"");
+          }
+          if (this._font !== font) {
+              this.dirty = true;
+          }
+          if (this.dirty) {
+              this.updateText();
+          }
+      };
+      Object.defineProperty(BitmapText.prototype, "tint", {
+          /**
+           * The tint of the BitmapText object.
+           * @default 0xffffff
+           */
+          get: function () {
+              return this._tint;
+          },
+          set: function (value) {
+              if (this._tint === value)
+                  { return; }
+              this._tint = value;
+              for (var i = 0; i < this._activePagesMeshData.length; i++) {
+                  this._activePagesMeshData[i].mesh.tint = value;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "align", {
+          /**
+           * The alignment of the BitmapText object.
+           * @member {string}
+           * @default 'left'
+           */
+          get: function () {
+              return this._align;
+          },
+          set: function (value) {
+              if (this._align !== value) {
+                  this._align = value;
+                  this.dirty = true;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "fontName", {
+          /** The name of the BitmapFont. */
+          get: function () {
+              return this._fontName;
+          },
+          set: function (value) {
+              if (!BitmapFont.available[value]) {
+                  throw new Error("Missing BitmapFont \"" + value + "\"");
+              }
+              if (this._fontName !== value) {
+                  this._fontName = value;
+                  this.dirty = true;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "fontSize", {
+          /** The size of the font to display. */
+          get: function () {
+              var _a;
+              return (_a = this._fontSize) !== null && _a !== void 0 ? _a : BitmapFont.available[this._fontName].size;
+          },
+          set: function (value) {
+              if (this._fontSize !== value) {
+                  this._fontSize = value;
+                  this.dirty = true;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "anchor", {
+          /**
+           * The anchor sets the origin point of the text.
+           *
+           * The default is `(0,0)`, this means the text's origin is the top left.
+           *
+           * Setting the anchor to `(0.5,0.5)` means the text's origin is centered.
+           *
+           * Setting the anchor to `(1,1)` would mean the text's origin point will be the bottom right corner.
+           */
+          get: function () {
+              return this._anchor;
+          },
+          set: function (value) {
+              if (typeof value === 'number') {
+                  this._anchor.set(value);
+              }
+              else {
+                  this._anchor.copyFrom(value);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "text", {
+          /** The text of the BitmapText object. */
+          get: function () {
+              return this._text;
+          },
+          set: function (text) {
+              text = String(text === null || text === undefined ? '' : text);
+              if (this._text === text) {
+                  return;
+              }
+              this._text = text;
+              this.dirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "maxWidth", {
+          /**
+           * The max width of this bitmap text in pixels. If the text provided is longer than the
+           * value provided, line breaks will be automatically inserted in the last whitespace.
+           * Disable by setting the value to 0.
+           */
+          get: function () {
+              return this._maxWidth;
+          },
+          set: function (value) {
+              if (this._maxWidth === value) {
+                  return;
+              }
+              this._maxWidth = value;
+              this.dirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "maxLineHeight", {
+          /**
+           * The max line height. This is useful when trying to use the total height of the Text,
+           * i.e. when trying to vertically align.
+           * @readonly
+           */
+          get: function () {
+              this.validate();
+              return this._maxLineHeight;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "textWidth", {
+          /**
+           * The width of the overall text, different from fontSize,
+           * which is defined in the style object.
+           * @readonly
+           */
+          get: function () {
+              this.validate();
+              return this._textWidth;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "letterSpacing", {
+          /** Additional space between characters. */
+          get: function () {
+              return this._letterSpacing;
+          },
+          set: function (value) {
+              if (this._letterSpacing !== value) {
+                  this._letterSpacing = value;
+                  this.dirty = true;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "roundPixels", {
+          /**
+           * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
+           * Advantages can include sharper image quality (like text) and faster rendering on canvas.
+           * The main disadvantage is movement of objects may appear less smooth.
+           * To set the global default, change {@link PIXI.settings.ROUND_PIXELS}
+           * @default PIXI.settings.ROUND_PIXELS
+           */
+          get: function () {
+              return this._roundPixels;
+          },
+          set: function (value) {
+              if (value !== this._roundPixels) {
+                  this._roundPixels = value;
+                  this.dirty = true;
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "textHeight", {
+          /**
+           * The height of the overall text, different from fontSize,
+           * which is defined in the style object.
+           * @readonly
+           */
+          get: function () {
+              this.validate();
+              return this._textHeight;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BitmapText.prototype, "resolution", {
+          /**
+           * The resolution / device pixel ratio of the canvas.
+           *
+           * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.
+           * @default 1
+           */
+          get: function () {
+              return this._resolution;
+          },
+          set: function (value) {
+              this._autoResolution = false;
+              if (this._resolution === value) {
+                  return;
+              }
+              this._resolution = value;
+              this.dirty = true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      BitmapText.prototype.destroy = function (options) {
+          var _textureCache = this._textureCache;
+          var data = BitmapFont.available[this._fontName];
+          var pageMeshDataPool = data.distanceFieldType === 'none'
+              ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;
+          pageMeshDataPool.push.apply(pageMeshDataPool, this._activePagesMeshData);
+          for (var _i = 0, _a = this._activePagesMeshData; _i < _a.length; _i++) {
+              var pageMeshData = _a[_i];
+              this.removeChild(pageMeshData.mesh);
+          }
+          this._activePagesMeshData = [];
+          // Release references to any cached textures in page pool
+          pageMeshDataPool
+              .filter(function (page) { return _textureCache[page.mesh.texture.baseTexture.uid]; })
+              .forEach(function (page) {
+              page.mesh.texture = Texture.EMPTY;
+          });
+          for (var id in _textureCache) {
+              var texture = _textureCache[id];
+              texture.destroy();
+              delete _textureCache[id];
+          }
+          this._font = null;
+          this._textureCache = null;
+          _super.prototype.destroy.call(this, options);
+      };
+      BitmapText.styleDefaults = {
+          align: 'left',
+          tint: 0xFFFFFF,
+          maxWidth: 0,
+          letterSpacing: 0,
+      };
+      return BitmapText;
+  }(Container));
 
+  /**
+   * {@link PIXI.Loader Loader} middleware for loading
+   * bitmap-based fonts suitable for using with {@link PIXI.BitmapText}.
+   * @memberof PIXI
+   */
+  var BitmapFontLoader = /** @class */ (function () {
+      function BitmapFontLoader() {
+      }
+      /**
+       * Called when the plugin is installed.
+       * @see PIXI.extensions.add
+       */
+      BitmapFontLoader.add = function () {
+          exports.LoaderResource.setExtensionXhrType('fnt', exports.LoaderResource.XHR_RESPONSE_TYPE.TEXT);
+      };
+      /**
+       * Called after a resource is loaded.
+       * @see PIXI.Loader.loaderMiddleware
+       * @param this
+       * @param {PIXI.LoaderResource} resource
+       * @param {Function} next
+       */
+      BitmapFontLoader.use = function (resource, next) {
+          var format = autoDetectFormat(resource.data);
+          // Resource was not recognised as any of the expected font data format
+          if (!format) {
+              next();
+              return;
+          }
+          var baseUrl = BitmapFontLoader.getBaseUrl(this, resource);
+          var data = format.parse(resource.data);
+          var textures = {};
+          // Handle completed, when the number of textures
+          // load is the same number as references in the fnt file
+          var completed = function (page) {
+              textures[page.metadata.pageFile] = page.texture;
+              if (Object.keys(textures).length === data.page.length) {
+                  resource.bitmapFont = BitmapFont.install(data, textures, true);
+                  next();
+              }
+          };
+          for (var i = 0; i < data.page.length; ++i) {
+              var pageFile = data.page[i].file;
+              var url = baseUrl + pageFile;
+              var exists = false;
+              // incase the image is loaded outside
+              // using the same loader, resource will be available
+              for (var name in this.resources) {
+                  var bitmapResource = this.resources[name];
+                  if (bitmapResource.url === url) {
+                      bitmapResource.metadata.pageFile = pageFile;
+                      if (bitmapResource.texture) {
+                          completed(bitmapResource);
+                      }
+                      else {
+                          bitmapResource.onAfterMiddleware.add(completed);
+                      }
+                      exists = true;
+                      break;
+                  }
+              }
+              // texture is not loaded, we'll attempt to add
+              // it to the load and add the texture to the list
+              if (!exists) {
+                  // Standard loading options for images
+                  var options = {
+                      crossOrigin: resource.crossOrigin,
+                      loadType: exports.LoaderResource.LOAD_TYPE.IMAGE,
+                      metadata: Object.assign({ pageFile: pageFile }, resource.metadata.imageMetadata),
+                      parentResource: resource,
+                  };
+                  this.add(url, options, completed);
+              }
+          }
+      };
+      /**
+       * Get folder path from a resource.
+       * @param loader
+       * @param resource
+       */
+      BitmapFontLoader.getBaseUrl = function (loader, resource) {
+          var resUrl = !resource.isDataUrl ? BitmapFontLoader.dirname(resource.url) : '';
+          if (resource.isDataUrl) {
+              if (resUrl === '.') {
+                  resUrl = '';
+              }
+              if (loader.baseUrl && resUrl) {
+                  // if baseurl has a trailing slash then add one to resUrl so the replace works below
+                  if (loader.baseUrl.charAt(loader.baseUrl.length - 1) === '/') {
+                      resUrl += '/';
+                  }
+              }
+          }
+          // remove baseUrl from resUrl
+          resUrl = resUrl.replace(loader.baseUrl, '');
+          // if there is an resUrl now, it needs a trailing slash. Ensure that it does if the string isn't empty.
+          if (resUrl && resUrl.charAt(resUrl.length - 1) !== '/') {
+              resUrl += '/';
+          }
+          return resUrl;
+      };
+      /**
+       * Replacement for NodeJS's path.dirname
+       * @param {string} url - Path to get directory for
+       */
+      BitmapFontLoader.dirname = function (url) {
+          var dir = url
+              .replace(/\\/g, '/') // convert windows notation to UNIX notation, URL-safe because it's a forbidden character
+              .replace(/\/$/, '') // replace trailing slash
+              .replace(/\/[^\/]*$/, ''); // remove everything after the last
+          // File request is relative, use current directory
+          if (dir === url) {
+              return '.';
+          }
+          // Started with a slash
+          else if (dir === '') {
+              return '/';
+          }
+          return dir;
+      };
+      /** @ignore */
+      BitmapFontLoader.extension = exports.ExtensionType.Loader;
+      return BitmapFontLoader;
+  }());
+
+  /*!
+   * @pixi/filter-alpha - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/filter-alpha is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-  CountLimiter.prototype.allowedToUpload = function allowedToUpload() {
-    return this.itemsLeft-- > 0;
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$7 = function(d, b) {
+      extendStatics$7 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$7(d, b);
   };
 
-  return CountLimiter;
-}();
-
-exports.default = CountLimiter;
+  function __extends$7(d, b) {
+      extendStatics$7(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-},{}],186:[function(require,module,exports){
-"use strict";
+  var fragment$4 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform float uAlpha;\n\nvoid main(void)\n{\n   gl_FragColor = texture2D(uSampler, vTextureCoord) * uAlpha;\n}\n";
 
-exports.__esModule = true;
+  /**
+   * Simplest filter - applies alpha.
+   *
+   * Use this instead of Container's alpha property to avoid visual layering of individual elements.
+   * AlphaFilter applies alpha evenly across the entire display object and any opaque elements it contains.
+   * If elements are not opaque, they will blend with each other anyway.
+   *
+   * Very handy if you want to use common features of all filters:
+   *
+   * 1. Assign a blendMode to this filter, blend all elements inside display object with background.
+   *
+   * 2. To use clipping in display coordinates, assign a filterArea to the same container that has this filter.
+   * @memberof PIXI.filters
+   */
+  var AlphaFilter = /** @class */ (function (_super) {
+      __extends$7(AlphaFilter, _super);
+      /**
+       * @param alpha - Amount of alpha from 0 to 1, where 0 is transparent
+       */
+      function AlphaFilter(alpha) {
+          if (alpha === void 0) { alpha = 1.0; }
+          var _this = _super.call(this, defaultVertex$1, fragment$4, { uAlpha: 1 }) || this;
+          _this.alpha = alpha;
+          return _this;
+      }
+      Object.defineProperty(AlphaFilter.prototype, "alpha", {
+          /**
+           * Coefficient for alpha multiplication
+           * @default 1
+           */
+          get: function () {
+              return this.uniforms.uAlpha;
+          },
+          set: function (value) {
+              this.uniforms.uAlpha = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return AlphaFilter;
+  }(Filter));
+
+  /*!
+   * @pixi/filter-blur - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/filter-blur is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$6 = function(d, b) {
+      extendStatics$6 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$6(d, b);
+  };
 
-/**
- * TimeLimiter limits the number of items handled by a {@link PIXI.BasePrepare} to a specified
- * number of milliseconds per frame.
- *
- * @class
- * @memberof PIXI
- */
-var TimeLimiter = function () {
-  /**
-   * @param {number} maxMilliseconds - The maximum milliseconds that can be spent preparing items each frame.
-   */
-  function TimeLimiter(maxMilliseconds) {
-    _classCallCheck(this, TimeLimiter);
-
-    /**
-     * The maximum milliseconds that can be spent preparing items each frame.
-     * @private
-     */
-    this.maxMilliseconds = maxMilliseconds;
-    /**
-     * The start time of the current frame.
-     * @type {number}
-     * @private
-     */
-    this.frameStart = 0;
+  function __extends$6(d, b) {
+      extendStatics$6(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
   }
 
-  /**
-   * Resets any counting properties to start fresh on a new frame.
-   */
-
+  var vertTemplate = "\n    attribute vec2 aVertexPosition;\n\n    uniform mat3 projectionMatrix;\n\n    uniform float strength;\n\n    varying vec2 vBlurTexCoords[%size%];\n\n    uniform vec4 inputSize;\n    uniform vec4 outputFrame;\n\n    vec4 filterVertexPosition( void )\n    {\n        vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n        return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n    }\n\n    vec2 filterTextureCoord( void )\n    {\n        return aVertexPosition * (outputFrame.zw * inputSize.zw);\n    }\n\n    void main(void)\n    {\n        gl_Position = filterVertexPosition();\n\n        vec2 textureCoord = filterTextureCoord();\n        %blur%\n    }";
+  function generateBlurVertSource(kernelSize, x) {
+      var halfLength = Math.ceil(kernelSize / 2);
+      var vertSource = vertTemplate;
+      var blurLoop = '';
+      var template;
+      if (x) {
+          template = 'vBlurTexCoords[%index%] =  textureCoord + vec2(%sampleIndex% * strength, 0.0);';
+      }
+      else {
+          template = 'vBlurTexCoords[%index%] =  textureCoord + vec2(0.0, %sampleIndex% * strength);';
+      }
+      for (var i = 0; i < kernelSize; i++) {
+          var blur = template.replace('%index%', i.toString());
+          blur = blur.replace('%sampleIndex%', i - (halfLength - 1) + ".0");
+          blurLoop += blur;
+          blurLoop += '\n';
+      }
+      vertSource = vertSource.replace('%blur%', blurLoop);
+      vertSource = vertSource.replace('%size%', kernelSize.toString());
+      return vertSource;
+  }
 
-  TimeLimiter.prototype.beginFrame = function beginFrame() {
-    this.frameStart = Date.now();
+  var GAUSSIAN_VALUES = {
+      5: [0.153388, 0.221461, 0.250301],
+      7: [0.071303, 0.131514, 0.189879, 0.214607],
+      9: [0.028532, 0.067234, 0.124009, 0.179044, 0.20236],
+      11: [0.0093, 0.028002, 0.065984, 0.121703, 0.175713, 0.198596],
+      13: [0.002406, 0.009255, 0.027867, 0.065666, 0.121117, 0.174868, 0.197641],
+      15: [0.000489, 0.002403, 0.009246, 0.02784, 0.065602, 0.120999, 0.174697, 0.197448],
   };
+  var fragTemplate = [
+      'varying vec2 vBlurTexCoords[%size%];',
+      'uniform sampler2D uSampler;',
+      'void main(void)',
+      '{',
+      '    gl_FragColor = vec4(0.0);',
+      '    %blur%',
+      '}' ].join('\n');
+  function generateBlurFragSource(kernelSize) {
+      var kernel = GAUSSIAN_VALUES[kernelSize];
+      var halfLength = kernel.length;
+      var fragSource = fragTemplate;
+      var blurLoop = '';
+      var template = 'gl_FragColor += texture2D(uSampler, vBlurTexCoords[%index%]) * %value%;';
+      var value;
+      for (var i = 0; i < kernelSize; i++) {
+          var blur = template.replace('%index%', i.toString());
+          value = i;
+          if (i >= halfLength) {
+              value = kernelSize - i - 1;
+          }
+          blur = blur.replace('%value%', kernel[value].toString());
+          blurLoop += blur;
+          blurLoop += '\n';
+      }
+      fragSource = fragSource.replace('%blur%', blurLoop);
+      fragSource = fragSource.replace('%size%', kernelSize.toString());
+      return fragSource;
+  }
 
   /**
-   * Checks to see if another item can be uploaded. This should only be called once per item.
-   * @return {boolean} If the item is allowed to be uploaded.
+   * The BlurFilterPass applies a horizontal or vertical Gaussian blur to an object.
+   * @memberof PIXI.filters
    */
+  var BlurFilterPass = /** @class */ (function (_super) {
+      __extends$6(BlurFilterPass, _super);
+      /**
+       * @param horizontal - Do pass along the x-axis (`true`) or y-axis (`false`).
+       * @param strength - The strength of the blur filter.
+       * @param quality - The quality of the blur filter.
+       * @param resolution - The resolution of the blur filter.
+       * @param kernelSize - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.
+       */
+      function BlurFilterPass(horizontal, strength, quality, resolution, kernelSize) {
+          if (strength === void 0) { strength = 8; }
+          if (quality === void 0) { quality = 4; }
+          if (resolution === void 0) { resolution = settings.FILTER_RESOLUTION; }
+          if (kernelSize === void 0) { kernelSize = 5; }
+          var _this = this;
+          var vertSrc = generateBlurVertSource(kernelSize, horizontal);
+          var fragSrc = generateBlurFragSource(kernelSize);
+          _this = _super.call(this, 
+          // vertex shader
+          vertSrc, 
+          // fragment shader
+          fragSrc) || this;
+          _this.horizontal = horizontal;
+          _this.resolution = resolution;
+          _this._quality = 0;
+          _this.quality = quality;
+          _this.blur = strength;
+          return _this;
+      }
+      /**
+       * Applies the filter.
+       * @param filterManager - The manager.
+       * @param input - The input target.
+       * @param output - The output target.
+       * @param clearMode - How to clear
+       */
+      BlurFilterPass.prototype.apply = function (filterManager, input, output, clearMode) {
+          if (output) {
+              if (this.horizontal) {
+                  this.uniforms.strength = (1 / output.width) * (output.width / input.width);
+              }
+              else {
+                  this.uniforms.strength = (1 / output.height) * (output.height / input.height);
+              }
+          }
+          else {
+              if (this.horizontal) // eslint-disable-line
+               {
+                  this.uniforms.strength = (1 / filterManager.renderer.width) * (filterManager.renderer.width / input.width);
+              }
+              else {
+                  this.uniforms.strength = (1 / filterManager.renderer.height) * (filterManager.renderer.height / input.height); // eslint-disable-line
+              }
+          }
+          // screen space!
+          this.uniforms.strength *= this.strength;
+          this.uniforms.strength /= this.passes;
+          if (this.passes === 1) {
+              filterManager.applyFilter(this, input, output, clearMode);
+          }
+          else {
+              var renderTarget = filterManager.getFilterTexture();
+              var renderer = filterManager.renderer;
+              var flip = input;
+              var flop = renderTarget;
+              this.state.blend = false;
+              filterManager.applyFilter(this, flip, flop, exports.CLEAR_MODES.CLEAR);
+              for (var i = 1; i < this.passes - 1; i++) {
+                  filterManager.bindAndClear(flip, exports.CLEAR_MODES.BLIT);
+                  this.uniforms.uSampler = flop;
+                  var temp = flop;
+                  flop = flip;
+                  flip = temp;
+                  renderer.shader.bind(this);
+                  renderer.geometry.draw(5);
+              }
+              this.state.blend = true;
+              filterManager.applyFilter(this, flop, output, clearMode);
+              filterManager.returnFilterTexture(renderTarget);
+          }
+      };
+      Object.defineProperty(BlurFilterPass.prototype, "blur", {
+          /**
+           * Sets the strength of both the blur.
+           * @default 16
+           */
+          get: function () {
+              return this.strength;
+          },
+          set: function (value) {
+              this.padding = 1 + (Math.abs(value) * 2);
+              this.strength = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BlurFilterPass.prototype, "quality", {
+          /**
+           * Sets the quality of the blur by modifying the number of passes. More passes means higher
+           * quality bluring but the lower the performance.
+           * @default 4
+           */
+          get: function () {
+              return this._quality;
+          },
+          set: function (value) {
+              this._quality = value;
+              this.passes = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return BlurFilterPass;
+  }(Filter));
 
+  /**
+   * The BlurFilter applies a Gaussian blur to an object.
+   *
+   * The strength of the blur can be set for the x-axis and y-axis separately.
+   * @memberof PIXI.filters
+   */
+  var BlurFilter = /** @class */ (function (_super) {
+      __extends$6(BlurFilter, _super);
+      /**
+       * @param strength - The strength of the blur filter.
+       * @param quality - The quality of the blur filter.
+       * @param [resolution=PIXI.settings.FILTER_RESOLUTION] - The resolution of the blur filter.
+       * @param kernelSize - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.
+       */
+      function BlurFilter(strength, quality, resolution, kernelSize) {
+          if (strength === void 0) { strength = 8; }
+          if (quality === void 0) { quality = 4; }
+          if (resolution === void 0) { resolution = settings.FILTER_RESOLUTION; }
+          if (kernelSize === void 0) { kernelSize = 5; }
+          var _this = _super.call(this) || this;
+          _this.blurXFilter = new BlurFilterPass(true, strength, quality, resolution, kernelSize);
+          _this.blurYFilter = new BlurFilterPass(false, strength, quality, resolution, kernelSize);
+          _this.resolution = resolution;
+          _this.quality = quality;
+          _this.blur = strength;
+          _this.repeatEdgePixels = false;
+          return _this;
+      }
+      /**
+       * Applies the filter.
+       * @param filterManager - The manager.
+       * @param input - The input target.
+       * @param output - The output target.
+       * @param clearMode - How to clear
+       */
+      BlurFilter.prototype.apply = function (filterManager, input, output, clearMode) {
+          var xStrength = Math.abs(this.blurXFilter.strength);
+          var yStrength = Math.abs(this.blurYFilter.strength);
+          if (xStrength && yStrength) {
+              var renderTarget = filterManager.getFilterTexture();
+              this.blurXFilter.apply(filterManager, input, renderTarget, exports.CLEAR_MODES.CLEAR);
+              this.blurYFilter.apply(filterManager, renderTarget, output, clearMode);
+              filterManager.returnFilterTexture(renderTarget);
+          }
+          else if (yStrength) {
+              this.blurYFilter.apply(filterManager, input, output, clearMode);
+          }
+          else {
+              this.blurXFilter.apply(filterManager, input, output, clearMode);
+          }
+      };
+      BlurFilter.prototype.updatePadding = function () {
+          if (this._repeatEdgePixels) {
+              this.padding = 0;
+          }
+          else {
+              this.padding = Math.max(Math.abs(this.blurXFilter.strength), Math.abs(this.blurYFilter.strength)) * 2;
+          }
+      };
+      Object.defineProperty(BlurFilter.prototype, "blur", {
+          /**
+           * Sets the strength of both the blurX and blurY properties simultaneously
+           * @default 2
+           */
+          get: function () {
+              return this.blurXFilter.blur;
+          },
+          set: function (value) {
+              this.blurXFilter.blur = this.blurYFilter.blur = value;
+              this.updatePadding();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BlurFilter.prototype, "quality", {
+          /**
+           * Sets the number of passes for blur. More passes means higher quality bluring.
+           * @default 1
+           */
+          get: function () {
+              return this.blurXFilter.quality;
+          },
+          set: function (value) {
+              this.blurXFilter.quality = this.blurYFilter.quality = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BlurFilter.prototype, "blurX", {
+          /**
+           * Sets the strength of the blurX property
+           * @default 2
+           */
+          get: function () {
+              return this.blurXFilter.blur;
+          },
+          set: function (value) {
+              this.blurXFilter.blur = value;
+              this.updatePadding();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BlurFilter.prototype, "blurY", {
+          /**
+           * Sets the strength of the blurY property
+           * @default 2
+           */
+          get: function () {
+              return this.blurYFilter.blur;
+          },
+          set: function (value) {
+              this.blurYFilter.blur = value;
+              this.updatePadding();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BlurFilter.prototype, "blendMode", {
+          /**
+           * Sets the blendmode of the filter
+           * @default PIXI.BLEND_MODES.NORMAL
+           */
+          get: function () {
+              return this.blurYFilter.blendMode;
+          },
+          set: function (value) {
+              this.blurYFilter.blendMode = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(BlurFilter.prototype, "repeatEdgePixels", {
+          /**
+           * If set to true the edge of the target will be clamped
+           * @default false
+           */
+          get: function () {
+              return this._repeatEdgePixels;
+          },
+          set: function (value) {
+              this._repeatEdgePixels = value;
+              this.updatePadding();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return BlurFilter;
+  }(Filter));
+
+  /*!
+   * @pixi/filter-color-matrix - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/filter-color-matrix is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-  TimeLimiter.prototype.allowedToUpload = function allowedToUpload() {
-    return Date.now() - this.frameStart < this.maxMilliseconds;
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$5 = function(d, b) {
+      extendStatics$5 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$5(d, b);
   };
 
-  return TimeLimiter;
-}();
-
-exports.default = TimeLimiter;
-
-},{}],187:[function(require,module,exports){
-'use strict';
-
-exports.__esModule = true;
-
-var _core = require('../../core');
-
-var core = _interopRequireWildcard(_core);
-
-var _BasePrepare2 = require('../BasePrepare');
-
-var _BasePrepare3 = _interopRequireDefault(_BasePrepare2);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
- * The prepare manager provides functionality to upload content to the GPU.
- *
- * An instance of this class is automatically created by default, and can be found at renderer.plugins.prepare
- *
- * @class
- * @extends PIXI.prepare.BasePrepare
- * @memberof PIXI.prepare
- */
-var WebGLPrepare = function (_BasePrepare) {
-    _inherits(WebGLPrepare, _BasePrepare);
-
-    /**
-     * @param {PIXI.WebGLRenderer} renderer - A reference to the current renderer
-     */
-    function WebGLPrepare(renderer) {
-        _classCallCheck(this, WebGLPrepare);
-
-        var _this = _possibleConstructorReturn(this, _BasePrepare.call(this, renderer));
-
-        _this.uploadHookHelper = _this.renderer;
-
-        // Add textures and graphics to upload
-        _this.registerFindHook(findGraphics);
-        _this.registerUploadHook(uploadBaseTextures);
-        _this.registerUploadHook(uploadGraphics);
-        return _this;
-    }
-
-    return WebGLPrepare;
-}(_BasePrepare3.default);
-/**
- * Built-in hook to upload PIXI.Texture objects to the GPU.
- *
- * @private
- * @param {PIXI.WebGLRenderer} renderer - instance of the webgl renderer
- * @param {PIXI.DisplayObject} item - Item to check
- * @return {boolean} If item was uploaded.
- */
-
-
-exports.default = WebGLPrepare;
-function uploadBaseTextures(renderer, item) {
-    if (item instanceof core.BaseTexture) {
-        // if the texture already has a GL texture, then the texture has been prepared or rendered
-        // before now. If the texture changed, then the changer should be calling texture.update() which
-        // reuploads the texture without need for preparing it again
-        if (!item._glTextures[renderer.CONTEXT_UID]) {
-            renderer.textureManager.updateTexture(item);
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Built-in hook to upload PIXI.Graphics to the GPU.
- *
- * @private
- * @param {PIXI.WebGLRenderer} renderer - instance of the webgl renderer
- * @param {PIXI.DisplayObject} item - Item to check
- * @return {boolean} If item was uploaded.
- */
-function uploadGraphics(renderer, item) {
-    if (item instanceof core.Graphics) {
-        // if the item is not dirty and already has webgl data, then it got prepared or rendered
-        // before now and we shouldn't waste time updating it again
-        if (item.dirty || item.clearDirty || !item._webGL[renderer.plugins.graphics.CONTEXT_UID]) {
-            renderer.plugins.graphics.updateGraphics(item);
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Built-in hook to find graphics.
- *
- * @private
- * @param {PIXI.DisplayObject} item - Display object to check
- * @param {Array<*>} queue - Collection of items to upload
- * @return {boolean} if a PIXI.Graphics object was found.
- */
-function findGraphics(item, queue) {
-    if (item instanceof core.Graphics) {
-        queue.push(item);
-
-        return true;
-    }
-
-    return false;
-}
-
-core.WebGLRenderer.registerPlugin('prepare', WebGLPrepare);
-
-},{"../../core":65,"../BasePrepare":182}],188:[function(require,module,exports){
-(function (global){
-'use strict';
-
-exports.__esModule = true;
-exports.loader = exports.prepare = exports.particles = exports.mesh = exports.loaders = exports.interaction = exports.filters = exports.extras = exports.extract = exports.accessibility = undefined;
-
-var _polyfill = require('./polyfill');
-
-Object.keys(_polyfill).forEach(function (key) {
-    if (key === "default" || key === "__esModule") return;
-    Object.defineProperty(exports, key, {
-        enumerable: true,
-        get: function get() {
-            return _polyfill[key];
-        }
-    });
-});
-
-var _core = require('./core');
+  function __extends$5(d, b) {
+      extendStatics$5(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-Object.keys(_core).forEach(function (key) {
-    if (key === "default" || key === "__esModule") return;
-    Object.defineProperty(exports, key, {
-        enumerable: true,
-        get: function get() {
-            return _core[key];
-        }
-    });
-});
+  var fragment$3 = "varying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float m[20];\nuniform float uAlpha;\n\nvoid main(void)\n{\n    vec4 c = texture2D(uSampler, vTextureCoord);\n\n    if (uAlpha == 0.0) {\n        gl_FragColor = c;\n        return;\n    }\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (c.a > 0.0) {\n      c.rgb /= c.a;\n    }\n\n    vec4 result;\n\n    result.r = (m[0] * c.r);\n        result.r += (m[1] * c.g);\n        result.r += (m[2] * c.b);\n        result.r += (m[3] * c.a);\n        result.r += m[4];\n\n    result.g = (m[5] * c.r);\n        result.g += (m[6] * c.g);\n        result.g += (m[7] * c.b);\n        result.g += (m[8] * c.a);\n        result.g += m[9];\n\n    result.b = (m[10] * c.r);\n       result.b += (m[11] * c.g);\n       result.b += (m[12] * c.b);\n       result.b += (m[13] * c.a);\n       result.b += m[14];\n\n    result.a = (m[15] * c.r);\n       result.a += (m[16] * c.g);\n       result.a += (m[17] * c.b);\n       result.a += (m[18] * c.a);\n       result.a += m[19];\n\n    vec3 rgb = mix(c.rgb, result.rgb, uAlpha);\n\n    // Premultiply alpha again.\n    rgb *= result.a;\n\n    gl_FragColor = vec4(rgb, result.a);\n}\n";
 
-var _deprecation = require('./deprecation');
+  /**
+   * The ColorMatrixFilter class lets you apply a 5x4 matrix transformation on the RGBA
+   * color and alpha values of every pixel on your displayObject to produce a result
+   * with a new set of RGBA color and alpha values. It's pretty powerful!
+   *
+   * ```js
+   *  let colorMatrix = new PIXI.filters.ColorMatrixFilter();
+   *  container.filters = [colorMatrix];
+   *  colorMatrix.contrast(2);
+   * ```
+   * @author Clément Chenebault <clement@goodboydigital.com>
+   * @memberof PIXI.filters
+   */
+  var ColorMatrixFilter = /** @class */ (function (_super) {
+      __extends$5(ColorMatrixFilter, _super);
+      function ColorMatrixFilter() {
+          var _this = this;
+          var uniforms = {
+              m: new Float32Array([1, 0, 0, 0, 0,
+                  0, 1, 0, 0, 0,
+                  0, 0, 1, 0, 0,
+                  0, 0, 0, 1, 0]),
+              uAlpha: 1,
+          };
+          _this = _super.call(this, defaultFilterVertex, fragment$3, uniforms) || this;
+          _this.alpha = 1;
+          return _this;
+      }
+      /**
+       * Transforms current matrix and set the new one
+       * @param {number[]} matrix - 5x4 matrix
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype._loadMatrix = function (matrix, multiply) {
+          if (multiply === void 0) { multiply = false; }
+          var newMatrix = matrix;
+          if (multiply) {
+              this._multiply(newMatrix, this.uniforms.m, matrix);
+              newMatrix = this._colorMatrix(newMatrix);
+          }
+          // set the new matrix
+          this.uniforms.m = newMatrix;
+      };
+      /**
+       * Multiplies two mat5's
+       * @private
+       * @param out - 5x4 matrix the receiving matrix
+       * @param a - 5x4 matrix the first operand
+       * @param b - 5x4 matrix the second operand
+       * @returns {number[]} 5x4 matrix
+       */
+      ColorMatrixFilter.prototype._multiply = function (out, a, b) {
+          // Red Channel
+          out[0] = (a[0] * b[0]) + (a[1] * b[5]) + (a[2] * b[10]) + (a[3] * b[15]);
+          out[1] = (a[0] * b[1]) + (a[1] * b[6]) + (a[2] * b[11]) + (a[3] * b[16]);
+          out[2] = (a[0] * b[2]) + (a[1] * b[7]) + (a[2] * b[12]) + (a[3] * b[17]);
+          out[3] = (a[0] * b[3]) + (a[1] * b[8]) + (a[2] * b[13]) + (a[3] * b[18]);
+          out[4] = (a[0] * b[4]) + (a[1] * b[9]) + (a[2] * b[14]) + (a[3] * b[19]) + a[4];
+          // Green Channel
+          out[5] = (a[5] * b[0]) + (a[6] * b[5]) + (a[7] * b[10]) + (a[8] * b[15]);
+          out[6] = (a[5] * b[1]) + (a[6] * b[6]) + (a[7] * b[11]) + (a[8] * b[16]);
+          out[7] = (a[5] * b[2]) + (a[6] * b[7]) + (a[7] * b[12]) + (a[8] * b[17]);
+          out[8] = (a[5] * b[3]) + (a[6] * b[8]) + (a[7] * b[13]) + (a[8] * b[18]);
+          out[9] = (a[5] * b[4]) + (a[6] * b[9]) + (a[7] * b[14]) + (a[8] * b[19]) + a[9];
+          // Blue Channel
+          out[10] = (a[10] * b[0]) + (a[11] * b[5]) + (a[12] * b[10]) + (a[13] * b[15]);
+          out[11] = (a[10] * b[1]) + (a[11] * b[6]) + (a[12] * b[11]) + (a[13] * b[16]);
+          out[12] = (a[10] * b[2]) + (a[11] * b[7]) + (a[12] * b[12]) + (a[13] * b[17]);
+          out[13] = (a[10] * b[3]) + (a[11] * b[8]) + (a[12] * b[13]) + (a[13] * b[18]);
+          out[14] = (a[10] * b[4]) + (a[11] * b[9]) + (a[12] * b[14]) + (a[13] * b[19]) + a[14];
+          // Alpha Channel
+          out[15] = (a[15] * b[0]) + (a[16] * b[5]) + (a[17] * b[10]) + (a[18] * b[15]);
+          out[16] = (a[15] * b[1]) + (a[16] * b[6]) + (a[17] * b[11]) + (a[18] * b[16]);
+          out[17] = (a[15] * b[2]) + (a[16] * b[7]) + (a[17] * b[12]) + (a[18] * b[17]);
+          out[18] = (a[15] * b[3]) + (a[16] * b[8]) + (a[17] * b[13]) + (a[18] * b[18]);
+          out[19] = (a[15] * b[4]) + (a[16] * b[9]) + (a[17] * b[14]) + (a[18] * b[19]) + a[19];
+          return out;
+      };
+      /**
+       * Create a Float32 Array and normalize the offset component to 0-1
+       * @param {number[]} matrix - 5x4 matrix
+       * @returns {number[]} 5x4 matrix with all values between 0-1
+       */
+      ColorMatrixFilter.prototype._colorMatrix = function (matrix) {
+          // Create a Float32 Array and normalize the offset component to 0-1
+          var m = new Float32Array(matrix);
+          m[4] /= 255;
+          m[9] /= 255;
+          m[14] /= 255;
+          m[19] /= 255;
+          return m;
+      };
+      /**
+       * Adjusts brightness
+       * @param b - value of the brigthness (0-1, where 0 is black)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.brightness = function (b, multiply) {
+          var matrix = [
+              b, 0, 0, 0, 0,
+              0, b, 0, 0, 0,
+              0, 0, b, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Sets each channel on the diagonal of the color matrix.
+       * This can be used to achieve a tinting effect on Containers similar to the tint field of some
+       * display objects like Sprite, Text, Graphics, and Mesh.
+       * @param color - Color of the tint. This is a hex value.
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.tint = function (color, multiply) {
+          var r = (color >> 16) & 0xff;
+          var g = (color >> 8) & 0xff;
+          var b = color & 0xff;
+          var matrix = [
+              r / 255, 0, 0, 0, 0,
+              0, g / 255, 0, 0, 0,
+              0, 0, b / 255, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Set the matrices in grey scales
+       * @param scale - value of the grey (0-1, where 0 is black)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.greyscale = function (scale, multiply) {
+          var matrix = [
+              scale, scale, scale, 0, 0,
+              scale, scale, scale, 0, 0,
+              scale, scale, scale, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Set the black and white matrice.
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.blackAndWhite = function (multiply) {
+          var matrix = [
+              0.3, 0.6, 0.1, 0, 0,
+              0.3, 0.6, 0.1, 0, 0,
+              0.3, 0.6, 0.1, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Set the hue property of the color
+       * @param rotation - in degrees
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.hue = function (rotation, multiply) {
+          rotation = (rotation || 0) / 180 * Math.PI;
+          var cosR = Math.cos(rotation);
+          var sinR = Math.sin(rotation);
+          var sqrt = Math.sqrt;
+          /* a good approximation for hue rotation
+           This matrix is far better than the versions with magic luminance constants
+           formerly used here, but also used in the starling framework (flash) and known from this
+           old part of the internet: quasimondo.com/archives/000565.php
+
+           This new matrix is based on rgb cube rotation in space. Look here for a more descriptive
+           implementation as a shader not a general matrix:
+           https://github.com/evanw/glfx.js/blob/58841c23919bd59787effc0333a4897b43835412/src/filters/adjust/huesaturation.js
+
+           This is the source for the code:
+           see http://stackoverflow.com/questions/8507885/shift-hue-of-an-rgb-color/8510751#8510751
+           */
+          var w = 1 / 3;
+          var sqrW = sqrt(w); // weight is
+          var a00 = cosR + ((1.0 - cosR) * w);
+          var a01 = (w * (1.0 - cosR)) - (sqrW * sinR);
+          var a02 = (w * (1.0 - cosR)) + (sqrW * sinR);
+          var a10 = (w * (1.0 - cosR)) + (sqrW * sinR);
+          var a11 = cosR + (w * (1.0 - cosR));
+          var a12 = (w * (1.0 - cosR)) - (sqrW * sinR);
+          var a20 = (w * (1.0 - cosR)) - (sqrW * sinR);
+          var a21 = (w * (1.0 - cosR)) + (sqrW * sinR);
+          var a22 = cosR + (w * (1.0 - cosR));
+          var matrix = [
+              a00, a01, a02, 0, 0,
+              a10, a11, a12, 0, 0,
+              a20, a21, a22, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Set the contrast matrix, increase the separation between dark and bright
+       * Increase contrast : shadows darker and highlights brighter
+       * Decrease contrast : bring the shadows up and the highlights down
+       * @param amount - value of the contrast (0-1)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.contrast = function (amount, multiply) {
+          var v = (amount || 0) + 1;
+          var o = -0.5 * (v - 1);
+          var matrix = [
+              v, 0, 0, 0, o,
+              0, v, 0, 0, o,
+              0, 0, v, 0, o,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Set the saturation matrix, increase the separation between colors
+       * Increase saturation : increase contrast, brightness, and sharpness
+       * @param amount - The saturation amount (0-1)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.saturate = function (amount, multiply) {
+          if (amount === void 0) { amount = 0; }
+          var x = (amount * 2 / 3) + 1;
+          var y = ((x - 1) * -0.5);
+          var matrix = [
+              x, y, y, 0, 0,
+              y, x, y, 0, 0,
+              y, y, x, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /** Desaturate image (remove color) Call the saturate function */
+      ColorMatrixFilter.prototype.desaturate = function () {
+          this.saturate(-1);
+      };
+      /**
+       * Negative image (inverse of classic rgb matrix)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.negative = function (multiply) {
+          var matrix = [
+              -1, 0, 0, 1, 0,
+              0, -1, 0, 1, 0,
+              0, 0, -1, 1, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Sepia image
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.sepia = function (multiply) {
+          var matrix = [
+              0.393, 0.7689999, 0.18899999, 0, 0,
+              0.349, 0.6859999, 0.16799999, 0, 0,
+              0.272, 0.5339999, 0.13099999, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Color motion picture process invented in 1916 (thanks Dominic Szablewski)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.technicolor = function (multiply) {
+          var matrix = [
+              1.9125277891456083, -0.8545344976951645, -0.09155508482755585, 0, 11.793603434377337,
+              -0.3087833385928097, 1.7658908555458428, -0.10601743074722245, 0, -70.35205161461398,
+              -0.231103377548616, -0.7501899197440212, 1.847597816108189, 0, 30.950940869491138,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Polaroid filter
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.polaroid = function (multiply) {
+          var matrix = [
+              1.438, -0.062, -0.062, 0, 0,
+              -0.122, 1.378, -0.122, 0, 0,
+              -0.016, -0.016, 1.483, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Filter who transforms : Red -> Blue and Blue -> Red
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.toBGR = function (multiply) {
+          var matrix = [
+              0, 0, 1, 0, 0,
+              0, 1, 0, 0, 0,
+              1, 0, 0, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Color reversal film introduced by Eastman Kodak in 1935. (thanks Dominic Szablewski)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.kodachrome = function (multiply) {
+          var matrix = [
+              1.1285582396593525, -0.3967382283601348, -0.03992559172921793, 0, 63.72958762196502,
+              -0.16404339962244616, 1.0835251566291304, -0.05498805115633132, 0, 24.732407896706203,
+              -0.16786010706155763, -0.5603416277695248, 1.6014850761964943, 0, 35.62982807460946,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Brown delicious browni filter (thanks Dominic Szablewski)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.browni = function (multiply) {
+          var matrix = [
+              0.5997023498159715, 0.34553243048391263, -0.2708298674538042, 0, 47.43192855600873,
+              -0.037703249837783157, 0.8609577587992641, 0.15059552388459913, 0, -36.96841498319127,
+              0.24113635128153335, -0.07441037908422492, 0.44972182064877153, 0, -7.562075277591283,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Vintage filter (thanks Dominic Szablewski)
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.vintage = function (multiply) {
+          var matrix = [
+              0.6279345635605994, 0.3202183420819367, -0.03965408211312453, 0, 9.651285835294123,
+              0.02578397704808868, 0.6441188644374771, 0.03259127616149294, 0, 7.462829176470591,
+              0.0466055556782719, -0.0851232987247891, 0.5241648018700465, 0, 5.159190588235296,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * We don't know exactly what it does, kind of gradient map, but funny to play with!
+       * @param desaturation - Tone values.
+       * @param toned - Tone values.
+       * @param lightColor - Tone values, example: `0xFFE580`
+       * @param darkColor - Tone values, example: `0xFFE580`
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.colorTone = function (desaturation, toned, lightColor, darkColor, multiply) {
+          desaturation = desaturation || 0.2;
+          toned = toned || 0.15;
+          lightColor = lightColor || 0xFFE580;
+          darkColor = darkColor || 0x338000;
+          var lR = ((lightColor >> 16) & 0xFF) / 255;
+          var lG = ((lightColor >> 8) & 0xFF) / 255;
+          var lB = (lightColor & 0xFF) / 255;
+          var dR = ((darkColor >> 16) & 0xFF) / 255;
+          var dG = ((darkColor >> 8) & 0xFF) / 255;
+          var dB = (darkColor & 0xFF) / 255;
+          var matrix = [
+              0.3, 0.59, 0.11, 0, 0,
+              lR, lG, lB, desaturation, 0,
+              dR, dG, dB, toned, 0,
+              lR - dR, lG - dG, lB - dB, 0, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Night effect
+       * @param intensity - The intensity of the night effect.
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.night = function (intensity, multiply) {
+          intensity = intensity || 0.1;
+          var matrix = [
+              intensity * (-2.0), -intensity, 0, 0, 0,
+              -intensity, 0, intensity, 0, 0,
+              0, intensity, intensity * 2.0, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * Predator effect
+       *
+       * Erase the current matrix by setting a new indepent one
+       * @param amount - how much the predator feels his future victim
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.predator = function (amount, multiply) {
+          var matrix = [
+              // row 1
+              11.224130630493164 * amount,
+              -4.794486999511719 * amount,
+              -2.8746118545532227 * amount,
+              0 * amount,
+              0.40342438220977783 * amount,
+              // row 2
+              -3.6330697536468506 * amount,
+              9.193157196044922 * amount,
+              -2.951810836791992 * amount,
+              0 * amount,
+              -1.316135048866272 * amount,
+              // row 3
+              -3.2184197902679443 * amount,
+              -4.2375030517578125 * amount,
+              7.476448059082031 * amount,
+              0 * amount,
+              0.8044459223747253 * amount,
+              // row 4
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /**
+       * LSD effect
+       *
+       * Multiply the current matrix
+       * @param multiply - if true, current matrix and matrix are multiplied. If false,
+       *  just set the current matrix with @param matrix
+       */
+      ColorMatrixFilter.prototype.lsd = function (multiply) {
+          var matrix = [
+              2, -0.4, 0.5, 0, 0,
+              -0.5, 2, -0.4, 0, 0,
+              -0.4, -0.5, 3, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, multiply);
+      };
+      /** Erase the current matrix by setting the default one. */
+      ColorMatrixFilter.prototype.reset = function () {
+          var matrix = [
+              1, 0, 0, 0, 0,
+              0, 1, 0, 0, 0,
+              0, 0, 1, 0, 0,
+              0, 0, 0, 1, 0 ];
+          this._loadMatrix(matrix, false);
+      };
+      Object.defineProperty(ColorMatrixFilter.prototype, "matrix", {
+          /**
+           * The matrix of the color matrix filter
+           * @member {number[]}
+           * @default [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]
+           */
+          get: function () {
+              return this.uniforms.m;
+          },
+          set: function (value) {
+              this.uniforms.m = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(ColorMatrixFilter.prototype, "alpha", {
+          /**
+           * The opacity value to use when mixing the original and resultant colors.
+           *
+           * When the value is 0, the original color is used without modification.
+           * When the value is 1, the result color is used.
+           * When in the range (0, 1) the color is interpolated between the original and result by this amount.
+           * @default 1
+           */
+          get: function () {
+              return this.uniforms.uAlpha;
+          },
+          set: function (value) {
+              this.uniforms.uAlpha = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return ColorMatrixFilter;
+  }(Filter));
+  // Americanized alias
+  ColorMatrixFilter.prototype.grayscale = ColorMatrixFilter.prototype.greyscale;
+
+  /*!
+   * @pixi/filter-displacement - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/filter-displacement is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-var _deprecation2 = _interopRequireDefault(_deprecation);
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$4 = function(d, b) {
+      extendStatics$4 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$4(d, b);
+  };
 
-var _accessibility = require('./accessibility');
+  function __extends$4(d, b) {
+      extendStatics$4(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-var accessibility = _interopRequireWildcard(_accessibility);
+  var fragment$2 = "varying vec2 vFilterCoord;\nvarying vec2 vTextureCoord;\n\nuniform vec2 scale;\nuniform mat2 rotation;\nuniform sampler2D uSampler;\nuniform sampler2D mapSampler;\n\nuniform highp vec4 inputSize;\nuniform vec4 inputClamp;\n\nvoid main(void)\n{\n  vec4 map =  texture2D(mapSampler, vFilterCoord);\n\n  map -= 0.5;\n  map.xy = scale * inputSize.zw * (rotation * map.xy);\n\n  gl_FragColor = texture2D(uSampler, clamp(vec2(vTextureCoord.x + map.x, vTextureCoord.y + map.y), inputClamp.xy, inputClamp.zw));\n}\n";
 
-var _extract = require('./extract');
+  var vertex$1 = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\nuniform mat3 filterMatrix;\n\nvarying vec2 vTextureCoord;\nvarying vec2 vFilterCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n\tgl_Position = filterVertexPosition();\n\tvTextureCoord = filterTextureCoord();\n\tvFilterCoord = ( filterMatrix * vec3( vTextureCoord, 1.0)  ).xy;\n}\n";
 
-var extract = _interopRequireWildcard(_extract);
+  /**
+   * The DisplacementFilter class uses the pixel values from the specified texture
+   * (called the displacement map) to perform a displacement of an object.
+   *
+   * You can use this filter to apply all manor of crazy warping effects.
+   * Currently the `r` property of the texture is used to offset the `x`
+   * and the `g` property of the texture is used to offset the `y`.
+   *
+   * The way it works is it uses the values of the displacement map to look up the
+   * correct pixels to output. This means it's not technically moving the original.
+   * Instead, it's starting at the output and asking "which pixel from the original goes here".
+   * For example, if a displacement map pixel has `red = 1` and the filter scale is `20`,
+   * this filter will output the pixel approximately 20 pixels to the right of the original.
+   * @memberof PIXI.filters
+   */
+  var DisplacementFilter = /** @class */ (function (_super) {
+      __extends$4(DisplacementFilter, _super);
+      /**
+       * @param {PIXI.Sprite} sprite - The sprite used for the displacement map. (make sure its added to the scene!)
+       * @param scale - The scale of the displacement
+       */
+      function DisplacementFilter(sprite, scale) {
+          var _this = this;
+          var maskMatrix = new Matrix();
+          sprite.renderable = false;
+          _this = _super.call(this, vertex$1, fragment$2, {
+              mapSampler: sprite._texture,
+              filterMatrix: maskMatrix,
+              scale: { x: 1, y: 1 },
+              rotation: new Float32Array([1, 0, 0, 1]),
+          }) || this;
+          _this.maskSprite = sprite;
+          _this.maskMatrix = maskMatrix;
+          if (scale === null || scale === undefined) {
+              scale = 20;
+          }
+          /**
+           * scaleX, scaleY for displacements
+           * @member {PIXI.Point}
+           */
+          _this.scale = new Point(scale, scale);
+          return _this;
+      }
+      /**
+       * Applies the filter.
+       * @param filterManager - The manager.
+       * @param input - The input target.
+       * @param output - The output target.
+       * @param clearMode - clearMode.
+       */
+      DisplacementFilter.prototype.apply = function (filterManager, input, output, clearMode) {
+          // fill maskMatrix with _normalized sprite texture coords_
+          this.uniforms.filterMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, this.maskSprite);
+          this.uniforms.scale.x = this.scale.x;
+          this.uniforms.scale.y = this.scale.y;
+          // Extract rotation from world transform
+          var wt = this.maskSprite.worldTransform;
+          var lenX = Math.sqrt((wt.a * wt.a) + (wt.b * wt.b));
+          var lenY = Math.sqrt((wt.c * wt.c) + (wt.d * wt.d));
+          if (lenX !== 0 && lenY !== 0) {
+              this.uniforms.rotation[0] = wt.a / lenX;
+              this.uniforms.rotation[1] = wt.b / lenX;
+              this.uniforms.rotation[2] = wt.c / lenY;
+              this.uniforms.rotation[3] = wt.d / lenY;
+          }
+          // draw the filter...
+          filterManager.applyFilter(this, input, output, clearMode);
+      };
+      Object.defineProperty(DisplacementFilter.prototype, "map", {
+          /** The texture used for the displacement map. Must be power of 2 sized texture. */
+          get: function () {
+              return this.uniforms.mapSampler;
+          },
+          set: function (value) {
+              this.uniforms.mapSampler = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return DisplacementFilter;
+  }(Filter));
+
+  /*!
+   * @pixi/filter-fxaa - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/filter-fxaa is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-var _extras = require('./extras');
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$3 = function(d, b) {
+      extendStatics$3 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$3(d, b);
+  };
 
-var extras = _interopRequireWildcard(_extras);
+  function __extends$3(d, b) {
+      extendStatics$3(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-var _filters = require('./filters');
+  var vertex = "\nattribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nvarying vec2 vFragCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvoid texcoords(vec2 fragCoord, vec2 inverseVP,\n               out vec2 v_rgbNW, out vec2 v_rgbNE,\n               out vec2 v_rgbSW, out vec2 v_rgbSE,\n               out vec2 v_rgbM) {\n    v_rgbNW = (fragCoord + vec2(-1.0, -1.0)) * inverseVP;\n    v_rgbNE = (fragCoord + vec2(1.0, -1.0)) * inverseVP;\n    v_rgbSW = (fragCoord + vec2(-1.0, 1.0)) * inverseVP;\n    v_rgbSE = (fragCoord + vec2(1.0, 1.0)) * inverseVP;\n    v_rgbM = vec2(fragCoord * inverseVP);\n}\n\nvoid main(void) {\n\n   gl_Position = filterVertexPosition();\n\n   vFragCoord = aVertexPosition * outputFrame.zw;\n\n   texcoords(vFragCoord, inputSize.zw, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n}\n";
 
-var filters = _interopRequireWildcard(_filters);
+  var fragment$1 = "varying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nvarying vec2 vFragCoord;\nuniform sampler2D uSampler;\nuniform highp vec4 inputSize;\n\n\n/**\n Basic FXAA implementation based on the code on geeks3d.com with the\n modification that the texture2DLod stuff was removed since it's\n unsupported by WebGL.\n\n --\n\n From:\n https://github.com/mitsuhiko/webgl-meincraft\n\n Copyright (c) 2011 by Armin Ronacher.\n\n Some rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are\n met:\n\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n * Redistributions in binary form must reproduce the above\n copyright notice, this list of conditions and the following\n disclaimer in the documentation and/or other materials provided\n with the distribution.\n\n * The names of the contributors may not be used to endorse or\n promote products derived from this software without specific\n prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef FXAA_REDUCE_MIN\n#define FXAA_REDUCE_MIN   (1.0/ 128.0)\n#endif\n#ifndef FXAA_REDUCE_MUL\n#define FXAA_REDUCE_MUL   (1.0 / 8.0)\n#endif\n#ifndef FXAA_SPAN_MAX\n#define FXAA_SPAN_MAX     8.0\n#endif\n\n//optimized version for mobile, where dependent\n//texture reads can be a bottleneck\nvec4 fxaa(sampler2D tex, vec2 fragCoord, vec2 inverseVP,\n          vec2 v_rgbNW, vec2 v_rgbNE,\n          vec2 v_rgbSW, vec2 v_rgbSE,\n          vec2 v_rgbM) {\n    vec4 color;\n    vec3 rgbNW = texture2D(tex, v_rgbNW).xyz;\n    vec3 rgbNE = texture2D(tex, v_rgbNE).xyz;\n    vec3 rgbSW = texture2D(tex, v_rgbSW).xyz;\n    vec3 rgbSE = texture2D(tex, v_rgbSE).xyz;\n    vec4 texColor = texture2D(tex, v_rgbM);\n    vec3 rgbM  = texColor.xyz;\n    vec3 luma = vec3(0.299, 0.587, 0.114);\n    float lumaNW = dot(rgbNW, luma);\n    float lumaNE = dot(rgbNE, luma);\n    float lumaSW = dot(rgbSW, luma);\n    float lumaSE = dot(rgbSE, luma);\n    float lumaM  = dot(rgbM,  luma);\n    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));\n    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));\n\n    mediump vec2 dir;\n    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));\n    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));\n\n    float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) *\n                          (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);\n\n    float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);\n    dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX),\n              max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),\n                  dir * rcpDirMin)) * inverseVP;\n\n    vec3 rgbA = 0.5 * (\n                       texture2D(tex, fragCoord * inverseVP + dir * (1.0 / 3.0 - 0.5)).xyz +\n                       texture2D(tex, fragCoord * inverseVP + dir * (2.0 / 3.0 - 0.5)).xyz);\n    vec3 rgbB = rgbA * 0.5 + 0.25 * (\n                                     texture2D(tex, fragCoord * inverseVP + dir * -0.5).xyz +\n                                     texture2D(tex, fragCoord * inverseVP + dir * 0.5).xyz);\n\n    float lumaB = dot(rgbB, luma);\n    if ((lumaB < lumaMin) || (lumaB > lumaMax))\n        color = vec4(rgbA, texColor.a);\n    else\n        color = vec4(rgbB, texColor.a);\n    return color;\n}\n\nvoid main() {\n\n      vec4 color;\n\n      color = fxaa(uSampler, vFragCoord, inputSize.zw, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n\n      gl_FragColor = color;\n}\n";
 
-var _interaction = require('./interaction');
+  /**
+   * Basic FXAA (Fast Approximate Anti-Aliasing) implementation based on the code on geeks3d.com
+   * with the modification that the texture2DLod stuff was removed since it is unsupported by WebGL.
+   * @see https://github.com/mitsuhiko/webgl-meincraft
+   * @memberof PIXI.filters
+   */
+  var FXAAFilter = /** @class */ (function (_super) {
+      __extends$3(FXAAFilter, _super);
+      function FXAAFilter() {
+          // TODO - needs work
+          return _super.call(this, vertex, fragment$1) || this;
+      }
+      return FXAAFilter;
+  }(Filter));
 
-var interaction = _interopRequireWildcard(_interaction);
+  /*!
+   * @pixi/filter-noise - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/filter-noise is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-var _loaders = require('./loaders');
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$2 = function(d, b) {
+      extendStatics$2 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$2(d, b);
+  };
 
-var loaders = _interopRequireWildcard(_loaders);
+  function __extends$2(d, b) {
+      extendStatics$2(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
-var _mesh = require('./mesh');
+  var fragment = "precision highp float;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform float uNoise;\nuniform float uSeed;\nuniform sampler2D uSampler;\n\nfloat rand(vec2 co)\n{\n    return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvoid main()\n{\n    vec4 color = texture2D(uSampler, vTextureCoord);\n    float randomValue = rand(gl_FragCoord.xy * uSeed);\n    float diff = (randomValue - 0.5) * uNoise;\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (color.a > 0.0) {\n        color.rgb /= color.a;\n    }\n\n    color.r += diff;\n    color.g += diff;\n    color.b += diff;\n\n    // Premultiply alpha again.\n    color.rgb *= color.a;\n\n    gl_FragColor = color;\n}\n";
 
-var mesh = _interopRequireWildcard(_mesh);
+  /**
+   * A Noise effect filter.
+   *
+   * original filter: https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/noise.js
+   * @memberof PIXI.filters
+   * @author Vico @vicocotea
+   */
+  var NoiseFilter = /** @class */ (function (_super) {
+      __extends$2(NoiseFilter, _super);
+      /**
+       * @param {number} [noise=0.5] - The noise intensity, should be a normalized value in the range [0, 1].
+       * @param {number} [seed] - A random seed for the noise generation. Default is `Math.random()`.
+       */
+      function NoiseFilter(noise, seed) {
+          if (noise === void 0) { noise = 0.5; }
+          if (seed === void 0) { seed = Math.random(); }
+          var _this = _super.call(this, defaultFilterVertex, fragment, {
+              uNoise: 0,
+              uSeed: 0,
+          }) || this;
+          _this.noise = noise;
+          _this.seed = seed;
+          return _this;
+      }
+      Object.defineProperty(NoiseFilter.prototype, "noise", {
+          /**
+           * The amount of noise to apply, this value should be in the range (0, 1].
+           * @default 0.5
+           */
+          get: function () {
+              return this.uniforms.uNoise;
+          },
+          set: function (value) {
+              this.uniforms.uNoise = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(NoiseFilter.prototype, "seed", {
+          /** A seed value to apply to the random noise generation. `Math.random()` is a good value to use. */
+          get: function () {
+              return this.uniforms.uSeed;
+          },
+          set: function (value) {
+              this.uniforms.uSeed = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return NoiseFilter;
+  }(Filter));
+
+  /*!
+   * @pixi/mixin-cache-as-bitmap - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/mixin-cache-as-bitmap is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-var _particles = require('./particles');
+  var _tempMatrix = new Matrix();
+  DisplayObject.prototype._cacheAsBitmap = false;
+  DisplayObject.prototype._cacheData = null;
+  DisplayObject.prototype._cacheAsBitmapResolution = null;
+  DisplayObject.prototype._cacheAsBitmapMultisample = exports.MSAA_QUALITY.NONE;
+  // figured there's no point adding ALL the extra variables to prototype.
+  // this model can hold the information needed. This can also be generated on demand as
+  // most objects are not cached as bitmaps.
+  /**
+   * @class
+   * @ignore
+   * @private
+   */
+  var CacheData = /** @class */ (function () {
+      function CacheData() {
+          this.textureCacheId = null;
+          this.originalRender = null;
+          this.originalRenderCanvas = null;
+          this.originalCalculateBounds = null;
+          this.originalGetLocalBounds = null;
+          this.originalUpdateTransform = null;
+          this.originalDestroy = null;
+          this.originalMask = null;
+          this.originalFilterArea = null;
+          this.originalContainsPoint = null;
+          this.sprite = null;
+      }
+      return CacheData;
+  }());
+  Object.defineProperties(DisplayObject.prototype, {
+      /**
+       * The resolution to use for cacheAsBitmap. By default this will use the renderer's resolution
+       * but can be overriden for performance. Lower values will reduce memory usage at the expense
+       * of render quality. A falsey value of `null` or `0` will default to the renderer's resolution.
+       * If `cacheAsBitmap` is set to `true`, this will re-render with the new resolution.
+       * @member {number} cacheAsBitmapResolution
+       * @memberof PIXI.DisplayObject#
+       * @default null
+       */
+      cacheAsBitmapResolution: {
+          get: function () {
+              return this._cacheAsBitmapResolution;
+          },
+          set: function (resolution) {
+              if (resolution === this._cacheAsBitmapResolution) {
+                  return;
+              }
+              this._cacheAsBitmapResolution = resolution;
+              if (this.cacheAsBitmap) {
+                  // Toggle to re-render at the new resolution
+                  this.cacheAsBitmap = false;
+                  this.cacheAsBitmap = true;
+              }
+          },
+      },
+      /**
+       * The number of samples to use for cacheAsBitmap. If set to `null`, the renderer's
+       * sample count is used.
+       * If `cacheAsBitmap` is set to `true`, this will re-render with the new number of samples.
+       * @member {number} cacheAsBitmapMultisample
+       * @memberof PIXI.DisplayObject#
+       * @default PIXI.MSAA_QUALITY.NONE
+       */
+      cacheAsBitmapMultisample: {
+          get: function () {
+              return this._cacheAsBitmapMultisample;
+          },
+          set: function (multisample) {
+              if (multisample === this._cacheAsBitmapMultisample) {
+                  return;
+              }
+              this._cacheAsBitmapMultisample = multisample;
+              if (this.cacheAsBitmap) {
+                  // Toggle to re-render with new multisample
+                  this.cacheAsBitmap = false;
+                  this.cacheAsBitmap = true;
+              }
+          },
+      },
+      /**
+       * Set this to true if you want this display object to be cached as a bitmap.
+       * This basically takes a snap shot of the display object as it is at that moment. It can
+       * provide a performance benefit for complex static displayObjects.
+       * To remove simply set this property to `false`
+       *
+       * IMPORTANT GOTCHA - Make sure that all your textures are preloaded BEFORE setting this property to true
+       * as it will take a snapshot of what is currently there. If the textures have not loaded then they will not appear.
+       * @member {boolean}
+       * @memberof PIXI.DisplayObject#
+       */
+      cacheAsBitmap: {
+          get: function () {
+              return this._cacheAsBitmap;
+          },
+          set: function (value) {
+              if (this._cacheAsBitmap === value) {
+                  return;
+              }
+              this._cacheAsBitmap = value;
+              var data;
+              if (value) {
+                  if (!this._cacheData) {
+                      this._cacheData = new CacheData();
+                  }
+                  data = this._cacheData;
+                  data.originalRender = this.render;
+                  data.originalRenderCanvas = this.renderCanvas;
+                  data.originalUpdateTransform = this.updateTransform;
+                  data.originalCalculateBounds = this.calculateBounds;
+                  data.originalGetLocalBounds = this.getLocalBounds;
+                  data.originalDestroy = this.destroy;
+                  data.originalContainsPoint = this.containsPoint;
+                  data.originalMask = this._mask;
+                  data.originalFilterArea = this.filterArea;
+                  this.render = this._renderCached;
+                  this.renderCanvas = this._renderCachedCanvas;
+                  this.destroy = this._cacheAsBitmapDestroy;
+              }
+              else {
+                  data = this._cacheData;
+                  if (data.sprite) {
+                      this._destroyCachedDisplayObject();
+                  }
+                  this.render = data.originalRender;
+                  this.renderCanvas = data.originalRenderCanvas;
+                  this.calculateBounds = data.originalCalculateBounds;
+                  this.getLocalBounds = data.originalGetLocalBounds;
+                  this.destroy = data.originalDestroy;
+                  this.updateTransform = data.originalUpdateTransform;
+                  this.containsPoint = data.originalContainsPoint;
+                  this._mask = data.originalMask;
+                  this.filterArea = data.originalFilterArea;
+              }
+          },
+      },
+  });
+  /**
+   * Renders a cached version of the sprite with WebGL
+   * @private
+   * @method _renderCached
+   * @memberof PIXI.DisplayObject#
+   * @param {PIXI.Renderer} renderer - the WebGL renderer
+   */
+  DisplayObject.prototype._renderCached = function _renderCached(renderer) {
+      if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
+          return;
+      }
+      this._initCachedDisplayObject(renderer);
+      this._cacheData.sprite.transform._worldID = this.transform._worldID;
+      this._cacheData.sprite.worldAlpha = this.worldAlpha;
+      this._cacheData.sprite._render(renderer);
+  };
+  /**
+   * Prepares the WebGL renderer to cache the sprite
+   * @private
+   * @method _initCachedDisplayObject
+   * @memberof PIXI.DisplayObject#
+   * @param {PIXI.Renderer} renderer - the WebGL renderer
+   */
+  DisplayObject.prototype._initCachedDisplayObject = function _initCachedDisplayObject(renderer) {
+      var _a;
+      if (this._cacheData && this._cacheData.sprite) {
+          return;
+      }
+      // make sure alpha is set to 1 otherwise it will get rendered as invisible!
+      var cacheAlpha = this.alpha;
+      this.alpha = 1;
+      // first we flush anything left in the renderer (otherwise it would get rendered to the cached texture)
+      renderer.batch.flush();
+      // this.filters= [];
+      // next we find the dimensions of the untransformed object
+      // this function also calls updatetransform on all its children as part of the measuring.
+      // This means we don't need to update the transform again in this function
+      // TODO pass an object to clone too? saves having to create a new one each time!
+      var bounds = this.getLocalBounds(null, true).clone();
+      // add some padding!
+      if (this.filters && this.filters.length) {
+          var padding = this.filters[0].padding;
+          bounds.pad(padding);
+      }
+      bounds.ceil(settings.RESOLUTION);
+      // for now we cache the current renderTarget that the WebGL renderer is currently using.
+      // this could be more elegant..
+      var cachedRenderTexture = renderer.renderTexture.current;
+      var cachedSourceFrame = renderer.renderTexture.sourceFrame.clone();
+      var cachedDestinationFrame = renderer.renderTexture.destinationFrame.clone();
+      var cachedProjectionTransform = renderer.projection.transform;
+      // We also store the filter stack - I will definitely look to change how this works a little later down the line.
+      // const stack = renderer.filterManager.filterStack;
+      // this renderTexture will be used to store the cached DisplayObject
+      var renderTexture = RenderTexture.create({
+          width: bounds.width,
+          height: bounds.height,
+          resolution: this.cacheAsBitmapResolution || renderer.resolution,
+          multisample: (_a = this.cacheAsBitmapMultisample) !== null && _a !== void 0 ? _a : renderer.multisample,
+      });
+      var textureCacheId = "cacheAsBitmap_" + uid();
+      this._cacheData.textureCacheId = textureCacheId;
+      BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);
+      Texture.addToCache(renderTexture, textureCacheId);
+      // need to set //
+      var m = this.transform.localTransform.copyTo(_tempMatrix).invert().translate(-bounds.x, -bounds.y);
+      // set all properties to there original so we can render to a texture
+      this.render = this._cacheData.originalRender;
+      renderer.render(this, { renderTexture: renderTexture, clear: true, transform: m, skipUpdateTransform: false });
+      renderer.framebuffer.blit();
+      // now restore the state be setting the new properties
+      renderer.projection.transform = cachedProjectionTransform;
+      renderer.renderTexture.bind(cachedRenderTexture, cachedSourceFrame, cachedDestinationFrame);
+      // renderer.filterManager.filterStack = stack;
+      this.render = this._renderCached;
+      // the rest is the same as for Canvas
+      this.updateTransform = this.displayObjectUpdateTransform;
+      this.calculateBounds = this._calculateCachedBounds;
+      this.getLocalBounds = this._getCachedLocalBounds;
+      this._mask = null;
+      this.filterArea = null;
+      this.alpha = cacheAlpha;
+      // create our cached sprite
+      var cachedSprite = new Sprite(renderTexture);
+      cachedSprite.transform.worldTransform = this.transform.worldTransform;
+      cachedSprite.anchor.x = -(bounds.x / bounds.width);
+      cachedSprite.anchor.y = -(bounds.y / bounds.height);
+      cachedSprite.alpha = cacheAlpha;
+      cachedSprite._bounds = this._bounds;
+      this._cacheData.sprite = cachedSprite;
+      this.transform._parentID = -1;
+      // restore the transform of the cached sprite to avoid the nasty flicker..
+      if (!this.parent) {
+          this.enableTempParent();
+          this.updateTransform();
+          this.disableTempParent(null);
+      }
+      else {
+          this.updateTransform();
+      }
+      // map the hit test..
+      this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
+  };
+  /**
+   * Renders a cached version of the sprite with canvas
+   * @private
+   * @method _renderCachedCanvas
+   * @memberof PIXI.DisplayObject#
+   * @param {PIXI.CanvasRenderer} renderer - The canvas renderer
+   */
+  DisplayObject.prototype._renderCachedCanvas = function _renderCachedCanvas(renderer) {
+      if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
+          return;
+      }
+      this._initCachedDisplayObjectCanvas(renderer);
+      this._cacheData.sprite.worldAlpha = this.worldAlpha;
+      this._cacheData.sprite._renderCanvas(renderer);
+  };
+  // TODO this can be the same as the WebGL version.. will need to do a little tweaking first though..
+  /**
+   * Prepares the Canvas renderer to cache the sprite
+   * @private
+   * @method _initCachedDisplayObjectCanvas
+   * @memberof PIXI.DisplayObject#
+   * @param {PIXI.CanvasRenderer} renderer - The canvas renderer
+   */
+  DisplayObject.prototype._initCachedDisplayObjectCanvas = function _initCachedDisplayObjectCanvas(renderer) {
+      if (this._cacheData && this._cacheData.sprite) {
+          return;
+      }
+      // get bounds actually transforms the object for us already!
+      var bounds = this.getLocalBounds(null, true);
+      var cacheAlpha = this.alpha;
+      this.alpha = 1;
+      var cachedRenderTarget = renderer.context;
+      var cachedProjectionTransform = renderer._projTransform;
+      bounds.ceil(settings.RESOLUTION);
+      var renderTexture = RenderTexture.create({ width: bounds.width, height: bounds.height });
+      var textureCacheId = "cacheAsBitmap_" + uid();
+      this._cacheData.textureCacheId = textureCacheId;
+      BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);
+      Texture.addToCache(renderTexture, textureCacheId);
+      // need to set //
+      var m = _tempMatrix;
+      this.transform.localTransform.copyTo(m);
+      m.invert();
+      m.tx -= bounds.x;
+      m.ty -= bounds.y;
+      // m.append(this.transform.worldTransform.)
+      // set all properties to there original so we can render to a texture
+      this.renderCanvas = this._cacheData.originalRenderCanvas;
+      renderer.render(this, { renderTexture: renderTexture, clear: true, transform: m, skipUpdateTransform: false });
+      // now restore the state be setting the new properties
+      renderer.context = cachedRenderTarget;
+      renderer._projTransform = cachedProjectionTransform;
+      this.renderCanvas = this._renderCachedCanvas;
+      // the rest is the same as for WebGL
+      this.updateTransform = this.displayObjectUpdateTransform;
+      this.calculateBounds = this._calculateCachedBounds;
+      this.getLocalBounds = this._getCachedLocalBounds;
+      this._mask = null;
+      this.filterArea = null;
+      this.alpha = cacheAlpha;
+      // create our cached sprite
+      var cachedSprite = new Sprite(renderTexture);
+      cachedSprite.transform.worldTransform = this.transform.worldTransform;
+      cachedSprite.anchor.x = -(bounds.x / bounds.width);
+      cachedSprite.anchor.y = -(bounds.y / bounds.height);
+      cachedSprite.alpha = cacheAlpha;
+      cachedSprite._bounds = this._bounds;
+      this._cacheData.sprite = cachedSprite;
+      this.transform._parentID = -1;
+      // restore the transform of the cached sprite to avoid the nasty flicker..
+      if (!this.parent) {
+          this.parent = renderer._tempDisplayObjectParent;
+          this.updateTransform();
+          this.parent = null;
+      }
+      else {
+          this.updateTransform();
+      }
+      // map the hit test..
+      this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
+  };
+  /**
+   * Calculates the bounds of the cached sprite
+   * @private
+   * @method
+   */
+  DisplayObject.prototype._calculateCachedBounds = function _calculateCachedBounds() {
+      this._bounds.clear();
+      this._cacheData.sprite.transform._worldID = this.transform._worldID;
+      this._cacheData.sprite._calculateBounds();
+      this._bounds.updateID = this._boundsID;
+  };
+  /**
+   * Gets the bounds of the cached sprite.
+   * @private
+   * @method
+   * @returns {Rectangle} The local bounds.
+   */
+  DisplayObject.prototype._getCachedLocalBounds = function _getCachedLocalBounds() {
+      return this._cacheData.sprite.getLocalBounds(null);
+  };
+  /**
+   * Destroys the cached sprite.
+   * @private
+   * @method
+   */
+  DisplayObject.prototype._destroyCachedDisplayObject = function _destroyCachedDisplayObject() {
+      this._cacheData.sprite._texture.destroy(true);
+      this._cacheData.sprite = null;
+      BaseTexture.removeFromCache(this._cacheData.textureCacheId);
+      Texture.removeFromCache(this._cacheData.textureCacheId);
+      this._cacheData.textureCacheId = null;
+  };
+  /**
+   * Destroys the cached object.
+   * @private
+   * @method
+   * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
+   *  have been set to that value.
+   *  Used when destroying containers, see the Container.destroy method.
+   */
+  DisplayObject.prototype._cacheAsBitmapDestroy = function _cacheAsBitmapDestroy(options) {
+      this.cacheAsBitmap = false;
+      this.destroy(options);
+  };
 
-var particles = _interopRequireWildcard(_particles);
+  /*!
+   * @pixi/mixin-get-child-by-name - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/mixin-get-child-by-name is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-var _prepare = require('./prepare');
+  /**
+   * The instance name of the object.
+   * @memberof PIXI.DisplayObject#
+   * @member {string} name
+   */
+  DisplayObject.prototype.name = null;
+  /**
+   * Returns the display object in the container.
+   *
+   * Recursive searches are done in a preorder traversal.
+   * @method getChildByName
+   * @memberof PIXI.Container#
+   * @param {string} name - Instance name.
+   * @param {boolean}[deep=false] - Whether to search recursively
+   * @returns {PIXI.DisplayObject} The child with the specified name.
+   */
+  Container.prototype.getChildByName = function getChildByName(name, deep) {
+      for (var i = 0, j = this.children.length; i < j; i++) {
+          if (this.children[i].name === name) {
+              return this.children[i];
+          }
+      }
+      if (deep) {
+          for (var i = 0, j = this.children.length; i < j; i++) {
+              var child = this.children[i];
+              if (!child.getChildByName) {
+                  continue;
+              }
+              var target = child.getChildByName(name, true);
+              if (target) {
+                  return target;
+              }
+          }
+      }
+      return null;
+  };
 
-var prepare = _interopRequireWildcard(_prepare);
+  /*!
+   * @pixi/mixin-get-global-position - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/mixin-get-global-position is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+  /**
+   * Returns the global position of the displayObject. Does not depend on object scale, rotation and pivot.
+   * @method getGlobalPosition
+   * @memberof PIXI.DisplayObject#
+   * @param {PIXI.Point} [point=new PIXI.Point()] - The point to write the global value to.
+   * @param {boolean} [skipUpdate=false] - Setting to true will stop the transforms of the scene graph from
+   *  being updated. This means the calculation returned MAY be out of date BUT will give you a
+   *  nice performance boost.
+   * @returns {PIXI.Point} The updated point.
+   */
+  DisplayObject.prototype.getGlobalPosition = function getGlobalPosition(point, skipUpdate) {
+      if (point === void 0) { point = new Point(); }
+      if (skipUpdate === void 0) { skipUpdate = false; }
+      if (this.parent) {
+          this.parent.toGlobal(this.position, point, skipUpdate);
+      }
+      else {
+          point.x = this.position.x;
+          point.y = this.position.y;
+      }
+      return point;
+  };
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  /*!
+   * @pixi/app - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/app is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-// export core
-_core.utils.mixins.performMixins();
+  /**
+   * Middleware for for Application's resize functionality
+   * @private
+   * @class
+   */
+  var ResizePlugin = /** @class */ (function () {
+      function ResizePlugin() {
+      }
+      /**
+       * Initialize the plugin with scope of application instance
+       * @static
+       * @private
+       * @param {object} [options] - See application options
+       */
+      ResizePlugin.init = function (options) {
+          var _this = this;
+          Object.defineProperty(this, 'resizeTo', 
+          /**
+           * The HTML element or window to automatically resize the
+           * renderer's view element to match width and height.
+           * @member {Window|HTMLElement}
+           * @name resizeTo
+           * @memberof PIXI.Application#
+           */
+          {
+              set: function (dom) {
+                  globalThis.removeEventListener('resize', this.queueResize);
+                  this._resizeTo = dom;
+                  if (dom) {
+                      globalThis.addEventListener('resize', this.queueResize);
+                      this.resize();
+                  }
+              },
+              get: function () {
+                  return this._resizeTo;
+              },
+          });
+          /**
+           * Resize is throttled, so it's safe to call this multiple times per frame and it'll
+           * only be called once.
+           * @memberof PIXI.Application#
+           * @method queueResize
+           * @private
+           */
+          this.queueResize = function () {
+              if (!_this._resizeTo) {
+                  return;
+              }
+              _this.cancelResize();
+              // // Throttle resize events per raf
+              _this._resizeId = requestAnimationFrame(function () { return _this.resize(); });
+          };
+          /**
+           * Cancel the resize queue.
+           * @memberof PIXI.Application#
+           * @method cancelResize
+           * @private
+           */
+          this.cancelResize = function () {
+              if (_this._resizeId) {
+                  cancelAnimationFrame(_this._resizeId);
+                  _this._resizeId = null;
+              }
+          };
+          /**
+           * Execute an immediate resize on the renderer, this is not
+           * throttled and can be expensive to call many times in a row.
+           * Will resize only if `resizeTo` property is set.
+           * @memberof PIXI.Application#
+           * @method resize
+           */
+          this.resize = function () {
+              if (!_this._resizeTo) {
+                  return;
+              }
+              // clear queue resize
+              _this.cancelResize();
+              var width;
+              var height;
+              // Resize to the window
+              if (_this._resizeTo === globalThis.window) {
+                  width = globalThis.innerWidth;
+                  height = globalThis.innerHeight;
+              }
+              // Resize to other HTML entities
+              else {
+                  var _a = _this._resizeTo, clientWidth = _a.clientWidth, clientHeight = _a.clientHeight;
+                  width = clientWidth;
+                  height = clientHeight;
+              }
+              _this.renderer.resize(width, height);
+          };
+          // On resize
+          this._resizeId = null;
+          this._resizeTo = null;
+          this.resizeTo = options.resizeTo || null;
+      };
+      /**
+       * Clean up the ticker, scoped to application
+       * @static
+       * @private
+       */
+      ResizePlugin.destroy = function () {
+          globalThis.removeEventListener('resize', this.queueResize);
+          this.cancelResize();
+          this.cancelResize = null;
+          this.queueResize = null;
+          this.resizeTo = null;
+          this.resize = null;
+      };
+      /** @ignore */
+      ResizePlugin.extension = exports.ExtensionType.Application;
+      return ResizePlugin;
+  }());
 
-/**
- * Alias for {@link PIXI.loaders.shared}.
- * @name loader
- * @memberof PIXI
- * @type {PIXI.loader.Loader}
- */
+  /**
+   * Convenience class to create a new PIXI application.
+   *
+   * This class automatically creates the renderer, ticker and root container.
+   * @example
+   * // Create the application
+   * const app = new PIXI.Application();
+   *
+   * // Add the view to the DOM
+   * document.body.appendChild(app.view);
+   *
+   * // ex, add display objects
+   * app.stage.addChild(PIXI.Sprite.from('something.png'));
+   * @class
+   * @memberof PIXI
+   */
+  var Application = /** @class */ (function () {
+      /**
+       * @param {PIXI.IApplicationOptions} [options] - The optional application and renderer parameters.
+       * @param {boolean} [options.antialias=false] -
+       *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
+       * @param {boolean} [options.autoDensity=false] -
+       *  Whether the CSS dimensions of the renderer's view should be resized automatically.
+       * @param {boolean} [options.autoStart=true] - Automatically starts the rendering after the construction.
+       *  **Note**: Setting this parameter to false does NOT stop the shared ticker even if you set
+       *  `options.sharedTicker` to `true` in case that it is already started. Stop it by your own.
+       * @param {number} [options.backgroundAlpha=1] -
+       *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
+       * @param {number} [options.backgroundColor=0x000000] -
+       *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
+       * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
+       * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
+       * @param {boolean} [options.forceCanvas=false] -
+       *  Force using {@link PIXI.CanvasRenderer}, even if WebGL is available. This option only is available when
+       *  using **pixi.js-legacy** or **@pixi/canvas-renderer** packages, otherwise it is ignored.
+       * @param {number} [options.height=600] - The height of the renderer's view.
+       * @param {string} [options.powerPreference] -
+       *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
+       *  can be `'default'`, `'high-performance'` or `'low-power'`.
+       *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
+       *  while setting to `'low-power'` will prioritize power saving over rendering performance.
+       * @param {boolean} [options.premultipliedAlpha=true] -
+       *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
+       * @param {boolean} [options.preserveDrawingBuffer=false] -
+       *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
+       *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
+       * @param {Window|HTMLElement} [options.resizeTo] - Element to automatically resize stage to.
+       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
+       *  The resolution / device pixel ratio of the renderer.
+       * @param {boolean} [options.sharedLoader=false] - `true` to use PIXI.Loader.shared, `false` to create new Loader.
+       * @param {boolean} [options.sharedTicker=false] - `true` to use PIXI.Ticker.shared, `false` to create new ticker.
+       *  If set to `false`, you cannot register a handler to occur before anything that runs on the shared ticker.
+       *  The system ticker will always run before both the shared ticker and the app ticker.
+       * @param {boolean} [options.transparent] -
+       *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
+       *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
+       * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
+       *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
+       *  canvas needs to be opaque, possibly for performance reasons on some older devices.
+       *  If you want to set transparency, please use `backgroundAlpha`. \
+       *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
+       *  set to `true` and `premultipliedAlpha` will be to `false`.
+       * @param {HTMLCanvasElement} [options.view=null] -
+       *  The canvas to use as the view. If omitted, a new canvas will be created.
+       * @param {number} [options.width=800] - The width of the renderer's view.
+       */
+      function Application(options) {
+          var _this = this;
+          /**
+           * The root display container that's rendered.
+           * @member {PIXI.Container}
+           */
+          this.stage = new Container();
+          // The default options
+          options = Object.assign({
+              forceCanvas: false,
+          }, options);
+          this.renderer = autoDetectRenderer(options);
+          // install plugins here
+          Application._plugins.forEach(function (plugin) {
+              plugin.init.call(_this, options);
+          });
+      }
+      /**
+       * Use the {@link PIXI.extensions.add} API to register plugins.
+       * @deprecated since 6.5.0
+       * @static
+       * @param {PIXI.IApplicationPlugin} plugin - Plugin being installed
+       */
+      Application.registerPlugin = function (plugin) {
+          deprecation('6.5.0', 'Application.registerPlugin() is deprecated, use extensions.add()');
+          extensions.add({
+              type: exports.ExtensionType.Application,
+              ref: plugin,
+          });
+      };
+      /** Render the current stage. */
+      Application.prototype.render = function () {
+          this.renderer.render(this.stage);
+      };
+      Object.defineProperty(Application.prototype, "view", {
+          /**
+           * Reference to the renderer's canvas element.
+           * @member {HTMLCanvasElement}
+           * @readonly
+           */
+          get: function () {
+              return this.renderer.view;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(Application.prototype, "screen", {
+          /**
+           * Reference to the renderer's screen rectangle. Its safe to use as `filterArea` or `hitArea` for the whole screen.
+           * @member {PIXI.Rectangle}
+           * @readonly
+           */
+          get: function () {
+              return this.renderer.screen;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /**
+       * Destroy and don't use after this.
+       * @param {boolean} [removeView=false] - Automatically remove canvas from DOM.
+       * @param {object|boolean} [stageOptions] - Options parameter. A boolean will act as if all options
+       *  have been set to that value
+       * @param {boolean} [stageOptions.children=false] - if set to true, all the children will have their destroy
+       *  method called as well. 'stageOptions' will be passed on to those calls.
+       * @param {boolean} [stageOptions.texture=false] - Only used for child Sprites if stageOptions.children is set
+       *  to true. Should it destroy the texture of the child sprite
+       * @param {boolean} [stageOptions.baseTexture=false] - Only used for child Sprites if stageOptions.children is set
+       *  to true. Should it destroy the base texture of the child sprite
+       */
+      Application.prototype.destroy = function (removeView, stageOptions) {
+          var _this = this;
+          // Destroy plugins in the opposite order
+          // which they were constructed
+          var plugins = Application._plugins.slice(0);
+          plugins.reverse();
+          plugins.forEach(function (plugin) {
+              plugin.destroy.call(_this);
+          });
+          this.stage.destroy(stageOptions);
+          this.stage = null;
+          this.renderer.destroy(removeView);
+          this.renderer = null;
+      };
+      /** Collection of installed plugins. */
+      Application._plugins = [];
+      return Application;
+  }());
+  extensions.handleByList(exports.ExtensionType.Application, Application._plugins);
+
+  extensions.add(ResizePlugin);
+
+  /*!
+   * @pixi/mesh-extras - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/mesh-extras is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics$1 = function(d, b) {
+      extendStatics$1 = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics$1(d, b);
+  };
 
-// handle mixins now, after all code has been added, including deprecation
+  function __extends$1(d, b) {
+      extendStatics$1(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
+  /**
+   * @memberof PIXI
+   */
+  var PlaneGeometry = /** @class */ (function (_super) {
+      __extends$1(PlaneGeometry, _super);
+      /**
+       * @param width - The width of the plane.
+       * @param height - The height of the plane.
+       * @param segWidth - Number of horizontal segments.
+       * @param segHeight - Number of vertical segments.
+       */
+      function PlaneGeometry(width, height, segWidth, segHeight) {
+          if (width === void 0) { width = 100; }
+          if (height === void 0) { height = 100; }
+          if (segWidth === void 0) { segWidth = 10; }
+          if (segHeight === void 0) { segHeight = 10; }
+          var _this = _super.call(this) || this;
+          _this.segWidth = segWidth;
+          _this.segHeight = segHeight;
+          _this.width = width;
+          _this.height = height;
+          _this.build();
+          return _this;
+      }
+      /**
+       * Refreshes plane coordinates
+       * @private
+       */
+      PlaneGeometry.prototype.build = function () {
+          var total = this.segWidth * this.segHeight;
+          var verts = [];
+          var uvs = [];
+          var indices = [];
+          var segmentsX = this.segWidth - 1;
+          var segmentsY = this.segHeight - 1;
+          var sizeX = (this.width) / segmentsX;
+          var sizeY = (this.height) / segmentsY;
+          for (var i = 0; i < total; i++) {
+              var x = (i % this.segWidth);
+              var y = ((i / this.segWidth) | 0);
+              verts.push(x * sizeX, y * sizeY);
+              uvs.push(x / segmentsX, y / segmentsY);
+          }
+          var totalSub = segmentsX * segmentsY;
+          for (var i = 0; i < totalSub; i++) {
+              var xpos = i % segmentsX;
+              var ypos = (i / segmentsX) | 0;
+              var value = (ypos * this.segWidth) + xpos;
+              var value2 = (ypos * this.segWidth) + xpos + 1;
+              var value3 = ((ypos + 1) * this.segWidth) + xpos;
+              var value4 = ((ypos + 1) * this.segWidth) + xpos + 1;
+              indices.push(value, value2, value3, value2, value4, value3);
+          }
+          this.buffers[0].data = new Float32Array(verts);
+          this.buffers[1].data = new Float32Array(uvs);
+          this.indexBuffer.data = new Uint16Array(indices);
+          // ensure that the changes are uploaded
+          this.buffers[0].update();
+          this.buffers[1].update();
+          this.indexBuffer.update();
+      };
+      return PlaneGeometry;
+  }(MeshGeometry));
 
-// export libs
-// import polyfills. Done as an export to make sure polyfills are imported first
-var loader = loaders.shared || null;
+  /**
+   * RopeGeometry allows you to draw a geometry across several points and then manipulate these points.
+   *
+   * ```js
+   * for (let i = 0; i < 20; i++) {
+   *     points.push(new PIXI.Point(i * 50, 0));
+   * };
+   * const rope = new PIXI.RopeGeometry(100, points);
+   * ```
+   * @memberof PIXI
+   */
+  var RopeGeometry = /** @class */ (function (_super) {
+      __extends$1(RopeGeometry, _super);
+      /**
+       * @param width - The width (i.e., thickness) of the rope.
+       * @param points - An array of {@link PIXI.Point} objects to construct this rope.
+       * @param textureScale - By default the rope texture will be stretched to match
+       *     rope length. If textureScale is positive this value will be treated as a scaling
+       *     factor and the texture will preserve its aspect ratio instead. To create a tiling rope
+       *     set baseTexture.wrapMode to {@link PIXI.WRAP_MODES.REPEAT} and use a power of two texture,
+       *     then set textureScale=1 to keep the original texture pixel size.
+       *     In order to reduce alpha channel artifacts provide a larger texture and downsample -
+       *     i.e. set textureScale=0.5 to scale it down twice.
+       */
+      function RopeGeometry(width, points, textureScale) {
+          if (width === void 0) { width = 200; }
+          if (textureScale === void 0) { textureScale = 0; }
+          var _this = _super.call(this, new Float32Array(points.length * 4), new Float32Array(points.length * 4), new Uint16Array((points.length - 1) * 6)) || this;
+          _this.points = points;
+          _this._width = width;
+          _this.textureScale = textureScale;
+          _this.build();
+          return _this;
+      }
+      Object.defineProperty(RopeGeometry.prototype, "width", {
+          /**
+           * The width (i.e., thickness) of the rope.
+           * @readonly
+           */
+          get: function () {
+              return this._width;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Refreshes Rope indices and uvs */
+      RopeGeometry.prototype.build = function () {
+          var points = this.points;
+          if (!points)
+              { return; }
+          var vertexBuffer = this.getBuffer('aVertexPosition');
+          var uvBuffer = this.getBuffer('aTextureCoord');
+          var indexBuffer = this.getIndex();
+          // if too little points, or texture hasn't got UVs set yet just move on.
+          if (points.length < 1) {
+              return;
+          }
+          // if the number of points has changed we will need to recreate the arraybuffers
+          if (vertexBuffer.data.length / 4 !== points.length) {
+              vertexBuffer.data = new Float32Array(points.length * 4);
+              uvBuffer.data = new Float32Array(points.length * 4);
+              indexBuffer.data = new Uint16Array((points.length - 1) * 6);
+          }
+          var uvs = uvBuffer.data;
+          var indices = indexBuffer.data;
+          uvs[0] = 0;
+          uvs[1] = 0;
+          uvs[2] = 0;
+          uvs[3] = 1;
+          var amount = 0;
+          var prev = points[0];
+          var textureWidth = this._width * this.textureScale;
+          var total = points.length; // - 1;
+          for (var i = 0; i < total; i++) {
+              // time to do some smart drawing!
+              var index = i * 4;
+              if (this.textureScale > 0) {
+                  // calculate pixel distance from previous point
+                  var dx = prev.x - points[i].x;
+                  var dy = prev.y - points[i].y;
+                  var distance = Math.sqrt((dx * dx) + (dy * dy));
+                  prev = points[i];
+                  amount += distance / textureWidth;
+              }
+              else {
+                  // stretch texture
+                  amount = i / (total - 1);
+              }
+              uvs[index] = amount;
+              uvs[index + 1] = 0;
+              uvs[index + 2] = amount;
+              uvs[index + 3] = 1;
+          }
+          var indexCount = 0;
+          for (var i = 0; i < total - 1; i++) {
+              var index = i * 2;
+              indices[indexCount++] = index;
+              indices[indexCount++] = index + 1;
+              indices[indexCount++] = index + 2;
+              indices[indexCount++] = index + 2;
+              indices[indexCount++] = index + 1;
+              indices[indexCount++] = index + 3;
+          }
+          // ensure that the changes are uploaded
+          uvBuffer.update();
+          indexBuffer.update();
+          this.updateVertices();
+      };
+      /** refreshes vertices of Rope mesh */
+      RopeGeometry.prototype.updateVertices = function () {
+          var points = this.points;
+          if (points.length < 1) {
+              return;
+          }
+          var lastPoint = points[0];
+          var nextPoint;
+          var perpX = 0;
+          var perpY = 0;
+          var vertices = this.buffers[0].data;
+          var total = points.length;
+          for (var i = 0; i < total; i++) {
+              var point = points[i];
+              var index = i * 4;
+              if (i < points.length - 1) {
+                  nextPoint = points[i + 1];
+              }
+              else {
+                  nextPoint = point;
+              }
+              perpY = -(nextPoint.x - lastPoint.x);
+              perpX = nextPoint.y - lastPoint.y;
+              var perpLength = Math.sqrt((perpX * perpX) + (perpY * perpY));
+              var num = this.textureScale > 0 ? this.textureScale * this._width / 2 : this._width / 2;
+              perpX /= perpLength;
+              perpY /= perpLength;
+              perpX *= num;
+              perpY *= num;
+              vertices[index] = point.x + perpX;
+              vertices[index + 1] = point.y + perpY;
+              vertices[index + 2] = point.x - perpX;
+              vertices[index + 3] = point.y - perpY;
+              lastPoint = point;
+          }
+          this.buffers[0].update();
+      };
+      RopeGeometry.prototype.update = function () {
+          if (this.textureScale > 0) {
+              this.build(); // we need to update UVs
+          }
+          else {
+              this.updateVertices();
+          }
+      };
+      return RopeGeometry;
+  }(MeshGeometry));
 
-exports.accessibility = accessibility;
-exports.extract = extract;
-exports.extras = extras;
-exports.filters = filters;
-exports.interaction = interaction;
-exports.loaders = loaders;
-exports.mesh = mesh;
-exports.particles = particles;
-exports.prepare = prepare;
-exports.loader = loader;
+  /**
+   * The rope allows you to draw a texture across several points and then manipulate these points
+   *
+   *```js
+   * for (let i = 0; i < 20; i++) {
+   *     points.push(new PIXI.Point(i * 50, 0));
+   * };
+   * let rope = new PIXI.SimpleRope(PIXI.Texture.from("snake.png"), points);
+   *  ```
+   * @memberof PIXI
+   */
+  var SimpleRope = /** @class */ (function (_super) {
+      __extends$1(SimpleRope, _super);
+      /**
+       * @param texture - The texture to use on the rope.
+       * @param points - An array of {@link PIXI.Point} objects to construct this rope.
+       * @param {number} textureScale - Optional. Positive values scale rope texture
+       * keeping its aspect ratio. You can reduce alpha channel artifacts by providing a larger texture
+       * and downsampling here. If set to zero, texture will be stretched instead.
+       */
+      function SimpleRope(texture, points, textureScale) {
+          if (textureScale === void 0) { textureScale = 0; }
+          var _this = this;
+          var ropeGeometry = new RopeGeometry(texture.height, points, textureScale);
+          var meshMaterial = new MeshMaterial(texture);
+          if (textureScale > 0) {
+              // attempt to set UV wrapping, will fail on non-power of two textures
+              texture.baseTexture.wrapMode = exports.WRAP_MODES.REPEAT;
+          }
+          _this = _super.call(this, ropeGeometry, meshMaterial) || this;
+          /**
+           * re-calculate vertices by rope points each frame
+           * @member {boolean}
+           */
+          _this.autoUpdate = true;
+          return _this;
+      }
+      SimpleRope.prototype._render = function (renderer) {
+          var geometry = this.geometry;
+          if (this.autoUpdate || geometry._width !== this.shader.texture.height) {
+              geometry._width = this.shader.texture.height;
+              geometry.update();
+          }
+          _super.prototype._render.call(this, renderer);
+      };
+      return SimpleRope;
+  }(Mesh));
 
-// Apply the deprecations
+  /**
+   * The SimplePlane allows you to draw a texture across several points and then manipulate these points
+   *
+   *```js
+   * for (let i = 0; i < 20; i++) {
+   *     points.push(new PIXI.Point(i * 50, 0));
+   * };
+   * let SimplePlane = new PIXI.SimplePlane(PIXI.Texture.from("snake.png"), points);
+   *  ```
+   * @memberof PIXI
+   */
+  var SimplePlane = /** @class */ (function (_super) {
+      __extends$1(SimplePlane, _super);
+      /**
+       * @param texture - The texture to use on the SimplePlane.
+       * @param verticesX - The number of vertices in the x-axis
+       * @param verticesY - The number of vertices in the y-axis
+       */
+      function SimplePlane(texture, verticesX, verticesY) {
+          var _this = this;
+          var planeGeometry = new PlaneGeometry(texture.width, texture.height, verticesX, verticesY);
+          var meshMaterial = new MeshMaterial(Texture.WHITE);
+          _this = _super.call(this, planeGeometry, meshMaterial) || this;
+          // lets call the setter to ensure all necessary updates are performed
+          _this.texture = texture;
+          _this.autoResize = true;
+          return _this;
+      }
+      /**
+       * Method used for overrides, to do something in case texture frame was changed.
+       * Meshes based on plane can override it and change more details based on texture.
+       */
+      SimplePlane.prototype.textureUpdated = function () {
+          this._textureID = this.shader.texture._updateID;
+          var geometry = this.geometry;
+          var _a = this.shader.texture, width = _a.width, height = _a.height;
+          if (this.autoResize && (geometry.width !== width || geometry.height !== height)) {
+              geometry.width = this.shader.texture.width;
+              geometry.height = this.shader.texture.height;
+              geometry.build();
+          }
+      };
+      Object.defineProperty(SimplePlane.prototype, "texture", {
+          get: function () {
+              return this.shader.texture;
+          },
+          set: function (value) {
+              // Track texture same way sprite does.
+              // For generated meshes like NineSlicePlane it can change the geometry.
+              // Unfortunately, this method might not work if you directly change texture in material.
+              if (this.shader.texture === value) {
+                  return;
+              }
+              this.shader.texture = value;
+              this._textureID = -1;
+              if (value.baseTexture.valid) {
+                  this.textureUpdated();
+              }
+              else {
+                  value.once('update', this.textureUpdated, this);
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      SimplePlane.prototype._render = function (renderer) {
+          if (this._textureID !== this.shader.texture._updateID) {
+              this.textureUpdated();
+          }
+          _super.prototype._render.call(this, renderer);
+      };
+      SimplePlane.prototype.destroy = function (options) {
+          this.shader.texture.off('update', this.textureUpdated, this);
+          _super.prototype.destroy.call(this, options);
+      };
+      return SimplePlane;
+  }(Mesh));
 
-if (typeof _deprecation2.default === 'function') {
-    (0, _deprecation2.default)(exports);
-}
+  /**
+   * The Simple Mesh class mimics Mesh in PixiJS v4, providing easy-to-use constructor arguments.
+   * For more robust customization, use {@link PIXI.Mesh}.
+   * @memberof PIXI
+   */
+  var SimpleMesh = /** @class */ (function (_super) {
+      __extends$1(SimpleMesh, _super);
+      /**
+       * @param texture - The texture to use
+       * @param {Float32Array} [vertices] - if you want to specify the vertices
+       * @param {Float32Array} [uvs] - if you want to specify the uvs
+       * @param {Uint16Array} [indices] - if you want to specify the indices
+       * @param drawMode - the drawMode, can be any of the Mesh.DRAW_MODES consts
+       */
+      function SimpleMesh(texture, vertices, uvs, indices, drawMode) {
+          if (texture === void 0) { texture = Texture.EMPTY; }
+          var _this = this;
+          var geometry = new MeshGeometry(vertices, uvs, indices);
+          geometry.getBuffer('aVertexPosition').static = false;
+          var meshMaterial = new MeshMaterial(texture);
+          _this = _super.call(this, geometry, meshMaterial, null, drawMode) || this;
+          _this.autoUpdate = true;
+          return _this;
+      }
+      Object.defineProperty(SimpleMesh.prototype, "vertices", {
+          /**
+           * Collection of vertices data.
+           * @type {Float32Array}
+           */
+          get: function () {
+              return this.geometry.getBuffer('aVertexPosition').data;
+          },
+          set: function (value) {
+              this.geometry.getBuffer('aVertexPosition').data = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      SimpleMesh.prototype._render = function (renderer) {
+          if (this.autoUpdate) {
+              this.geometry.getBuffer('aVertexPosition').update();
+          }
+          _super.prototype._render.call(this, renderer);
+      };
+      return SimpleMesh;
+  }(Mesh));
 
-// Always export PixiJS globally.
-global.PIXI = exports; // eslint-disable-line
+  var DEFAULT_BORDER_SIZE = 10;
+  /**
+   * The NineSlicePlane allows you to stretch a texture using 9-slice scaling. The corners will remain unscaled (useful
+   * for buttons with rounded corners for example) and the other areas will be scaled horizontally and or vertically
+   *
+   *```js
+   * let Plane9 = new PIXI.NineSlicePlane(PIXI.Texture.from('BoxWithRoundedCorners.png'), 15, 15, 15, 15);
+   *  ```
+   * <pre>
+   *      A                          B
+   *    +---+----------------------+---+
+   *  C | 1 |          2           | 3 |
+   *    +---+----------------------+---+
+   *    |   |                      |   |
+   *    | 4 |          5           | 6 |
+   *    |   |                      |   |
+   *    +---+----------------------+---+
+   *  D | 7 |          8           | 9 |
+   *    +---+----------------------+---+
+   *  When changing this objects width and/or height:
+   *     areas 1 3 7 and 9 will remain unscaled.
+   *     areas 2 and 8 will be stretched horizontally
+   *     areas 4 and 6 will be stretched vertically
+   *     area 5 will be stretched both horizontally and vertically
+   * </pre>
+   * @memberof PIXI
+   */
+  var NineSlicePlane = /** @class */ (function (_super) {
+      __extends$1(NineSlicePlane, _super);
+      /**
+       * @param texture - The texture to use on the NineSlicePlane.
+       * @param {number} [leftWidth=10] - size of the left vertical bar (A)
+       * @param {number} [topHeight=10] - size of the top horizontal bar (C)
+       * @param {number} [rightWidth=10] - size of the right vertical bar (B)
+       * @param {number} [bottomHeight=10] - size of the bottom horizontal bar (D)
+       */
+      function NineSlicePlane(texture, leftWidth, topHeight, rightWidth, bottomHeight) {
+          if (leftWidth === void 0) { leftWidth = DEFAULT_BORDER_SIZE; }
+          if (topHeight === void 0) { topHeight = DEFAULT_BORDER_SIZE; }
+          if (rightWidth === void 0) { rightWidth = DEFAULT_BORDER_SIZE; }
+          if (bottomHeight === void 0) { bottomHeight = DEFAULT_BORDER_SIZE; }
+          var _this = _super.call(this, Texture.WHITE, 4, 4) || this;
+          _this._origWidth = texture.orig.width;
+          _this._origHeight = texture.orig.height;
+          /** The width of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
+          _this._width = _this._origWidth;
+          /** The height of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
+          _this._height = _this._origHeight;
+          _this._leftWidth = leftWidth;
+          _this._rightWidth = rightWidth;
+          _this._topHeight = topHeight;
+          _this._bottomHeight = bottomHeight;
+          // lets call the setter to ensure all necessary updates are performed
+          _this.texture = texture;
+          return _this;
+      }
+      NineSlicePlane.prototype.textureUpdated = function () {
+          this._textureID = this.shader.texture._updateID;
+          this._refresh();
+      };
+      Object.defineProperty(NineSlicePlane.prototype, "vertices", {
+          get: function () {
+              return this.geometry.getBuffer('aVertexPosition').data;
+          },
+          set: function (value) {
+              this.geometry.getBuffer('aVertexPosition').data = value;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Updates the horizontal vertices. */
+      NineSlicePlane.prototype.updateHorizontalVertices = function () {
+          var vertices = this.vertices;
+          var scale = this._getMinScale();
+          vertices[9] = vertices[11] = vertices[13] = vertices[15] = this._topHeight * scale;
+          vertices[17] = vertices[19] = vertices[21] = vertices[23] = this._height - (this._bottomHeight * scale);
+          vertices[25] = vertices[27] = vertices[29] = vertices[31] = this._height;
+      };
+      /** Updates the vertical vertices. */
+      NineSlicePlane.prototype.updateVerticalVertices = function () {
+          var vertices = this.vertices;
+          var scale = this._getMinScale();
+          vertices[2] = vertices[10] = vertices[18] = vertices[26] = this._leftWidth * scale;
+          vertices[4] = vertices[12] = vertices[20] = vertices[28] = this._width - (this._rightWidth * scale);
+          vertices[6] = vertices[14] = vertices[22] = vertices[30] = this._width;
+      };
+      /**
+       * Returns the smaller of a set of vertical and horizontal scale of nine slice corners.
+       * @returns Smaller number of vertical and horizontal scale.
+       */
+      NineSlicePlane.prototype._getMinScale = function () {
+          var w = this._leftWidth + this._rightWidth;
+          var scaleW = this._width > w ? 1.0 : this._width / w;
+          var h = this._topHeight + this._bottomHeight;
+          var scaleH = this._height > h ? 1.0 : this._height / h;
+          var scale = Math.min(scaleW, scaleH);
+          return scale;
+      };
+      Object.defineProperty(NineSlicePlane.prototype, "width", {
+          /** The width of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
+          get: function () {
+              return this._width;
+          },
+          set: function (value) {
+              this._width = value;
+              this._refresh();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(NineSlicePlane.prototype, "height", {
+          /** The height of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
+          get: function () {
+              return this._height;
+          },
+          set: function (value) {
+              this._height = value;
+              this._refresh();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(NineSlicePlane.prototype, "leftWidth", {
+          /** The width of the left column. */
+          get: function () {
+              return this._leftWidth;
+          },
+          set: function (value) {
+              this._leftWidth = value;
+              this._refresh();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(NineSlicePlane.prototype, "rightWidth", {
+          /** The width of the right column. */
+          get: function () {
+              return this._rightWidth;
+          },
+          set: function (value) {
+              this._rightWidth = value;
+              this._refresh();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(NineSlicePlane.prototype, "topHeight", {
+          /** The height of the top row. */
+          get: function () {
+              return this._topHeight;
+          },
+          set: function (value) {
+              this._topHeight = value;
+              this._refresh();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(NineSlicePlane.prototype, "bottomHeight", {
+          /** The height of the bottom row. */
+          get: function () {
+              return this._bottomHeight;
+          },
+          set: function (value) {
+              this._bottomHeight = value;
+              this._refresh();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      /** Refreshes NineSlicePlane coords. All of them. */
+      NineSlicePlane.prototype._refresh = function () {
+          var texture = this.texture;
+          var uvs = this.geometry.buffers[1].data;
+          this._origWidth = texture.orig.width;
+          this._origHeight = texture.orig.height;
+          var _uvw = 1.0 / this._origWidth;
+          var _uvh = 1.0 / this._origHeight;
+          uvs[0] = uvs[8] = uvs[16] = uvs[24] = 0;
+          uvs[1] = uvs[3] = uvs[5] = uvs[7] = 0;
+          uvs[6] = uvs[14] = uvs[22] = uvs[30] = 1;
+          uvs[25] = uvs[27] = uvs[29] = uvs[31] = 1;
+          uvs[2] = uvs[10] = uvs[18] = uvs[26] = _uvw * this._leftWidth;
+          uvs[4] = uvs[12] = uvs[20] = uvs[28] = 1 - (_uvw * this._rightWidth);
+          uvs[9] = uvs[11] = uvs[13] = uvs[15] = _uvh * this._topHeight;
+          uvs[17] = uvs[19] = uvs[21] = uvs[23] = 1 - (_uvh * this._bottomHeight);
+          this.updateHorizontalVertices();
+          this.updateVerticalVertices();
+          this.geometry.buffers[0].update();
+          this.geometry.buffers[1].update();
+      };
+      return NineSlicePlane;
+  }(SimplePlane));
+
+  /*!
+   * @pixi/sprite-animated - v6.5.10
+   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
+   *
+   * @pixi/sprite-animated is licensed under the MIT License.
+   * http://www.opensource.org/licenses/mit-license
+   */
 
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
+      return extendStatics(d, b);
+  };
 
-},{"./accessibility":42,"./core":65,"./deprecation":130,"./extract":132,"./extras":141,"./filters":152,"./interaction":159,"./loaders":162,"./mesh":171,"./particles":174,"./polyfill":180,"./prepare":184}]},{},[188])(188)
-});
+  function __extends(d, b) {
+      extendStatics(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
 
+  /**
+   * An AnimatedSprite is a simple way to display an animation depicted by a list of textures.
+   *
+   * ```js
+   * let alienImages = ["image_sequence_01.png","image_sequence_02.png","image_sequence_03.png","image_sequence_04.png"];
+   * let textureArray = [];
+   *
+   * for (let i=0; i < 4; i++)
+   * {
+   *      let texture = PIXI.Texture.from(alienImages[i]);
+   *      textureArray.push(texture);
+   * };
+   *
+   * let animatedSprite = new PIXI.AnimatedSprite(textureArray);
+   * ```
+   *
+   * The more efficient and simpler way to create an animated sprite is using a {@link PIXI.Spritesheet}
+   * containing the animation definitions:
+   *
+   * ```js
+   * PIXI.Loader.shared.add("assets/spritesheet.json").load(setup);
+   *
+   * function setup() {
+   *   let sheet = PIXI.Loader.shared.resources["assets/spritesheet.json"].spritesheet;
+   *   animatedSprite = new PIXI.AnimatedSprite(sheet.animations["image_sequence"]);
+   *   ...
+   * }
+   * ```
+   * @memberof PIXI
+   */
+  var AnimatedSprite = /** @class */ (function (_super) {
+      __extends(AnimatedSprite, _super);
+      /**
+       * @param textures - An array of {@link PIXI.Texture} or frame
+       *  objects that make up the animation.
+       * @param {boolean} [autoUpdate=true] - Whether to use PIXI.Ticker.shared to auto update animation time.
+       */
+      function AnimatedSprite(textures, autoUpdate) {
+          if (autoUpdate === void 0) { autoUpdate = true; }
+          var _this = _super.call(this, textures[0] instanceof Texture ? textures[0] : textures[0].texture) || this;
+          _this._textures = null;
+          _this._durations = null;
+          _this._autoUpdate = autoUpdate;
+          _this._isConnectedToTicker = false;
+          _this.animationSpeed = 1;
+          _this.loop = true;
+          _this.updateAnchor = false;
+          _this.onComplete = null;
+          _this.onFrameChange = null;
+          _this.onLoop = null;
+          _this._currentTime = 0;
+          _this._playing = false;
+          _this._previousFrame = null;
+          _this.textures = textures;
+          return _this;
+      }
+      /** Stops the AnimatedSprite. */
+      AnimatedSprite.prototype.stop = function () {
+          if (!this._playing) {
+              return;
+          }
+          this._playing = false;
+          if (this._autoUpdate && this._isConnectedToTicker) {
+              Ticker.shared.remove(this.update, this);
+              this._isConnectedToTicker = false;
+          }
+      };
+      /** Plays the AnimatedSprite. */
+      AnimatedSprite.prototype.play = function () {
+          if (this._playing) {
+              return;
+          }
+          this._playing = true;
+          if (this._autoUpdate && !this._isConnectedToTicker) {
+              Ticker.shared.add(this.update, this, exports.UPDATE_PRIORITY.HIGH);
+              this._isConnectedToTicker = true;
+          }
+      };
+      /**
+       * Stops the AnimatedSprite and goes to a specific frame.
+       * @param frameNumber - Frame index to stop at.
+       */
+      AnimatedSprite.prototype.gotoAndStop = function (frameNumber) {
+          this.stop();
+          var previousFrame = this.currentFrame;
+          this._currentTime = frameNumber;
+          if (previousFrame !== this.currentFrame) {
+              this.updateTexture();
+          }
+      };
+      /**
+       * Goes to a specific frame and begins playing the AnimatedSprite.
+       * @param frameNumber - Frame index to start at.
+       */
+      AnimatedSprite.prototype.gotoAndPlay = function (frameNumber) {
+          var previousFrame = this.currentFrame;
+          this._currentTime = frameNumber;
+          if (previousFrame !== this.currentFrame) {
+              this.updateTexture();
+          }
+          this.play();
+      };
+      /**
+       * Updates the object transform for rendering.
+       * @param deltaTime - Time since last tick.
+       */
+      AnimatedSprite.prototype.update = function (deltaTime) {
+          if (!this._playing) {
+              return;
+          }
+          var elapsed = this.animationSpeed * deltaTime;
+          var previousFrame = this.currentFrame;
+          if (this._durations !== null) {
+              var lag = this._currentTime % 1 * this._durations[this.currentFrame];
+              lag += elapsed / 60 * 1000;
+              while (lag < 0) {
+                  this._currentTime--;
+                  lag += this._durations[this.currentFrame];
+              }
+              var sign = Math.sign(this.animationSpeed * deltaTime);
+              this._currentTime = Math.floor(this._currentTime);
+              while (lag >= this._durations[this.currentFrame]) {
+                  lag -= this._durations[this.currentFrame] * sign;
+                  this._currentTime += sign;
+              }
+              this._currentTime += lag / this._durations[this.currentFrame];
+          }
+          else {
+              this._currentTime += elapsed;
+          }
+          if (this._currentTime < 0 && !this.loop) {
+              this.gotoAndStop(0);
+              if (this.onComplete) {
+                  this.onComplete();
+              }
+          }
+          else if (this._currentTime >= this._textures.length && !this.loop) {
+              this.gotoAndStop(this._textures.length - 1);
+              if (this.onComplete) {
+                  this.onComplete();
+              }
+          }
+          else if (previousFrame !== this.currentFrame) {
+              if (this.loop && this.onLoop) {
+                  if (this.animationSpeed > 0 && this.currentFrame < previousFrame) {
+                      this.onLoop();
+                  }
+                  else if (this.animationSpeed < 0 && this.currentFrame > previousFrame) {
+                      this.onLoop();
+                  }
+              }
+              this.updateTexture();
+          }
+      };
+      /** Updates the displayed texture to match the current frame index. */
+      AnimatedSprite.prototype.updateTexture = function () {
+          var currentFrame = this.currentFrame;
+          if (this._previousFrame === currentFrame) {
+              return;
+          }
+          this._previousFrame = currentFrame;
+          this._texture = this._textures[currentFrame];
+          this._textureID = -1;
+          this._textureTrimmedID = -1;
+          this._cachedTint = 0xFFFFFF;
+          this.uvs = this._texture._uvs.uvsFloat32;
+          if (this.updateAnchor) {
+              this._anchor.copyFrom(this._texture.defaultAnchor);
+          }
+          if (this.onFrameChange) {
+              this.onFrameChange(this.currentFrame);
+          }
+      };
+      /**
+       * Stops the AnimatedSprite and destroys it.
+       * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
+       *  have been set to that value.
+       * @param {boolean} [options.children=false] - If set to true, all the children will have their destroy
+       *      method called as well. 'options' will be passed on to those calls.
+       * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well.
+       * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well.
+       */
+      AnimatedSprite.prototype.destroy = function (options) {
+          this.stop();
+          _super.prototype.destroy.call(this, options);
+          this.onComplete = null;
+          this.onFrameChange = null;
+          this.onLoop = null;
+      };
+      /**
+       * A short hand way of creating an AnimatedSprite from an array of frame ids.
+       * @param frames - The array of frames ids the AnimatedSprite will use as its texture frames.
+       * @returns - The new animated sprite with the specified frames.
+       */
+      AnimatedSprite.fromFrames = function (frames) {
+          var textures = [];
+          for (var i = 0; i < frames.length; ++i) {
+              textures.push(Texture.from(frames[i]));
+          }
+          return new AnimatedSprite(textures);
+      };
+      /**
+       * A short hand way of creating an AnimatedSprite from an array of image ids.
+       * @param images - The array of image urls the AnimatedSprite will use as its texture frames.
+       * @returns The new animate sprite with the specified images as frames.
+       */
+      AnimatedSprite.fromImages = function (images) {
+          var textures = [];
+          for (var i = 0; i < images.length; ++i) {
+              textures.push(Texture.from(images[i]));
+          }
+          return new AnimatedSprite(textures);
+      };
+      Object.defineProperty(AnimatedSprite.prototype, "totalFrames", {
+          /**
+           * The total number of frames in the AnimatedSprite. This is the same as number of textures
+           * assigned to the AnimatedSprite.
+           * @readonly
+           * @default 0
+           */
+          get: function () {
+              return this._textures.length;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(AnimatedSprite.prototype, "textures", {
+          /** The array of textures used for this AnimatedSprite. */
+          get: function () {
+              return this._textures;
+          },
+          set: function (value) {
+              if (value[0] instanceof Texture) {
+                  this._textures = value;
+                  this._durations = null;
+              }
+              else {
+                  this._textures = [];
+                  this._durations = [];
+                  for (var i = 0; i < value.length; i++) {
+                      this._textures.push(value[i].texture);
+                      this._durations.push(value[i].time);
+                  }
+              }
+              this._previousFrame = null;
+              this.gotoAndStop(0);
+              this.updateTexture();
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(AnimatedSprite.prototype, "currentFrame", {
+          /**
+           * The AnimatedSprites current frame index.
+           * @readonly
+           */
+          get: function () {
+              var currentFrame = Math.floor(this._currentTime) % this._textures.length;
+              if (currentFrame < 0) {
+                  currentFrame += this._textures.length;
+              }
+              return currentFrame;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(AnimatedSprite.prototype, "playing", {
+          /**
+           * Indicates if the AnimatedSprite is currently playing.
+           * @readonly
+           */
+          get: function () {
+              return this._playing;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(AnimatedSprite.prototype, "autoUpdate", {
+          /** Whether to use PIXI.Ticker.shared to auto update animation time. */
+          get: function () {
+              return this._autoUpdate;
+          },
+          set: function (value) {
+              if (value !== this._autoUpdate) {
+                  this._autoUpdate = value;
+                  if (!this._autoUpdate && this._isConnectedToTicker) {
+                      Ticker.shared.remove(this.update, this);
+                      this._isConnectedToTicker = false;
+                  }
+                  else if (this._autoUpdate && !this._isConnectedToTicker && this._playing) {
+                      Ticker.shared.add(this.update, this);
+                      this._isConnectedToTicker = true;
+                  }
+              }
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return AnimatedSprite;
+  }(Sprite));
+
+  extensions.add(
+  // Install renderer plugins
+  AccessibilityManager, Extract, InteractionManager, ParticleRenderer, Prepare, BatchRenderer, TilingSpriteRenderer, 
+  // Install loader plugins
+  BitmapFontLoader, CompressedTextureLoader, DDSLoader, KTXLoader, SpritesheetLoader, 
+  // Install application plugins
+  TickerPlugin, AppLoaderPlugin);
+  /**
+   * This namespace contains WebGL-only display filters that can be applied
+   * to DisplayObjects using the {@link PIXI.DisplayObject#filters filters} property.
+   *
+   * Since PixiJS only had a handful of built-in filters, additional filters
+   * can be downloaded {@link https://github.com/pixijs/pixi-filters here} from the
+   * PixiJS Filters repository.
+   *
+   * All filters must extend {@link PIXI.Filter}.
+   * @example
+   * // Create a new application
+   * const app = new PIXI.Application();
+   *
+   * // Draw a green rectangle
+   * const rect = new PIXI.Graphics()
+   *     .beginFill(0x00ff00)
+   *     .drawRect(40, 40, 200, 200);
+   *
+   * // Add a blur filter
+   * rect.filters = [new PIXI.filters.BlurFilter()];
+   *
+   * // Display rectangle
+   * app.stage.addChild(rect);
+   * document.body.appendChild(app.view);
+   * @namespace PIXI.filters
+   */
+  var filters = {
+      AlphaFilter: AlphaFilter,
+      BlurFilter: BlurFilter,
+      BlurFilterPass: BlurFilterPass,
+      ColorMatrixFilter: ColorMatrixFilter,
+      DisplacementFilter: DisplacementFilter,
+      FXAAFilter: FXAAFilter,
+      NoiseFilter: NoiseFilter,
+  };
 
+  exports.AbstractBatchRenderer = AbstractBatchRenderer;
+  exports.AbstractMultiResource = AbstractMultiResource;
+  exports.AbstractRenderer = AbstractRenderer;
+  exports.AccessibilityManager = AccessibilityManager;
+  exports.AnimatedSprite = AnimatedSprite;
+  exports.AppLoaderPlugin = AppLoaderPlugin;
+  exports.Application = Application;
+  exports.ArrayResource = ArrayResource;
+  exports.Attribute = Attribute;
+  exports.BaseImageResource = BaseImageResource;
+  exports.BasePrepare = BasePrepare;
+  exports.BaseRenderTexture = BaseRenderTexture;
+  exports.BaseTexture = BaseTexture;
+  exports.BatchDrawCall = BatchDrawCall;
+  exports.BatchGeometry = BatchGeometry;
+  exports.BatchPluginFactory = BatchPluginFactory;
+  exports.BatchRenderer = BatchRenderer;
+  exports.BatchShaderGenerator = BatchShaderGenerator;
+  exports.BatchSystem = BatchSystem;
+  exports.BatchTextureArray = BatchTextureArray;
+  exports.BitmapFont = BitmapFont;
+  exports.BitmapFontData = BitmapFontData;
+  exports.BitmapFontLoader = BitmapFontLoader;
+  exports.BitmapText = BitmapText;
+  exports.BlobResource = BlobResource;
+  exports.Bounds = Bounds;
+  exports.BrowserAdapter = BrowserAdapter;
+  exports.Buffer = Buffer;
+  exports.BufferResource = BufferResource;
+  exports.CanvasResource = CanvasResource;
+  exports.Circle = Circle;
+  exports.CompressedTextureLoader = CompressedTextureLoader;
+  exports.CompressedTextureResource = CompressedTextureResource;
+  exports.Container = Container;
+  exports.ContextSystem = ContextSystem;
+  exports.CountLimiter = CountLimiter;
+  exports.CubeResource = CubeResource;
+  exports.DDSLoader = DDSLoader;
+  exports.DEG_TO_RAD = DEG_TO_RAD;
+  exports.DisplayObject = DisplayObject;
+  exports.Ellipse = Ellipse;
+  exports.Extract = Extract;
+  exports.FORMATS_TO_COMPONENTS = FORMATS_TO_COMPONENTS;
+  exports.FillStyle = FillStyle;
+  exports.Filter = Filter;
+  exports.FilterState = FilterState;
+  exports.FilterSystem = FilterSystem;
+  exports.Framebuffer = Framebuffer;
+  exports.FramebufferSystem = FramebufferSystem;
+  exports.GLFramebuffer = GLFramebuffer;
+  exports.GLProgram = GLProgram;
+  exports.GLTexture = GLTexture;
+  exports.GRAPHICS_CURVES = GRAPHICS_CURVES;
+  exports.Geometry = Geometry;
+  exports.GeometrySystem = GeometrySystem;
+  exports.Graphics = Graphics;
+  exports.GraphicsData = GraphicsData;
+  exports.GraphicsGeometry = GraphicsGeometry;
+  exports.IGLUniformData = IGLUniformData;
+  exports.INSTALLED = INSTALLED;
+  exports.INTERNAL_FORMAT_TO_BYTES_PER_PIXEL = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL;
+  exports.ImageBitmapResource = ImageBitmapResource;
+  exports.ImageResource = ImageResource;
+  exports.InteractionData = InteractionData;
+  exports.InteractionEvent = InteractionEvent;
+  exports.InteractionManager = InteractionManager;
+  exports.InteractionTrackingData = InteractionTrackingData;
+  exports.KTXLoader = KTXLoader;
+  exports.LineStyle = LineStyle;
+  exports.Loader = Loader;
+  exports.MaskData = MaskData;
+  exports.MaskSystem = MaskSystem;
+  exports.Matrix = Matrix;
+  exports.Mesh = Mesh;
+  exports.MeshBatchUvs = MeshBatchUvs;
+  exports.MeshGeometry = MeshGeometry;
+  exports.MeshMaterial = MeshMaterial;
+  exports.NineSlicePlane = NineSlicePlane;
+  exports.ObjectRenderer = ObjectRenderer;
+  exports.ObservablePoint = ObservablePoint;
+  exports.PI_2 = PI_2;
+  exports.ParticleContainer = ParticleContainer;
+  exports.ParticleRenderer = ParticleRenderer;
+  exports.PlaneGeometry = PlaneGeometry;
+  exports.Point = Point;
+  exports.Polygon = Polygon;
+  exports.Prepare = Prepare;
+  exports.Program = Program;
+  exports.ProjectionSystem = ProjectionSystem;
+  exports.Quad = Quad;
+  exports.QuadUv = QuadUv;
+  exports.RAD_TO_DEG = RAD_TO_DEG;
+  exports.Rectangle = Rectangle;
+  exports.RenderTexture = RenderTexture;
+  exports.RenderTexturePool = RenderTexturePool;
+  exports.RenderTextureSystem = RenderTextureSystem;
+  exports.Renderer = Renderer;
+  exports.ResizePlugin = ResizePlugin;
+  exports.Resource = Resource;
+  exports.RopeGeometry = RopeGeometry;
+  exports.RoundedRectangle = RoundedRectangle;
+  exports.Runner = Runner;
+  exports.SVGResource = SVGResource;
+  exports.ScissorSystem = ScissorSystem;
+  exports.Shader = Shader;
+  exports.ShaderSystem = ShaderSystem;
+  exports.SimpleMesh = SimpleMesh;
+  exports.SimplePlane = SimplePlane;
+  exports.SimpleRope = SimpleRope;
+  exports.Sprite = Sprite;
+  exports.SpriteMaskFilter = SpriteMaskFilter;
+  exports.Spritesheet = Spritesheet;
+  exports.SpritesheetLoader = SpritesheetLoader;
+  exports.State = State;
+  exports.StateSystem = StateSystem;
+  exports.StencilSystem = StencilSystem;
+  exports.System = System;
+  exports.TYPES_TO_BYTES_PER_COMPONENT = TYPES_TO_BYTES_PER_COMPONENT;
+  exports.TYPES_TO_BYTES_PER_PIXEL = TYPES_TO_BYTES_PER_PIXEL;
+  exports.TemporaryDisplayObject = TemporaryDisplayObject;
+  exports.Text = Text;
+  exports.TextFormat = TextFormat;
+  exports.TextMetrics = TextMetrics;
+  exports.TextStyle = TextStyle;
+  exports.Texture = Texture;
+  exports.TextureGCSystem = TextureGCSystem;
+  exports.TextureLoader = TextureLoader;
+  exports.TextureMatrix = TextureMatrix;
+  exports.TextureSystem = TextureSystem;
+  exports.TextureUvs = TextureUvs;
+  exports.Ticker = Ticker;
+  exports.TickerPlugin = TickerPlugin;
+  exports.TilingSprite = TilingSprite;
+  exports.TilingSpriteRenderer = TilingSpriteRenderer;
+  exports.TimeLimiter = TimeLimiter;
+  exports.Transform = Transform;
+  exports.UniformGroup = UniformGroup;
+  exports.VERSION = VERSION;
+  exports.VideoResource = VideoResource;
+  exports.ViewableBuffer = ViewableBuffer;
+  exports.XMLFormat = XMLFormat;
+  exports.XMLStringFormat = XMLStringFormat;
+  exports.accessibleTarget = accessibleTarget;
+  exports.autoDetectFormat = autoDetectFormat;
+  exports.autoDetectRenderer = autoDetectRenderer;
+  exports.autoDetectResource = autoDetectResource;
+  exports.checkMaxIfStatementsInShader = checkMaxIfStatementsInShader;
+  exports.createUBOElements = createUBOElements;
+  exports.defaultFilterVertex = defaultFilterVertex;
+  exports.defaultVertex = defaultVertex$1;
+  exports.extensions = extensions;
+  exports.filters = filters;
+  exports.generateProgram = generateProgram;
+  exports.generateUniformBufferSync = generateUniformBufferSync;
+  exports.getTestContext = getTestContext;
+  exports.getUBOData = getUBOData;
+  exports.graphicsUtils = graphicsUtils;
+  exports.groupD8 = groupD8;
+  exports.interactiveTarget = interactiveTarget;
+  exports.isMobile = isMobile;
+  exports.parseDDS = parseDDS;
+  exports.parseKTX = parseKTX;
+  exports.resources = resources;
+  exports.settings = settings;
+  exports.systems = systems;
+  exports.uniformParsers = uniformParsers;
+  exports.utils = utils;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+  return exports;
+
+})({});
 //# sourceMappingURL=pixi.js.map

From 5a3733ce85c61f28b4e78066d45383ab5a788ce1 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 23 Aug 2023 13:58:26 -0500
Subject: [PATCH 062/188] Scope: pixi fixed initialisation for v6 (this is
 still backwards compatible)

---
 IDE/frontend-dev/scope-src/scope-browser.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index b2fda3978..59ba4d6f8 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -21,7 +21,11 @@ var Model = require('./Model');
 var settings = new Model();
 
 // Pixi.js renderer and stage
-var renderer = PIXI.autoDetectRenderer(window.innerWidth, window.innerHeight, {transparent: true});
+var renderer = PIXI.autoDetectRenderer({
+  width: window.innerWidth,
+  heigh: window.innerHeight,
+  transparent: true,
+});
 renderer.view.style.position = "absolute";
 renderer.view.style.display = "block";
 renderer.autoResize = true;

From 7aca8a5913a6e3f37489912ec057a66c89027bd1 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 23 Aug 2023 14:08:05 -0500
Subject: [PATCH 063/188] frontend-dev: do not exit on scope-browserify error.
 Also re-enable livereload

---
 IDE/frontend-dev/gulpfile.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/IDE/frontend-dev/gulpfile.js b/IDE/frontend-dev/gulpfile.js
index 090103833..cf071fe81 100644
--- a/IDE/frontend-dev/gulpfile.js
+++ b/IDE/frontend-dev/gulpfile.js
@@ -132,7 +132,6 @@ gulp.task('scope-browserify', () => {
         .on('error', function(error){
     		console.error(error);
     		this.emit('end');
-			exit(1);
     	})
         .pipe(source('bundle.js'))
         .pipe(buffer())
@@ -150,7 +149,7 @@ gulp.task('sass', () => {
 });
 
 gulp.task('watch-local', () => {
-	//livereload.listen();
+	livereload.listen();
 	// when the browser js changes, browserify it
 	gulp.watch(['./src/**'], ['browserify']);
 	// when the scope browser js changes, browserify it

From 4face1c3ebdcb49b993d6ec8c9a8ff3fa0bae4a0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 23 Aug 2023 14:08:40 -0500
Subject: [PATCH 064/188] Scope: antialias

---
 IDE/frontend-dev/scope-src/scope-browser.js | 3 +++
 IDE/public/scope/js/bundle.js               | 9 ++++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 59ba4d6f8..4ee8aa067 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -25,6 +25,9 @@ var renderer = PIXI.autoDetectRenderer({
   width: window.innerWidth,
   heigh: window.innerHeight,
   transparent: true,
+  antialias: true,
+  autoDensity: true, // somehow makes CSS compensate for increased resolution. Not sure it's needed for us
+  //resolution: 2, // sort of oversampling for antialias
 });
 renderer.view.style.position = "absolute";
 renderer.view.style.display = "block";
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 4bd9b9f91..8e14fbf76 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1391,7 +1391,14 @@ var Model = require('./Model');
 var settings = new Model();
 
 // Pixi.js renderer and stage
-var renderer = PIXI.autoDetectRenderer(window.innerWidth, window.innerHeight, { transparent: true });
+var renderer = PIXI.autoDetectRenderer({
+  width: window.innerWidth,
+  heigh: window.innerHeight,
+  transparent: true,
+  antialias: true,
+  autoDensity: true // somehow makes CSS compensate for increased resolution. Not sure it's needed for us
+  //resolution: 2, // sort of oversampling for antialias
+});
 renderer.view.style.position = "absolute";
 renderer.view.style.display = "block";
 renderer.autoResize = true;

From e7e929cec63ad1358e27f63c3964b18bce528c30 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 23 Aug 2023 14:09:01 -0500
Subject: [PATCH 065/188] Scope: added (disabled) load test that doesn't
 require a Bela program to be running

---
 IDE/public/scope/js/scope-worker.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index 6d36b06c7..ce15bc7de 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -157,3 +157,26 @@ var ws_onmessage = function(ws, e){
 	}, [outArray.buffer]);
 
 };
+
+// load test
+/*
+let testArray = new Float32Array(0);
+let testPtr = 0;
+setInterval(() => {
+	if(testArray.length != outArrayWidth) {
+		testArray = new Float32Array(outArrayWidth);
+		for(let n = 0; n < outFrameWidth ; ++n) {
+			for(let c = 0; c < numChannels ; ++c) {
+				testArray[c * outFrameWidth + n] = (n + testPtr) / outFrameWidth* 150 + c * 150;
+			}
+		}
+		testPtr += 10;
+		if(testPtr >= outFrameWidth)
+			testPtr = 0;
+	}
+	postMessage({
+		outArray: testArray,
+		oldDataSeparator: -1,
+	}, [testArray.buffer]);
+}, 20);
+//*/

From 469957c22e5e93c16950bbee09aecf153daa3c4b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 11:18:03 -0500
Subject: [PATCH 066/188] Scope: allow to disable individual websockets with
 controlDisabled= and dataDisabled=

---
 IDE/frontend-dev/scope-src/scope-browser.js | 22 ++++++++++++---------
 IDE/public/scope/js/bundle.js               | 22 ++++++++++++---------
 2 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 4ee8aa067..50aa19355 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -4,12 +4,13 @@
 let remoteHost = location.hostname + ":5432";
 let qs = new URLSearchParams(location.search);
 let qsRemoteHost = qs.get("remoteHost");
-let qsControlOnly = qs.get("controlOnly");
+let controlDisabled = qs.get("controlDisabled");
+let dataDisabled = qs.get("dataDisabled");
 if(qsRemoteHost)
   remoteHost = qsRemoteHost
 var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
-if(!qsControlOnly) {
+if(!dataDisabled) {
   worker.postMessage({
     event: 'wsConnect',
     remote: wsRemote,
@@ -87,7 +88,7 @@ var ws_onmessage = function(msg){
       console.log('could not stringify settings:', e);
       return;
     }
-    if (ws.readyState === 1) ws.send(out);
+    if (ws && ws.readyState === 1) ws.send(out);
   } else if (data.event == 'set-slider'){
     sliderView.emit('set-slider', data);
   } else if (data.event == 'set-setting'){
@@ -102,10 +103,13 @@ function setWsCbs(ws) {
   ws.onmessage = ws_onmessage;
 }
 
-// scope websocket
 let wsUrl = wsRemote + "scope_control";
-var ws = new WebSocket(wsUrl);
-setWsCbs(ws);
+// scope websocket
+let ws;
+if(!controlDisabled) {
+  ws = new WebSocket(wsUrl);
+  setWsCbs(ws);
+}
 
 var paused = false, oneShot = false;
 
@@ -141,7 +145,7 @@ controlView.on('settings-event', (key, value) => {
     console.log('error creating settings JSON', e);
     return;
   }
-  if (ws.readyState === 1) ws.send(out);
+  if (ws && ws.readyState === 1) ws.send(out);
   settings.setKey(key, value);
 });
 
@@ -196,7 +200,7 @@ sliderView.on('slider-value', (slider, value) => {
     console.log('could not stringify slider json:', e);
     return;
   }
-  if (ws.readyState === 1) ws.send(out)
+  if (ws && ws.readyState === 1) ws.send(out)
 });
 
 belaSocket.on('cpu-usage', CPU);
@@ -214,7 +218,7 @@ settings.on('set', (data, changedKeys) => {
       console.log('unable to stringify framewidth', e);
       return;
     }
-    if (ws.readyState === 1) ws.send(out);
+    if (ws && ws.readyState === 1) ws.send(out);
   } else {
     worker.postMessage({
       event   : 'settings',
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 8e14fbf76..48c78aa2b 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1375,11 +1375,12 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 var remoteHost = location.hostname + ":5432";
 var qs = new URLSearchParams(location.search);
 var qsRemoteHost = qs.get("remoteHost");
-var qsControlOnly = qs.get("controlOnly");
+var controlDisabled = qs.get("controlDisabled");
+var dataDisabled = qs.get("dataDisabled");
 if (qsRemoteHost) remoteHost = qsRemoteHost;
 var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
-if (!qsControlOnly) {
+if (!dataDisabled) {
   worker.postMessage({
     event: 'wsConnect',
     remote: wsRemote
@@ -1454,7 +1455,7 @@ var ws_onmessage = function ws_onmessage(msg) {
       console.log('could not stringify settings:', e);
       return;
     }
-    if (ws.readyState === 1) ws.send(out);
+    if (ws && ws.readyState === 1) ws.send(out);
   } else if (data.event == 'set-slider') {
     sliderView.emit('set-slider', data);
   } else if (data.event == 'set-setting') {
@@ -1469,10 +1470,13 @@ function setWsCbs(ws) {
   ws.onmessage = ws_onmessage;
 }
 
-// scope websocket
 var wsUrl = wsRemote + "scope_control";
-var ws = new WebSocket(wsUrl);
-setWsCbs(ws);
+// scope websocket
+var ws = void 0;
+if (!controlDisabled) {
+  ws = new WebSocket(wsUrl);
+  setWsCbs(ws);
+}
 
 var paused = false,
     oneShot = false;
@@ -1508,7 +1512,7 @@ controlView.on('settings-event', function (key, value) {
     console.log('error creating settings JSON', e);
     return;
   }
-  if (ws.readyState === 1) ws.send(out);
+  if (ws && ws.readyState === 1) ws.send(out);
   settings.setKey(key, value);
 });
 
@@ -1561,7 +1565,7 @@ sliderView.on('slider-value', function (slider, value) {
     console.log('could not stringify slider json:', e);
     return;
   }
-  if (ws.readyState === 1) ws.send(out);
+  if (ws && ws.readyState === 1) ws.send(out);
 });
 
 belaSocket.on('cpu-usage', CPU);
@@ -1578,7 +1582,7 @@ settings.on('set', function (data, changedKeys) {
       console.log('unable to stringify framewidth', e);
       return;
     }
-    if (ws.readyState === 1) ws.send(out);
+    if (ws && ws.readyState === 1) ws.send(out);
   } else {
     worker.postMessage({
       event: 'settings',

From a045e6c12d05d53a8ff1d4e137839a833bea9575 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 14:07:50 -0500
Subject: [PATCH 067/188] Scope: pixi-legacy v7.2.4

---
 IDE/frontend-dev/scope-src/scope-browser.js |     2 +-
 IDE/public/scope/js/bundle.js               |     2 +-
 IDE/public/scope/js/pixi-legacy.js          | 27334 ++++++++++++
 IDE/public/scope/js/pixi.js                 | 38831 ------------------
 4 files changed, 27336 insertions(+), 38833 deletions(-)
 create mode 100644 IDE/public/scope/js/pixi-legacy.js
 delete mode 100644 IDE/public/scope/js/pixi.js

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 50aa19355..0a45973eb 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -25,7 +25,7 @@ var settings = new Model();
 var renderer = PIXI.autoDetectRenderer({
   width: window.innerWidth,
   heigh: window.innerHeight,
-  transparent: true,
+  backgroundAlpha: 0,
   antialias: true,
   autoDensity: true, // somehow makes CSS compensate for increased resolution. Not sure it's needed for us
   //resolution: 2, // sort of oversampling for antialias
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 48c78aa2b..fe6397e30 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1395,7 +1395,7 @@ var settings = new Model();
 var renderer = PIXI.autoDetectRenderer({
   width: window.innerWidth,
   heigh: window.innerHeight,
-  transparent: true,
+  backgroundAlpha: 0,
   antialias: true,
   autoDensity: true // somehow makes CSS compensate for increased resolution. Not sure it's needed for us
   //resolution: 2, // sort of oversampling for antialias
diff --git a/IDE/public/scope/js/pixi-legacy.js b/IDE/public/scope/js/pixi-legacy.js
new file mode 100644
index 000000000..01566f9bd
--- /dev/null
+++ b/IDE/public/scope/js/pixi-legacy.js
@@ -0,0 +1,27334 @@
+/*!
+ * pixi.js-legacy - v7.2.4
+ * Compiled Thu, 06 Apr 2023 19:36:45 UTC
+ *
+ * pixi.js-legacy is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ */
+var PIXI = (function (exports) {
+  'use strict';
+
+  var ENV = /* @__PURE__ */ ((ENV2) => {
+    ENV2[ENV2["WEBGL_LEGACY"] = 0] = "WEBGL_LEGACY";
+    ENV2[ENV2["WEBGL"] = 1] = "WEBGL";
+    ENV2[ENV2["WEBGL2"] = 2] = "WEBGL2";
+    return ENV2;
+  })(ENV || {});
+  var RENDERER_TYPE = /* @__PURE__ */ ((RENDERER_TYPE2) => {
+    RENDERER_TYPE2[RENDERER_TYPE2["UNKNOWN"] = 0] = "UNKNOWN";
+    RENDERER_TYPE2[RENDERER_TYPE2["WEBGL"] = 1] = "WEBGL";
+    RENDERER_TYPE2[RENDERER_TYPE2["CANVAS"] = 2] = "CANVAS";
+    return RENDERER_TYPE2;
+  })(RENDERER_TYPE || {});
+  var BUFFER_BITS = /* @__PURE__ */ ((BUFFER_BITS2) => {
+    BUFFER_BITS2[BUFFER_BITS2["COLOR"] = 16384] = "COLOR";
+    BUFFER_BITS2[BUFFER_BITS2["DEPTH"] = 256] = "DEPTH";
+    BUFFER_BITS2[BUFFER_BITS2["STENCIL"] = 1024] = "STENCIL";
+    return BUFFER_BITS2;
+  })(BUFFER_BITS || {});
+  var BLEND_MODES = /* @__PURE__ */ ((BLEND_MODES2) => {
+    BLEND_MODES2[BLEND_MODES2["NORMAL"] = 0] = "NORMAL";
+    BLEND_MODES2[BLEND_MODES2["ADD"] = 1] = "ADD";
+    BLEND_MODES2[BLEND_MODES2["MULTIPLY"] = 2] = "MULTIPLY";
+    BLEND_MODES2[BLEND_MODES2["SCREEN"] = 3] = "SCREEN";
+    BLEND_MODES2[BLEND_MODES2["OVERLAY"] = 4] = "OVERLAY";
+    BLEND_MODES2[BLEND_MODES2["DARKEN"] = 5] = "DARKEN";
+    BLEND_MODES2[BLEND_MODES2["LIGHTEN"] = 6] = "LIGHTEN";
+    BLEND_MODES2[BLEND_MODES2["COLOR_DODGE"] = 7] = "COLOR_DODGE";
+    BLEND_MODES2[BLEND_MODES2["COLOR_BURN"] = 8] = "COLOR_BURN";
+    BLEND_MODES2[BLEND_MODES2["HARD_LIGHT"] = 9] = "HARD_LIGHT";
+    BLEND_MODES2[BLEND_MODES2["SOFT_LIGHT"] = 10] = "SOFT_LIGHT";
+    BLEND_MODES2[BLEND_MODES2["DIFFERENCE"] = 11] = "DIFFERENCE";
+    BLEND_MODES2[BLEND_MODES2["EXCLUSION"] = 12] = "EXCLUSION";
+    BLEND_MODES2[BLEND_MODES2["HUE"] = 13] = "HUE";
+    BLEND_MODES2[BLEND_MODES2["SATURATION"] = 14] = "SATURATION";
+    BLEND_MODES2[BLEND_MODES2["COLOR"] = 15] = "COLOR";
+    BLEND_MODES2[BLEND_MODES2["LUMINOSITY"] = 16] = "LUMINOSITY";
+    BLEND_MODES2[BLEND_MODES2["NORMAL_NPM"] = 17] = "NORMAL_NPM";
+    BLEND_MODES2[BLEND_MODES2["ADD_NPM"] = 18] = "ADD_NPM";
+    BLEND_MODES2[BLEND_MODES2["SCREEN_NPM"] = 19] = "SCREEN_NPM";
+    BLEND_MODES2[BLEND_MODES2["NONE"] = 20] = "NONE";
+    BLEND_MODES2[BLEND_MODES2["SRC_OVER"] = 0] = "SRC_OVER";
+    BLEND_MODES2[BLEND_MODES2["SRC_IN"] = 21] = "SRC_IN";
+    BLEND_MODES2[BLEND_MODES2["SRC_OUT"] = 22] = "SRC_OUT";
+    BLEND_MODES2[BLEND_MODES2["SRC_ATOP"] = 23] = "SRC_ATOP";
+    BLEND_MODES2[BLEND_MODES2["DST_OVER"] = 24] = "DST_OVER";
+    BLEND_MODES2[BLEND_MODES2["DST_IN"] = 25] = "DST_IN";
+    BLEND_MODES2[BLEND_MODES2["DST_OUT"] = 26] = "DST_OUT";
+    BLEND_MODES2[BLEND_MODES2["DST_ATOP"] = 27] = "DST_ATOP";
+    BLEND_MODES2[BLEND_MODES2["ERASE"] = 26] = "ERASE";
+    BLEND_MODES2[BLEND_MODES2["SUBTRACT"] = 28] = "SUBTRACT";
+    BLEND_MODES2[BLEND_MODES2["XOR"] = 29] = "XOR";
+    return BLEND_MODES2;
+  })(BLEND_MODES || {});
+  var DRAW_MODES = /* @__PURE__ */ ((DRAW_MODES2) => {
+    DRAW_MODES2[DRAW_MODES2["POINTS"] = 0] = "POINTS";
+    DRAW_MODES2[DRAW_MODES2["LINES"] = 1] = "LINES";
+    DRAW_MODES2[DRAW_MODES2["LINE_LOOP"] = 2] = "LINE_LOOP";
+    DRAW_MODES2[DRAW_MODES2["LINE_STRIP"] = 3] = "LINE_STRIP";
+    DRAW_MODES2[DRAW_MODES2["TRIANGLES"] = 4] = "TRIANGLES";
+    DRAW_MODES2[DRAW_MODES2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+    DRAW_MODES2[DRAW_MODES2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+    return DRAW_MODES2;
+  })(DRAW_MODES || {});
+  var FORMATS = /* @__PURE__ */ ((FORMATS2) => {
+    FORMATS2[FORMATS2["RGBA"] = 6408] = "RGBA";
+    FORMATS2[FORMATS2["RGB"] = 6407] = "RGB";
+    FORMATS2[FORMATS2["RG"] = 33319] = "RG";
+    FORMATS2[FORMATS2["RED"] = 6403] = "RED";
+    FORMATS2[FORMATS2["RGBA_INTEGER"] = 36249] = "RGBA_INTEGER";
+    FORMATS2[FORMATS2["RGB_INTEGER"] = 36248] = "RGB_INTEGER";
+    FORMATS2[FORMATS2["RG_INTEGER"] = 33320] = "RG_INTEGER";
+    FORMATS2[FORMATS2["RED_INTEGER"] = 36244] = "RED_INTEGER";
+    FORMATS2[FORMATS2["ALPHA"] = 6406] = "ALPHA";
+    FORMATS2[FORMATS2["LUMINANCE"] = 6409] = "LUMINANCE";
+    FORMATS2[FORMATS2["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
+    FORMATS2[FORMATS2["DEPTH_COMPONENT"] = 6402] = "DEPTH_COMPONENT";
+    FORMATS2[FORMATS2["DEPTH_STENCIL"] = 34041] = "DEPTH_STENCIL";
+    return FORMATS2;
+  })(FORMATS || {});
+  var TARGETS = /* @__PURE__ */ ((TARGETS2) => {
+    TARGETS2[TARGETS2["TEXTURE_2D"] = 3553] = "TEXTURE_2D";
+    TARGETS2[TARGETS2["TEXTURE_CUBE_MAP"] = 34067] = "TEXTURE_CUBE_MAP";
+    TARGETS2[TARGETS2["TEXTURE_2D_ARRAY"] = 35866] = "TEXTURE_2D_ARRAY";
+    TARGETS2[TARGETS2["TEXTURE_CUBE_MAP_POSITIVE_X"] = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X";
+    TARGETS2[TARGETS2["TEXTURE_CUBE_MAP_NEGATIVE_X"] = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X";
+    TARGETS2[TARGETS2["TEXTURE_CUBE_MAP_POSITIVE_Y"] = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y";
+    TARGETS2[TARGETS2["TEXTURE_CUBE_MAP_NEGATIVE_Y"] = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y";
+    TARGETS2[TARGETS2["TEXTURE_CUBE_MAP_POSITIVE_Z"] = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z";
+    TARGETS2[TARGETS2["TEXTURE_CUBE_MAP_NEGATIVE_Z"] = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z";
+    return TARGETS2;
+  })(TARGETS || {});
+  var TYPES = /* @__PURE__ */ ((TYPES2) => {
+    TYPES2[TYPES2["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
+    TYPES2[TYPES2["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
+    TYPES2[TYPES2["UNSIGNED_SHORT_5_6_5"] = 33635] = "UNSIGNED_SHORT_5_6_5";
+    TYPES2[TYPES2["UNSIGNED_SHORT_4_4_4_4"] = 32819] = "UNSIGNED_SHORT_4_4_4_4";
+    TYPES2[TYPES2["UNSIGNED_SHORT_5_5_5_1"] = 32820] = "UNSIGNED_SHORT_5_5_5_1";
+    TYPES2[TYPES2["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
+    TYPES2[TYPES2["UNSIGNED_INT_10F_11F_11F_REV"] = 35899] = "UNSIGNED_INT_10F_11F_11F_REV";
+    TYPES2[TYPES2["UNSIGNED_INT_2_10_10_10_REV"] = 33640] = "UNSIGNED_INT_2_10_10_10_REV";
+    TYPES2[TYPES2["UNSIGNED_INT_24_8"] = 34042] = "UNSIGNED_INT_24_8";
+    TYPES2[TYPES2["UNSIGNED_INT_5_9_9_9_REV"] = 35902] = "UNSIGNED_INT_5_9_9_9_REV";
+    TYPES2[TYPES2["BYTE"] = 5120] = "BYTE";
+    TYPES2[TYPES2["SHORT"] = 5122] = "SHORT";
+    TYPES2[TYPES2["INT"] = 5124] = "INT";
+    TYPES2[TYPES2["FLOAT"] = 5126] = "FLOAT";
+    TYPES2[TYPES2["FLOAT_32_UNSIGNED_INT_24_8_REV"] = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV";
+    TYPES2[TYPES2["HALF_FLOAT"] = 36193] = "HALF_FLOAT";
+    return TYPES2;
+  })(TYPES || {});
+  var SAMPLER_TYPES = /* @__PURE__ */ ((SAMPLER_TYPES2) => {
+    SAMPLER_TYPES2[SAMPLER_TYPES2["FLOAT"] = 0] = "FLOAT";
+    SAMPLER_TYPES2[SAMPLER_TYPES2["INT"] = 1] = "INT";
+    SAMPLER_TYPES2[SAMPLER_TYPES2["UINT"] = 2] = "UINT";
+    return SAMPLER_TYPES2;
+  })(SAMPLER_TYPES || {});
+  var SCALE_MODES = /* @__PURE__ */ ((SCALE_MODES2) => {
+    SCALE_MODES2[SCALE_MODES2["NEAREST"] = 0] = "NEAREST";
+    SCALE_MODES2[SCALE_MODES2["LINEAR"] = 1] = "LINEAR";
+    return SCALE_MODES2;
+  })(SCALE_MODES || {});
+  var WRAP_MODES = /* @__PURE__ */ ((WRAP_MODES2) => {
+    WRAP_MODES2[WRAP_MODES2["CLAMP"] = 33071] = "CLAMP";
+    WRAP_MODES2[WRAP_MODES2["REPEAT"] = 10497] = "REPEAT";
+    WRAP_MODES2[WRAP_MODES2["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+    return WRAP_MODES2;
+  })(WRAP_MODES || {});
+  var MIPMAP_MODES = /* @__PURE__ */ ((MIPMAP_MODES2) => {
+    MIPMAP_MODES2[MIPMAP_MODES2["OFF"] = 0] = "OFF";
+    MIPMAP_MODES2[MIPMAP_MODES2["POW2"] = 1] = "POW2";
+    MIPMAP_MODES2[MIPMAP_MODES2["ON"] = 2] = "ON";
+    MIPMAP_MODES2[MIPMAP_MODES2["ON_MANUAL"] = 3] = "ON_MANUAL";
+    return MIPMAP_MODES2;
+  })(MIPMAP_MODES || {});
+  var ALPHA_MODES = /* @__PURE__ */ ((ALPHA_MODES2) => {
+    ALPHA_MODES2[ALPHA_MODES2["NPM"] = 0] = "NPM";
+    ALPHA_MODES2[ALPHA_MODES2["UNPACK"] = 1] = "UNPACK";
+    ALPHA_MODES2[ALPHA_MODES2["PMA"] = 2] = "PMA";
+    ALPHA_MODES2[ALPHA_MODES2["NO_PREMULTIPLIED_ALPHA"] = 0] = "NO_PREMULTIPLIED_ALPHA";
+    ALPHA_MODES2[ALPHA_MODES2["PREMULTIPLY_ON_UPLOAD"] = 1] = "PREMULTIPLY_ON_UPLOAD";
+    ALPHA_MODES2[ALPHA_MODES2["PREMULTIPLIED_ALPHA"] = 2] = "PREMULTIPLIED_ALPHA";
+    return ALPHA_MODES2;
+  })(ALPHA_MODES || {});
+  var CLEAR_MODES = /* @__PURE__ */ ((CLEAR_MODES2) => {
+    CLEAR_MODES2[CLEAR_MODES2["NO"] = 0] = "NO";
+    CLEAR_MODES2[CLEAR_MODES2["YES"] = 1] = "YES";
+    CLEAR_MODES2[CLEAR_MODES2["AUTO"] = 2] = "AUTO";
+    CLEAR_MODES2[CLEAR_MODES2["BLEND"] = 0] = "BLEND";
+    CLEAR_MODES2[CLEAR_MODES2["CLEAR"] = 1] = "CLEAR";
+    CLEAR_MODES2[CLEAR_MODES2["BLIT"] = 2] = "BLIT";
+    return CLEAR_MODES2;
+  })(CLEAR_MODES || {});
+  var GC_MODES = /* @__PURE__ */ ((GC_MODES2) => {
+    GC_MODES2[GC_MODES2["AUTO"] = 0] = "AUTO";
+    GC_MODES2[GC_MODES2["MANUAL"] = 1] = "MANUAL";
+    return GC_MODES2;
+  })(GC_MODES || {});
+  var PRECISION = /* @__PURE__ */ ((PRECISION2) => {
+    PRECISION2["LOW"] = "lowp";
+    PRECISION2["MEDIUM"] = "mediump";
+    PRECISION2["HIGH"] = "highp";
+    return PRECISION2;
+  })(PRECISION || {});
+  var MASK_TYPES = /* @__PURE__ */ ((MASK_TYPES2) => {
+    MASK_TYPES2[MASK_TYPES2["NONE"] = 0] = "NONE";
+    MASK_TYPES2[MASK_TYPES2["SCISSOR"] = 1] = "SCISSOR";
+    MASK_TYPES2[MASK_TYPES2["STENCIL"] = 2] = "STENCIL";
+    MASK_TYPES2[MASK_TYPES2["SPRITE"] = 3] = "SPRITE";
+    MASK_TYPES2[MASK_TYPES2["COLOR"] = 4] = "COLOR";
+    return MASK_TYPES2;
+  })(MASK_TYPES || {});
+  var COLOR_MASK_BITS = /* @__PURE__ */ ((COLOR_MASK_BITS2) => {
+    COLOR_MASK_BITS2[COLOR_MASK_BITS2["RED"] = 1] = "RED";
+    COLOR_MASK_BITS2[COLOR_MASK_BITS2["GREEN"] = 2] = "GREEN";
+    COLOR_MASK_BITS2[COLOR_MASK_BITS2["BLUE"] = 4] = "BLUE";
+    COLOR_MASK_BITS2[COLOR_MASK_BITS2["ALPHA"] = 8] = "ALPHA";
+    return COLOR_MASK_BITS2;
+  })(COLOR_MASK_BITS || {});
+  var MSAA_QUALITY = /* @__PURE__ */ ((MSAA_QUALITY2) => {
+    MSAA_QUALITY2[MSAA_QUALITY2["NONE"] = 0] = "NONE";
+    MSAA_QUALITY2[MSAA_QUALITY2["LOW"] = 2] = "LOW";
+    MSAA_QUALITY2[MSAA_QUALITY2["MEDIUM"] = 4] = "MEDIUM";
+    MSAA_QUALITY2[MSAA_QUALITY2["HIGH"] = 8] = "HIGH";
+    return MSAA_QUALITY2;
+  })(MSAA_QUALITY || {});
+  var BUFFER_TYPE = /* @__PURE__ */ ((BUFFER_TYPE2) => {
+    BUFFER_TYPE2[BUFFER_TYPE2["ELEMENT_ARRAY_BUFFER"] = 34963] = "ELEMENT_ARRAY_BUFFER";
+    BUFFER_TYPE2[BUFFER_TYPE2["ARRAY_BUFFER"] = 34962] = "ARRAY_BUFFER";
+    BUFFER_TYPE2[BUFFER_TYPE2["UNIFORM_BUFFER"] = 35345] = "UNIFORM_BUFFER";
+    return BUFFER_TYPE2;
+  })(BUFFER_TYPE || {});
+
+  const BrowserAdapter = {
+    createCanvas: (width, height) => {
+      const canvas = document.createElement("canvas");
+      canvas.width = width;
+      canvas.height = height;
+      return canvas;
+    },
+    getCanvasRenderingContext2D: () => CanvasRenderingContext2D,
+    getWebGLRenderingContext: () => WebGLRenderingContext,
+    getNavigator: () => navigator,
+    getBaseUrl: () => document.baseURI ?? window.location.href,
+    getFontFaceSet: () => document.fonts,
+    fetch: (url, options) => fetch(url, options),
+    parseXML: (xml) => {
+      const parser = new DOMParser();
+      return parser.parseFromString(xml, "text/xml");
+    }
+  };
+
+  const settings = {
+    ADAPTER: BrowserAdapter,
+    RESOLUTION: 1,
+    CREATE_IMAGE_BITMAP: false,
+    ROUND_PIXELS: false
+  };
+
+  var appleIphone = /iPhone/i;
+  var appleIpod = /iPod/i;
+  var appleTablet = /iPad/i;
+  var appleUniversal = /\biOS-universal(?:.+)Mac\b/i;
+  var androidPhone = /\bAndroid(?:.+)Mobile\b/i;
+  var androidTablet = /Android/i;
+  var amazonPhone = /(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i;
+  var amazonTablet = /Silk/i;
+  var windowsPhone = /Windows Phone/i;
+  var windowsTablet = /\bWindows(?:.+)ARM\b/i;
+  var otherBlackBerry = /BlackBerry/i;
+  var otherBlackBerry10 = /BB10/i;
+  var otherOpera = /Opera Mini/i;
+  var otherChrome = /\b(CriOS|Chrome)(?:.+)Mobile/i;
+  var otherFirefox = /Mobile(?:.+)Firefox\b/i;
+  var isAppleTabletOnIos13 = function (navigator) {
+      return (typeof navigator !== 'undefined' &&
+          navigator.platform === 'MacIntel' &&
+          typeof navigator.maxTouchPoints === 'number' &&
+          navigator.maxTouchPoints > 1 &&
+          typeof MSStream === 'undefined');
+  };
+  function createMatch(userAgent) {
+      return function (regex) { return regex.test(userAgent); };
+  }
+  function isMobile$1(param) {
+      var nav = {
+          userAgent: '',
+          platform: '',
+          maxTouchPoints: 0
+      };
+      if (!param && typeof navigator !== 'undefined') {
+          nav = {
+              userAgent: navigator.userAgent,
+              platform: navigator.platform,
+              maxTouchPoints: navigator.maxTouchPoints || 0
+          };
+      }
+      else if (typeof param === 'string') {
+          nav.userAgent = param;
+      }
+      else if (param && param.userAgent) {
+          nav = {
+              userAgent: param.userAgent,
+              platform: param.platform,
+              maxTouchPoints: param.maxTouchPoints || 0
+          };
+      }
+      var userAgent = nav.userAgent;
+      var tmp = userAgent.split('[FBAN');
+      if (typeof tmp[1] !== 'undefined') {
+          userAgent = tmp[0];
+      }
+      tmp = userAgent.split('Twitter');
+      if (typeof tmp[1] !== 'undefined') {
+          userAgent = tmp[0];
+      }
+      var match = createMatch(userAgent);
+      var result = {
+          apple: {
+              phone: match(appleIphone) && !match(windowsPhone),
+              ipod: match(appleIpod),
+              tablet: !match(appleIphone) &&
+                  (match(appleTablet) || isAppleTabletOnIos13(nav)) &&
+                  !match(windowsPhone),
+              universal: match(appleUniversal),
+              device: (match(appleIphone) ||
+                  match(appleIpod) ||
+                  match(appleTablet) ||
+                  match(appleUniversal) ||
+                  isAppleTabletOnIos13(nav)) &&
+                  !match(windowsPhone)
+          },
+          amazon: {
+              phone: match(amazonPhone),
+              tablet: !match(amazonPhone) && match(amazonTablet),
+              device: match(amazonPhone) || match(amazonTablet)
+          },
+          android: {
+              phone: (!match(windowsPhone) && match(amazonPhone)) ||
+                  (!match(windowsPhone) && match(androidPhone)),
+              tablet: !match(windowsPhone) &&
+                  !match(amazonPhone) &&
+                  !match(androidPhone) &&
+                  (match(amazonTablet) || match(androidTablet)),
+              device: (!match(windowsPhone) &&
+                  (match(amazonPhone) ||
+                      match(amazonTablet) ||
+                      match(androidPhone) ||
+                      match(androidTablet))) ||
+                  match(/\bokhttp\b/i)
+          },
+          windows: {
+              phone: match(windowsPhone),
+              tablet: match(windowsTablet),
+              device: match(windowsPhone) || match(windowsTablet)
+          },
+          other: {
+              blackberry: match(otherBlackBerry),
+              blackberry10: match(otherBlackBerry10),
+              opera: match(otherOpera),
+              firefox: match(otherFirefox),
+              chrome: match(otherChrome),
+              device: match(otherBlackBerry) ||
+                  match(otherBlackBerry10) ||
+                  match(otherOpera) ||
+                  match(otherFirefox) ||
+                  match(otherChrome)
+          },
+          any: false,
+          phone: false,
+          tablet: false
+      };
+      result.any =
+          result.apple.device ||
+              result.android.device ||
+              result.windows.device ||
+              result.other.device;
+      result.phone =
+          result.apple.phone || result.android.phone || result.windows.phone;
+      result.tablet =
+          result.apple.tablet || result.android.tablet || result.windows.tablet;
+      return result;
+  }
+
+  const isMobileCall = isMobile$1.default ?? isMobile$1;
+  const isMobile = isMobileCall(globalThis.navigator);
+
+  settings.RETINA_PREFIX = /@([0-9\.]+)x/;
+  settings.FAIL_IF_MAJOR_PERFORMANCE_CAVEAT = false;
+
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  function getDefaultExportFromCjs (x) {
+  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+  }
+
+  function createCommonjsModule(fn, basedir, module) {
+  	return module = {
+  		path: basedir,
+  		exports: {},
+  		require: function (path, base) {
+  			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+  		}
+  	}, fn(module, module.exports), module.exports;
+  }
+
+  function getDefaultExportFromNamespaceIfPresent (n) {
+  	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
+  }
+
+  function getDefaultExportFromNamespaceIfNotNamed (n) {
+  	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
+  }
+
+  function getAugmentedNamespace(n) {
+  	if (n.__esModule) return n;
+  	var a = Object.defineProperty({}, '__esModule', {value: true});
+  	Object.keys(n).forEach(function (k) {
+  		var d = Object.getOwnPropertyDescriptor(n, k);
+  		Object.defineProperty(a, k, d.get ? d : {
+  			enumerable: true,
+  			get: function () {
+  				return n[k];
+  			}
+  		});
+  	});
+  	return a;
+  }
+
+  function commonjsRequire () {
+  	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+  }
+
+  var eventemitter3 = createCommonjsModule(function (module) {
+  'use strict';
+
+  var has = Object.prototype.hasOwnProperty
+    , prefix = '~';
+
+  /**
+   * Constructor to create a storage for our `EE` objects.
+   * An `Events` instance is a plain object whose properties are event names.
+   *
+   * @constructor
+   * @private
+   */
+  function Events() {}
+
+  //
+  // We try to not inherit from `Object.prototype`. In some engines creating an
+  // instance in this way is faster than calling `Object.create(null)` directly.
+  // If `Object.create(null)` is not supported we prefix the event names with a
+  // character to make sure that the built-in object properties are not
+  // overridden or used as an attack vector.
+  //
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+
+    //
+    // This hack is needed because the `__proto__` property is still inherited in
+    // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+    //
+    if (!new Events().__proto__) prefix = false;
+  }
+
+  /**
+   * Representation of a single event listener.
+   *
+   * @param {Function} fn The listener function.
+   * @param {*} context The context to invoke the listener with.
+   * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+   * @constructor
+   * @private
+   */
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+
+  /**
+   * Add a listener for a given event.
+   *
+   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} context The context to invoke the listener with.
+   * @param {Boolean} once Specify if the listener is a one-time listener.
+   * @returns {EventEmitter}
+   * @private
+   */
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== 'function') {
+      throw new TypeError('The listener must be a function');
+    }
+
+    var listener = new EE(fn, context || emitter, once)
+      , evt = prefix ? prefix + event : event;
+
+    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+    else emitter._events[evt] = [emitter._events[evt], listener];
+
+    return emitter;
+  }
+
+  /**
+   * Clear event by name.
+   *
+   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+   * @param {(String|Symbol)} evt The Event name.
+   * @private
+   */
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0) emitter._events = new Events();
+    else delete emitter._events[evt];
+  }
+
+  /**
+   * Minimal `EventEmitter` interface that is molded against the Node.js
+   * `EventEmitter` interface.
+   *
+   * @constructor
+   * @public
+   */
+  function EventEmitter() {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+
+  /**
+   * Return an array listing the events for which the emitter has registered
+   * listeners.
+   *
+   * @returns {Array}
+   * @public
+   */
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = []
+      , events
+      , name;
+
+    if (this._eventsCount === 0) return names;
+
+    for (name in (events = this._events)) {
+      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+    }
+
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+
+    return names;
+  };
+
+  /**
+   * Return the listeners registered for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Array} The registered listeners.
+   * @public
+   */
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event
+      , handlers = this._events[evt];
+
+    if (!handlers) return [];
+    if (handlers.fn) return [handlers.fn];
+
+    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+
+    return ee;
+  };
+
+  /**
+   * Return the number of listeners listening to a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Number} The number of listeners.
+   * @public
+   */
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event
+      , listeners = this._events[evt];
+
+    if (!listeners) return 0;
+    if (listeners.fn) return 1;
+    return listeners.length;
+  };
+
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @returns {Boolean} `true` if the event had listeners, else `false`.
+   * @public
+   */
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+
+    if (!this._events[evt]) return false;
+
+    var listeners = this._events[evt]
+      , len = arguments.length
+      , args
+      , i;
+
+    if (listeners.fn) {
+      if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+      switch (len) {
+        case 1: return listeners.fn.call(listeners.context), true;
+        case 2: return listeners.fn.call(listeners.context, a1), true;
+        case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+
+      for (i = 1, args = new Array(len -1); i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length
+        , j;
+
+      for (i = 0; i < length; i++) {
+        if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+        switch (len) {
+          case 1: listeners[i].fn.call(listeners[i].context); break;
+          case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+          case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+          case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+          default:
+            if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+              args[j - 1] = arguments[j];
+            }
+
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+
+    return true;
+  };
+
+  /**
+   * Add a listener for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} [context=this] The context to invoke the listener with.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+
+  /**
+   * Add a one-time listener for a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn The listener function.
+   * @param {*} [context=this] The context to invoke the listener with.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+
+  /**
+   * Remove the listeners of a given event.
+   *
+   * @param {(String|Symbol)} event The event name.
+   * @param {Function} fn Only remove the listeners that match this function.
+   * @param {*} context Only remove the listeners that have this context.
+   * @param {Boolean} once Only remove one-time listeners.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+
+    if (!this._events[evt]) return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+
+    var listeners = this._events[evt];
+
+    if (listeners.fn) {
+      if (
+        listeners.fn === fn &&
+        (!once || listeners.once) &&
+        (!context || listeners.context === context)
+      ) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+        if (
+          listeners[i].fn !== fn ||
+          (once && !listeners[i].once) ||
+          (context && listeners[i].context !== context)
+        ) {
+          events.push(listeners[i]);
+        }
+      }
+
+      //
+      // Reset the array, or remove it completely if we have no more listeners.
+      //
+      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+      else clearEvent(this, evt);
+    }
+
+    return this;
+  };
+
+  /**
+   * Remove all listeners, or those of the specified event.
+   *
+   * @param {(String|Symbol)} [event] The event name.
+   * @returns {EventEmitter} `this`.
+   * @public
+   */
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt]) clearEvent(this, evt);
+    } else {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+
+    return this;
+  };
+
+  //
+  // Alias methods names because people roll like that.
+  //
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+  //
+  // Expose the prefix.
+  //
+  EventEmitter.prefixed = prefix;
+
+  //
+  // Allow `EventEmitter` to be imported as module namespace.
+  //
+  EventEmitter.EventEmitter = EventEmitter;
+
+  //
+  // Expose the module.
+  //
+  if ('undefined' !== 'object') {
+    module.exports = EventEmitter;
+  }
+  });
+
+  'use strict';
+
+  var earcut_1 = earcut;
+  var _default = earcut;
+
+  function earcut(data, holeIndices, dim) {
+
+      dim = dim || 2;
+
+      var hasHoles = holeIndices && holeIndices.length,
+          outerLen = hasHoles ? holeIndices[0] * dim : data.length,
+          outerNode = linkedList(data, 0, outerLen, dim, true),
+          triangles = [];
+
+      if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+
+      var minX, minY, maxX, maxY, x, y, invSize;
+
+      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+
+      // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+      if (data.length > 80 * dim) {
+          minX = maxX = data[0];
+          minY = maxY = data[1];
+
+          for (var i = dim; i < outerLen; i += dim) {
+              x = data[i];
+              y = data[i + 1];
+              if (x < minX) minX = x;
+              if (y < minY) minY = y;
+              if (x > maxX) maxX = x;
+              if (y > maxY) maxY = y;
+          }
+
+          // minX, minY and invSize are later used to transform coords into integers for z-order calculation
+          invSize = Math.max(maxX - minX, maxY - minY);
+          invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
+
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+
+      return triangles;
+  }
+
+  // create a circular doubly linked list from polygon points in the specified winding order
+  function linkedList(data, start, end, dim, clockwise) {
+      var i, last;
+
+      if (clockwise === (signedArea(data, start, end, dim) > 0)) {
+          for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+      } else {
+          for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+      }
+
+      if (last && equals(last, last.next)) {
+          removeNode(last);
+          last = last.next;
+      }
+
+      return last;
+  }
+
+  // eliminate colinear or duplicate points
+  function filterPoints(start, end) {
+      if (!start) return start;
+      if (!end) end = start;
+
+      var p = start,
+          again;
+      do {
+          again = false;
+
+          if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+              removeNode(p);
+              p = end = p.prev;
+              if (p === p.next) break;
+              again = true;
+
+          } else {
+              p = p.next;
+          }
+      } while (again || p !== end);
+
+      return end;
+  }
+
+  // main ear slicing loop which triangulates a polygon (given as a linked list)
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+      if (!ear) return;
+
+      // interlink polygon nodes in z-order
+      if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+
+      var stop = ear,
+          prev, next;
+
+      // iterate through ears, slicing them one by one
+      while (ear.prev !== ear.next) {
+          prev = ear.prev;
+          next = ear.next;
+
+          if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+              // cut off the triangle
+              triangles.push(prev.i / dim | 0);
+              triangles.push(ear.i / dim | 0);
+              triangles.push(next.i / dim | 0);
+
+              removeNode(ear);
+
+              // skipping the next vertex leads to less sliver triangles
+              ear = next.next;
+              stop = next.next;
+
+              continue;
+          }
+
+          ear = next;
+
+          // if we looped through the whole remaining polygon and can't find any more ears
+          if (ear === stop) {
+              // try filtering points and slicing again
+              if (!pass) {
+                  earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+
+              // if this didn't work, try curing all small self-intersections locally
+              } else if (pass === 1) {
+                  ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+                  earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+
+              // as a last resort, try splitting the remaining polygon into two
+              } else if (pass === 2) {
+                  splitEarcut(ear, triangles, dim, minX, minY, invSize);
+              }
+
+              break;
+          }
+      }
+  }
+
+  // check whether a polygon node forms a valid ear with adjacent nodes
+  function isEar(ear) {
+      var a = ear.prev,
+          b = ear,
+          c = ear.next;
+
+      if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+      // now make sure we don't have other points inside the potential ear
+      var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+
+      // triangle bbox; min & max are calculated like this for speed
+      var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
+          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
+          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
+          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
+
+      var p = c.next;
+      while (p !== a) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
+              area(p.prev, p, p.next) >= 0) return false;
+          p = p.next;
+      }
+
+      return true;
+  }
+
+  function isEarHashed(ear, minX, minY, invSize) {
+      var a = ear.prev,
+          b = ear,
+          c = ear.next;
+
+      if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+      var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+
+      // triangle bbox; min & max are calculated like this for speed
+      var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
+          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
+          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
+          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
+
+      // z-order range for the current triangle bbox;
+      var minZ = zOrder(x0, y0, minX, minY, invSize),
+          maxZ = zOrder(x1, y1, minX, minY, invSize);
+
+      var p = ear.prevZ,
+          n = ear.nextZ;
+
+      // look for points inside the triangle in both directions
+      while (p && p.z >= minZ && n && n.z <= maxZ) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+          p = p.prevZ;
+
+          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+          n = n.nextZ;
+      }
+
+      // look for remaining points in decreasing z-order
+      while (p && p.z >= minZ) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+          p = p.prevZ;
+      }
+
+      // look for remaining points in increasing z-order
+      while (n && n.z <= maxZ) {
+          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+          n = n.nextZ;
+      }
+
+      return true;
+  }
+
+  // go through all polygon nodes and cure small local self-intersections
+  function cureLocalIntersections(start, triangles, dim) {
+      var p = start;
+      do {
+          var a = p.prev,
+              b = p.next.next;
+
+          if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+
+              triangles.push(a.i / dim | 0);
+              triangles.push(p.i / dim | 0);
+              triangles.push(b.i / dim | 0);
+
+              // remove two nodes involved
+              removeNode(p);
+              removeNode(p.next);
+
+              p = start = b;
+          }
+          p = p.next;
+      } while (p !== start);
+
+      return filterPoints(p);
+  }
+
+  // try splitting polygon into two and triangulate them independently
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+      // look for a valid diagonal that divides the polygon into two
+      var a = start;
+      do {
+          var b = a.next.next;
+          while (b !== a.prev) {
+              if (a.i !== b.i && isValidDiagonal(a, b)) {
+                  // split the polygon in two by the diagonal
+                  var c = splitPolygon(a, b);
+
+                  // filter colinear points around the cuts
+                  a = filterPoints(a, a.next);
+                  c = filterPoints(c, c.next);
+
+                  // run earcut on each half
+                  earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+                  earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+                  return;
+              }
+              b = b.next;
+          }
+          a = a.next;
+      } while (a !== start);
+  }
+
+  // link every hole into the outer loop, producing a single-ring polygon without holes
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+      var queue = [],
+          i, len, start, end, list;
+
+      for (i = 0, len = holeIndices.length; i < len; i++) {
+          start = holeIndices[i] * dim;
+          end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+          list = linkedList(data, start, end, dim, false);
+          if (list === list.next) list.steiner = true;
+          queue.push(getLeftmost(list));
+      }
+
+      queue.sort(compareX);
+
+      // process holes from left to right
+      for (i = 0; i < queue.length; i++) {
+          outerNode = eliminateHole(queue[i], outerNode);
+      }
+
+      return outerNode;
+  }
+
+  function compareX(a, b) {
+      return a.x - b.x;
+  }
+
+  // find a bridge between vertices that connects hole with an outer ring and and link it
+  function eliminateHole(hole, outerNode) {
+      var bridge = findHoleBridge(hole, outerNode);
+      if (!bridge) {
+          return outerNode;
+      }
+
+      var bridgeReverse = splitPolygon(bridge, hole);
+
+      // filter collinear points around the cuts
+      filterPoints(bridgeReverse, bridgeReverse.next);
+      return filterPoints(bridge, bridge.next);
+  }
+
+  // David Eberly's algorithm for finding a bridge between hole and outer polygon
+  function findHoleBridge(hole, outerNode) {
+      var p = outerNode,
+          hx = hole.x,
+          hy = hole.y,
+          qx = -Infinity,
+          m;
+
+      // find a segment intersected by a ray from the hole's leftmost point to the left;
+      // segment's endpoint with lesser x will be potential connection point
+      do {
+          if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+              var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+              if (x <= hx && x > qx) {
+                  qx = x;
+                  m = p.x < p.next.x ? p : p.next;
+                  if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
+              }
+          }
+          p = p.next;
+      } while (p !== outerNode);
+
+      if (!m) return null;
+
+      // look for points inside the triangle of hole point, segment intersection and endpoint;
+      // if there are no points found, we have a valid connection;
+      // otherwise choose the point of the minimum angle with the ray as connection point
+
+      var stop = m,
+          mx = m.x,
+          my = m.y,
+          tanMin = Infinity,
+          tan;
+
+      p = m;
+
+      do {
+          if (hx >= p.x && p.x >= mx && hx !== p.x &&
+                  pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+
+              tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
+
+              if (locallyInside(p, hole) &&
+                  (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
+                  m = p;
+                  tanMin = tan;
+              }
+          }
+
+          p = p.next;
+      } while (p !== stop);
+
+      return m;
+  }
+
+  // whether sector in vertex m contains sector in vertex p in the same coordinates
+  function sectorContainsSector(m, p) {
+      return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+
+  // interlink polygon nodes in z-order
+  function indexCurve(start, minX, minY, invSize) {
+      var p = start;
+      do {
+          if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+          p.prevZ = p.prev;
+          p.nextZ = p.next;
+          p = p.next;
+      } while (p !== start);
+
+      p.prevZ.nextZ = null;
+      p.prevZ = null;
+
+      sortLinked(p);
+  }
+
+  // Simon Tatham's linked list merge sort algorithm
+  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+  function sortLinked(list) {
+      var i, p, q, e, tail, numMerges, pSize, qSize,
+          inSize = 1;
+
+      do {
+          p = list;
+          list = null;
+          tail = null;
+          numMerges = 0;
+
+          while (p) {
+              numMerges++;
+              q = p;
+              pSize = 0;
+              for (i = 0; i < inSize; i++) {
+                  pSize++;
+                  q = q.nextZ;
+                  if (!q) break;
+              }
+              qSize = inSize;
+
+              while (pSize > 0 || (qSize > 0 && q)) {
+
+                  if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+                      e = p;
+                      p = p.nextZ;
+                      pSize--;
+                  } else {
+                      e = q;
+                      q = q.nextZ;
+                      qSize--;
+                  }
+
+                  if (tail) tail.nextZ = e;
+                  else list = e;
+
+                  e.prevZ = tail;
+                  tail = e;
+              }
+
+              p = q;
+          }
+
+          tail.nextZ = null;
+          inSize *= 2;
+
+      } while (numMerges > 1);
+
+      return list;
+  }
+
+  // z-order of a point given coords and inverse of the longer side of data bbox
+  function zOrder(x, y, minX, minY, invSize) {
+      // coords are transformed into non-negative 15-bit integer range
+      x = (x - minX) * invSize | 0;
+      y = (y - minY) * invSize | 0;
+
+      x = (x | (x << 8)) & 0x00FF00FF;
+      x = (x | (x << 4)) & 0x0F0F0F0F;
+      x = (x | (x << 2)) & 0x33333333;
+      x = (x | (x << 1)) & 0x55555555;
+
+      y = (y | (y << 8)) & 0x00FF00FF;
+      y = (y | (y << 4)) & 0x0F0F0F0F;
+      y = (y | (y << 2)) & 0x33333333;
+      y = (y | (y << 1)) & 0x55555555;
+
+      return x | (y << 1);
+  }
+
+  // find the leftmost node of a polygon ring
+  function getLeftmost(start) {
+      var p = start,
+          leftmost = start;
+      do {
+          if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) leftmost = p;
+          p = p.next;
+      } while (p !== start);
+
+      return leftmost;
+  }
+
+  // check if a point lies within a convex triangle
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+      return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
+             (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
+             (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+
+  // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+  function isValidDiagonal(a, b) {
+      return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+             (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+              (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+              equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
+  }
+
+  // signed area of a triangle
+  function area(p, q, r) {
+      return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+
+  // check if two points are equal
+  function equals(p1, p2) {
+      return p1.x === p2.x && p1.y === p2.y;
+  }
+
+  // check if two segments intersect
+  function intersects(p1, q1, p2, q2) {
+      var o1 = sign$1(area(p1, q1, p2));
+      var o2 = sign$1(area(p1, q1, q2));
+      var o3 = sign$1(area(p2, q2, p1));
+      var o4 = sign$1(area(p2, q2, q1));
+
+      if (o1 !== o2 && o3 !== o4) return true; // general case
+
+      if (o1 === 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
+      if (o2 === 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
+      if (o3 === 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
+      if (o4 === 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
+
+      return false;
+  }
+
+  // for collinear points p, q, r, check if point q lies on segment pr
+  function onSegment(p, q, r) {
+      return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+
+  function sign$1(num) {
+      return num > 0 ? 1 : num < 0 ? -1 : 0;
+  }
+
+  // check if a polygon diagonal intersects any polygon segments
+  function intersectsPolygon(a, b) {
+      var p = a;
+      do {
+          if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
+                  intersects(p, p.next, a, b)) return true;
+          p = p.next;
+      } while (p !== a);
+
+      return false;
+  }
+
+  // check if a polygon diagonal is locally inside the polygon
+  function locallyInside(a, b) {
+      return area(a.prev, a, a.next) < 0 ?
+          area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
+          area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+
+  // check if the middle point of a polygon diagonal is inside the polygon
+  function middleInside(a, b) {
+      var p = a,
+          inside = false,
+          px = (a.x + b.x) / 2,
+          py = (a.y + b.y) / 2;
+      do {
+          if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
+                  (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
+              inside = !inside;
+          p = p.next;
+      } while (p !== a);
+
+      return inside;
+  }
+
+  // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
+  // if one belongs to the outer ring and another to a hole, it merges it into a single ring
+  function splitPolygon(a, b) {
+      var a2 = new Node(a.i, a.x, a.y),
+          b2 = new Node(b.i, b.x, b.y),
+          an = a.next,
+          bp = b.prev;
+
+      a.next = b;
+      b.prev = a;
+
+      a2.next = an;
+      an.prev = a2;
+
+      b2.next = a2;
+      a2.prev = b2;
+
+      bp.next = b2;
+      b2.prev = bp;
+
+      return b2;
+  }
+
+  // create a node and optionally link it with previous one (in a circular doubly linked list)
+  function insertNode(i, x, y, last) {
+      var p = new Node(i, x, y);
+
+      if (!last) {
+          p.prev = p;
+          p.next = p;
+
+      } else {
+          p.next = last.next;
+          p.prev = last;
+          last.next.prev = p;
+          last.next = p;
+      }
+      return p;
+  }
+
+  function removeNode(p) {
+      p.next.prev = p.prev;
+      p.prev.next = p.next;
+
+      if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+      if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+  }
+
+  function Node(i, x, y) {
+      // vertex index in coordinates array
+      this.i = i;
+
+      // vertex coordinates
+      this.x = x;
+      this.y = y;
+
+      // previous and next vertex nodes in a polygon ring
+      this.prev = null;
+      this.next = null;
+
+      // z-order curve value
+      this.z = 0;
+
+      // previous and next nodes in z-order
+      this.prevZ = null;
+      this.nextZ = null;
+
+      // indicates whether this is a steiner point
+      this.steiner = false;
+  }
+
+  // return a percentage difference between the polygon area and its triangulation area;
+  // used to verify correctness of triangulation
+  earcut.deviation = function (data, holeIndices, dim, triangles) {
+      var hasHoles = holeIndices && holeIndices.length;
+      var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+
+      var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+      if (hasHoles) {
+          for (var i = 0, len = holeIndices.length; i < len; i++) {
+              var start = holeIndices[i] * dim;
+              var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+              polygonArea -= Math.abs(signedArea(data, start, end, dim));
+          }
+      }
+
+      var trianglesArea = 0;
+      for (i = 0; i < triangles.length; i += 3) {
+          var a = triangles[i] * dim;
+          var b = triangles[i + 1] * dim;
+          var c = triangles[i + 2] * dim;
+          trianglesArea += Math.abs(
+              (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
+              (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
+      }
+
+      return polygonArea === 0 && trianglesArea === 0 ? 0 :
+          Math.abs((trianglesArea - polygonArea) / polygonArea);
+  };
+
+  function signedArea(data, start, end, dim) {
+      var sum = 0;
+      for (var i = start, j = end - dim; i < end; i += dim) {
+          sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+          j = i;
+      }
+      return sum;
+  }
+
+  // turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
+  earcut.flatten = function (data) {
+      var dim = data[0][0].length,
+          result = {vertices: [], holes: [], dimensions: dim},
+          holeIndex = 0;
+
+      for (var i = 0; i < data.length; i++) {
+          for (var j = 0; j < data[i].length; j++) {
+              for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);
+          }
+          if (i > 0) {
+              holeIndex += data[i - 1].length;
+              result.holes.push(holeIndex);
+          }
+      }
+      return result;
+  };
+  earcut_1.default = _default;
+
+  var punycode = createCommonjsModule(function (module, exports) {
+  /*! https://mths.be/punycode v1.3.2 by @mathias */
+  ;(function(root) {
+
+  	/** Detect free variables */
+  	var freeExports = 'object' == 'object' && exports &&
+  		!exports.nodeType && exports;
+  	var freeModule = 'object' == 'object' && module &&
+  		!module.nodeType && module;
+  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+  	if (
+  		freeGlobal.global === freeGlobal ||
+  		freeGlobal.window === freeGlobal ||
+  		freeGlobal.self === freeGlobal
+  	) {
+  		root = freeGlobal;
+  	}
+
+  	/**
+  	 * The `punycode` object.
+  	 * @name punycode
+  	 * @type Object
+  	 */
+  	var punycode,
+
+  	/** Highest positive signed 32-bit float value */
+  	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
+
+  	/** Bootstring parameters */
+  	base = 36,
+  	tMin = 1,
+  	tMax = 26,
+  	skew = 38,
+  	damp = 700,
+  	initialBias = 72,
+  	initialN = 128, // 0x80
+  	delimiter = '-', // '\x2D'
+
+  	/** Regular expressions */
+  	regexPunycode = /^xn--/,
+  	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
+  	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
+
+  	/** Error messages */
+  	errors = {
+  		'overflow': 'Overflow: input needs wider integers to process',
+  		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+  		'invalid-input': 'Invalid input'
+  	},
+
+  	/** Convenience shortcuts */
+  	baseMinusTMin = base - tMin,
+  	floor = Math.floor,
+  	stringFromCharCode = String.fromCharCode,
+
+  	/** Temporary variable */
+  	key;
+
+  	/*--------------------------------------------------------------------------*/
+
+  	/**
+  	 * A generic error utility function.
+  	 * @private
+  	 * @param {String} type The error type.
+  	 * @returns {Error} Throws a `RangeError` with the applicable error message.
+  	 */
+  	function error(type) {
+  		throw RangeError(errors[type]);
+  	}
+
+  	/**
+  	 * A generic `Array#map` utility function.
+  	 * @private
+  	 * @param {Array} array The array to iterate over.
+  	 * @param {Function} callback The function that gets called for every array
+  	 * item.
+  	 * @returns {Array} A new array of values returned by the callback function.
+  	 */
+  	function map(array, fn) {
+  		var length = array.length;
+  		var result = [];
+  		while (length--) {
+  			result[length] = fn(array[length]);
+  		}
+  		return result;
+  	}
+
+  	/**
+  	 * A simple `Array#map`-like wrapper to work with domain name strings or email
+  	 * addresses.
+  	 * @private
+  	 * @param {String} domain The domain name or email address.
+  	 * @param {Function} callback The function that gets called for every
+  	 * character.
+  	 * @returns {Array} A new string of characters returned by the callback
+  	 * function.
+  	 */
+  	function mapDomain(string, fn) {
+  		var parts = string.split('@');
+  		var result = '';
+  		if (parts.length > 1) {
+  			// In email addresses, only the domain name should be punycoded. Leave
+  			// the local part (i.e. everything up to `@`) intact.
+  			result = parts[0] + '@';
+  			string = parts[1];
+  		}
+  		// Avoid `split(regex)` for IE8 compatibility. See #17.
+  		string = string.replace(regexSeparators, '\x2E');
+  		var labels = string.split('.');
+  		var encoded = map(labels, fn).join('.');
+  		return result + encoded;
+  	}
+
+  	/**
+  	 * Creates an array containing the numeric code points of each Unicode
+  	 * character in the string. While JavaScript uses UCS-2 internally,
+  	 * this function will convert a pair of surrogate halves (each of which
+  	 * UCS-2 exposes as separate characters) into a single code point,
+  	 * matching UTF-16.
+  	 * @see `punycode.ucs2.encode`
+  	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+  	 * @memberOf punycode.ucs2
+  	 * @name decode
+  	 * @param {String} string The Unicode input string (UCS-2).
+  	 * @returns {Array} The new array of code points.
+  	 */
+  	function ucs2decode(string) {
+  		var output = [],
+  		    counter = 0,
+  		    length = string.length,
+  		    value,
+  		    extra;
+  		while (counter < length) {
+  			value = string.charCodeAt(counter++);
+  			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+  				// high surrogate, and there is a next character
+  				extra = string.charCodeAt(counter++);
+  				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+  					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+  				} else {
+  					// unmatched surrogate; only append this code unit, in case the next
+  					// code unit is the high surrogate of a surrogate pair
+  					output.push(value);
+  					counter--;
+  				}
+  			} else {
+  				output.push(value);
+  			}
+  		}
+  		return output;
+  	}
+
+  	/**
+  	 * Creates a string based on an array of numeric code points.
+  	 * @see `punycode.ucs2.decode`
+  	 * @memberOf punycode.ucs2
+  	 * @name encode
+  	 * @param {Array} codePoints The array of numeric code points.
+  	 * @returns {String} The new Unicode string (UCS-2).
+  	 */
+  	function ucs2encode(array) {
+  		return map(array, function(value) {
+  			var output = '';
+  			if (value > 0xFFFF) {
+  				value -= 0x10000;
+  				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+  				value = 0xDC00 | value & 0x3FF;
+  			}
+  			output += stringFromCharCode(value);
+  			return output;
+  		}).join('');
+  	}
+
+  	/**
+  	 * Converts a basic code point into a digit/integer.
+  	 * @see `digitToBasic()`
+  	 * @private
+  	 * @param {Number} codePoint The basic numeric code point value.
+  	 * @returns {Number} The numeric value of a basic code point (for use in
+  	 * representing integers) in the range `0` to `base - 1`, or `base` if
+  	 * the code point does not represent a value.
+  	 */
+  	function basicToDigit(codePoint) {
+  		if (codePoint - 48 < 10) {
+  			return codePoint - 22;
+  		}
+  		if (codePoint - 65 < 26) {
+  			return codePoint - 65;
+  		}
+  		if (codePoint - 97 < 26) {
+  			return codePoint - 97;
+  		}
+  		return base;
+  	}
+
+  	/**
+  	 * Converts a digit/integer into a basic code point.
+  	 * @see `basicToDigit()`
+  	 * @private
+  	 * @param {Number} digit The numeric value of a basic code point.
+  	 * @returns {Number} The basic code point whose value (when used for
+  	 * representing integers) is `digit`, which needs to be in the range
+  	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+  	 * used; else, the lowercase form is used. The behavior is undefined
+  	 * if `flag` is non-zero and `digit` has no uppercase form.
+  	 */
+  	function digitToBasic(digit, flag) {
+  		//  0..25 map to ASCII a..z or A..Z
+  		// 26..35 map to ASCII 0..9
+  		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+  	}
+
+  	/**
+  	 * Bias adaptation function as per section 3.4 of RFC 3492.
+  	 * http://tools.ietf.org/html/rfc3492#section-3.4
+  	 * @private
+  	 */
+  	function adapt(delta, numPoints, firstTime) {
+  		var k = 0;
+  		delta = firstTime ? floor(delta / damp) : delta >> 1;
+  		delta += floor(delta / numPoints);
+  		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+  			delta = floor(delta / baseMinusTMin);
+  		}
+  		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+  	}
+
+  	/**
+  	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+  	 * symbols.
+  	 * @memberOf punycode
+  	 * @param {String} input The Punycode string of ASCII-only symbols.
+  	 * @returns {String} The resulting string of Unicode symbols.
+  	 */
+  	function decode(input) {
+  		// Don't use UCS-2
+  		var output = [],
+  		    inputLength = input.length,
+  		    out,
+  		    i = 0,
+  		    n = initialN,
+  		    bias = initialBias,
+  		    basic,
+  		    j,
+  		    index,
+  		    oldi,
+  		    w,
+  		    k,
+  		    digit,
+  		    t,
+  		    /** Cached calculation results */
+  		    baseMinusT;
+
+  		// Handle the basic code points: let `basic` be the number of input code
+  		// points before the last delimiter, or `0` if there is none, then copy
+  		// the first basic code points to the output.
+
+  		basic = input.lastIndexOf(delimiter);
+  		if (basic < 0) {
+  			basic = 0;
+  		}
+
+  		for (j = 0; j < basic; ++j) {
+  			// if it's not a basic code point
+  			if (input.charCodeAt(j) >= 0x80) {
+  				error('not-basic');
+  			}
+  			output.push(input.charCodeAt(j));
+  		}
+
+  		// Main decoding loop: start just after the last delimiter if any basic code
+  		// points were copied; start at the beginning otherwise.
+
+  		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+  			// `index` is the index of the next character to be consumed.
+  			// Decode a generalized variable-length integer into `delta`,
+  			// which gets added to `i`. The overflow checking is easier
+  			// if we increase `i` as we go, then subtract off its starting
+  			// value at the end to obtain `delta`.
+  			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
+
+  				if (index >= inputLength) {
+  					error('invalid-input');
+  				}
+
+  				digit = basicToDigit(input.charCodeAt(index++));
+
+  				if (digit >= base || digit > floor((maxInt - i) / w)) {
+  					error('overflow');
+  				}
+
+  				i += digit * w;
+  				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+  				if (digit < t) {
+  					break;
+  				}
+
+  				baseMinusT = base - t;
+  				if (w > floor(maxInt / baseMinusT)) {
+  					error('overflow');
+  				}
+
+  				w *= baseMinusT;
+
+  			}
+
+  			out = output.length + 1;
+  			bias = adapt(i - oldi, out, oldi == 0);
+
+  			// `i` was supposed to wrap around from `out` to `0`,
+  			// incrementing `n` each time, so we'll fix that now:
+  			if (floor(i / out) > maxInt - n) {
+  				error('overflow');
+  			}
+
+  			n += floor(i / out);
+  			i %= out;
+
+  			// Insert `n` at position `i` of the output
+  			output.splice(i++, 0, n);
+
+  		}
+
+  		return ucs2encode(output);
+  	}
+
+  	/**
+  	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
+  	 * Punycode string of ASCII-only symbols.
+  	 * @memberOf punycode
+  	 * @param {String} input The string of Unicode symbols.
+  	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
+  	 */
+  	function encode(input) {
+  		var n,
+  		    delta,
+  		    handledCPCount,
+  		    basicLength,
+  		    bias,
+  		    j,
+  		    m,
+  		    q,
+  		    k,
+  		    t,
+  		    currentValue,
+  		    output = [],
+  		    /** `inputLength` will hold the number of code points in `input`. */
+  		    inputLength,
+  		    /** Cached calculation results */
+  		    handledCPCountPlusOne,
+  		    baseMinusT,
+  		    qMinusT;
+
+  		// Convert the input in UCS-2 to Unicode
+  		input = ucs2decode(input);
+
+  		// Cache the length
+  		inputLength = input.length;
+
+  		// Initialize the state
+  		n = initialN;
+  		delta = 0;
+  		bias = initialBias;
+
+  		// Handle the basic code points
+  		for (j = 0; j < inputLength; ++j) {
+  			currentValue = input[j];
+  			if (currentValue < 0x80) {
+  				output.push(stringFromCharCode(currentValue));
+  			}
+  		}
+
+  		handledCPCount = basicLength = output.length;
+
+  		// `handledCPCount` is the number of code points that have been handled;
+  		// `basicLength` is the number of basic code points.
+
+  		// Finish the basic string - if it is not empty - with a delimiter
+  		if (basicLength) {
+  			output.push(delimiter);
+  		}
+
+  		// Main encoding loop:
+  		while (handledCPCount < inputLength) {
+
+  			// All non-basic code points < n have been handled already. Find the next
+  			// larger one:
+  			for (m = maxInt, j = 0; j < inputLength; ++j) {
+  				currentValue = input[j];
+  				if (currentValue >= n && currentValue < m) {
+  					m = currentValue;
+  				}
+  			}
+
+  			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+  			// but guard against overflow
+  			handledCPCountPlusOne = handledCPCount + 1;
+  			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+  				error('overflow');
+  			}
+
+  			delta += (m - n) * handledCPCountPlusOne;
+  			n = m;
+
+  			for (j = 0; j < inputLength; ++j) {
+  				currentValue = input[j];
+
+  				if (currentValue < n && ++delta > maxInt) {
+  					error('overflow');
+  				}
+
+  				if (currentValue == n) {
+  					// Represent delta as a generalized variable-length integer
+  					for (q = delta, k = base; /* no condition */; k += base) {
+  						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+  						if (q < t) {
+  							break;
+  						}
+  						qMinusT = q - t;
+  						baseMinusT = base - t;
+  						output.push(
+  							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+  						);
+  						q = floor(qMinusT / baseMinusT);
+  					}
+
+  					output.push(stringFromCharCode(digitToBasic(q, 0)));
+  					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+  					delta = 0;
+  					++handledCPCount;
+  				}
+  			}
+
+  			++delta;
+  			++n;
+
+  		}
+  		return output.join('');
+  	}
+
+  	/**
+  	 * Converts a Punycode string representing a domain name or an email address
+  	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+  	 * it doesn't matter if you call it on a string that has already been
+  	 * converted to Unicode.
+  	 * @memberOf punycode
+  	 * @param {String} input The Punycoded domain name or email address to
+  	 * convert to Unicode.
+  	 * @returns {String} The Unicode representation of the given Punycode
+  	 * string.
+  	 */
+  	function toUnicode(input) {
+  		return mapDomain(input, function(string) {
+  			return regexPunycode.test(string)
+  				? decode(string.slice(4).toLowerCase())
+  				: string;
+  		});
+  	}
+
+  	/**
+  	 * Converts a Unicode string representing a domain name or an email address to
+  	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
+  	 * i.e. it doesn't matter if you call it with a domain that's already in
+  	 * ASCII.
+  	 * @memberOf punycode
+  	 * @param {String} input The domain name or email address to convert, as a
+  	 * Unicode string.
+  	 * @returns {String} The Punycode representation of the given domain name or
+  	 * email address.
+  	 */
+  	function toASCII(input) {
+  		return mapDomain(input, function(string) {
+  			return regexNonASCII.test(string)
+  				? 'xn--' + encode(string)
+  				: string;
+  		});
+  	}
+
+  	/*--------------------------------------------------------------------------*/
+
+  	/** Define the public API */
+  	punycode = {
+  		/**
+  		 * A string representing the current Punycode.js version number.
+  		 * @memberOf punycode
+  		 * @type String
+  		 */
+  		'version': '1.3.2',
+  		/**
+  		 * An object of methods to convert from JavaScript's internal character
+  		 * representation (UCS-2) to Unicode code points, and back.
+  		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+  		 * @memberOf punycode
+  		 * @type Object
+  		 */
+  		'ucs2': {
+  			'decode': ucs2decode,
+  			'encode': ucs2encode
+  		},
+  		'decode': decode,
+  		'encode': encode,
+  		'toASCII': toASCII,
+  		'toUnicode': toUnicode
+  	};
+
+  	/** Expose `punycode` */
+  	// Some AMD build optimizers, like r.js, check for specific condition patterns
+  	// like the following:
+  	if (
+  		typeof undefined == 'function' &&
+  		typeof undefined.amd == 'object' &&
+  		undefined.amd
+  	) {
+  		undefined('punycode', function() {
+  			return punycode;
+  		});
+  	} else if (freeExports && freeModule) {
+  		if (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+
+  			freeModule.exports = punycode;
+  		} else { // in Narwhal or RingoJS v0.7.0-
+  			for (key in punycode) {
+  				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+  			}
+  		}
+  	} else { // in Rhino or a web browser
+  		root.punycode = punycode;
+  	}
+
+  }(commonjsGlobal));
+  });
+
+  'use strict';
+
+  var util = {
+    isString: function(arg) {
+      return typeof(arg) === 'string';
+    },
+    isObject: function(arg) {
+      return typeof(arg) === 'object' && arg !== null;
+    },
+    isNull: function(arg) {
+      return arg === null;
+    },
+    isNullOrUndefined: function(arg) {
+      return arg == null;
+    }
+  };
+
+  // Copyright Joyent, Inc. and other Node contributors.
+  //
+  // 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.
+
+  'use strict';
+
+  // If obj.hasOwnProperty has been overridden, then calling
+  // obj.hasOwnProperty(prop) will break.
+  // See: https://github.com/joyent/node/issues/1707
+  function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  }
+
+  var decode = function(qs, sep, eq, options) {
+    sep = sep || '&';
+    eq = eq || '=';
+    var obj = {};
+
+    if (typeof qs !== 'string' || qs.length === 0) {
+      return obj;
+    }
+
+    var regexp = /\+/g;
+    qs = qs.split(sep);
+
+    var maxKeys = 1000;
+    if (options && typeof options.maxKeys === 'number') {
+      maxKeys = options.maxKeys;
+    }
+
+    var len = qs.length;
+    // maxKeys <= 0 means that we should not limit keys count
+    if (maxKeys > 0 && len > maxKeys) {
+      len = maxKeys;
+    }
+
+    for (var i = 0; i < len; ++i) {
+      var x = qs[i].replace(regexp, '%20'),
+          idx = x.indexOf(eq),
+          kstr, vstr, k, v;
+
+      if (idx >= 0) {
+        kstr = x.substr(0, idx);
+        vstr = x.substr(idx + 1);
+      } else {
+        kstr = x;
+        vstr = '';
+      }
+
+      k = decodeURIComponent(kstr);
+      v = decodeURIComponent(vstr);
+
+      if (!hasOwnProperty(obj, k)) {
+        obj[k] = v;
+      } else if (Array.isArray(obj[k])) {
+        obj[k].push(v);
+      } else {
+        obj[k] = [obj[k], v];
+      }
+    }
+
+    return obj;
+  };
+
+  // Copyright Joyent, Inc. and other Node contributors.
+  //
+  // 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.
+
+  'use strict';
+
+  var stringifyPrimitive = function(v) {
+    switch (typeof v) {
+      case 'string':
+        return v;
+
+      case 'boolean':
+        return v ? 'true' : 'false';
+
+      case 'number':
+        return isFinite(v) ? v : '';
+
+      default:
+        return '';
+    }
+  };
+
+  var encode = function(obj, sep, eq, name) {
+    sep = sep || '&';
+    eq = eq || '=';
+    if (obj === null) {
+      obj = undefined;
+    }
+
+    if (typeof obj === 'object') {
+      return Object.keys(obj).map(function(k) {
+        var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+        if (Array.isArray(obj[k])) {
+          return obj[k].map(function(v) {
+            return ks + encodeURIComponent(stringifyPrimitive(v));
+          }).join(sep);
+        } else {
+          return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+        }
+      }).join(sep);
+
+    }
+
+    if (!name) return '';
+    return encodeURIComponent(stringifyPrimitive(name)) + eq +
+           encodeURIComponent(stringifyPrimitive(obj));
+  };
+
+  var querystring = createCommonjsModule(function (module, exports) {
+  'use strict';
+
+  exports.decode = exports.parse = decode;
+  exports.encode = exports.stringify = encode;
+  });
+
+  // Copyright Joyent, Inc. and other Node contributors.
+  //
+  // 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.
+
+  'use strict';
+
+
+
+
+  var parse = urlParse;
+  var resolve = urlResolve;
+  var resolveObject = urlResolveObject;
+  var format = urlFormat;
+
+  var Url_1 = Url;
+
+  function Url() {
+    this.protocol = null;
+    this.slashes = null;
+    this.auth = null;
+    this.host = null;
+    this.port = null;
+    this.hostname = null;
+    this.hash = null;
+    this.search = null;
+    this.query = null;
+    this.pathname = null;
+    this.path = null;
+    this.href = null;
+  }
+
+  // Reference: RFC 3986, RFC 1808, RFC 2396
+
+  // define these here so at least they only have to be
+  // compiled once on the first module load.
+  var protocolPattern = /^([a-z0-9.+-]+:)/i,
+      portPattern = /:[0-9]*$/,
+
+      // Special case for a simple path URL
+      simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
+
+      // RFC 2396: characters reserved for delimiting URLs.
+      // We actually just auto-escape these.
+      delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+      // RFC 2396: characters not allowed for various reasons.
+      unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+      // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
+      autoEscape = ['\''].concat(unwise),
+      // Characters that are never ever allowed in a hostname.
+      // Note that any invalid chars are also handled, but these
+      // are the ones that are *expected* to be seen, so we fast-path
+      // them.
+      nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+      hostEndingChars = ['/', '?', '#'],
+      hostnameMaxLen = 255,
+      hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
+      hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
+      // protocols that can allow "unsafe" and "unwise" chars.
+      unsafeProtocol = {
+        'javascript': true,
+        'javascript:': true
+      },
+      // protocols that never have a hostname.
+      hostlessProtocol = {
+        'javascript': true,
+        'javascript:': true
+      },
+      // protocols that always contain a // bit.
+      slashedProtocol = {
+        'http': true,
+        'https': true,
+        'ftp': true,
+        'gopher': true,
+        'file': true,
+        'http:': true,
+        'https:': true,
+        'ftp:': true,
+        'gopher:': true,
+        'file:': true
+      };
+
+  function urlParse(url, parseQueryString, slashesDenoteHost) {
+    if (url && util.isObject(url) && url instanceof Url) return url;
+
+    var u = new Url;
+    u.parse(url, parseQueryString, slashesDenoteHost);
+    return u;
+  }
+
+  Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+    if (!util.isString(url)) {
+      throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+    }
+
+    // Copy chrome, IE, opera backslash-handling behavior.
+    // Back slashes before the query string get converted to forward slashes
+    // See: https://code.google.com/p/chromium/issues/detail?id=25916
+    var queryIndex = url.indexOf('?'),
+        splitter =
+            (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
+        uSplit = url.split(splitter),
+        slashRegex = /\\/g;
+    uSplit[0] = uSplit[0].replace(slashRegex, '/');
+    url = uSplit.join(splitter);
+
+    var rest = url;
+
+    // trim before proceeding.
+    // This is to support parse stuff like "  http://foo.com  \n"
+    rest = rest.trim();
+
+    if (!slashesDenoteHost && url.split('#').length === 1) {
+      // Try fast path regexp
+      var simplePath = simplePathPattern.exec(rest);
+      if (simplePath) {
+        this.path = rest;
+        this.href = rest;
+        this.pathname = simplePath[1];
+        if (simplePath[2]) {
+          this.search = simplePath[2];
+          if (parseQueryString) {
+            this.query = querystring.parse(this.search.substr(1));
+          } else {
+            this.query = this.search.substr(1);
+          }
+        } else if (parseQueryString) {
+          this.search = '';
+          this.query = {};
+        }
+        return this;
+      }
+    }
+
+    var proto = protocolPattern.exec(rest);
+    if (proto) {
+      proto = proto[0];
+      var lowerProto = proto.toLowerCase();
+      this.protocol = lowerProto;
+      rest = rest.substr(proto.length);
+    }
+
+    // figure out if it's got a host
+    // user@server is *always* interpreted as a hostname, and url
+    // resolution will treat //foo/bar as host=foo,path=bar because that's
+    // how the browser resolves relative URLs.
+    if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+      var slashes = rest.substr(0, 2) === '//';
+      if (slashes && !(proto && hostlessProtocol[proto])) {
+        rest = rest.substr(2);
+        this.slashes = true;
+      }
+    }
+
+    if (!hostlessProtocol[proto] &&
+        (slashes || (proto && !slashedProtocol[proto]))) {
+
+      // there's a hostname.
+      // the first instance of /, ?, ;, or # ends the host.
+      //
+      // If there is an @ in the hostname, then non-host chars *are* allowed
+      // to the left of the last @ sign, unless some host-ending character
+      // comes *before* the @-sign.
+      // URLs are obnoxious.
+      //
+      // ex:
+      // http://a@b@c/ => user:a@b host:c
+      // http://a@b?@c => user:a host:c path:/?@c
+
+      // v0.12 TODO(isaacs): This is not quite how Chrome does things.
+      // Review our test case against browsers more comprehensively.
+
+      // find the first instance of any hostEndingChars
+      var hostEnd = -1;
+      for (var i = 0; i < hostEndingChars.length; i++) {
+        var hec = rest.indexOf(hostEndingChars[i]);
+        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+          hostEnd = hec;
+      }
+
+      // at this point, either we have an explicit point where the
+      // auth portion cannot go past, or the last @ char is the decider.
+      var auth, atSign;
+      if (hostEnd === -1) {
+        // atSign can be anywhere.
+        atSign = rest.lastIndexOf('@');
+      } else {
+        // atSign must be in auth portion.
+        // http://a@b/c@d => host:b auth:a path:/c@d
+        atSign = rest.lastIndexOf('@', hostEnd);
+      }
+
+      // Now we have a portion which is definitely the auth.
+      // Pull that off.
+      if (atSign !== -1) {
+        auth = rest.slice(0, atSign);
+        rest = rest.slice(atSign + 1);
+        this.auth = decodeURIComponent(auth);
+      }
+
+      // the host is the remaining to the left of the first non-host char
+      hostEnd = -1;
+      for (var i = 0; i < nonHostChars.length; i++) {
+        var hec = rest.indexOf(nonHostChars[i]);
+        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+          hostEnd = hec;
+      }
+      // if we still have not hit it, then the entire thing is a host.
+      if (hostEnd === -1)
+        hostEnd = rest.length;
+
+      this.host = rest.slice(0, hostEnd);
+      rest = rest.slice(hostEnd);
+
+      // pull out port.
+      this.parseHost();
+
+      // we've indicated that there is a hostname,
+      // so even if it's empty, it has to be present.
+      this.hostname = this.hostname || '';
+
+      // if hostname begins with [ and ends with ]
+      // assume that it's an IPv6 address.
+      var ipv6Hostname = this.hostname[0] === '[' &&
+          this.hostname[this.hostname.length - 1] === ']';
+
+      // validate a little.
+      if (!ipv6Hostname) {
+        var hostparts = this.hostname.split(/\./);
+        for (var i = 0, l = hostparts.length; i < l; i++) {
+          var part = hostparts[i];
+          if (!part) continue;
+          if (!part.match(hostnamePartPattern)) {
+            var newpart = '';
+            for (var j = 0, k = part.length; j < k; j++) {
+              if (part.charCodeAt(j) > 127) {
+                // we replace non-ASCII char with a temporary placeholder
+                // we need this to make sure size of hostname is not
+                // broken by replacing non-ASCII by nothing
+                newpart += 'x';
+              } else {
+                newpart += part[j];
+              }
+            }
+            // we test again with ASCII char only
+            if (!newpart.match(hostnamePartPattern)) {
+              var validParts = hostparts.slice(0, i);
+              var notHost = hostparts.slice(i + 1);
+              var bit = part.match(hostnamePartStart);
+              if (bit) {
+                validParts.push(bit[1]);
+                notHost.unshift(bit[2]);
+              }
+              if (notHost.length) {
+                rest = '/' + notHost.join('.') + rest;
+              }
+              this.hostname = validParts.join('.');
+              break;
+            }
+          }
+        }
+      }
+
+      if (this.hostname.length > hostnameMaxLen) {
+        this.hostname = '';
+      } else {
+        // hostnames are always lower case.
+        this.hostname = this.hostname.toLowerCase();
+      }
+
+      if (!ipv6Hostname) {
+        // IDNA Support: Returns a punycoded representation of "domain".
+        // It only converts parts of the domain name that
+        // have non-ASCII characters, i.e. it doesn't matter if
+        // you call it with a domain that already is ASCII-only.
+        this.hostname = punycode.toASCII(this.hostname);
+      }
+
+      var p = this.port ? ':' + this.port : '';
+      var h = this.hostname || '';
+      this.host = h + p;
+      this.href += this.host;
+
+      // strip [ and ] from the hostname
+      // the host field still retains them, though
+      if (ipv6Hostname) {
+        this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+        if (rest[0] !== '/') {
+          rest = '/' + rest;
+        }
+      }
+    }
+
+    // now rest is set to the post-host stuff.
+    // chop off any delim chars.
+    if (!unsafeProtocol[lowerProto]) {
+
+      // First, make 100% sure that any "autoEscape" chars get
+      // escaped, even if encodeURIComponent doesn't think they
+      // need to be.
+      for (var i = 0, l = autoEscape.length; i < l; i++) {
+        var ae = autoEscape[i];
+        if (rest.indexOf(ae) === -1)
+          continue;
+        var esc = encodeURIComponent(ae);
+        if (esc === ae) {
+          esc = escape(ae);
+        }
+        rest = rest.split(ae).join(esc);
+      }
+    }
+
+
+    // chop off from the tail first.
+    var hash = rest.indexOf('#');
+    if (hash !== -1) {
+      // got a fragment string.
+      this.hash = rest.substr(hash);
+      rest = rest.slice(0, hash);
+    }
+    var qm = rest.indexOf('?');
+    if (qm !== -1) {
+      this.search = rest.substr(qm);
+      this.query = rest.substr(qm + 1);
+      if (parseQueryString) {
+        this.query = querystring.parse(this.query);
+      }
+      rest = rest.slice(0, qm);
+    } else if (parseQueryString) {
+      // no query string, but parseQueryString still requested
+      this.search = '';
+      this.query = {};
+    }
+    if (rest) this.pathname = rest;
+    if (slashedProtocol[lowerProto] &&
+        this.hostname && !this.pathname) {
+      this.pathname = '/';
+    }
+
+    //to support http.request
+    if (this.pathname || this.search) {
+      var p = this.pathname || '';
+      var s = this.search || '';
+      this.path = p + s;
+    }
+
+    // finally, reconstruct the href based on what has been validated.
+    this.href = this.format();
+    return this;
+  };
+
+  // format a parsed object into a url string
+  function urlFormat(obj) {
+    // ensure it's an object, and not a string url.
+    // If it's an obj, this is a no-op.
+    // this way, you can call url_format() on strings
+    // to clean up potentially wonky urls.
+    if (util.isString(obj)) obj = urlParse(obj);
+    if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
+    return obj.format();
+  }
+
+  Url.prototype.format = function() {
+    var auth = this.auth || '';
+    if (auth) {
+      auth = encodeURIComponent(auth);
+      auth = auth.replace(/%3A/i, ':');
+      auth += '@';
+    }
+
+    var protocol = this.protocol || '',
+        pathname = this.pathname || '',
+        hash = this.hash || '',
+        host = false,
+        query = '';
+
+    if (this.host) {
+      host = auth + this.host;
+    } else if (this.hostname) {
+      host = auth + (this.hostname.indexOf(':') === -1 ?
+          this.hostname :
+          '[' + this.hostname + ']');
+      if (this.port) {
+        host += ':' + this.port;
+      }
+    }
+
+    if (this.query &&
+        util.isObject(this.query) &&
+        Object.keys(this.query).length) {
+      query = querystring.stringify(this.query);
+    }
+
+    var search = this.search || (query && ('?' + query)) || '';
+
+    if (protocol && protocol.substr(-1) !== ':') protocol += ':';
+
+    // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
+    // unless they had them to begin with.
+    if (this.slashes ||
+        (!protocol || slashedProtocol[protocol]) && host !== false) {
+      host = '//' + (host || '');
+      if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
+    } else if (!host) {
+      host = '';
+    }
+
+    if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
+    if (search && search.charAt(0) !== '?') search = '?' + search;
+
+    pathname = pathname.replace(/[?#]/g, function(match) {
+      return encodeURIComponent(match);
+    });
+    search = search.replace('#', '%23');
+
+    return protocol + host + pathname + search + hash;
+  };
+
+  function urlResolve(source, relative) {
+    return urlParse(source, false, true).resolve(relative);
+  }
+
+  Url.prototype.resolve = function(relative) {
+    return this.resolveObject(urlParse(relative, false, true)).format();
+  };
+
+  function urlResolveObject(source, relative) {
+    if (!source) return relative;
+    return urlParse(source, false, true).resolveObject(relative);
+  }
+
+  Url.prototype.resolveObject = function(relative) {
+    if (util.isString(relative)) {
+      var rel = new Url();
+      rel.parse(relative, false, true);
+      relative = rel;
+    }
+
+    var result = new Url();
+    var tkeys = Object.keys(this);
+    for (var tk = 0; tk < tkeys.length; tk++) {
+      var tkey = tkeys[tk];
+      result[tkey] = this[tkey];
+    }
+
+    // hash is always overridden, no matter what.
+    // even href="" will remove it.
+    result.hash = relative.hash;
+
+    // if the relative url is empty, then there's nothing left to do here.
+    if (relative.href === '') {
+      result.href = result.format();
+      return result;
+    }
+
+    // hrefs like //foo/bar always cut to the protocol.
+    if (relative.slashes && !relative.protocol) {
+      // take everything except the protocol from relative
+      var rkeys = Object.keys(relative);
+      for (var rk = 0; rk < rkeys.length; rk++) {
+        var rkey = rkeys[rk];
+        if (rkey !== 'protocol')
+          result[rkey] = relative[rkey];
+      }
+
+      //urlParse appends trailing / to urls like http://www.example.com
+      if (slashedProtocol[result.protocol] &&
+          result.hostname && !result.pathname) {
+        result.path = result.pathname = '/';
+      }
+
+      result.href = result.format();
+      return result;
+    }
+
+    if (relative.protocol && relative.protocol !== result.protocol) {
+      // if it's a known url protocol, then changing
+      // the protocol does weird things
+      // first, if it's not file:, then we MUST have a host,
+      // and if there was a path
+      // to begin with, then we MUST have a path.
+      // if it is file:, then the host is dropped,
+      // because that's known to be hostless.
+      // anything else is assumed to be absolute.
+      if (!slashedProtocol[relative.protocol]) {
+        var keys = Object.keys(relative);
+        for (var v = 0; v < keys.length; v++) {
+          var k = keys[v];
+          result[k] = relative[k];
+        }
+        result.href = result.format();
+        return result;
+      }
+
+      result.protocol = relative.protocol;
+      if (!relative.host && !hostlessProtocol[relative.protocol]) {
+        var relPath = (relative.pathname || '').split('/');
+        while (relPath.length && !(relative.host = relPath.shift()));
+        if (!relative.host) relative.host = '';
+        if (!relative.hostname) relative.hostname = '';
+        if (relPath[0] !== '') relPath.unshift('');
+        if (relPath.length < 2) relPath.unshift('');
+        result.pathname = relPath.join('/');
+      } else {
+        result.pathname = relative.pathname;
+      }
+      result.search = relative.search;
+      result.query = relative.query;
+      result.host = relative.host || '';
+      result.auth = relative.auth;
+      result.hostname = relative.hostname || relative.host;
+      result.port = relative.port;
+      // to support http.request
+      if (result.pathname || result.search) {
+        var p = result.pathname || '';
+        var s = result.search || '';
+        result.path = p + s;
+      }
+      result.slashes = result.slashes || relative.slashes;
+      result.href = result.format();
+      return result;
+    }
+
+    var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
+        isRelAbs = (
+            relative.host ||
+            relative.pathname && relative.pathname.charAt(0) === '/'
+        ),
+        mustEndAbs = (isRelAbs || isSourceAbs ||
+                      (result.host && relative.pathname)),
+        removeAllDots = mustEndAbs,
+        srcPath = result.pathname && result.pathname.split('/') || [],
+        relPath = relative.pathname && relative.pathname.split('/') || [],
+        psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+    // if the url is a non-slashed url, then relative
+    // links like ../.. should be able
+    // to crawl up to the hostname, as well.  This is strange.
+    // result.protocol has already been set by now.
+    // Later on, put the first path part into the host field.
+    if (psychotic) {
+      result.hostname = '';
+      result.port = null;
+      if (result.host) {
+        if (srcPath[0] === '') srcPath[0] = result.host;
+        else srcPath.unshift(result.host);
+      }
+      result.host = '';
+      if (relative.protocol) {
+        relative.hostname = null;
+        relative.port = null;
+        if (relative.host) {
+          if (relPath[0] === '') relPath[0] = relative.host;
+          else relPath.unshift(relative.host);
+        }
+        relative.host = null;
+      }
+      mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+    }
+
+    if (isRelAbs) {
+      // it's absolute.
+      result.host = (relative.host || relative.host === '') ?
+                    relative.host : result.host;
+      result.hostname = (relative.hostname || relative.hostname === '') ?
+                        relative.hostname : result.hostname;
+      result.search = relative.search;
+      result.query = relative.query;
+      srcPath = relPath;
+      // fall through to the dot-handling below.
+    } else if (relPath.length) {
+      // it's relative
+      // throw away the existing file, and take the new path instead.
+      if (!srcPath) srcPath = [];
+      srcPath.pop();
+      srcPath = srcPath.concat(relPath);
+      result.search = relative.search;
+      result.query = relative.query;
+    } else if (!util.isNullOrUndefined(relative.search)) {
+      // just pull out the search.
+      // like href='?foo'.
+      // Put this after the other two cases because it simplifies the booleans
+      if (psychotic) {
+        result.hostname = result.host = srcPath.shift();
+        //occationaly the auth can get stuck only in host
+        //this especially happens in cases like
+        //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+        var authInHost = result.host && result.host.indexOf('@') > 0 ?
+                         result.host.split('@') : false;
+        if (authInHost) {
+          result.auth = authInHost.shift();
+          result.host = result.hostname = authInHost.shift();
+        }
+      }
+      result.search = relative.search;
+      result.query = relative.query;
+      //to support http.request
+      if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+        result.path = (result.pathname ? result.pathname : '') +
+                      (result.search ? result.search : '');
+      }
+      result.href = result.format();
+      return result;
+    }
+
+    if (!srcPath.length) {
+      // no path at all.  easy.
+      // we've already handled the other stuff above.
+      result.pathname = null;
+      //to support http.request
+      if (result.search) {
+        result.path = '/' + result.search;
+      } else {
+        result.path = null;
+      }
+      result.href = result.format();
+      return result;
+    }
+
+    // if a url ENDs in . or .., then it must get a trailing slash.
+    // however, if it ends in anything else non-slashy,
+    // then it must NOT get a trailing slash.
+    var last = srcPath.slice(-1)[0];
+    var hasTrailingSlash = (
+        (result.host || relative.host || srcPath.length > 1) &&
+        (last === '.' || last === '..') || last === '');
+
+    // strip single dots, resolve double dots to parent dir
+    // if the path tries to go above the root, `up` ends up > 0
+    var up = 0;
+    for (var i = srcPath.length; i >= 0; i--) {
+      last = srcPath[i];
+      if (last === '.') {
+        srcPath.splice(i, 1);
+      } else if (last === '..') {
+        srcPath.splice(i, 1);
+        up++;
+      } else if (up) {
+        srcPath.splice(i, 1);
+        up--;
+      }
+    }
+
+    // if the path is allowed to go above the root, restore leading ..s
+    if (!mustEndAbs && !removeAllDots) {
+      for (; up--; up) {
+        srcPath.unshift('..');
+      }
+    }
+
+    if (mustEndAbs && srcPath[0] !== '' &&
+        (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+      srcPath.unshift('');
+    }
+
+    if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+      srcPath.push('');
+    }
+
+    var isAbsolute = srcPath[0] === '' ||
+        (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+    // put the host back
+    if (psychotic) {
+      result.hostname = result.host = isAbsolute ? '' :
+                                      srcPath.length ? srcPath.shift() : '';
+      //occationaly the auth can get stuck only in host
+      //this especially happens in cases like
+      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+      var authInHost = result.host && result.host.indexOf('@') > 0 ?
+                       result.host.split('@') : false;
+      if (authInHost) {
+        result.auth = authInHost.shift();
+        result.host = result.hostname = authInHost.shift();
+      }
+    }
+
+    mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+
+    if (mustEndAbs && !isAbsolute) {
+      srcPath.unshift('');
+    }
+
+    if (!srcPath.length) {
+      result.pathname = null;
+      result.path = null;
+    } else {
+      result.pathname = srcPath.join('/');
+    }
+
+    //to support request.http
+    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+      result.path = (result.pathname ? result.pathname : '') +
+                    (result.search ? result.search : '');
+    }
+    result.auth = relative.auth || result.auth;
+    result.slashes = result.slashes || relative.slashes;
+    result.href = result.format();
+    return result;
+  };
+
+  Url.prototype.parseHost = function() {
+    var host = this.host;
+    var port = portPattern.exec(host);
+    if (port) {
+      port = port[0];
+      if (port !== ':') {
+        this.port = port.substr(1);
+      }
+      host = host.substr(0, host.length - port.length);
+    }
+    if (host) this.hostname = host;
+  };
+
+  var url$1 = {
+  	parse: parse,
+  	resolve: resolve,
+  	resolveObject: resolveObject,
+  	format: format,
+  	Url: Url_1
+  };
+
+  const url = {
+    parse: parse,
+    format: format,
+    resolve: resolve
+  };
+
+  function assertPath(path2) {
+    if (typeof path2 !== "string") {
+      throw new TypeError(`Path must be a string. Received ${JSON.stringify(path2)}`);
+    }
+  }
+  function removeUrlParams(url) {
+    const re = url.split("?")[0];
+    return re.split("#")[0];
+  }
+  function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function replaceAll(str, find, replace) {
+    return str.replace(new RegExp(escapeRegExp(find), "g"), replace);
+  }
+  function normalizeStringPosix(path2, allowAboveRoot) {
+    let res = "";
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code = -1;
+    for (let i = 0; i <= path2.length; ++i) {
+      if (i < path2.length) {
+        code = path2.charCodeAt(i);
+      } else if (code === 47) {
+        break;
+      } else {
+        code = 47;
+      }
+      if (code === 47) {
+        if (lastSlash === i - 1 || dots === 1) {
+        } else if (lastSlash !== i - 1 && dots === 2) {
+          if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+            if (res.length > 2) {
+              const lastSlashIndex = res.lastIndexOf("/");
+              if (lastSlashIndex !== res.length - 1) {
+                if (lastSlashIndex === -1) {
+                  res = "";
+                  lastSegmentLength = 0;
+                } else {
+                  res = res.slice(0, lastSlashIndex);
+                  lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                }
+                lastSlash = i;
+                dots = 0;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSegmentLength = 0;
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            lastSegmentLength = 2;
+          }
+        } else {
+          if (res.length > 0) {
+            res += `/${path2.slice(lastSlash + 1, i)}`;
+          } else {
+            res = path2.slice(lastSlash + 1, i);
+          }
+          lastSegmentLength = i - lastSlash - 1;
+        }
+        lastSlash = i;
+        dots = 0;
+      } else if (code === 46 && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
+      }
+    }
+    return res;
+  }
+  const path = {
+    toPosix(path2) {
+      return replaceAll(path2, "\\", "/");
+    },
+    isUrl(path2) {
+      return /^https?:/.test(this.toPosix(path2));
+    },
+    isDataUrl(path2) {
+      return /^data:([a-z]+\/[a-z0-9-+.]+(;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}()_|~`]+)*)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s<>]*?)$/i.test(path2);
+    },
+    hasProtocol(path2) {
+      return /^[^/:]+:\//.test(this.toPosix(path2));
+    },
+    getProtocol(path2) {
+      assertPath(path2);
+      path2 = this.toPosix(path2);
+      let protocol = "";
+      const isFile = /^file:\/\/\//.exec(path2);
+      const isHttp = /^[^/:]+:\/\//.exec(path2);
+      const isWindows = /^[^/:]+:\//.exec(path2);
+      if (isFile || isHttp || isWindows) {
+        const arr = isFile?.[0] || isHttp?.[0] || isWindows?.[0];
+        protocol = arr;
+        path2 = path2.slice(arr.length);
+      }
+      return protocol;
+    },
+    toAbsolute(url, customBaseUrl, customRootUrl) {
+      if (this.isDataUrl(url))
+        return url;
+      const baseUrl = removeUrlParams(this.toPosix(customBaseUrl ?? settings.ADAPTER.getBaseUrl()));
+      const rootUrl = removeUrlParams(this.toPosix(customRootUrl ?? this.rootname(baseUrl)));
+      assertPath(url);
+      url = this.toPosix(url);
+      if (url.startsWith("/")) {
+        return path.join(rootUrl, url.slice(1));
+      }
+      const absolutePath = this.isAbsolute(url) ? url : this.join(baseUrl, url);
+      return absolutePath;
+    },
+    normalize(path2) {
+      path2 = this.toPosix(path2);
+      assertPath(path2);
+      if (path2.length === 0)
+        return ".";
+      let protocol = "";
+      const isAbsolute = path2.startsWith("/");
+      if (this.hasProtocol(path2)) {
+        protocol = this.rootname(path2);
+        path2 = path2.slice(protocol.length);
+      }
+      const trailingSeparator = path2.endsWith("/");
+      path2 = normalizeStringPosix(path2, false);
+      if (path2.length > 0 && trailingSeparator)
+        path2 += "/";
+      if (isAbsolute)
+        return `/${path2}`;
+      return protocol + path2;
+    },
+    isAbsolute(path2) {
+      assertPath(path2);
+      path2 = this.toPosix(path2);
+      if (this.hasProtocol(path2))
+        return true;
+      return path2.startsWith("/");
+    },
+    join(...segments) {
+      if (segments.length === 0) {
+        return ".";
+      }
+      let joined;
+      for (let i = 0; i < segments.length; ++i) {
+        const arg = segments[i];
+        assertPath(arg);
+        if (arg.length > 0) {
+          if (joined === void 0)
+            joined = arg;
+          else {
+            const prevArg = segments[i - 1] ?? "";
+            if (this.extname(prevArg)) {
+              joined += `/../${arg}`;
+            } else {
+              joined += `/${arg}`;
+            }
+          }
+        }
+      }
+      if (joined === void 0) {
+        return ".";
+      }
+      return this.normalize(joined);
+    },
+    dirname(path2) {
+      assertPath(path2);
+      if (path2.length === 0)
+        return ".";
+      path2 = this.toPosix(path2);
+      let code = path2.charCodeAt(0);
+      const hasRoot = code === 47;
+      let end = -1;
+      let matchedSlash = true;
+      const proto = this.getProtocol(path2);
+      const origpath = path2;
+      path2 = path2.slice(proto.length);
+      for (let i = path2.length - 1; i >= 1; --i) {
+        code = path2.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            end = i;
+            break;
+          }
+        } else {
+          matchedSlash = false;
+        }
+      }
+      if (end === -1)
+        return hasRoot ? "/" : this.isUrl(origpath) ? proto + path2 : proto;
+      if (hasRoot && end === 1)
+        return "//";
+      return proto + path2.slice(0, end);
+    },
+    rootname(path2) {
+      assertPath(path2);
+      path2 = this.toPosix(path2);
+      let root = "";
+      if (path2.startsWith("/"))
+        root = "/";
+      else {
+        root = this.getProtocol(path2);
+      }
+      if (this.isUrl(path2)) {
+        const index = path2.indexOf("/", root.length);
+        if (index !== -1) {
+          root = path2.slice(0, index);
+        } else
+          root = path2;
+        if (!root.endsWith("/"))
+          root += "/";
+      }
+      return root;
+    },
+    basename(path2, ext) {
+      assertPath(path2);
+      if (ext)
+        assertPath(ext);
+      path2 = removeUrlParams(this.toPosix(path2));
+      let start = 0;
+      let end = -1;
+      let matchedSlash = true;
+      let i;
+      if (ext !== void 0 && ext.length > 0 && ext.length <= path2.length) {
+        if (ext.length === path2.length && ext === path2)
+          return "";
+        let extIdx = ext.length - 1;
+        let firstNonSlashEnd = -1;
+        for (i = path2.length - 1; i >= 0; --i) {
+          const code = path2.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else {
+            if (firstNonSlashEnd === -1) {
+              matchedSlash = false;
+              firstNonSlashEnd = i + 1;
+            }
+            if (extIdx >= 0) {
+              if (code === ext.charCodeAt(extIdx)) {
+                if (--extIdx === -1) {
+                  end = i;
+                }
+              } else {
+                extIdx = -1;
+                end = firstNonSlashEnd;
+              }
+            }
+          }
+        }
+        if (start === end)
+          end = firstNonSlashEnd;
+        else if (end === -1)
+          end = path2.length;
+        return path2.slice(start, end);
+      }
+      for (i = path2.length - 1; i >= 0; --i) {
+        if (path2.charCodeAt(i) === 47) {
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+      if (end === -1)
+        return "";
+      return path2.slice(start, end);
+    },
+    extname(path2) {
+      assertPath(path2);
+      path2 = removeUrlParams(this.toPosix(path2));
+      let startDot = -1;
+      let startPart = 0;
+      let end = -1;
+      let matchedSlash = true;
+      let preDotState = 0;
+      for (let i = path2.length - 1; i >= 0; --i) {
+        const code = path2.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+        if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+        if (code === 46) {
+          if (startDot === -1)
+            startDot = i;
+          else if (preDotState !== 1)
+            preDotState = 1;
+        } else if (startDot !== -1) {
+          preDotState = -1;
+        }
+      }
+      if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+        return "";
+      }
+      return path2.slice(startDot, end);
+    },
+    parse(path2) {
+      assertPath(path2);
+      const ret = { root: "", dir: "", base: "", ext: "", name: "" };
+      if (path2.length === 0)
+        return ret;
+      path2 = removeUrlParams(this.toPosix(path2));
+      let code = path2.charCodeAt(0);
+      const isAbsolute = this.isAbsolute(path2);
+      let start;
+      const protocol = "";
+      ret.root = this.rootname(path2);
+      if (isAbsolute || this.hasProtocol(path2)) {
+        start = 1;
+      } else {
+        start = 0;
+      }
+      let startDot = -1;
+      let startPart = 0;
+      let end = -1;
+      let matchedSlash = true;
+      let i = path2.length - 1;
+      let preDotState = 0;
+      for (; i >= start; --i) {
+        code = path2.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+        if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+        if (code === 46) {
+          if (startDot === -1)
+            startDot = i;
+          else if (preDotState !== 1)
+            preDotState = 1;
+        } else if (startDot !== -1) {
+          preDotState = -1;
+        }
+      }
+      if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+        if (end !== -1) {
+          if (startPart === 0 && isAbsolute)
+            ret.base = ret.name = path2.slice(1, end);
+          else
+            ret.base = ret.name = path2.slice(startPart, end);
+        }
+      } else {
+        if (startPart === 0 && isAbsolute) {
+          ret.name = path2.slice(1, startDot);
+          ret.base = path2.slice(1, end);
+        } else {
+          ret.name = path2.slice(startPart, startDot);
+          ret.base = path2.slice(startPart, end);
+        }
+        ret.ext = path2.slice(startDot, end);
+      }
+      ret.dir = this.dirname(path2);
+      if (protocol)
+        ret.dir = protocol + ret.dir;
+      return ret;
+    },
+    sep: "/",
+    delimiter: ":"
+  };
+
+  const warnings = {};
+  function deprecation$1(version, message, ignoreDepth = 3) {
+    if (warnings[message]) {
+      return;
+    }
+    let stack = new Error().stack;
+    if (typeof stack === "undefined") {
+      console.warn("PixiJS Deprecation Warning: ", `${message}
+Deprecated since v${version}`);
+    } else {
+      stack = stack.split("\n").splice(ignoreDepth).join("\n");
+      if (console.groupCollapsed) {
+        console.groupCollapsed("%cPixiJS Deprecation Warning: %c%s", "color:#614108;background:#fffbe6", "font-weight:normal;color:#614108;background:#fffbe6", `${message}
+Deprecated since v${version}`);
+        console.warn(stack);
+        console.groupEnd();
+      } else {
+        console.warn("PixiJS Deprecation Warning: ", `${message}
+Deprecated since v${version}`);
+        console.warn(stack);
+      }
+    }
+    warnings[message] = true;
+  }
+
+  function skipHello() {
+    deprecation$1("7.0.0", "skipHello is deprecated, please use settings.RENDER_OPTIONS.hello");
+  }
+  function sayHello() {
+    deprecation$1("7.0.0", `sayHello is deprecated, please use Renderer's "hello" option`);
+  }
+
+  let supported;
+  function isWebGLSupported() {
+    if (typeof supported === "undefined") {
+      supported = function supported2() {
+        const contextOptions = {
+          stencil: true,
+          failIfMajorPerformanceCaveat: settings.FAIL_IF_MAJOR_PERFORMANCE_CAVEAT
+        };
+        try {
+          if (!settings.ADAPTER.getWebGLRenderingContext()) {
+            return false;
+          }
+          const canvas = settings.ADAPTER.createCanvas();
+          let gl = canvas.getContext("webgl", contextOptions) || canvas.getContext("experimental-webgl", contextOptions);
+          const success = !!gl?.getContextAttributes()?.stencil;
+          if (gl) {
+            const loseContext = gl.getExtension("WEBGL_lose_context");
+            if (loseContext) {
+              loseContext.loseContext();
+            }
+          }
+          gl = null;
+          return success;
+        } catch (e) {
+          return false;
+        }
+      }();
+    }
+    return supported;
+  }
+
+  var r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return "string"==typeof r?r.length>0:"number"==typeof r},n=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=Math.pow(10,t)),Math.round(n*r)/n+0},e=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=1),r>n?n:r>t?r:t},u=function(r){return (r=isFinite(r)?r%360:0)>0?r:r+360},a=function(r){return {r:e(r.r,0,255),g:e(r.g,0,255),b:e(r.b,0,255),a:e(r.a)}},o=function(r){return {r:n(r.r),g:n(r.g),b:n(r.b),a:n(r.a,3)}},i=/^#([0-9a-f]{3,8})$/i,s=function(r){var t=r.toString(16);return t.length<2?"0"+t:t},h=function(r){var t=r.r,n=r.g,e=r.b,u=r.a,a=Math.max(t,n,e),o=a-Math.min(t,n,e),i=o?a===t?(n-e)/o:a===n?2+(e-t)/o:4+(t-n)/o:0;return {h:60*(i<0?i+6:i),s:a?o/a*100:0,v:a/255*100,a:u}},b=function(r){var t=r.h,n=r.s,e=r.v,u=r.a;t=t/360*6,n/=100,e/=100;var a=Math.floor(t),o=e*(1-n),i=e*(1-(t-a)*n),s=e*(1-(1-t+a)*n),h=a%6;return {r:255*[e,i,o,o,s,e][h],g:255*[s,e,e,i,o,o][h],b:255*[o,o,s,e,e,i][h],a:u}},g=function(r){return {h:u(r.h),s:e(r.s,0,100),l:e(r.l,0,100),a:e(r.a)}},d=function(r){return {h:n(r.h),s:n(r.s),l:n(r.l),a:n(r.a,3)}},f=function(r){return b((n=(t=r).s,{h:t.h,s:(n*=((e=t.l)<50?e:100-e)/100)>0?2*n/(e+n)*100:0,v:e+n,a:t.a}));var t,n,e;},c=function(r){return {h:(t=h(r)).h,s:(u=(200-(n=t.s))*(e=t.v)/100)>0&&u<200?n*e/100/(u<=100?u:200-u)*100:0,l:u/2,a:t.a};var t,n,e,u;},l=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,p=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,v=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,m=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,y={string:[[function(r){var t=i.exec(r);return t?(r=t[1]).length<=4?{r:parseInt(r[0]+r[0],16),g:parseInt(r[1]+r[1],16),b:parseInt(r[2]+r[2],16),a:4===r.length?n(parseInt(r[3]+r[3],16)/255,2):1}:6===r.length||8===r.length?{r:parseInt(r.substr(0,2),16),g:parseInt(r.substr(2,2),16),b:parseInt(r.substr(4,2),16),a:8===r.length?n(parseInt(r.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(r){var t=v.exec(r)||m.exec(r);return t?t[2]!==t[4]||t[4]!==t[6]?null:a({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:void 0===t[7]?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(t){var n=l.exec(t)||p.exec(t);if(!n)return null;var e,u,a=g({h:(e=n[1],u=n[2],void 0===u&&(u="deg"),Number(e)*(r[u]||1)),s:Number(n[3]),l:Number(n[4]),a:void 0===n[5]?1:Number(n[5])/(n[6]?100:1)});return f(a)},"hsl"]],object:[[function(r){var n=r.r,e=r.g,u=r.b,o=r.a,i=void 0===o?1:o;return t(n)&&t(e)&&t(u)?a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},"rgb"],[function(r){var n=r.h,e=r.s,u=r.l,a=r.a,o=void 0===a?1:a;if(!t(n)||!t(e)||!t(u))return null;var i=g({h:Number(n),s:Number(e),l:Number(u),a:Number(o)});return f(i)},"hsl"],[function(r){var n=r.h,a=r.s,o=r.v,i=r.a,s=void 0===i?1:i;if(!t(n)||!t(a)||!t(o))return null;var h=function(r){return {h:u(r.h),s:e(r.s,0,100),v:e(r.v,0,100),a:e(r.a)}}({h:Number(n),s:Number(a),v:Number(o),a:Number(s)});return b(h)},"hsv"]]},N=function(r,t){for(var n=0;n<t.length;n++){var e=t[n][0](r);if(e)return [e,t[n][1]]}return [null,void 0]},x=function(r){return "string"==typeof r?N(r.trim(),y.string):"object"==typeof r&&null!==r?N(r,y.object):[null,void 0]},I=function(r){return x(r)[1]},M=function(r,t){var n=c(r);return {h:n.h,s:e(n.s+100*t,0,100),l:n.l,a:n.a}},H=function(r){return (299*r.r+587*r.g+114*r.b)/1e3/255},$=function(r,t){var n=c(r);return {h:n.h,s:n.s,l:e(n.l+100*t,0,100),a:n.a}},j=function(){function r(r){this.parsed=x(r)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1};}return r.prototype.isValid=function(){return null!==this.parsed},r.prototype.brightness=function(){return n(H(this.rgba),2)},r.prototype.isDark=function(){return H(this.rgba)<.5},r.prototype.isLight=function(){return H(this.rgba)>=.5},r.prototype.toHex=function(){return r=o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)<1?s(n(255*a)):"","#"+s(t)+s(e)+s(u)+i;var r,t,e,u,a,i;},r.prototype.toRgb=function(){return o(this.rgba)},r.prototype.toRgbString=function(){return r=o(this.rgba),t=r.r,n=r.g,e=r.b,(u=r.a)<1?"rgba("+t+", "+n+", "+e+", "+u+")":"rgb("+t+", "+n+", "+e+")";var r,t,n,e,u;},r.prototype.toHsl=function(){return d(c(this.rgba))},r.prototype.toHslString=function(){return r=d(c(this.rgba)),t=r.h,n=r.s,e=r.l,(u=r.a)<1?"hsla("+t+", "+n+"%, "+e+"%, "+u+")":"hsl("+t+", "+n+"%, "+e+"%)";var r,t,n,e,u;},r.prototype.toHsv=function(){return r=h(this.rgba),{h:n(r.h),s:n(r.s),v:n(r.v),a:n(r.a,3)};var r;},r.prototype.invert=function(){return w({r:255-(r=this.rgba).r,g:255-r.g,b:255-r.b,a:r.a});var r;},r.prototype.saturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,-r))},r.prototype.grayscale=function(){return w(M(this.rgba,-1))},r.prototype.lighten=function(r){return void 0===r&&(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&&(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&&(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return "number"==typeof r?w({r:(t=this.rgba).r,g:t.g,b:t.b,a:r}):n(this.rgba.a,3);var t;},r.prototype.hue=function(r){var t=c(this.rgba);return "number"==typeof r?w({h:r,s:t.s,l:t.l,a:t.a}):n(t.h)},r.prototype.isEqual=function(r){return this.toHex()===w(r).toHex()},r}(),w=function(r){return r instanceof j?r:new j(r)},S=[],k=function(r){r.forEach(function(r){S.indexOf(r)<0&&(r(j,y),S.push(r));});},E=function(){return new j({r:255*Math.random(),g:255*Math.random(),b:255*Math.random()})};
+
+  function namesPlugin(e,f){var a={white:"#ffffff",bisque:"#ffe4c4",blue:"#0000ff",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",antiquewhite:"#faebd7",aqua:"#00ffff",azure:"#f0ffff",whitesmoke:"#f5f5f5",papayawhip:"#ffefd5",plum:"#dda0dd",blanchedalmond:"#ffebcd",black:"#000000",gold:"#ffd700",goldenrod:"#daa520",gainsboro:"#dcdcdc",cornsilk:"#fff8dc",cornflowerblue:"#6495ed",burlywood:"#deb887",aquamarine:"#7fffd4",beige:"#f5f5dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkkhaki:"#bdb76b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",peachpuff:"#ffdab9",darkmagenta:"#8b008b",darkred:"#8b0000",darkorchid:"#9932cc",darkorange:"#ff8c00",darkslateblue:"#483d8b",gray:"#808080",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",deeppink:"#ff1493",deepskyblue:"#00bfff",wheat:"#f5deb3",firebrick:"#b22222",floralwhite:"#fffaf0",ghostwhite:"#f8f8ff",darkviolet:"#9400d3",magenta:"#ff00ff",green:"#008000",dodgerblue:"#1e90ff",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",blueviolet:"#8a2be2",forestgreen:"#228b22",lawngreen:"#7cfc00",indianred:"#cd5c5c",indigo:"#4b0082",fuchsia:"#ff00ff",brown:"#a52a2a",maroon:"#800000",mediumblue:"#0000cd",lightcoral:"#f08080",darkturquoise:"#00ced1",lightcyan:"#e0ffff",ivory:"#fffff0",lightyellow:"#ffffe0",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",linen:"#faf0e6",mediumaquamarine:"#66cdaa",lemonchiffon:"#fffacd",lime:"#00ff00",khaki:"#f0e68c",mediumseagreen:"#3cb371",limegreen:"#32cd32",mediumspringgreen:"#00fa9a",lightskyblue:"#87cefa",lightblue:"#add8e6",midnightblue:"#191970",lightpink:"#ffb6c1",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",mintcream:"#f5fffa",lightslategray:"#778899",lightslategrey:"#778899",navajowhite:"#ffdead",navy:"#000080",mediumvioletred:"#c71585",powderblue:"#b0e0e6",palegoldenrod:"#eee8aa",oldlace:"#fdf5e6",paleturquoise:"#afeeee",mediumturquoise:"#48d1cc",mediumorchid:"#ba55d3",rebeccapurple:"#663399",lightsteelblue:"#b0c4de",mediumslateblue:"#7b68ee",thistle:"#d8bfd8",tan:"#d2b48c",orchid:"#da70d6",mediumpurple:"#9370db",purple:"#800080",pink:"#ffc0cb",skyblue:"#87ceeb",springgreen:"#00ff7f",palegreen:"#98fb98",red:"#ff0000",yellow:"#ffff00",slateblue:"#6a5acd",lavenderblush:"#fff0f5",peru:"#cd853f",palevioletred:"#db7093",violet:"#ee82ee",teal:"#008080",slategray:"#708090",slategrey:"#708090",aliceblue:"#f0f8ff",darkseagreen:"#8fbc8f",darkolivegreen:"#556b2f",greenyellow:"#adff2f",seagreen:"#2e8b57",seashell:"#fff5ee",tomato:"#ff6347",silver:"#c0c0c0",sienna:"#a0522d",lavender:"#e6e6fa",lightgreen:"#90ee90",orange:"#ffa500",orangered:"#ff4500",steelblue:"#4682b4",royalblue:"#4169e1",turquoise:"#40e0d0",yellowgreen:"#9acd32",salmon:"#fa8072",saddlebrown:"#8b4513",sandybrown:"#f4a460",rosybrown:"#bc8f8f",darksalmon:"#e9967a",lightgoldenrodyellow:"#fafad2",snow:"#fffafa",lightgrey:"#d3d3d3",lightgray:"#d3d3d3",dimgray:"#696969",dimgrey:"#696969",olivedrab:"#6b8e23",olive:"#808000"},r={};for(var d in a)r[a[d]]=d;var l={};e.prototype.toName=function(f){if(!(this.rgba.a||this.rgba.r||this.rgba.g||this.rgba.b))return "transparent";var d,i,n=r[this.toHex()];if(n)return n;if(null==f?void 0:f.closest){var o=this.toRgb(),t=1/0,b="black";if(!l.length)for(var c in a)l[c]=new e(a[c]).toRgb();for(var g in a){var u=(d=o,i=l[g],Math.pow(d.r-i.r,2)+Math.pow(d.g-i.g,2)+Math.pow(d.b-i.b,2));u<t&&(t=u,b=g);}return b}};f.string.push([function(f){var r=f.toLowerCase(),d="transparent"===r?"#0000":a[r];return d?new e(d).toRgb():null},"name"]);}
+
+  k([namesPlugin]);
+  const _Color = class {
+    constructor(value = 16777215) {
+      this._value = null;
+      this._components = new Float32Array(4);
+      this._components.fill(1);
+      this._int = 16777215;
+      this.value = value;
+    }
+    get red() {
+      return this._components[0];
+    }
+    get green() {
+      return this._components[1];
+    }
+    get blue() {
+      return this._components[2];
+    }
+    get alpha() {
+      return this._components[3];
+    }
+    setValue(value) {
+      this.value = value;
+      return this;
+    }
+    set value(value) {
+      if (value instanceof _Color) {
+        this._value = this.cloneSource(value._value);
+        this._int = value._int;
+        this._components.set(value._components);
+      } else if (value === null) {
+        throw new Error("Cannot set PIXI.Color#value to null");
+      } else if (this._value === null || !this.isSourceEqual(this._value, value)) {
+        this.normalize(value);
+        this._value = this.cloneSource(value);
+      }
+    }
+    get value() {
+      return this._value;
+    }
+    cloneSource(value) {
+      if (typeof value === "string" || typeof value === "number" || value instanceof Number || value === null) {
+        return value;
+      } else if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+        return value.slice(0);
+      } else if (typeof value === "object" && value !== null) {
+        return { ...value };
+      }
+      return value;
+    }
+    isSourceEqual(value1, value2) {
+      const type1 = typeof value1;
+      const type2 = typeof value2;
+      if (type1 !== type2) {
+        return false;
+      } else if (type1 === "number" || type1 === "string" || value1 instanceof Number) {
+        return value1 === value2;
+      } else if (Array.isArray(value1) && Array.isArray(value2) || ArrayBuffer.isView(value1) && ArrayBuffer.isView(value2)) {
+        if (value1.length !== value2.length) {
+          return false;
+        }
+        return value1.every((v, i) => v === value2[i]);
+      } else if (value1 !== null && value2 !== null) {
+        const keys1 = Object.keys(value1);
+        const keys2 = Object.keys(value2);
+        if (keys1.length !== keys2.length) {
+          return false;
+        }
+        return keys1.every((key) => value1[key] === value2[key]);
+      }
+      return value1 === value2;
+    }
+    toRgba() {
+      const [r, g, b, a] = this._components;
+      return { r, g, b, a };
+    }
+    toRgb() {
+      const [r, g, b] = this._components;
+      return { r, g, b };
+    }
+    toRgbaString() {
+      const [r, g, b] = this.toUint8RgbArray();
+      return `rgba(${r},${g},${b},${this.alpha})`;
+    }
+    toUint8RgbArray(out) {
+      const [r, g, b] = this._components;
+      out = out ?? [];
+      out[0] = Math.round(r * 255);
+      out[1] = Math.round(g * 255);
+      out[2] = Math.round(b * 255);
+      return out;
+    }
+    toRgbArray(out) {
+      out = out ?? [];
+      const [r, g, b] = this._components;
+      out[0] = r;
+      out[1] = g;
+      out[2] = b;
+      return out;
+    }
+    toNumber() {
+      return this._int;
+    }
+    toLittleEndianNumber() {
+      const value = this._int;
+      return (value >> 16) + (value & 65280) + ((value & 255) << 16);
+    }
+    multiply(value) {
+      const [r, g, b, a] = _Color.temp.setValue(value)._components;
+      this._components[0] *= r;
+      this._components[1] *= g;
+      this._components[2] *= b;
+      this._components[3] *= a;
+      this.refreshInt();
+      this._value = null;
+      return this;
+    }
+    premultiply(alpha, applyToRGB = true) {
+      if (applyToRGB) {
+        this._components[0] *= alpha;
+        this._components[1] *= alpha;
+        this._components[2] *= alpha;
+      }
+      this._components[3] = alpha;
+      this.refreshInt();
+      this._value = null;
+      return this;
+    }
+    toPremultiplied(alpha, applyToRGB = true) {
+      if (alpha === 1) {
+        return (255 << 24) + this._int;
+      }
+      if (alpha === 0) {
+        return applyToRGB ? 0 : this._int;
+      }
+      let r = this._int >> 16 & 255;
+      let g = this._int >> 8 & 255;
+      let b = this._int & 255;
+      if (applyToRGB) {
+        r = r * alpha + 0.5 | 0;
+        g = g * alpha + 0.5 | 0;
+        b = b * alpha + 0.5 | 0;
+      }
+      return (alpha * 255 << 24) + (r << 16) + (g << 8) + b;
+    }
+    toHex() {
+      const hexString = this._int.toString(16);
+      return `#${"000000".substring(0, 6 - hexString.length) + hexString}`;
+    }
+    toHexa() {
+      const alphaValue = Math.round(this._components[3] * 255);
+      const alphaString = alphaValue.toString(16);
+      return this.toHex() + "00".substring(0, 2 - alphaString.length) + alphaString;
+    }
+    setAlpha(alpha) {
+      this._components[3] = this._clamp(alpha);
+      return this;
+    }
+    round(steps) {
+      const [r, g, b] = this._components;
+      this._components[0] = Math.round(r * steps) / steps;
+      this._components[1] = Math.round(g * steps) / steps;
+      this._components[2] = Math.round(b * steps) / steps;
+      this.refreshInt();
+      this._value = null;
+      return this;
+    }
+    toArray(out) {
+      out = out ?? [];
+      const [r, g, b, a] = this._components;
+      out[0] = r;
+      out[1] = g;
+      out[2] = b;
+      out[3] = a;
+      return out;
+    }
+    normalize(value) {
+      let r;
+      let g;
+      let b;
+      let a;
+      if ((typeof value === "number" || value instanceof Number) && value >= 0 && value <= 16777215) {
+        const int = value;
+        r = (int >> 16 & 255) / 255;
+        g = (int >> 8 & 255) / 255;
+        b = (int & 255) / 255;
+        a = 1;
+      } else if ((Array.isArray(value) || value instanceof Float32Array) && value.length >= 3 && value.length <= 4) {
+        value = this._clamp(value);
+        [r, g, b, a = 1] = value;
+      } else if ((value instanceof Uint8Array || value instanceof Uint8ClampedArray) && value.length >= 3 && value.length <= 4) {
+        value = this._clamp(value, 0, 255);
+        [r, g, b, a = 255] = value;
+        r /= 255;
+        g /= 255;
+        b /= 255;
+        a /= 255;
+      } else if (typeof value === "string" || typeof value === "object") {
+        if (typeof value === "string") {
+          const match = _Color.HEX_PATTERN.exec(value);
+          if (match) {
+            value = `#${match[2]}`;
+          }
+        }
+        const color = w(value);
+        if (color.isValid()) {
+          ({ r, g, b, a } = color.rgba);
+          r /= 255;
+          g /= 255;
+          b /= 255;
+        }
+      }
+      if (r !== void 0) {
+        this._components[0] = r;
+        this._components[1] = g;
+        this._components[2] = b;
+        this._components[3] = a;
+        this.refreshInt();
+      } else {
+        throw new Error(`Unable to convert color ${value}`);
+      }
+    }
+    refreshInt() {
+      this._clamp(this._components);
+      const [r, g, b] = this._components;
+      this._int = (r * 255 << 16) + (g * 255 << 8) + (b * 255 | 0);
+    }
+    _clamp(value, min = 0, max = 1) {
+      if (typeof value === "number") {
+        return Math.min(Math.max(value, min), max);
+      }
+      value.forEach((v, i) => {
+        value[i] = Math.min(Math.max(v, min), max);
+      });
+      return value;
+    }
+  };
+  let Color = _Color;
+  Color.shared = new _Color();
+  Color.temp = new _Color();
+  Color.HEX_PATTERN = /^(#|0x)?(([a-f0-9]{3}){1,2}([a-f0-9]{2})?)$/i;
+
+  function hex2rgb(hex, out = []) {
+    deprecation$1("7.2.0", "utils.hex2rgb is deprecated, use Color#toRgbArray instead");
+    return Color.shared.setValue(hex).toRgbArray(out);
+  }
+  function hex2string(hex) {
+    deprecation$1("7.2.0", "utils.hex2string is deprecated, use Color#toHex instead");
+    return Color.shared.setValue(hex).toHex();
+  }
+  function string2hex(string) {
+    deprecation$1("7.2.0", "utils.string2hex is deprecated, use Color#toNumber instead");
+    return Color.shared.setValue(string).toNumber();
+  }
+  function rgb2hex(rgb) {
+    deprecation$1("7.2.0", "utils.rgb2hex is deprecated, use Color#toNumber instead");
+    return Color.shared.setValue(rgb).toNumber();
+  }
+
+  function mapPremultipliedBlendModes() {
+    const pm = [];
+    const npm = [];
+    for (let i = 0; i < 32; i++) {
+      pm[i] = i;
+      npm[i] = i;
+    }
+    pm[BLEND_MODES.NORMAL_NPM] = BLEND_MODES.NORMAL;
+    pm[BLEND_MODES.ADD_NPM] = BLEND_MODES.ADD;
+    pm[BLEND_MODES.SCREEN_NPM] = BLEND_MODES.SCREEN;
+    npm[BLEND_MODES.NORMAL] = BLEND_MODES.NORMAL_NPM;
+    npm[BLEND_MODES.ADD] = BLEND_MODES.ADD_NPM;
+    npm[BLEND_MODES.SCREEN] = BLEND_MODES.SCREEN_NPM;
+    const array = [];
+    array.push(npm);
+    array.push(pm);
+    return array;
+  }
+  const premultiplyBlendMode = mapPremultipliedBlendModes();
+  function correctBlendMode(blendMode, premultiplied) {
+    return premultiplyBlendMode[premultiplied ? 1 : 0][blendMode];
+  }
+  function premultiplyRgba(rgb, alpha, out, premultiply = true) {
+    deprecation$1("7.2.0", `utils.premultiplyRgba has moved to Color.premultiply`);
+    return Color.shared.setValue(rgb).premultiply(alpha, premultiply).toArray(out ?? new Float32Array(4));
+  }
+  function premultiplyTint(tint, alpha) {
+    deprecation$1("7.2.0", `utils.premultiplyTint has moved to Color.toPremultiplied`);
+    return Color.shared.setValue(tint).toPremultiplied(alpha);
+  }
+  function premultiplyTintToRgba(tint, alpha, out, premultiply = true) {
+    deprecation$1("7.2.0", `utils.premultiplyTintToRgba has moved to Color.premultiply`);
+    return Color.shared.setValue(tint).premultiply(alpha, premultiply).toArray(out ?? new Float32Array(4));
+  }
+
+  const DATA_URI = /^\s*data:(?:([\w-]+)\/([\w+.-]+))?(?:;charset=([\w-]+))?(?:;(base64))?,(.*)/i;
+
+  function createIndicesForQuads(size, outBuffer = null) {
+    const totalIndices = size * 6;
+    outBuffer = outBuffer || new Uint16Array(totalIndices);
+    if (outBuffer.length !== totalIndices) {
+      throw new Error(`Out buffer length is incorrect, got ${outBuffer.length} and expected ${totalIndices}`);
+    }
+    for (let i = 0, j = 0; i < totalIndices; i += 6, j += 4) {
+      outBuffer[i + 0] = j + 0;
+      outBuffer[i + 1] = j + 1;
+      outBuffer[i + 2] = j + 2;
+      outBuffer[i + 3] = j + 0;
+      outBuffer[i + 4] = j + 2;
+      outBuffer[i + 5] = j + 3;
+    }
+    return outBuffer;
+  }
+
+  function getBufferType(array) {
+    if (array.BYTES_PER_ELEMENT === 4) {
+      if (array instanceof Float32Array) {
+        return "Float32Array";
+      } else if (array instanceof Uint32Array) {
+        return "Uint32Array";
+      }
+      return "Int32Array";
+    } else if (array.BYTES_PER_ELEMENT === 2) {
+      if (array instanceof Uint16Array) {
+        return "Uint16Array";
+      }
+    } else if (array.BYTES_PER_ELEMENT === 1) {
+      if (array instanceof Uint8Array) {
+        return "Uint8Array";
+      }
+    }
+    return null;
+  }
+
+  const map$2 = { Float32Array, Uint32Array, Int32Array, Uint8Array };
+  function interleaveTypedArrays$1(arrays, sizes) {
+    let outSize = 0;
+    let stride = 0;
+    const views = {};
+    for (let i = 0; i < arrays.length; i++) {
+      stride += sizes[i];
+      outSize += arrays[i].length;
+    }
+    const buffer = new ArrayBuffer(outSize * 4);
+    let out = null;
+    let littleOffset = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const size = sizes[i];
+      const array = arrays[i];
+      const type = getBufferType(array);
+      if (!views[type]) {
+        views[type] = new map$2[type](buffer);
+      }
+      out = views[type];
+      for (let j = 0; j < array.length; j++) {
+        const indexStart = (j / size | 0) * stride + littleOffset;
+        const index = j % size;
+        out[indexStart + index] = array[j];
+      }
+      littleOffset += size;
+    }
+    return new Float32Array(buffer);
+  }
+
+  function nextPow2(v) {
+    v += v === 0 ? 1 : 0;
+    --v;
+    v |= v >>> 1;
+    v |= v >>> 2;
+    v |= v >>> 4;
+    v |= v >>> 8;
+    v |= v >>> 16;
+    return v + 1;
+  }
+  function isPow2(v) {
+    return !(v & v - 1) && !!v;
+  }
+  function log2(v) {
+    let r = (v > 65535 ? 1 : 0) << 4;
+    v >>>= r;
+    let shift = (v > 255 ? 1 : 0) << 3;
+    v >>>= shift;
+    r |= shift;
+    shift = (v > 15 ? 1 : 0) << 2;
+    v >>>= shift;
+    r |= shift;
+    shift = (v > 3 ? 1 : 0) << 1;
+    v >>>= shift;
+    r |= shift;
+    return r | v >> 1;
+  }
+
+  function removeItems(arr, startIdx, removeCount) {
+    const length = arr.length;
+    let i;
+    if (startIdx >= length || removeCount === 0) {
+      return;
+    }
+    removeCount = startIdx + removeCount > length ? length - startIdx : removeCount;
+    const len = length - removeCount;
+    for (i = startIdx; i < len; ++i) {
+      arr[i] = arr[i + removeCount];
+    }
+    arr.length = len;
+  }
+
+  function sign(n) {
+    if (n === 0)
+      return 0;
+    return n < 0 ? -1 : 1;
+  }
+
+  let nextUid = 0;
+  function uid() {
+    return ++nextUid;
+  }
+
+  const _BoundingBox = class {
+    constructor(left, top, right, bottom) {
+      this.left = left;
+      this.top = top;
+      this.right = right;
+      this.bottom = bottom;
+    }
+    get width() {
+      return this.right - this.left;
+    }
+    get height() {
+      return this.bottom - this.top;
+    }
+    isEmpty() {
+      return this.left === this.right || this.top === this.bottom;
+    }
+  };
+  let BoundingBox = _BoundingBox;
+  BoundingBox.EMPTY = new _BoundingBox(0, 0, 0, 0);
+
+  const ProgramCache = {};
+  const TextureCache = /* @__PURE__ */ Object.create(null);
+  const BaseTextureCache = /* @__PURE__ */ Object.create(null);
+  function destroyTextureCache() {
+    let key;
+    for (key in TextureCache) {
+      TextureCache[key].destroy();
+    }
+    for (key in BaseTextureCache) {
+      BaseTextureCache[key].destroy();
+    }
+  }
+  function clearTextureCache() {
+    let key;
+    for (key in TextureCache) {
+      delete TextureCache[key];
+    }
+    for (key in BaseTextureCache) {
+      delete BaseTextureCache[key];
+    }
+  }
+
+  class CanvasRenderTarget {
+    constructor(width, height, resolution) {
+      this._canvas = settings.ADAPTER.createCanvas();
+      this._context = this._canvas.getContext("2d");
+      this.resolution = resolution || settings.RESOLUTION;
+      this.resize(width, height);
+    }
+    clear() {
+      this._checkDestroyed();
+      this._context.setTransform(1, 0, 0, 1, 0, 0);
+      this._context.clearRect(0, 0, this._canvas.width, this._canvas.height);
+    }
+    resize(desiredWidth, desiredHeight) {
+      this._checkDestroyed();
+      this._canvas.width = Math.round(desiredWidth * this.resolution);
+      this._canvas.height = Math.round(desiredHeight * this.resolution);
+    }
+    destroy() {
+      this._context = null;
+      this._canvas = null;
+    }
+    get width() {
+      this._checkDestroyed();
+      return this._canvas.width;
+    }
+    set width(val) {
+      this._checkDestroyed();
+      this._canvas.width = Math.round(val);
+    }
+    get height() {
+      this._checkDestroyed();
+      return this._canvas.height;
+    }
+    set height(val) {
+      this._checkDestroyed();
+      this._canvas.height = Math.round(val);
+    }
+    get canvas() {
+      this._checkDestroyed();
+      return this._canvas;
+    }
+    get context() {
+      this._checkDestroyed();
+      return this._context;
+    }
+    _checkDestroyed() {
+      if (this._canvas === null) {
+        throw new TypeError("The CanvasRenderTarget has already been destroyed");
+      }
+    }
+  }
+
+  function checkRow(data, width, y) {
+    for (let x = 0, index = 4 * y * width; x < width; ++x, index += 4) {
+      if (data[index + 3] !== 0)
+        return false;
+    }
+    return true;
+  }
+  function checkColumn(data, width, x, top, bottom) {
+    const stride = 4 * width;
+    for (let y = top, index = top * stride + 4 * x; y <= bottom; ++y, index += stride) {
+      if (data[index + 3] !== 0)
+        return false;
+    }
+    return true;
+  }
+  function getCanvasBoundingBox(canvas) {
+    const { width, height } = canvas;
+    const context = canvas.getContext("2d", {
+      willReadFrequently: true
+    });
+    if (context === null) {
+      throw new TypeError("Failed to get canvas 2D context");
+    }
+    const imageData = context.getImageData(0, 0, width, height);
+    const data = imageData.data;
+    let left = 0;
+    let top = 0;
+    let right = width - 1;
+    let bottom = height - 1;
+    while (top < height && checkRow(data, width, top))
+      ++top;
+    if (top === height)
+      return BoundingBox.EMPTY;
+    while (checkRow(data, width, bottom))
+      --bottom;
+    while (checkColumn(data, width, left, top, bottom))
+      ++left;
+    while (checkColumn(data, width, right, top, bottom))
+      --right;
+    ++right;
+    ++bottom;
+    return new BoundingBox(left, top, right, bottom);
+  }
+
+  function trimCanvas(canvas) {
+    const boundingBox = getCanvasBoundingBox(canvas);
+    const { width, height } = boundingBox;
+    let data = null;
+    if (!boundingBox.isEmpty()) {
+      const context = canvas.getContext("2d");
+      if (context === null) {
+        throw new TypeError("Failed to get canvas 2D context");
+      }
+      data = context.getImageData(boundingBox.left, boundingBox.top, width, height);
+    }
+    return { width, height, data };
+  }
+
+  function decomposeDataUri(dataUri) {
+    const dataUriMatch = DATA_URI.exec(dataUri);
+    if (dataUriMatch) {
+      return {
+        mediaType: dataUriMatch[1] ? dataUriMatch[1].toLowerCase() : void 0,
+        subType: dataUriMatch[2] ? dataUriMatch[2].toLowerCase() : void 0,
+        charset: dataUriMatch[3] ? dataUriMatch[3].toLowerCase() : void 0,
+        encoding: dataUriMatch[4] ? dataUriMatch[4].toLowerCase() : void 0,
+        data: dataUriMatch[5]
+      };
+    }
+    return void 0;
+  }
+
+  let tempAnchor;
+  function determineCrossOrigin(url$1, loc = globalThis.location) {
+    if (url$1.startsWith("data:")) {
+      return "";
+    }
+    loc = loc || globalThis.location;
+    if (!tempAnchor) {
+      tempAnchor = document.createElement("a");
+    }
+    tempAnchor.href = url$1;
+    const parsedUrl = url.parse(tempAnchor.href);
+    const samePort = !parsedUrl.port && loc.port === "" || parsedUrl.port === loc.port;
+    if (parsedUrl.hostname !== loc.hostname || !samePort || parsedUrl.protocol !== loc.protocol) {
+      return "anonymous";
+    }
+    return "";
+  }
+
+  function getResolutionOfUrl(url, defaultValue = 1) {
+    const resolution = settings.RETINA_PREFIX?.exec(url);
+    if (resolution) {
+      return parseFloat(resolution[1]);
+    }
+    return defaultValue;
+  }
+
+  var utils = {
+    __proto__: null,
+    isMobile: isMobile,
+    EventEmitter: eventemitter3,
+    earcut: earcut_1,
+    url: url,
+    path: path,
+    sayHello: sayHello,
+    skipHello: skipHello,
+    isWebGLSupported: isWebGLSupported,
+    hex2rgb: hex2rgb,
+    hex2string: hex2string,
+    rgb2hex: rgb2hex,
+    string2hex: string2hex,
+    correctBlendMode: correctBlendMode,
+    premultiplyBlendMode: premultiplyBlendMode,
+    premultiplyRgba: premultiplyRgba,
+    premultiplyTint: premultiplyTint,
+    premultiplyTintToRgba: premultiplyTintToRgba,
+    DATA_URI: DATA_URI,
+    createIndicesForQuads: createIndicesForQuads,
+    getBufferType: getBufferType,
+    interleaveTypedArrays: interleaveTypedArrays$1,
+    isPow2: isPow2,
+    log2: log2,
+    nextPow2: nextPow2,
+    removeItems: removeItems,
+    sign: sign,
+    uid: uid,
+    deprecation: deprecation$1,
+    BoundingBox: BoundingBox,
+    BaseTextureCache: BaseTextureCache,
+    ProgramCache: ProgramCache,
+    TextureCache: TextureCache,
+    clearTextureCache: clearTextureCache,
+    destroyTextureCache: destroyTextureCache,
+    CanvasRenderTarget: CanvasRenderTarget,
+    getCanvasBoundingBox: getCanvasBoundingBox,
+    trimCanvas: trimCanvas,
+    decomposeDataUri: decomposeDataUri,
+    determineCrossOrigin: determineCrossOrigin,
+    getResolutionOfUrl: getResolutionOfUrl
+  };
+
+  var ExtensionType = /* @__PURE__ */ ((ExtensionType2) => {
+    ExtensionType2["Renderer"] = "renderer";
+    ExtensionType2["Application"] = "application";
+    ExtensionType2["RendererSystem"] = "renderer-webgl-system";
+    ExtensionType2["RendererPlugin"] = "renderer-webgl-plugin";
+    ExtensionType2["CanvasRendererSystem"] = "renderer-canvas-system";
+    ExtensionType2["CanvasRendererPlugin"] = "renderer-canvas-plugin";
+    ExtensionType2["Asset"] = "asset";
+    ExtensionType2["LoadParser"] = "load-parser";
+    ExtensionType2["ResolveParser"] = "resolve-parser";
+    ExtensionType2["CacheParser"] = "cache-parser";
+    ExtensionType2["DetectionParser"] = "detection-parser";
+    return ExtensionType2;
+  })(ExtensionType || {});
+  const normalizeExtension = (ext) => {
+    if (typeof ext === "function" || typeof ext === "object" && ext.extension) {
+      if (!ext.extension) {
+        throw new Error("Extension class must have an extension object");
+      }
+      const metadata = typeof ext.extension !== "object" ? { type: ext.extension } : ext.extension;
+      ext = { ...metadata, ref: ext };
+    }
+    if (typeof ext === "object") {
+      ext = { ...ext };
+    } else {
+      throw new Error("Invalid extension type");
+    }
+    if (typeof ext.type === "string") {
+      ext.type = [ext.type];
+    }
+    return ext;
+  };
+  const normalizePriority = (ext, defaultPriority) => normalizeExtension(ext).priority ?? defaultPriority;
+  const extensions$1 = {
+    _addHandlers: {},
+    _removeHandlers: {},
+    _queue: {},
+    remove(...extensions2) {
+      extensions2.map(normalizeExtension).forEach((ext) => {
+        ext.type.forEach((type) => this._removeHandlers[type]?.(ext));
+      });
+      return this;
+    },
+    add(...extensions2) {
+      extensions2.map(normalizeExtension).forEach((ext) => {
+        ext.type.forEach((type) => {
+          const handlers = this._addHandlers;
+          const queue = this._queue;
+          if (!handlers[type]) {
+            queue[type] = queue[type] || [];
+            queue[type].push(ext);
+          } else {
+            handlers[type](ext);
+          }
+        });
+      });
+      return this;
+    },
+    handle(type, onAdd, onRemove) {
+      const addHandlers = this._addHandlers;
+      const removeHandlers = this._removeHandlers;
+      if (addHandlers[type] || removeHandlers[type]) {
+        throw new Error(`Extension type ${type} already has a handler`);
+      }
+      addHandlers[type] = onAdd;
+      removeHandlers[type] = onRemove;
+      const queue = this._queue;
+      if (queue[type]) {
+        queue[type].forEach((ext) => onAdd(ext));
+        delete queue[type];
+      }
+      return this;
+    },
+    handleByMap(type, map) {
+      return this.handle(type, (extension) => {
+        map[extension.name] = extension.ref;
+      }, (extension) => {
+        delete map[extension.name];
+      });
+    },
+    handleByList(type, list, defaultPriority = -1) {
+      return this.handle(type, (extension) => {
+        if (list.includes(extension.ref)) {
+          return;
+        }
+        list.push(extension.ref);
+        list.sort((a, b) => normalizePriority(b, defaultPriority) - normalizePriority(a, defaultPriority));
+      }, (extension) => {
+        const index = list.indexOf(extension.ref);
+        if (index !== -1) {
+          list.splice(index, 1);
+        }
+      });
+    }
+  };
+
+  class ViewableBuffer {
+    constructor(sizeOrBuffer) {
+      if (typeof sizeOrBuffer === "number") {
+        this.rawBinaryData = new ArrayBuffer(sizeOrBuffer);
+      } else if (sizeOrBuffer instanceof Uint8Array) {
+        this.rawBinaryData = sizeOrBuffer.buffer;
+      } else {
+        this.rawBinaryData = sizeOrBuffer;
+      }
+      this.uint32View = new Uint32Array(this.rawBinaryData);
+      this.float32View = new Float32Array(this.rawBinaryData);
+    }
+    get int8View() {
+      if (!this._int8View) {
+        this._int8View = new Int8Array(this.rawBinaryData);
+      }
+      return this._int8View;
+    }
+    get uint8View() {
+      if (!this._uint8View) {
+        this._uint8View = new Uint8Array(this.rawBinaryData);
+      }
+      return this._uint8View;
+    }
+    get int16View() {
+      if (!this._int16View) {
+        this._int16View = new Int16Array(this.rawBinaryData);
+      }
+      return this._int16View;
+    }
+    get uint16View() {
+      if (!this._uint16View) {
+        this._uint16View = new Uint16Array(this.rawBinaryData);
+      }
+      return this._uint16View;
+    }
+    get int32View() {
+      if (!this._int32View) {
+        this._int32View = new Int32Array(this.rawBinaryData);
+      }
+      return this._int32View;
+    }
+    view(type) {
+      return this[`${type}View`];
+    }
+    destroy() {
+      this.rawBinaryData = null;
+      this._int8View = null;
+      this._uint8View = null;
+      this._int16View = null;
+      this._uint16View = null;
+      this._int32View = null;
+      this.uint32View = null;
+      this.float32View = null;
+    }
+    static sizeOf(type) {
+      switch (type) {
+        case "int8":
+        case "uint8":
+          return 1;
+        case "int16":
+        case "uint16":
+          return 2;
+        case "int32":
+        case "uint32":
+        case "float32":
+          return 4;
+        default:
+          throw new Error(`${type} isn't a valid view type`);
+      }
+    }
+  }
+
+  const fragTemplate$1 = [
+    "precision mediump float;",
+    "void main(void){",
+    "float test = 0.1;",
+    "%forloop%",
+    "gl_FragColor = vec4(0.0);",
+    "}"
+  ].join("\n");
+  function generateIfTestSrc(maxIfs) {
+    let src = "";
+    for (let i = 0; i < maxIfs; ++i) {
+      if (i > 0) {
+        src += "\nelse ";
+      }
+      if (i < maxIfs - 1) {
+        src += `if(test == ${i}.0){}`;
+      }
+    }
+    return src;
+  }
+  function checkMaxIfStatementsInShader(maxIfs, gl) {
+    if (maxIfs === 0) {
+      throw new Error("Invalid value of `0` passed to `checkMaxIfStatementsInShader`");
+    }
+    const shader = gl.createShader(gl.FRAGMENT_SHADER);
+    while (true) {
+      const fragmentSrc = fragTemplate$1.replace(/%forloop%/gi, generateIfTestSrc(maxIfs));
+      gl.shaderSource(shader, fragmentSrc);
+      gl.compileShader(shader);
+      if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        maxIfs = maxIfs / 2 | 0;
+      } else {
+        break;
+      }
+    }
+    return maxIfs;
+  }
+
+  const BLEND$1 = 0;
+  const OFFSET$1 = 1;
+  const CULLING$1 = 2;
+  const DEPTH_TEST$1 = 3;
+  const WINDING$1 = 4;
+  const DEPTH_MASK$1 = 5;
+  class State {
+    constructor() {
+      this.data = 0;
+      this.blendMode = BLEND_MODES.NORMAL;
+      this.polygonOffset = 0;
+      this.blend = true;
+      this.depthMask = true;
+    }
+    get blend() {
+      return !!(this.data & 1 << BLEND$1);
+    }
+    set blend(value) {
+      if (!!(this.data & 1 << BLEND$1) !== value) {
+        this.data ^= 1 << BLEND$1;
+      }
+    }
+    get offsets() {
+      return !!(this.data & 1 << OFFSET$1);
+    }
+    set offsets(value) {
+      if (!!(this.data & 1 << OFFSET$1) !== value) {
+        this.data ^= 1 << OFFSET$1;
+      }
+    }
+    get culling() {
+      return !!(this.data & 1 << CULLING$1);
+    }
+    set culling(value) {
+      if (!!(this.data & 1 << CULLING$1) !== value) {
+        this.data ^= 1 << CULLING$1;
+      }
+    }
+    get depthTest() {
+      return !!(this.data & 1 << DEPTH_TEST$1);
+    }
+    set depthTest(value) {
+      if (!!(this.data & 1 << DEPTH_TEST$1) !== value) {
+        this.data ^= 1 << DEPTH_TEST$1;
+      }
+    }
+    get depthMask() {
+      return !!(this.data & 1 << DEPTH_MASK$1);
+    }
+    set depthMask(value) {
+      if (!!(this.data & 1 << DEPTH_MASK$1) !== value) {
+        this.data ^= 1 << DEPTH_MASK$1;
+      }
+    }
+    get clockwiseFrontFace() {
+      return !!(this.data & 1 << WINDING$1);
+    }
+    set clockwiseFrontFace(value) {
+      if (!!(this.data & 1 << WINDING$1) !== value) {
+        this.data ^= 1 << WINDING$1;
+      }
+    }
+    get blendMode() {
+      return this._blendMode;
+    }
+    set blendMode(value) {
+      this.blend = value !== BLEND_MODES.NONE;
+      this._blendMode = value;
+    }
+    get polygonOffset() {
+      return this._polygonOffset;
+    }
+    set polygonOffset(value) {
+      this.offsets = !!value;
+      this._polygonOffset = value;
+    }
+    toString() {
+      return `[@pixi/core:State blendMode=${this.blendMode} clockwiseFrontFace=${this.clockwiseFrontFace} culling=${this.culling} depthMask=${this.depthMask} polygonOffset=${this.polygonOffset}]`;
+    }
+    static for2d() {
+      const state = new State();
+      state.depthTest = false;
+      state.blend = true;
+      return state;
+    }
+  }
+
+  const INSTALLED = [];
+  function autoDetectResource(source, options) {
+    if (!source) {
+      return null;
+    }
+    let extension = "";
+    if (typeof source === "string") {
+      const result = /\.(\w{3,4})(?:$|\?|#)/i.exec(source);
+      if (result) {
+        extension = result[1].toLowerCase();
+      }
+    }
+    for (let i = INSTALLED.length - 1; i >= 0; --i) {
+      const ResourcePlugin = INSTALLED[i];
+      if (ResourcePlugin.test && ResourcePlugin.test(source, extension)) {
+        return new ResourcePlugin(source, options);
+      }
+    }
+    throw new Error("Unrecognized source type to auto-detect Resource");
+  }
+
+  class Runner {
+    constructor(name) {
+      this.items = [];
+      this._name = name;
+      this._aliasCount = 0;
+    }
+    emit(a0, a1, a2, a3, a4, a5, a6, a7) {
+      if (arguments.length > 8) {
+        throw new Error("max arguments reached");
+      }
+      const { name, items } = this;
+      this._aliasCount++;
+      for (let i = 0, len = items.length; i < len; i++) {
+        items[i][name](a0, a1, a2, a3, a4, a5, a6, a7);
+      }
+      if (items === this.items) {
+        this._aliasCount--;
+      }
+      return this;
+    }
+    ensureNonAliasedItems() {
+      if (this._aliasCount > 0 && this.items.length > 1) {
+        this._aliasCount = 0;
+        this.items = this.items.slice(0);
+      }
+    }
+    add(item) {
+      if (item[this._name]) {
+        this.ensureNonAliasedItems();
+        this.remove(item);
+        this.items.push(item);
+      }
+      return this;
+    }
+    remove(item) {
+      const index = this.items.indexOf(item);
+      if (index !== -1) {
+        this.ensureNonAliasedItems();
+        this.items.splice(index, 1);
+      }
+      return this;
+    }
+    contains(item) {
+      return this.items.includes(item);
+    }
+    removeAll() {
+      this.ensureNonAliasedItems();
+      this.items.length = 0;
+      return this;
+    }
+    destroy() {
+      this.removeAll();
+      this.items = null;
+      this._name = null;
+    }
+    get empty() {
+      return this.items.length === 0;
+    }
+    get name() {
+      return this._name;
+    }
+  }
+  Object.defineProperties(Runner.prototype, {
+    dispatch: { value: Runner.prototype.emit },
+    run: { value: Runner.prototype.emit }
+  });
+
+  class Resource {
+    constructor(width = 0, height = 0) {
+      this._width = width;
+      this._height = height;
+      this.destroyed = false;
+      this.internal = false;
+      this.onResize = new Runner("setRealSize");
+      this.onUpdate = new Runner("update");
+      this.onError = new Runner("onError");
+    }
+    bind(baseTexture) {
+      this.onResize.add(baseTexture);
+      this.onUpdate.add(baseTexture);
+      this.onError.add(baseTexture);
+      if (this._width || this._height) {
+        this.onResize.emit(this._width, this._height);
+      }
+    }
+    unbind(baseTexture) {
+      this.onResize.remove(baseTexture);
+      this.onUpdate.remove(baseTexture);
+      this.onError.remove(baseTexture);
+    }
+    resize(width, height) {
+      if (width !== this._width || height !== this._height) {
+        this._width = width;
+        this._height = height;
+        this.onResize.emit(width, height);
+      }
+    }
+    get valid() {
+      return !!this._width && !!this._height;
+    }
+    update() {
+      if (!this.destroyed) {
+        this.onUpdate.emit();
+      }
+    }
+    load() {
+      return Promise.resolve(this);
+    }
+    get width() {
+      return this._width;
+    }
+    get height() {
+      return this._height;
+    }
+    style(_renderer, _baseTexture, _glTexture) {
+      return false;
+    }
+    dispose() {
+    }
+    destroy() {
+      if (!this.destroyed) {
+        this.destroyed = true;
+        this.dispose();
+        this.onError.removeAll();
+        this.onError = null;
+        this.onResize.removeAll();
+        this.onResize = null;
+        this.onUpdate.removeAll();
+        this.onUpdate = null;
+      }
+    }
+    static test(_source, _extension) {
+      return false;
+    }
+  }
+
+  class BufferResource extends Resource {
+    constructor(source, options) {
+      const { width, height } = options || {};
+      if (!width || !height) {
+        throw new Error("BufferResource width or height invalid");
+      }
+      super(width, height);
+      this.data = source;
+    }
+    upload(renderer, baseTexture, glTexture) {
+      const gl = renderer.gl;
+      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === ALPHA_MODES.UNPACK);
+      const width = baseTexture.realWidth;
+      const height = baseTexture.realHeight;
+      if (glTexture.width === width && glTexture.height === height) {
+        gl.texSubImage2D(baseTexture.target, 0, 0, 0, width, height, baseTexture.format, glTexture.type, this.data);
+      } else {
+        glTexture.width = width;
+        glTexture.height = height;
+        gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, width, height, 0, baseTexture.format, glTexture.type, this.data);
+      }
+      return true;
+    }
+    dispose() {
+      this.data = null;
+    }
+    static test(source) {
+      return source instanceof Float32Array || source instanceof Uint8Array || source instanceof Uint32Array;
+    }
+  }
+
+  const defaultBufferOptions = {
+    scaleMode: SCALE_MODES.NEAREST,
+    format: FORMATS.RGBA,
+    alphaMode: ALPHA_MODES.NPM
+  };
+  const _BaseTexture = class extends eventemitter3 {
+    constructor(resource = null, options = null) {
+      super();
+      options = Object.assign({}, _BaseTexture.defaultOptions, options);
+      const {
+        alphaMode,
+        mipmap,
+        anisotropicLevel,
+        scaleMode,
+        width,
+        height,
+        wrapMode,
+        format,
+        type,
+        target,
+        resolution,
+        resourceOptions
+      } = options;
+      if (resource && !(resource instanceof Resource)) {
+        resource = autoDetectResource(resource, resourceOptions);
+        resource.internal = true;
+      }
+      this.resolution = resolution || settings.RESOLUTION;
+      this.width = Math.round((width || 0) * this.resolution) / this.resolution;
+      this.height = Math.round((height || 0) * this.resolution) / this.resolution;
+      this._mipmap = mipmap;
+      this.anisotropicLevel = anisotropicLevel;
+      this._wrapMode = wrapMode;
+      this._scaleMode = scaleMode;
+      this.format = format;
+      this.type = type;
+      this.target = target;
+      this.alphaMode = alphaMode;
+      this.uid = uid();
+      this.touched = 0;
+      this.isPowerOfTwo = false;
+      this._refreshPOT();
+      this._glTextures = {};
+      this.dirtyId = 0;
+      this.dirtyStyleId = 0;
+      this.cacheId = null;
+      this.valid = width > 0 && height > 0;
+      this.textureCacheIds = [];
+      this.destroyed = false;
+      this.resource = null;
+      this._batchEnabled = 0;
+      this._batchLocation = 0;
+      this.parentTextureArray = null;
+      this.setResource(resource);
+    }
+    get realWidth() {
+      return Math.round(this.width * this.resolution);
+    }
+    get realHeight() {
+      return Math.round(this.height * this.resolution);
+    }
+    get mipmap() {
+      return this._mipmap;
+    }
+    set mipmap(value) {
+      if (this._mipmap !== value) {
+        this._mipmap = value;
+        this.dirtyStyleId++;
+      }
+    }
+    get scaleMode() {
+      return this._scaleMode;
+    }
+    set scaleMode(value) {
+      if (this._scaleMode !== value) {
+        this._scaleMode = value;
+        this.dirtyStyleId++;
+      }
+    }
+    get wrapMode() {
+      return this._wrapMode;
+    }
+    set wrapMode(value) {
+      if (this._wrapMode !== value) {
+        this._wrapMode = value;
+        this.dirtyStyleId++;
+      }
+    }
+    setStyle(scaleMode, mipmap) {
+      let dirty;
+      if (scaleMode !== void 0 && scaleMode !== this.scaleMode) {
+        this.scaleMode = scaleMode;
+        dirty = true;
+      }
+      if (mipmap !== void 0 && mipmap !== this.mipmap) {
+        this.mipmap = mipmap;
+        dirty = true;
+      }
+      if (dirty) {
+        this.dirtyStyleId++;
+      }
+      return this;
+    }
+    setSize(desiredWidth, desiredHeight, resolution) {
+      resolution = resolution || this.resolution;
+      return this.setRealSize(desiredWidth * resolution, desiredHeight * resolution, resolution);
+    }
+    setRealSize(realWidth, realHeight, resolution) {
+      this.resolution = resolution || this.resolution;
+      this.width = Math.round(realWidth) / this.resolution;
+      this.height = Math.round(realHeight) / this.resolution;
+      this._refreshPOT();
+      this.update();
+      return this;
+    }
+    _refreshPOT() {
+      this.isPowerOfTwo = isPow2(this.realWidth) && isPow2(this.realHeight);
+    }
+    setResolution(resolution) {
+      const oldResolution = this.resolution;
+      if (oldResolution === resolution) {
+        return this;
+      }
+      this.resolution = resolution;
+      if (this.valid) {
+        this.width = Math.round(this.width * oldResolution) / resolution;
+        this.height = Math.round(this.height * oldResolution) / resolution;
+        this.emit("update", this);
+      }
+      this._refreshPOT();
+      return this;
+    }
+    setResource(resource) {
+      if (this.resource === resource) {
+        return this;
+      }
+      if (this.resource) {
+        throw new Error("Resource can be set only once");
+      }
+      resource.bind(this);
+      this.resource = resource;
+      return this;
+    }
+    update() {
+      if (!this.valid) {
+        if (this.width > 0 && this.height > 0) {
+          this.valid = true;
+          this.emit("loaded", this);
+          this.emit("update", this);
+        }
+      } else {
+        this.dirtyId++;
+        this.dirtyStyleId++;
+        this.emit("update", this);
+      }
+    }
+    onError(event) {
+      this.emit("error", this, event);
+    }
+    destroy() {
+      if (this.resource) {
+        this.resource.unbind(this);
+        if (this.resource.internal) {
+          this.resource.destroy();
+        }
+        this.resource = null;
+      }
+      if (this.cacheId) {
+        delete BaseTextureCache[this.cacheId];
+        delete TextureCache[this.cacheId];
+        this.cacheId = null;
+      }
+      this.dispose();
+      _BaseTexture.removeFromCache(this);
+      this.textureCacheIds = null;
+      this.destroyed = true;
+    }
+    dispose() {
+      this.emit("dispose", this);
+    }
+    castToBaseTexture() {
+      return this;
+    }
+    static from(source, options, strict = settings.STRICT_TEXTURE_CACHE) {
+      const isFrame = typeof source === "string";
+      let cacheId = null;
+      if (isFrame) {
+        cacheId = source;
+      } else {
+        if (!source._pixiId) {
+          const prefix = options?.pixiIdPrefix || "pixiid";
+          source._pixiId = `${prefix}_${uid()}`;
+        }
+        cacheId = source._pixiId;
+      }
+      let baseTexture = BaseTextureCache[cacheId];
+      if (isFrame && strict && !baseTexture) {
+        throw new Error(`The cacheId "${cacheId}" does not exist in BaseTextureCache.`);
+      }
+      if (!baseTexture) {
+        baseTexture = new _BaseTexture(source, options);
+        baseTexture.cacheId = cacheId;
+        _BaseTexture.addToCache(baseTexture, cacheId);
+      }
+      return baseTexture;
+    }
+    static fromBuffer(buffer, width, height, options) {
+      buffer = buffer || new Float32Array(width * height * 4);
+      const resource = new BufferResource(buffer, { width, height });
+      const type = buffer instanceof Float32Array ? TYPES.FLOAT : TYPES.UNSIGNED_BYTE;
+      return new _BaseTexture(resource, Object.assign({}, defaultBufferOptions, { type }, options));
+    }
+    static addToCache(baseTexture, id) {
+      if (id) {
+        if (!baseTexture.textureCacheIds.includes(id)) {
+          baseTexture.textureCacheIds.push(id);
+        }
+        if (BaseTextureCache[id] && BaseTextureCache[id] !== baseTexture) {
+          console.warn(`BaseTexture added to the cache with an id [${id}] that already had an entry`);
+        }
+        BaseTextureCache[id] = baseTexture;
+      }
+    }
+    static removeFromCache(baseTexture) {
+      if (typeof baseTexture === "string") {
+        const baseTextureFromCache = BaseTextureCache[baseTexture];
+        if (baseTextureFromCache) {
+          const index = baseTextureFromCache.textureCacheIds.indexOf(baseTexture);
+          if (index > -1) {
+            baseTextureFromCache.textureCacheIds.splice(index, 1);
+          }
+          delete BaseTextureCache[baseTexture];
+          return baseTextureFromCache;
+        }
+      } else if (baseTexture?.textureCacheIds) {
+        for (let i = 0; i < baseTexture.textureCacheIds.length; ++i) {
+          delete BaseTextureCache[baseTexture.textureCacheIds[i]];
+        }
+        baseTexture.textureCacheIds.length = 0;
+        return baseTexture;
+      }
+      return null;
+    }
+  };
+  let BaseTexture = _BaseTexture;
+  BaseTexture.defaultOptions = {
+    mipmap: MIPMAP_MODES.POW2,
+    anisotropicLevel: 0,
+    scaleMode: SCALE_MODES.LINEAR,
+    wrapMode: WRAP_MODES.CLAMP,
+    alphaMode: ALPHA_MODES.UNPACK,
+    target: TARGETS.TEXTURE_2D,
+    format: FORMATS.RGBA,
+    type: TYPES.UNSIGNED_BYTE
+  };
+  BaseTexture._globalBatch = 0;
+
+  class BatchDrawCall {
+    constructor() {
+      this.texArray = null;
+      this.blend = 0;
+      this.type = DRAW_MODES.TRIANGLES;
+      this.start = 0;
+      this.size = 0;
+      this.data = null;
+    }
+  }
+
+  let UID$4 = 0;
+  class Buffer {
+    constructor(data, _static = true, index = false) {
+      this.data = data || new Float32Array(1);
+      this._glBuffers = {};
+      this._updateID = 0;
+      this.index = index;
+      this.static = _static;
+      this.id = UID$4++;
+      this.disposeRunner = new Runner("disposeBuffer");
+    }
+    update(data) {
+      if (data instanceof Array) {
+        data = new Float32Array(data);
+      }
+      this.data = data || this.data;
+      this._updateID++;
+    }
+    dispose() {
+      this.disposeRunner.emit(this, false);
+    }
+    destroy() {
+      this.dispose();
+      this.data = null;
+    }
+    set index(value) {
+      this.type = value ? BUFFER_TYPE.ELEMENT_ARRAY_BUFFER : BUFFER_TYPE.ARRAY_BUFFER;
+    }
+    get index() {
+      return this.type === BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+    }
+    static from(data) {
+      if (data instanceof Array) {
+        data = new Float32Array(data);
+      }
+      return new Buffer(data);
+    }
+  }
+
+  class Attribute {
+    constructor(buffer, size = 0, normalized = false, type = TYPES.FLOAT, stride, start, instance, divisor = 1) {
+      this.buffer = buffer;
+      this.size = size;
+      this.normalized = normalized;
+      this.type = type;
+      this.stride = stride;
+      this.start = start;
+      this.instance = instance;
+      this.divisor = divisor;
+    }
+    destroy() {
+      this.buffer = null;
+    }
+    static from(buffer, size, normalized, type, stride) {
+      return new Attribute(buffer, size, normalized, type, stride);
+    }
+  }
+
+  const map$1 = {
+    Float32Array,
+    Uint32Array,
+    Int32Array,
+    Uint8Array
+  };
+  function interleaveTypedArrays(arrays, sizes) {
+    let outSize = 0;
+    let stride = 0;
+    const views = {};
+    for (let i = 0; i < arrays.length; i++) {
+      stride += sizes[i];
+      outSize += arrays[i].length;
+    }
+    const buffer = new ArrayBuffer(outSize * 4);
+    let out = null;
+    let littleOffset = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const size = sizes[i];
+      const array = arrays[i];
+      const type = getBufferType(array);
+      if (!views[type]) {
+        views[type] = new map$1[type](buffer);
+      }
+      out = views[type];
+      for (let j = 0; j < array.length; j++) {
+        const indexStart = (j / size | 0) * stride + littleOffset;
+        const index = j % size;
+        out[indexStart + index] = array[j];
+      }
+      littleOffset += size;
+    }
+    return new Float32Array(buffer);
+  }
+
+  const byteSizeMap$1 = { 5126: 4, 5123: 2, 5121: 1 };
+  let UID$3 = 0;
+  const map = {
+    Float32Array,
+    Uint32Array,
+    Int32Array,
+    Uint8Array,
+    Uint16Array
+  };
+  class Geometry {
+    constructor(buffers = [], attributes = {}) {
+      this.buffers = buffers;
+      this.indexBuffer = null;
+      this.attributes = attributes;
+      this.glVertexArrayObjects = {};
+      this.id = UID$3++;
+      this.instanced = false;
+      this.instanceCount = 1;
+      this.disposeRunner = new Runner("disposeGeometry");
+      this.refCount = 0;
+    }
+    addAttribute(id, buffer, size = 0, normalized = false, type, stride, start, instance = false) {
+      if (!buffer) {
+        throw new Error("You must pass a buffer when creating an attribute");
+      }
+      if (!(buffer instanceof Buffer)) {
+        if (buffer instanceof Array) {
+          buffer = new Float32Array(buffer);
+        }
+        buffer = new Buffer(buffer);
+      }
+      const ids = id.split("|");
+      if (ids.length > 1) {
+        for (let i = 0; i < ids.length; i++) {
+          this.addAttribute(ids[i], buffer, size, normalized, type);
+        }
+        return this;
+      }
+      let bufferIndex = this.buffers.indexOf(buffer);
+      if (bufferIndex === -1) {
+        this.buffers.push(buffer);
+        bufferIndex = this.buffers.length - 1;
+      }
+      this.attributes[id] = new Attribute(bufferIndex, size, normalized, type, stride, start, instance);
+      this.instanced = this.instanced || instance;
+      return this;
+    }
+    getAttribute(id) {
+      return this.attributes[id];
+    }
+    getBuffer(id) {
+      return this.buffers[this.getAttribute(id).buffer];
+    }
+    addIndex(buffer) {
+      if (!(buffer instanceof Buffer)) {
+        if (buffer instanceof Array) {
+          buffer = new Uint16Array(buffer);
+        }
+        buffer = new Buffer(buffer);
+      }
+      buffer.type = BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+      this.indexBuffer = buffer;
+      if (!this.buffers.includes(buffer)) {
+        this.buffers.push(buffer);
+      }
+      return this;
+    }
+    getIndex() {
+      return this.indexBuffer;
+    }
+    interleave() {
+      if (this.buffers.length === 1 || this.buffers.length === 2 && this.indexBuffer)
+        return this;
+      const arrays = [];
+      const sizes = [];
+      const interleavedBuffer = new Buffer();
+      let i;
+      for (i in this.attributes) {
+        const attribute = this.attributes[i];
+        const buffer = this.buffers[attribute.buffer];
+        arrays.push(buffer.data);
+        sizes.push(attribute.size * byteSizeMap$1[attribute.type] / 4);
+        attribute.buffer = 0;
+      }
+      interleavedBuffer.data = interleaveTypedArrays(arrays, sizes);
+      for (i = 0; i < this.buffers.length; i++) {
+        if (this.buffers[i] !== this.indexBuffer) {
+          this.buffers[i].destroy();
+        }
+      }
+      this.buffers = [interleavedBuffer];
+      if (this.indexBuffer) {
+        this.buffers.push(this.indexBuffer);
+      }
+      return this;
+    }
+    getSize() {
+      for (const i in this.attributes) {
+        const attribute = this.attributes[i];
+        const buffer = this.buffers[attribute.buffer];
+        return buffer.data.length / (attribute.stride / 4 || attribute.size);
+      }
+      return 0;
+    }
+    dispose() {
+      this.disposeRunner.emit(this, false);
+    }
+    destroy() {
+      this.dispose();
+      this.buffers = null;
+      this.indexBuffer = null;
+      this.attributes = null;
+    }
+    clone() {
+      const geometry = new Geometry();
+      for (let i = 0; i < this.buffers.length; i++) {
+        geometry.buffers[i] = new Buffer(this.buffers[i].data.slice(0));
+      }
+      for (const i in this.attributes) {
+        const attrib = this.attributes[i];
+        geometry.attributes[i] = new Attribute(attrib.buffer, attrib.size, attrib.normalized, attrib.type, attrib.stride, attrib.start, attrib.instance);
+      }
+      if (this.indexBuffer) {
+        geometry.indexBuffer = geometry.buffers[this.buffers.indexOf(this.indexBuffer)];
+        geometry.indexBuffer.type = BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+      }
+      return geometry;
+    }
+    static merge(geometries) {
+      const geometryOut = new Geometry();
+      const arrays = [];
+      const sizes = [];
+      const offsets = [];
+      let geometry;
+      for (let i = 0; i < geometries.length; i++) {
+        geometry = geometries[i];
+        for (let j = 0; j < geometry.buffers.length; j++) {
+          sizes[j] = sizes[j] || 0;
+          sizes[j] += geometry.buffers[j].data.length;
+          offsets[j] = 0;
+        }
+      }
+      for (let i = 0; i < geometry.buffers.length; i++) {
+        arrays[i] = new map[getBufferType(geometry.buffers[i].data)](sizes[i]);
+        geometryOut.buffers[i] = new Buffer(arrays[i]);
+      }
+      for (let i = 0; i < geometries.length; i++) {
+        geometry = geometries[i];
+        for (let j = 0; j < geometry.buffers.length; j++) {
+          arrays[j].set(geometry.buffers[j].data, offsets[j]);
+          offsets[j] += geometry.buffers[j].data.length;
+        }
+      }
+      geometryOut.attributes = geometry.attributes;
+      if (geometry.indexBuffer) {
+        geometryOut.indexBuffer = geometryOut.buffers[geometry.buffers.indexOf(geometry.indexBuffer)];
+        geometryOut.indexBuffer.type = BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
+        let offset = 0;
+        let stride = 0;
+        let offset2 = 0;
+        let bufferIndexToCount = 0;
+        for (let i = 0; i < geometry.buffers.length; i++) {
+          if (geometry.buffers[i] !== geometry.indexBuffer) {
+            bufferIndexToCount = i;
+            break;
+          }
+        }
+        for (const i in geometry.attributes) {
+          const attribute = geometry.attributes[i];
+          if ((attribute.buffer | 0) === bufferIndexToCount) {
+            stride += attribute.size * byteSizeMap$1[attribute.type] / 4;
+          }
+        }
+        for (let i = 0; i < geometries.length; i++) {
+          const indexBufferData = geometries[i].indexBuffer.data;
+          for (let j = 0; j < indexBufferData.length; j++) {
+            geometryOut.indexBuffer.data[j + offset2] += offset;
+          }
+          offset += geometries[i].buffers[bufferIndexToCount].data.length / stride;
+          offset2 += indexBufferData.length;
+        }
+      }
+      return geometryOut;
+    }
+  }
+
+  class BatchGeometry extends Geometry {
+    constructor(_static = false) {
+      super();
+      this._buffer = new Buffer(null, _static, false);
+      this._indexBuffer = new Buffer(null, _static, true);
+      this.addAttribute("aVertexPosition", this._buffer, 2, false, TYPES.FLOAT).addAttribute("aTextureCoord", this._buffer, 2, false, TYPES.FLOAT).addAttribute("aColor", this._buffer, 4, true, TYPES.UNSIGNED_BYTE).addAttribute("aTextureId", this._buffer, 1, true, TYPES.FLOAT).addIndex(this._indexBuffer);
+    }
+  }
+
+  const PI_2 = Math.PI * 2;
+  const RAD_TO_DEG = 180 / Math.PI;
+  const DEG_TO_RAD = Math.PI / 180;
+  var SHAPES = /* @__PURE__ */ ((SHAPES2) => {
+    SHAPES2[SHAPES2["POLY"] = 0] = "POLY";
+    SHAPES2[SHAPES2["RECT"] = 1] = "RECT";
+    SHAPES2[SHAPES2["CIRC"] = 2] = "CIRC";
+    SHAPES2[SHAPES2["ELIP"] = 3] = "ELIP";
+    SHAPES2[SHAPES2["RREC"] = 4] = "RREC";
+    return SHAPES2;
+  })(SHAPES || {});
+
+  class Point {
+    constructor(x = 0, y = 0) {
+      this.x = 0;
+      this.y = 0;
+      this.x = x;
+      this.y = y;
+    }
+    clone() {
+      return new Point(this.x, this.y);
+    }
+    copyFrom(p) {
+      this.set(p.x, p.y);
+      return this;
+    }
+    copyTo(p) {
+      p.set(this.x, this.y);
+      return p;
+    }
+    equals(p) {
+      return p.x === this.x && p.y === this.y;
+    }
+    set(x = 0, y = x) {
+      this.x = x;
+      this.y = y;
+      return this;
+    }
+    toString() {
+      return `[@pixi/math:Point x=${this.x} y=${this.y}]`;
+    }
+  }
+
+  const tempPoints$1 = [new Point(), new Point(), new Point(), new Point()];
+  class Rectangle {
+    constructor(x = 0, y = 0, width = 0, height = 0) {
+      this.x = Number(x);
+      this.y = Number(y);
+      this.width = Number(width);
+      this.height = Number(height);
+      this.type = SHAPES.RECT;
+    }
+    get left() {
+      return this.x;
+    }
+    get right() {
+      return this.x + this.width;
+    }
+    get top() {
+      return this.y;
+    }
+    get bottom() {
+      return this.y + this.height;
+    }
+    static get EMPTY() {
+      return new Rectangle(0, 0, 0, 0);
+    }
+    clone() {
+      return new Rectangle(this.x, this.y, this.width, this.height);
+    }
+    copyFrom(rectangle) {
+      this.x = rectangle.x;
+      this.y = rectangle.y;
+      this.width = rectangle.width;
+      this.height = rectangle.height;
+      return this;
+    }
+    copyTo(rectangle) {
+      rectangle.x = this.x;
+      rectangle.y = this.y;
+      rectangle.width = this.width;
+      rectangle.height = this.height;
+      return rectangle;
+    }
+    contains(x, y) {
+      if (this.width <= 0 || this.height <= 0) {
+        return false;
+      }
+      if (x >= this.x && x < this.x + this.width) {
+        if (y >= this.y && y < this.y + this.height) {
+          return true;
+        }
+      }
+      return false;
+    }
+    intersects(other, transform) {
+      if (!transform) {
+        const x02 = this.x < other.x ? other.x : this.x;
+        const x12 = this.right > other.right ? other.right : this.right;
+        if (x12 <= x02) {
+          return false;
+        }
+        const y02 = this.y < other.y ? other.y : this.y;
+        const y12 = this.bottom > other.bottom ? other.bottom : this.bottom;
+        return y12 > y02;
+      }
+      const x0 = this.left;
+      const x1 = this.right;
+      const y0 = this.top;
+      const y1 = this.bottom;
+      if (x1 <= x0 || y1 <= y0) {
+        return false;
+      }
+      const lt = tempPoints$1[0].set(other.left, other.top);
+      const lb = tempPoints$1[1].set(other.left, other.bottom);
+      const rt = tempPoints$1[2].set(other.right, other.top);
+      const rb = tempPoints$1[3].set(other.right, other.bottom);
+      if (rt.x <= lt.x || lb.y <= lt.y) {
+        return false;
+      }
+      const s = Math.sign(transform.a * transform.d - transform.b * transform.c);
+      if (s === 0) {
+        return false;
+      }
+      transform.apply(lt, lt);
+      transform.apply(lb, lb);
+      transform.apply(rt, rt);
+      transform.apply(rb, rb);
+      if (Math.max(lt.x, lb.x, rt.x, rb.x) <= x0 || Math.min(lt.x, lb.x, rt.x, rb.x) >= x1 || Math.max(lt.y, lb.y, rt.y, rb.y) <= y0 || Math.min(lt.y, lb.y, rt.y, rb.y) >= y1) {
+        return false;
+      }
+      const nx = s * (lb.y - lt.y);
+      const ny = s * (lt.x - lb.x);
+      const n00 = nx * x0 + ny * y0;
+      const n10 = nx * x1 + ny * y0;
+      const n01 = nx * x0 + ny * y1;
+      const n11 = nx * x1 + ny * y1;
+      if (Math.max(n00, n10, n01, n11) <= nx * lt.x + ny * lt.y || Math.min(n00, n10, n01, n11) >= nx * rb.x + ny * rb.y) {
+        return false;
+      }
+      const mx = s * (lt.y - rt.y);
+      const my = s * (rt.x - lt.x);
+      const m00 = mx * x0 + my * y0;
+      const m10 = mx * x1 + my * y0;
+      const m01 = mx * x0 + my * y1;
+      const m11 = mx * x1 + my * y1;
+      if (Math.max(m00, m10, m01, m11) <= mx * lt.x + my * lt.y || Math.min(m00, m10, m01, m11) >= mx * rb.x + my * rb.y) {
+        return false;
+      }
+      return true;
+    }
+    pad(paddingX = 0, paddingY = paddingX) {
+      this.x -= paddingX;
+      this.y -= paddingY;
+      this.width += paddingX * 2;
+      this.height += paddingY * 2;
+      return this;
+    }
+    fit(rectangle) {
+      const x1 = Math.max(this.x, rectangle.x);
+      const x2 = Math.min(this.x + this.width, rectangle.x + rectangle.width);
+      const y1 = Math.max(this.y, rectangle.y);
+      const y2 = Math.min(this.y + this.height, rectangle.y + rectangle.height);
+      this.x = x1;
+      this.width = Math.max(x2 - x1, 0);
+      this.y = y1;
+      this.height = Math.max(y2 - y1, 0);
+      return this;
+    }
+    ceil(resolution = 1, eps = 1e-3) {
+      const x2 = Math.ceil((this.x + this.width - eps) * resolution) / resolution;
+      const y2 = Math.ceil((this.y + this.height - eps) * resolution) / resolution;
+      this.x = Math.floor((this.x + eps) * resolution) / resolution;
+      this.y = Math.floor((this.y + eps) * resolution) / resolution;
+      this.width = x2 - this.x;
+      this.height = y2 - this.y;
+      return this;
+    }
+    enlarge(rectangle) {
+      const x1 = Math.min(this.x, rectangle.x);
+      const x2 = Math.max(this.x + this.width, rectangle.x + rectangle.width);
+      const y1 = Math.min(this.y, rectangle.y);
+      const y2 = Math.max(this.y + this.height, rectangle.y + rectangle.height);
+      this.x = x1;
+      this.width = x2 - x1;
+      this.y = y1;
+      this.height = y2 - y1;
+      return this;
+    }
+    toString() {
+      return `[@pixi/math:Rectangle x=${this.x} y=${this.y} width=${this.width} height=${this.height}]`;
+    }
+  }
+
+  class Circle {
+    constructor(x = 0, y = 0, radius = 0) {
+      this.x = x;
+      this.y = y;
+      this.radius = radius;
+      this.type = SHAPES.CIRC;
+    }
+    clone() {
+      return new Circle(this.x, this.y, this.radius);
+    }
+    contains(x, y) {
+      if (this.radius <= 0) {
+        return false;
+      }
+      const r2 = this.radius * this.radius;
+      let dx = this.x - x;
+      let dy = this.y - y;
+      dx *= dx;
+      dy *= dy;
+      return dx + dy <= r2;
+    }
+    getBounds() {
+      return new Rectangle(this.x - this.radius, this.y - this.radius, this.radius * 2, this.radius * 2);
+    }
+    toString() {
+      return `[@pixi/math:Circle x=${this.x} y=${this.y} radius=${this.radius}]`;
+    }
+  }
+
+  class Ellipse {
+    constructor(x = 0, y = 0, halfWidth = 0, halfHeight = 0) {
+      this.x = x;
+      this.y = y;
+      this.width = halfWidth;
+      this.height = halfHeight;
+      this.type = SHAPES.ELIP;
+    }
+    clone() {
+      return new Ellipse(this.x, this.y, this.width, this.height);
+    }
+    contains(x, y) {
+      if (this.width <= 0 || this.height <= 0) {
+        return false;
+      }
+      let normx = (x - this.x) / this.width;
+      let normy = (y - this.y) / this.height;
+      normx *= normx;
+      normy *= normy;
+      return normx + normy <= 1;
+    }
+    getBounds() {
+      return new Rectangle(this.x - this.width, this.y - this.height, this.width, this.height);
+    }
+    toString() {
+      return `[@pixi/math:Ellipse x=${this.x} y=${this.y} width=${this.width} height=${this.height}]`;
+    }
+  }
+
+  class Polygon {
+    constructor(...points) {
+      let flat = Array.isArray(points[0]) ? points[0] : points;
+      if (typeof flat[0] !== "number") {
+        const p = [];
+        for (let i = 0, il = flat.length; i < il; i++) {
+          p.push(flat[i].x, flat[i].y);
+        }
+        flat = p;
+      }
+      this.points = flat;
+      this.type = SHAPES.POLY;
+      this.closeStroke = true;
+    }
+    clone() {
+      const points = this.points.slice();
+      const polygon = new Polygon(points);
+      polygon.closeStroke = this.closeStroke;
+      return polygon;
+    }
+    contains(x, y) {
+      let inside = false;
+      const length = this.points.length / 2;
+      for (let i = 0, j = length - 1; i < length; j = i++) {
+        const xi = this.points[i * 2];
+        const yi = this.points[i * 2 + 1];
+        const xj = this.points[j * 2];
+        const yj = this.points[j * 2 + 1];
+        const intersect = yi > y !== yj > y && x < (xj - xi) * ((y - yi) / (yj - yi)) + xi;
+        if (intersect) {
+          inside = !inside;
+        }
+      }
+      return inside;
+    }
+    toString() {
+      return `[@pixi/math:PolygoncloseStroke=${this.closeStroke}points=${this.points.reduce((pointsDesc, currentPoint) => `${pointsDesc}, ${currentPoint}`, "")}]`;
+    }
+  }
+
+  class RoundedRectangle {
+    constructor(x = 0, y = 0, width = 0, height = 0, radius = 20) {
+      this.x = x;
+      this.y = y;
+      this.width = width;
+      this.height = height;
+      this.radius = radius;
+      this.type = SHAPES.RREC;
+    }
+    clone() {
+      return new RoundedRectangle(this.x, this.y, this.width, this.height, this.radius);
+    }
+    contains(x, y) {
+      if (this.width <= 0 || this.height <= 0) {
+        return false;
+      }
+      if (x >= this.x && x <= this.x + this.width) {
+        if (y >= this.y && y <= this.y + this.height) {
+          const radius = Math.max(0, Math.min(this.radius, Math.min(this.width, this.height) / 2));
+          if (y >= this.y + radius && y <= this.y + this.height - radius || x >= this.x + radius && x <= this.x + this.width - radius) {
+            return true;
+          }
+          let dx = x - (this.x + radius);
+          let dy = y - (this.y + radius);
+          const radius2 = radius * radius;
+          if (dx * dx + dy * dy <= radius2) {
+            return true;
+          }
+          dx = x - (this.x + this.width - radius);
+          if (dx * dx + dy * dy <= radius2) {
+            return true;
+          }
+          dy = y - (this.y + this.height - radius);
+          if (dx * dx + dy * dy <= radius2) {
+            return true;
+          }
+          dx = x - (this.x + radius);
+          if (dx * dx + dy * dy <= radius2) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    toString() {
+      return `[@pixi/math:RoundedRectangle x=${this.x} y=${this.y}width=${this.width} height=${this.height} radius=${this.radius}]`;
+    }
+  }
+
+  class Matrix {
+    constructor(a = 1, b = 0, c = 0, d = 1, tx = 0, ty = 0) {
+      this.array = null;
+      this.a = a;
+      this.b = b;
+      this.c = c;
+      this.d = d;
+      this.tx = tx;
+      this.ty = ty;
+    }
+    fromArray(array) {
+      this.a = array[0];
+      this.b = array[1];
+      this.c = array[3];
+      this.d = array[4];
+      this.tx = array[2];
+      this.ty = array[5];
+    }
+    set(a, b, c, d, tx, ty) {
+      this.a = a;
+      this.b = b;
+      this.c = c;
+      this.d = d;
+      this.tx = tx;
+      this.ty = ty;
+      return this;
+    }
+    toArray(transpose, out) {
+      if (!this.array) {
+        this.array = new Float32Array(9);
+      }
+      const array = out || this.array;
+      if (transpose) {
+        array[0] = this.a;
+        array[1] = this.b;
+        array[2] = 0;
+        array[3] = this.c;
+        array[4] = this.d;
+        array[5] = 0;
+        array[6] = this.tx;
+        array[7] = this.ty;
+        array[8] = 1;
+      } else {
+        array[0] = this.a;
+        array[1] = this.c;
+        array[2] = this.tx;
+        array[3] = this.b;
+        array[4] = this.d;
+        array[5] = this.ty;
+        array[6] = 0;
+        array[7] = 0;
+        array[8] = 1;
+      }
+      return array;
+    }
+    apply(pos, newPos) {
+      newPos = newPos || new Point();
+      const x = pos.x;
+      const y = pos.y;
+      newPos.x = this.a * x + this.c * y + this.tx;
+      newPos.y = this.b * x + this.d * y + this.ty;
+      return newPos;
+    }
+    applyInverse(pos, newPos) {
+      newPos = newPos || new Point();
+      const id = 1 / (this.a * this.d + this.c * -this.b);
+      const x = pos.x;
+      const y = pos.y;
+      newPos.x = this.d * id * x + -this.c * id * y + (this.ty * this.c - this.tx * this.d) * id;
+      newPos.y = this.a * id * y + -this.b * id * x + (-this.ty * this.a + this.tx * this.b) * id;
+      return newPos;
+    }
+    translate(x, y) {
+      this.tx += x;
+      this.ty += y;
+      return this;
+    }
+    scale(x, y) {
+      this.a *= x;
+      this.d *= y;
+      this.c *= x;
+      this.b *= y;
+      this.tx *= x;
+      this.ty *= y;
+      return this;
+    }
+    rotate(angle) {
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      const a1 = this.a;
+      const c1 = this.c;
+      const tx1 = this.tx;
+      this.a = a1 * cos - this.b * sin;
+      this.b = a1 * sin + this.b * cos;
+      this.c = c1 * cos - this.d * sin;
+      this.d = c1 * sin + this.d * cos;
+      this.tx = tx1 * cos - this.ty * sin;
+      this.ty = tx1 * sin + this.ty * cos;
+      return this;
+    }
+    append(matrix) {
+      const a1 = this.a;
+      const b1 = this.b;
+      const c1 = this.c;
+      const d1 = this.d;
+      this.a = matrix.a * a1 + matrix.b * c1;
+      this.b = matrix.a * b1 + matrix.b * d1;
+      this.c = matrix.c * a1 + matrix.d * c1;
+      this.d = matrix.c * b1 + matrix.d * d1;
+      this.tx = matrix.tx * a1 + matrix.ty * c1 + this.tx;
+      this.ty = matrix.tx * b1 + matrix.ty * d1 + this.ty;
+      return this;
+    }
+    setTransform(x, y, pivotX, pivotY, scaleX, scaleY, rotation, skewX, skewY) {
+      this.a = Math.cos(rotation + skewY) * scaleX;
+      this.b = Math.sin(rotation + skewY) * scaleX;
+      this.c = -Math.sin(rotation - skewX) * scaleY;
+      this.d = Math.cos(rotation - skewX) * scaleY;
+      this.tx = x - (pivotX * this.a + pivotY * this.c);
+      this.ty = y - (pivotX * this.b + pivotY * this.d);
+      return this;
+    }
+    prepend(matrix) {
+      const tx1 = this.tx;
+      if (matrix.a !== 1 || matrix.b !== 0 || matrix.c !== 0 || matrix.d !== 1) {
+        const a1 = this.a;
+        const c1 = this.c;
+        this.a = a1 * matrix.a + this.b * matrix.c;
+        this.b = a1 * matrix.b + this.b * matrix.d;
+        this.c = c1 * matrix.a + this.d * matrix.c;
+        this.d = c1 * matrix.b + this.d * matrix.d;
+      }
+      this.tx = tx1 * matrix.a + this.ty * matrix.c + matrix.tx;
+      this.ty = tx1 * matrix.b + this.ty * matrix.d + matrix.ty;
+      return this;
+    }
+    decompose(transform) {
+      const a = this.a;
+      const b = this.b;
+      const c = this.c;
+      const d = this.d;
+      const pivot = transform.pivot;
+      const skewX = -Math.atan2(-c, d);
+      const skewY = Math.atan2(b, a);
+      const delta = Math.abs(skewX + skewY);
+      if (delta < 1e-5 || Math.abs(PI_2 - delta) < 1e-5) {
+        transform.rotation = skewY;
+        transform.skew.x = transform.skew.y = 0;
+      } else {
+        transform.rotation = 0;
+        transform.skew.x = skewX;
+        transform.skew.y = skewY;
+      }
+      transform.scale.x = Math.sqrt(a * a + b * b);
+      transform.scale.y = Math.sqrt(c * c + d * d);
+      transform.position.x = this.tx + (pivot.x * a + pivot.y * c);
+      transform.position.y = this.ty + (pivot.x * b + pivot.y * d);
+      return transform;
+    }
+    invert() {
+      const a1 = this.a;
+      const b1 = this.b;
+      const c1 = this.c;
+      const d1 = this.d;
+      const tx1 = this.tx;
+      const n = a1 * d1 - b1 * c1;
+      this.a = d1 / n;
+      this.b = -b1 / n;
+      this.c = -c1 / n;
+      this.d = a1 / n;
+      this.tx = (c1 * this.ty - d1 * tx1) / n;
+      this.ty = -(a1 * this.ty - b1 * tx1) / n;
+      return this;
+    }
+    identity() {
+      this.a = 1;
+      this.b = 0;
+      this.c = 0;
+      this.d = 1;
+      this.tx = 0;
+      this.ty = 0;
+      return this;
+    }
+    clone() {
+      const matrix = new Matrix();
+      matrix.a = this.a;
+      matrix.b = this.b;
+      matrix.c = this.c;
+      matrix.d = this.d;
+      matrix.tx = this.tx;
+      matrix.ty = this.ty;
+      return matrix;
+    }
+    copyTo(matrix) {
+      matrix.a = this.a;
+      matrix.b = this.b;
+      matrix.c = this.c;
+      matrix.d = this.d;
+      matrix.tx = this.tx;
+      matrix.ty = this.ty;
+      return matrix;
+    }
+    copyFrom(matrix) {
+      this.a = matrix.a;
+      this.b = matrix.b;
+      this.c = matrix.c;
+      this.d = matrix.d;
+      this.tx = matrix.tx;
+      this.ty = matrix.ty;
+      return this;
+    }
+    toString() {
+      return `[@pixi/math:Matrix a=${this.a} b=${this.b} c=${this.c} d=${this.d} tx=${this.tx} ty=${this.ty}]`;
+    }
+    static get IDENTITY() {
+      return new Matrix();
+    }
+    static get TEMP_MATRIX() {
+      return new Matrix();
+    }
+  }
+
+  const ux = [1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1];
+  const uy = [0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1];
+  const vx = [0, -1, -1, -1, 0, 1, 1, 1, 0, 1, 1, 1, 0, -1, -1, -1];
+  const vy = [1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, 1, 1, 1, 0, -1];
+  const rotationCayley = [];
+  const rotationMatrices = [];
+  const signum = Math.sign;
+  function init() {
+    for (let i = 0; i < 16; i++) {
+      const row = [];
+      rotationCayley.push(row);
+      for (let j = 0; j < 16; j++) {
+        const _ux = signum(ux[i] * ux[j] + vx[i] * uy[j]);
+        const _uy = signum(uy[i] * ux[j] + vy[i] * uy[j]);
+        const _vx = signum(ux[i] * vx[j] + vx[i] * vy[j]);
+        const _vy = signum(uy[i] * vx[j] + vy[i] * vy[j]);
+        for (let k = 0; k < 16; k++) {
+          if (ux[k] === _ux && uy[k] === _uy && vx[k] === _vx && vy[k] === _vy) {
+            row.push(k);
+            break;
+          }
+        }
+      }
+    }
+    for (let i = 0; i < 16; i++) {
+      const mat = new Matrix();
+      mat.set(ux[i], uy[i], vx[i], vy[i], 0, 0);
+      rotationMatrices.push(mat);
+    }
+  }
+  init();
+  const groupD8 = {
+    E: 0,
+    SE: 1,
+    S: 2,
+    SW: 3,
+    W: 4,
+    NW: 5,
+    N: 6,
+    NE: 7,
+    MIRROR_VERTICAL: 8,
+    MAIN_DIAGONAL: 10,
+    MIRROR_HORIZONTAL: 12,
+    REVERSE_DIAGONAL: 14,
+    uX: (ind) => ux[ind],
+    uY: (ind) => uy[ind],
+    vX: (ind) => vx[ind],
+    vY: (ind) => vy[ind],
+    inv: (rotation) => {
+      if (rotation & 8) {
+        return rotation & 15;
+      }
+      return -rotation & 7;
+    },
+    add: (rotationSecond, rotationFirst) => rotationCayley[rotationSecond][rotationFirst],
+    sub: (rotationSecond, rotationFirst) => rotationCayley[rotationSecond][groupD8.inv(rotationFirst)],
+    rotate180: (rotation) => rotation ^ 4,
+    isVertical: (rotation) => (rotation & 3) === 2,
+    byDirection: (dx, dy) => {
+      if (Math.abs(dx) * 2 <= Math.abs(dy)) {
+        if (dy >= 0) {
+          return groupD8.S;
+        }
+        return groupD8.N;
+      } else if (Math.abs(dy) * 2 <= Math.abs(dx)) {
+        if (dx > 0) {
+          return groupD8.E;
+        }
+        return groupD8.W;
+      } else if (dy > 0) {
+        if (dx > 0) {
+          return groupD8.SE;
+        }
+        return groupD8.SW;
+      } else if (dx > 0) {
+        return groupD8.NE;
+      }
+      return groupD8.NW;
+    },
+    matrixAppendRotationInv: (matrix, rotation, tx = 0, ty = 0) => {
+      const mat = rotationMatrices[groupD8.inv(rotation)];
+      mat.tx = tx;
+      mat.ty = ty;
+      matrix.append(mat);
+    }
+  };
+
+  class ObservablePoint {
+    constructor(cb, scope, x = 0, y = 0) {
+      this._x = x;
+      this._y = y;
+      this.cb = cb;
+      this.scope = scope;
+    }
+    clone(cb = this.cb, scope = this.scope) {
+      return new ObservablePoint(cb, scope, this._x, this._y);
+    }
+    set(x = 0, y = x) {
+      if (this._x !== x || this._y !== y) {
+        this._x = x;
+        this._y = y;
+        this.cb.call(this.scope);
+      }
+      return this;
+    }
+    copyFrom(p) {
+      if (this._x !== p.x || this._y !== p.y) {
+        this._x = p.x;
+        this._y = p.y;
+        this.cb.call(this.scope);
+      }
+      return this;
+    }
+    copyTo(p) {
+      p.set(this._x, this._y);
+      return p;
+    }
+    equals(p) {
+      return p.x === this._x && p.y === this._y;
+    }
+    toString() {
+      return `[@pixi/math:ObservablePoint x=${0} y=${0} scope=${this.scope}]`;
+    }
+    get x() {
+      return this._x;
+    }
+    set x(value) {
+      if (this._x !== value) {
+        this._x = value;
+        this.cb.call(this.scope);
+      }
+    }
+    get y() {
+      return this._y;
+    }
+    set y(value) {
+      if (this._y !== value) {
+        this._y = value;
+        this.cb.call(this.scope);
+      }
+    }
+  }
+
+  const _Transform = class {
+    constructor() {
+      this.worldTransform = new Matrix();
+      this.localTransform = new Matrix();
+      this.position = new ObservablePoint(this.onChange, this, 0, 0);
+      this.scale = new ObservablePoint(this.onChange, this, 1, 1);
+      this.pivot = new ObservablePoint(this.onChange, this, 0, 0);
+      this.skew = new ObservablePoint(this.updateSkew, this, 0, 0);
+      this._rotation = 0;
+      this._cx = 1;
+      this._sx = 0;
+      this._cy = 0;
+      this._sy = 1;
+      this._localID = 0;
+      this._currentLocalID = 0;
+      this._worldID = 0;
+      this._parentID = 0;
+    }
+    onChange() {
+      this._localID++;
+    }
+    updateSkew() {
+      this._cx = Math.cos(this._rotation + this.skew.y);
+      this._sx = Math.sin(this._rotation + this.skew.y);
+      this._cy = -Math.sin(this._rotation - this.skew.x);
+      this._sy = Math.cos(this._rotation - this.skew.x);
+      this._localID++;
+    }
+    toString() {
+      return `[@pixi/math:Transform position=(${this.position.x}, ${this.position.y}) rotation=${this.rotation} scale=(${this.scale.x}, ${this.scale.y}) skew=(${this.skew.x}, ${this.skew.y}) ]`;
+    }
+    updateLocalTransform() {
+      const lt = this.localTransform;
+      if (this._localID !== this._currentLocalID) {
+        lt.a = this._cx * this.scale.x;
+        lt.b = this._sx * this.scale.x;
+        lt.c = this._cy * this.scale.y;
+        lt.d = this._sy * this.scale.y;
+        lt.tx = this.position.x - (this.pivot.x * lt.a + this.pivot.y * lt.c);
+        lt.ty = this.position.y - (this.pivot.x * lt.b + this.pivot.y * lt.d);
+        this._currentLocalID = this._localID;
+        this._parentID = -1;
+      }
+    }
+    updateTransform(parentTransform) {
+      const lt = this.localTransform;
+      if (this._localID !== this._currentLocalID) {
+        lt.a = this._cx * this.scale.x;
+        lt.b = this._sx * this.scale.x;
+        lt.c = this._cy * this.scale.y;
+        lt.d = this._sy * this.scale.y;
+        lt.tx = this.position.x - (this.pivot.x * lt.a + this.pivot.y * lt.c);
+        lt.ty = this.position.y - (this.pivot.x * lt.b + this.pivot.y * lt.d);
+        this._currentLocalID = this._localID;
+        this._parentID = -1;
+      }
+      if (this._parentID !== parentTransform._worldID) {
+        const pt = parentTransform.worldTransform;
+        const wt = this.worldTransform;
+        wt.a = lt.a * pt.a + lt.b * pt.c;
+        wt.b = lt.a * pt.b + lt.b * pt.d;
+        wt.c = lt.c * pt.a + lt.d * pt.c;
+        wt.d = lt.c * pt.b + lt.d * pt.d;
+        wt.tx = lt.tx * pt.a + lt.ty * pt.c + pt.tx;
+        wt.ty = lt.tx * pt.b + lt.ty * pt.d + pt.ty;
+        this._parentID = parentTransform._worldID;
+        this._worldID++;
+      }
+    }
+    setFromMatrix(matrix) {
+      matrix.decompose(this);
+      this._localID++;
+    }
+    get rotation() {
+      return this._rotation;
+    }
+    set rotation(value) {
+      if (this._rotation !== value) {
+        this._rotation = value;
+        this.updateSkew();
+      }
+    }
+  };
+  let Transform = _Transform;
+  Transform.IDENTITY = new _Transform();
+
+  var defaultFragment$2 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n   gl_FragColor *= texture2D(uSampler, vTextureCoord);\n}";
+
+  var defaultVertex$3 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void){\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}\n";
+
+  function compileShader(gl, type, src) {
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    return shader;
+  }
+
+  function booleanArray(size) {
+    const array = new Array(size);
+    for (let i = 0; i < array.length; i++) {
+      array[i] = false;
+    }
+    return array;
+  }
+  function defaultValue(type, size) {
+    switch (type) {
+      case "float":
+        return 0;
+      case "vec2":
+        return new Float32Array(2 * size);
+      case "vec3":
+        return new Float32Array(3 * size);
+      case "vec4":
+        return new Float32Array(4 * size);
+      case "int":
+      case "uint":
+      case "sampler2D":
+      case "sampler2DArray":
+        return 0;
+      case "ivec2":
+        return new Int32Array(2 * size);
+      case "ivec3":
+        return new Int32Array(3 * size);
+      case "ivec4":
+        return new Int32Array(4 * size);
+      case "uvec2":
+        return new Uint32Array(2 * size);
+      case "uvec3":
+        return new Uint32Array(3 * size);
+      case "uvec4":
+        return new Uint32Array(4 * size);
+      case "bool":
+        return false;
+      case "bvec2":
+        return booleanArray(2 * size);
+      case "bvec3":
+        return booleanArray(3 * size);
+      case "bvec4":
+        return booleanArray(4 * size);
+      case "mat2":
+        return new Float32Array([
+          1,
+          0,
+          0,
+          1
+        ]);
+      case "mat3":
+        return new Float32Array([
+          1,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          1
+        ]);
+      case "mat4":
+        return new Float32Array([
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ]);
+    }
+    return null;
+  }
+
+  const uniformParsers = [
+    {
+      test: (data) => data.type === "float" && data.size === 1 && !data.isArray,
+      code: (name) => `
+            if(uv["${name}"] !== ud["${name}"].value)
+            {
+                ud["${name}"].value = uv["${name}"]
+                gl.uniform1f(ud["${name}"].location, uv["${name}"])
+            }
+            `
+    },
+    {
+      test: (data, uniform) => (data.type === "sampler2D" || data.type === "samplerCube" || data.type === "sampler2DArray") && data.size === 1 && !data.isArray && (uniform == null || uniform.castToBaseTexture !== void 0),
+      code: (name) => `t = syncData.textureCount++;
+
+            renderer.texture.bind(uv["${name}"], t);
+
+            if(ud["${name}"].value !== t)
+            {
+                ud["${name}"].value = t;
+                gl.uniform1i(ud["${name}"].location, t);
+; // eslint-disable-line max-len
+            }`
+    },
+    {
+      test: (data, uniform) => data.type === "mat3" && data.size === 1 && !data.isArray && uniform.a !== void 0,
+      code: (name) => `
+            gl.uniformMatrix3fv(ud["${name}"].location, false, uv["${name}"].toArray(true));
+            `,
+      codeUbo: (name) => `
+                var ${name}_matrix = uv.${name}.toArray(true);
+
+                data[offset] = ${name}_matrix[0];
+                data[offset+1] = ${name}_matrix[1];
+                data[offset+2] = ${name}_matrix[2];
+        
+                data[offset + 4] = ${name}_matrix[3];
+                data[offset + 5] = ${name}_matrix[4];
+                data[offset + 6] = ${name}_matrix[5];
+        
+                data[offset + 8] = ${name}_matrix[6];
+                data[offset + 9] = ${name}_matrix[7];
+                data[offset + 10] = ${name}_matrix[8];
+            `
+    },
+    {
+      test: (data, uniform) => data.type === "vec2" && data.size === 1 && !data.isArray && uniform.x !== void 0,
+      code: (name) => `
+                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);
+                }`,
+      codeUbo: (name) => `
+                v = uv.${name};
+
+                data[offset] = v.x;
+                data[offset+1] = v.y;
+            `
+    },
+    {
+      test: (data) => data.type === "vec2" && data.size === 1 && !data.isArray,
+      code: (name) => `
+                cv = ud["${name}"].value;
+                v = uv["${name}"];
+
+                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]);
+                }
+            `
+    },
+    {
+      test: (data, uniform) => data.type === "vec4" && data.size === 1 && !data.isArray && uniform.width !== void 0,
+      code: (name) => `
+                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)
+                }`,
+      codeUbo: (name) => `
+                    v = uv.${name};
+
+                    data[offset] = v.x;
+                    data[offset+1] = v.y;
+                    data[offset+2] = v.width;
+                    data[offset+3] = v.height;
+                `
+    },
+    {
+      test: (data, uniform) => data.type === "vec4" && data.size === 1 && !data.isArray && uniform.red !== void 0,
+      code: (name) => `
+                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)
+                }`,
+      codeUbo: (name) => `
+                    v = uv.${name};
+
+                    data[offset] = v.red;
+                    data[offset+1] = v.green;
+                    data[offset+2] = v.blue;
+                    data[offset+3] = v.alpha;
+                `
+    },
+    {
+      test: (data, uniform) => data.type === "vec3" && data.size === 1 && !data.isArray && uniform.red !== void 0,
+      code: (name) => `
+                cv = ud["${name}"].value;
+                v = uv["${name}"];
+
+                if(cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue || cv[3] !== v.a)
+                {
+                    cv[0] = v.red;
+                    cv[1] = v.green;
+                    cv[2] = v.blue;
+    
+                    gl.uniform3f(ud["${name}"].location, v.red, v.green, v.blue)
+                }`,
+      codeUbo: (name) => `
+                    v = uv.${name};
+
+                    data[offset] = v.red;
+                    data[offset+1] = v.green;
+                    data[offset+2] = v.blue;
+                `
+    },
+    {
+      test: (data) => data.type === "vec4" && data.size === 1 && !data.isArray,
+      code: (name) => `
+                cv = ud["${name}"].value;
+                v = uv["${name}"];
+
+                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])
+                }`
+    }
+  ];
+
+  const GLSL_TO_SINGLE_SETTERS_CACHED = {
+    float: `
+    if (cv !== v)
+    {
+        cu.value = v;
+        gl.uniform1f(location, v);
+    }`,
+    vec2: `
+    if (cv[0] !== v[0] || cv[1] !== v[1])
+    {
+        cv[0] = v[0];
+        cv[1] = v[1];
+
+        gl.uniform2f(location, v[0], v[1])
+    }`,
+    vec3: `
+    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(location, v[0], v[1], v[2])
+    }`,
+    vec4: `
+    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(location, v[0], v[1], v[2], v[3]);
+    }`,
+    int: `
+    if (cv !== v)
+    {
+        cu.value = v;
+
+        gl.uniform1i(location, v);
+    }`,
+    ivec2: `
+    if (cv[0] !== v[0] || cv[1] !== v[1])
+    {
+        cv[0] = v[0];
+        cv[1] = v[1];
+
+        gl.uniform2i(location, v[0], v[1]);
+    }`,
+    ivec3: `
+    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(location, v[0], v[1], v[2]);
+    }`,
+    ivec4: `
+    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(location, v[0], v[1], v[2], v[3]);
+    }`,
+    uint: `
+    if (cv !== v)
+    {
+        cu.value = v;
+
+        gl.uniform1ui(location, v);
+    }`,
+    uvec2: `
+    if (cv[0] !== v[0] || cv[1] !== v[1])
+    {
+        cv[0] = v[0];
+        cv[1] = v[1];
+
+        gl.uniform2ui(location, v[0], v[1]);
+    }`,
+    uvec3: `
+    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(location, v[0], v[1], v[2]);
+    }`,
+    uvec4: `
+    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(location, v[0], v[1], v[2], v[3]);
+    }`,
+    bool: `
+    if (cv !== v)
+    {
+        cu.value = v;
+        gl.uniform1i(location, v);
+    }`,
+    bvec2: `
+    if (cv[0] != v[0] || cv[1] != v[1])
+    {
+        cv[0] = v[0];
+        cv[1] = v[1];
+
+        gl.uniform2i(location, v[0], v[1]);
+    }`,
+    bvec3: `
+    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(location, v[0], v[1], v[2]);
+    }`,
+    bvec4: `
+    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(location, v[0], v[1], v[2], v[3]);
+    }`,
+    mat2: "gl.uniformMatrix2fv(location, false, v)",
+    mat3: "gl.uniformMatrix3fv(location, false, v)",
+    mat4: "gl.uniformMatrix4fv(location, false, v)",
+    sampler2D: `
+    if (cv !== v)
+    {
+        cu.value = v;
+
+        gl.uniform1i(location, v);
+    }`,
+    samplerCube: `
+    if (cv !== v)
+    {
+        cu.value = v;
+
+        gl.uniform1i(location, v);
+    }`,
+    sampler2DArray: `
+    if (cv !== v)
+    {
+        cu.value = v;
+
+        gl.uniform1i(location, v);
+    }`
+  };
+  const GLSL_TO_ARRAY_SETTERS = {
+    float: `gl.uniform1fv(location, v)`,
+    vec2: `gl.uniform2fv(location, v)`,
+    vec3: `gl.uniform3fv(location, v)`,
+    vec4: "gl.uniform4fv(location, v)",
+    mat4: "gl.uniformMatrix4fv(location, false, v)",
+    mat3: "gl.uniformMatrix3fv(location, false, v)",
+    mat2: "gl.uniformMatrix2fv(location, false, v)",
+    int: "gl.uniform1iv(location, v)",
+    ivec2: "gl.uniform2iv(location, v)",
+    ivec3: "gl.uniform3iv(location, v)",
+    ivec4: "gl.uniform4iv(location, v)",
+    uint: "gl.uniform1uiv(location, v)",
+    uvec2: "gl.uniform2uiv(location, v)",
+    uvec3: "gl.uniform3uiv(location, v)",
+    uvec4: "gl.uniform4uiv(location, v)",
+    bool: "gl.uniform1iv(location, v)",
+    bvec2: "gl.uniform2iv(location, v)",
+    bvec3: "gl.uniform3iv(location, v)",
+    bvec4: "gl.uniform4iv(location, v)",
+    sampler2D: "gl.uniform1iv(location, v)",
+    samplerCube: "gl.uniform1iv(location, v)",
+    sampler2DArray: "gl.uniform1iv(location, v)"
+  };
+  function generateUniformsSync(group, uniformData) {
+    const funcFragments = [`
+        var v = null;
+        var cv = null;
+        var cu = null;
+        var t = 0;
+        var gl = renderer.gl;
+    `];
+    for (const i in group.uniforms) {
+      const data = uniformData[i];
+      if (!data) {
+        if (group.uniforms[i]?.group) {
+          if (group.uniforms[i].ubo) {
+            funcFragments.push(`
+                        renderer.shader.syncUniformBufferGroup(uv.${i}, '${i}');
+                    `);
+          } else {
+            funcFragments.push(`
+                        renderer.shader.syncUniformGroup(uv.${i}, syncData);
+                    `);
+          }
+        }
+        continue;
+      }
+      const uniform = group.uniforms[i];
+      let parsed = false;
+      for (let j = 0; j < uniformParsers.length; j++) {
+        if (uniformParsers[j].test(data, uniform)) {
+          funcFragments.push(uniformParsers[j].code(i, uniform));
+          parsed = true;
+          break;
+        }
+      }
+      if (!parsed) {
+        const templateType = data.size === 1 && !data.isArray ? GLSL_TO_SINGLE_SETTERS_CACHED : GLSL_TO_ARRAY_SETTERS;
+        const template = templateType[data.type].replace("location", `ud["${i}"].location`);
+        funcFragments.push(`
+            cu = ud["${i}"];
+            cv = cu.value;
+            v = uv["${i}"];
+            ${template};`);
+      }
+    }
+    return new Function("ud", "uv", "renderer", "syncData", funcFragments.join("\n"));
+  }
+
+  const unknownContext = {};
+  let context = unknownContext;
+  function getTestContext() {
+    if (context === unknownContext || context?.isContextLost()) {
+      const canvas = settings.ADAPTER.createCanvas();
+      let gl;
+      if (settings.PREFER_ENV >= ENV.WEBGL2) {
+        gl = canvas.getContext("webgl2", {});
+      }
+      if (!gl) {
+        gl = canvas.getContext("webgl", {}) || canvas.getContext("experimental-webgl", {});
+        if (!gl) {
+          gl = null;
+        } else {
+          gl.getExtension("WEBGL_draw_buffers");
+        }
+      }
+      context = gl;
+    }
+    return context;
+  }
+
+  let maxFragmentPrecision;
+  function getMaxFragmentPrecision() {
+    if (!maxFragmentPrecision) {
+      maxFragmentPrecision = PRECISION.MEDIUM;
+      const gl = getTestContext();
+      if (gl) {
+        if (gl.getShaderPrecisionFormat) {
+          const shaderFragment = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT);
+          maxFragmentPrecision = shaderFragment.precision ? PRECISION.HIGH : PRECISION.MEDIUM;
+        }
+      }
+    }
+    return maxFragmentPrecision;
+  }
+
+  function logPrettyShaderError(gl, shader) {
+    const shaderSrc = gl.getShaderSource(shader).split("\n").map((line, index) => `${index}: ${line}`);
+    const shaderLog = gl.getShaderInfoLog(shader);
+    const splitShader = shaderLog.split("\n");
+    const dedupe = {};
+    const lineNumbers = splitShader.map((line) => parseFloat(line.replace(/^ERROR\: 0\:([\d]+)\:.*$/, "$1"))).filter((n) => {
+      if (n && !dedupe[n]) {
+        dedupe[n] = true;
+        return true;
+      }
+      return false;
+    });
+    const logArgs = [""];
+    lineNumbers.forEach((number) => {
+      shaderSrc[number - 1] = `%c${shaderSrc[number - 1]}%c`;
+      logArgs.push("background: #FF0000; color:#FFFFFF; font-size: 10px", "font-size: 10px");
+    });
+    const fragmentSourceToLog = shaderSrc.join("\n");
+    logArgs[0] = fragmentSourceToLog;
+    console.error(shaderLog);
+    console.groupCollapsed("click to view full shader code");
+    console.warn(...logArgs);
+    console.groupEnd();
+  }
+  function logProgramError(gl, program, vertexShader, fragmentShader) {
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+        logPrettyShaderError(gl, vertexShader);
+      }
+      if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+        logPrettyShaderError(gl, fragmentShader);
+      }
+      console.error("PixiJS Error: Could not initialize shader.");
+      if (gl.getProgramInfoLog(program) !== "") {
+        console.warn("PixiJS Warning: gl.getProgramInfoLog()", gl.getProgramInfoLog(program));
+      }
+    }
+  }
+
+  const GLSL_TO_SIZE = {
+    float: 1,
+    vec2: 2,
+    vec3: 3,
+    vec4: 4,
+    int: 1,
+    ivec2: 2,
+    ivec3: 3,
+    ivec4: 4,
+    uint: 1,
+    uvec2: 2,
+    uvec3: 3,
+    uvec4: 4,
+    bool: 1,
+    bvec2: 2,
+    bvec3: 3,
+    bvec4: 4,
+    mat2: 4,
+    mat3: 9,
+    mat4: 16,
+    sampler2D: 1
+  };
+  function mapSize(type) {
+    return GLSL_TO_SIZE[type];
+  }
+
+  let GL_TABLE = null;
+  const GL_TO_GLSL_TYPES = {
+    FLOAT: "float",
+    FLOAT_VEC2: "vec2",
+    FLOAT_VEC3: "vec3",
+    FLOAT_VEC4: "vec4",
+    INT: "int",
+    INT_VEC2: "ivec2",
+    INT_VEC3: "ivec3",
+    INT_VEC4: "ivec4",
+    UNSIGNED_INT: "uint",
+    UNSIGNED_INT_VEC2: "uvec2",
+    UNSIGNED_INT_VEC3: "uvec3",
+    UNSIGNED_INT_VEC4: "uvec4",
+    BOOL: "bool",
+    BOOL_VEC2: "bvec2",
+    BOOL_VEC3: "bvec3",
+    BOOL_VEC4: "bvec4",
+    FLOAT_MAT2: "mat2",
+    FLOAT_MAT3: "mat3",
+    FLOAT_MAT4: "mat4",
+    SAMPLER_2D: "sampler2D",
+    INT_SAMPLER_2D: "sampler2D",
+    UNSIGNED_INT_SAMPLER_2D: "sampler2D",
+    SAMPLER_CUBE: "samplerCube",
+    INT_SAMPLER_CUBE: "samplerCube",
+    UNSIGNED_INT_SAMPLER_CUBE: "samplerCube",
+    SAMPLER_2D_ARRAY: "sampler2DArray",
+    INT_SAMPLER_2D_ARRAY: "sampler2DArray",
+    UNSIGNED_INT_SAMPLER_2D_ARRAY: "sampler2DArray"
+  };
+  function mapType(gl, type) {
+    if (!GL_TABLE) {
+      const typeNames = Object.keys(GL_TO_GLSL_TYPES);
+      GL_TABLE = {};
+      for (let i = 0; i < typeNames.length; ++i) {
+        const tn = typeNames[i];
+        GL_TABLE[gl[tn]] = GL_TO_GLSL_TYPES[tn];
+      }
+    }
+    return GL_TABLE[type];
+  }
+
+  function setPrecision(src, requestedPrecision, maxSupportedPrecision) {
+    if (src.substring(0, 9) !== "precision") {
+      let precision = requestedPrecision;
+      if (requestedPrecision === PRECISION.HIGH && maxSupportedPrecision !== PRECISION.HIGH) {
+        precision = PRECISION.MEDIUM;
+      }
+      return `precision ${precision} float;
+${src}`;
+    } else if (maxSupportedPrecision !== PRECISION.HIGH && src.substring(0, 15) === "precision highp") {
+      return src.replace("precision highp", "precision mediump");
+    }
+    return src;
+  }
+
+  let unsafeEval;
+  function unsafeEvalSupported() {
+    if (typeof unsafeEval === "boolean") {
+      return unsafeEval;
+    }
+    try {
+      const func = new Function("param1", "param2", "param3", "return param1[param2] === param3;");
+      unsafeEval = func({ a: "b" }, "a", "b") === true;
+    } catch (e) {
+      unsafeEval = false;
+    }
+    return unsafeEval;
+  }
+
+  let UID$2 = 0;
+  const nameCache = {};
+  const _Program = class {
+    constructor(vertexSrc, fragmentSrc, name = "pixi-shader", extra = {}) {
+      this.extra = {};
+      this.id = UID$2++;
+      this.vertexSrc = vertexSrc || _Program.defaultVertexSrc;
+      this.fragmentSrc = fragmentSrc || _Program.defaultFragmentSrc;
+      this.vertexSrc = this.vertexSrc.trim();
+      this.fragmentSrc = this.fragmentSrc.trim();
+      this.extra = extra;
+      if (this.vertexSrc.substring(0, 8) !== "#version") {
+        name = name.replace(/\s+/g, "-");
+        if (nameCache[name]) {
+          nameCache[name]++;
+          name += `-${nameCache[name]}`;
+        } else {
+          nameCache[name] = 1;
+        }
+        this.vertexSrc = `#define SHADER_NAME ${name}
+${this.vertexSrc}`;
+        this.fragmentSrc = `#define SHADER_NAME ${name}
+${this.fragmentSrc}`;
+        this.vertexSrc = setPrecision(this.vertexSrc, _Program.defaultVertexPrecision, PRECISION.HIGH);
+        this.fragmentSrc = setPrecision(this.fragmentSrc, _Program.defaultFragmentPrecision, getMaxFragmentPrecision());
+      }
+      this.glPrograms = {};
+      this.syncUniforms = null;
+    }
+    static get defaultVertexSrc() {
+      return defaultVertex$3;
+    }
+    static get defaultFragmentSrc() {
+      return defaultFragment$2;
+    }
+    static from(vertexSrc, fragmentSrc, name) {
+      const key = vertexSrc + fragmentSrc;
+      let program = ProgramCache[key];
+      if (!program) {
+        ProgramCache[key] = program = new _Program(vertexSrc, fragmentSrc, name);
+      }
+      return program;
+    }
+  };
+  let Program = _Program;
+  Program.defaultVertexPrecision = PRECISION.HIGH;
+  Program.defaultFragmentPrecision = isMobile.apple.device ? PRECISION.HIGH : PRECISION.MEDIUM;
+
+  let UID$1 = 0;
+  class UniformGroup {
+    constructor(uniforms, isStatic, isUbo) {
+      this.group = true;
+      this.syncUniforms = {};
+      this.dirtyId = 0;
+      this.id = UID$1++;
+      this.static = !!isStatic;
+      this.ubo = !!isUbo;
+      if (uniforms instanceof Buffer) {
+        this.buffer = uniforms;
+        this.buffer.type = BUFFER_TYPE.UNIFORM_BUFFER;
+        this.autoManage = false;
+        this.ubo = true;
+      } else {
+        this.uniforms = uniforms;
+        if (this.ubo) {
+          this.buffer = new Buffer(new Float32Array(1));
+          this.buffer.type = BUFFER_TYPE.UNIFORM_BUFFER;
+          this.autoManage = true;
+        }
+      }
+    }
+    update() {
+      this.dirtyId++;
+      if (!this.autoManage && this.buffer) {
+        this.buffer.update();
+      }
+    }
+    add(name, uniforms, _static) {
+      if (!this.ubo) {
+        this.uniforms[name] = new UniformGroup(uniforms, _static);
+      } else {
+        throw new Error("[UniformGroup] uniform groups in ubo mode cannot be modified, or have uniform groups nested in them");
+      }
+    }
+    static from(uniforms, _static, _ubo) {
+      return new UniformGroup(uniforms, _static, _ubo);
+    }
+    static uboFrom(uniforms, _static) {
+      return new UniformGroup(uniforms, _static ?? true, true);
+    }
+  }
+
+  class Shader {
+    constructor(program, uniforms) {
+      this.uniformBindCount = 0;
+      this.program = program;
+      if (uniforms) {
+        if (uniforms instanceof UniformGroup) {
+          this.uniformGroup = uniforms;
+        } else {
+          this.uniformGroup = new UniformGroup(uniforms);
+        }
+      } else {
+        this.uniformGroup = new UniformGroup({});
+      }
+      this.disposeRunner = new Runner("disposeShader");
+    }
+    checkUniformExists(name, group) {
+      if (group.uniforms[name]) {
+        return true;
+      }
+      for (const i in group.uniforms) {
+        const uniform = group.uniforms[i];
+        if (uniform.group) {
+          if (this.checkUniformExists(name, uniform)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    destroy() {
+      this.uniformGroup = null;
+      this.disposeRunner.emit(this);
+      this.disposeRunner.destroy();
+    }
+    get uniforms() {
+      return this.uniformGroup.uniforms;
+    }
+    static from(vertexSrc, fragmentSrc, uniforms) {
+      const program = Program.from(vertexSrc, fragmentSrc);
+      return new Shader(program, uniforms);
+    }
+  }
+
+  class BatchShaderGenerator {
+    constructor(vertexSrc, fragTemplate) {
+      this.vertexSrc = vertexSrc;
+      this.fragTemplate = fragTemplate;
+      this.programCache = {};
+      this.defaultGroupCache = {};
+      if (!fragTemplate.includes("%count%")) {
+        throw new Error('Fragment template must contain "%count%".');
+      }
+      if (!fragTemplate.includes("%forloop%")) {
+        throw new Error('Fragment template must contain "%forloop%".');
+      }
+    }
+    generateShader(maxTextures) {
+      if (!this.programCache[maxTextures]) {
+        const sampleValues = new Int32Array(maxTextures);
+        for (let i = 0; i < maxTextures; i++) {
+          sampleValues[i] = i;
+        }
+        this.defaultGroupCache[maxTextures] = UniformGroup.from({ uSamplers: sampleValues }, true);
+        let fragmentSrc = this.fragTemplate;
+        fragmentSrc = fragmentSrc.replace(/%count%/gi, `${maxTextures}`);
+        fragmentSrc = fragmentSrc.replace(/%forloop%/gi, this.generateSampleSrc(maxTextures));
+        this.programCache[maxTextures] = new Program(this.vertexSrc, fragmentSrc);
+      }
+      const uniforms = {
+        tint: new Float32Array([1, 1, 1, 1]),
+        translationMatrix: new Matrix(),
+        default: this.defaultGroupCache[maxTextures]
+      };
+      return new Shader(this.programCache[maxTextures], uniforms);
+    }
+    generateSampleSrc(maxTextures) {
+      let src = "";
+      src += "\n";
+      src += "\n";
+      for (let i = 0; i < maxTextures; i++) {
+        if (i > 0) {
+          src += "\nelse ";
+        }
+        if (i < maxTextures - 1) {
+          src += `if(vTextureId < ${i}.5)`;
+        }
+        src += "\n{";
+        src += `
+	color = texture2D(uSamplers[${i}], vTextureCoord);`;
+        src += "\n}";
+      }
+      src += "\n";
+      src += "\n";
+      return src;
+    }
+  }
+
+  class BatchTextureArray {
+    constructor() {
+      this.elements = [];
+      this.ids = [];
+      this.count = 0;
+    }
+    clear() {
+      for (let i = 0; i < this.count; i++) {
+        this.elements[i] = null;
+      }
+      this.count = 0;
+    }
+  }
+
+  function canUploadSameBuffer() {
+    return !isMobile.apple.device;
+  }
+
+  function maxRecommendedTextures(max) {
+    let allowMax = true;
+    const navigator = settings.ADAPTER.getNavigator();
+    if (isMobile.tablet || isMobile.phone) {
+      if (isMobile.apple.device) {
+        const match = navigator.userAgent.match(/OS (\d+)_(\d+)?/);
+        if (match) {
+          const majorVersion = parseInt(match[1], 10);
+          if (majorVersion < 11) {
+            allowMax = false;
+          }
+        }
+      }
+      if (isMobile.android.device) {
+        const match = navigator.userAgent.match(/Android\s([0-9.]*)/);
+        if (match) {
+          const majorVersion = parseInt(match[1], 10);
+          if (majorVersion < 7) {
+            allowMax = false;
+          }
+        }
+      }
+    }
+    return allowMax ? max : 4;
+  }
+
+  class ObjectRenderer {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    flush() {
+    }
+    destroy() {
+      this.renderer = null;
+    }
+    start() {
+    }
+    stop() {
+      this.flush();
+    }
+    render(_object) {
+    }
+  }
+
+  var defaultFragment$1 = "varying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\nuniform sampler2D uSamplers[%count%];\n\nvoid main(void){\n    vec4 color;\n    %forloop%\n    gl_FragColor = color * vColor;\n}\n";
+
+  var defaultVertex$2 = "precision highp float;\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\nattribute float aTextureId;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform vec4 tint;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\n\nvoid main(void){\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vTextureId = aTextureId;\n    vColor = aColor * tint;\n}\n";
+
+  const _BatchRenderer = class extends ObjectRenderer {
+    constructor(renderer) {
+      super(renderer);
+      this.setShaderGenerator();
+      this.geometryClass = BatchGeometry;
+      this.vertexSize = 6;
+      this.state = State.for2d();
+      this.size = _BatchRenderer.defaultBatchSize * 4;
+      this._vertexCount = 0;
+      this._indexCount = 0;
+      this._bufferedElements = [];
+      this._bufferedTextures = [];
+      this._bufferSize = 0;
+      this._shader = null;
+      this._packedGeometries = [];
+      this._packedGeometryPoolSize = 2;
+      this._flushId = 0;
+      this._aBuffers = {};
+      this._iBuffers = {};
+      this.maxTextures = 1;
+      this.renderer.on("prerender", this.onPrerender, this);
+      renderer.runners.contextChange.add(this);
+      this._dcIndex = 0;
+      this._aIndex = 0;
+      this._iIndex = 0;
+      this._attributeBuffer = null;
+      this._indexBuffer = null;
+      this._tempBoundTextures = [];
+    }
+    static get defaultMaxTextures() {
+      this._defaultMaxTextures = this._defaultMaxTextures ?? maxRecommendedTextures(32);
+      return this._defaultMaxTextures;
+    }
+    static set defaultMaxTextures(value) {
+      this._defaultMaxTextures = value;
+    }
+    static get canUploadSameBuffer() {
+      this._canUploadSameBuffer = this._canUploadSameBuffer ?? canUploadSameBuffer();
+      return this._canUploadSameBuffer;
+    }
+    static set canUploadSameBuffer(value) {
+      this._canUploadSameBuffer = value;
+    }
+    get MAX_TEXTURES() {
+      deprecation$1("7.1.0", "BatchRenderer#MAX_TEXTURES renamed to BatchRenderer#maxTextures");
+      return this.maxTextures;
+    }
+    static get defaultVertexSrc() {
+      return defaultVertex$2;
+    }
+    static get defaultFragmentTemplate() {
+      return defaultFragment$1;
+    }
+    setShaderGenerator({
+      vertex = _BatchRenderer.defaultVertexSrc,
+      fragment = _BatchRenderer.defaultFragmentTemplate
+    } = {}) {
+      this.shaderGenerator = new BatchShaderGenerator(vertex, fragment);
+    }
+    contextChange() {
+      const gl = this.renderer.gl;
+      if (settings.PREFER_ENV === ENV.WEBGL_LEGACY) {
+        this.maxTextures = 1;
+      } else {
+        this.maxTextures = Math.min(gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS), _BatchRenderer.defaultMaxTextures);
+        this.maxTextures = checkMaxIfStatementsInShader(this.maxTextures, gl);
+      }
+      this._shader = this.shaderGenerator.generateShader(this.maxTextures);
+      for (let i = 0; i < this._packedGeometryPoolSize; i++) {
+        this._packedGeometries[i] = new this.geometryClass();
+      }
+      this.initFlushBuffers();
+    }
+    initFlushBuffers() {
+      const {
+        _drawCallPool,
+        _textureArrayPool
+      } = _BatchRenderer;
+      const MAX_SPRITES = this.size / 4;
+      const MAX_TA = Math.floor(MAX_SPRITES / this.maxTextures) + 1;
+      while (_drawCallPool.length < MAX_SPRITES) {
+        _drawCallPool.push(new BatchDrawCall());
+      }
+      while (_textureArrayPool.length < MAX_TA) {
+        _textureArrayPool.push(new BatchTextureArray());
+      }
+      for (let i = 0; i < this.maxTextures; i++) {
+        this._tempBoundTextures[i] = null;
+      }
+    }
+    onPrerender() {
+      this._flushId = 0;
+    }
+    render(element) {
+      if (!element._texture.valid) {
+        return;
+      }
+      if (this._vertexCount + element.vertexData.length / 2 > this.size) {
+        this.flush();
+      }
+      this._vertexCount += element.vertexData.length / 2;
+      this._indexCount += element.indices.length;
+      this._bufferedTextures[this._bufferSize] = element._texture.baseTexture;
+      this._bufferedElements[this._bufferSize++] = element;
+    }
+    buildTexturesAndDrawCalls() {
+      const {
+        _bufferedTextures: textures,
+        maxTextures
+      } = this;
+      const textureArrays = _BatchRenderer._textureArrayPool;
+      const batch = this.renderer.batch;
+      const boundTextures = this._tempBoundTextures;
+      const touch = this.renderer.textureGC.count;
+      let TICK = ++BaseTexture._globalBatch;
+      let countTexArrays = 0;
+      let texArray = textureArrays[0];
+      let start = 0;
+      batch.copyBoundTextures(boundTextures, maxTextures);
+      for (let i = 0; i < this._bufferSize; ++i) {
+        const tex = textures[i];
+        textures[i] = null;
+        if (tex._batchEnabled === TICK) {
+          continue;
+        }
+        if (texArray.count >= maxTextures) {
+          batch.boundArray(texArray, boundTextures, TICK, maxTextures);
+          this.buildDrawCalls(texArray, start, i);
+          start = i;
+          texArray = textureArrays[++countTexArrays];
+          ++TICK;
+        }
+        tex._batchEnabled = TICK;
+        tex.touched = touch;
+        texArray.elements[texArray.count++] = tex;
+      }
+      if (texArray.count > 0) {
+        batch.boundArray(texArray, boundTextures, TICK, maxTextures);
+        this.buildDrawCalls(texArray, start, this._bufferSize);
+        ++countTexArrays;
+        ++TICK;
+      }
+      for (let i = 0; i < boundTextures.length; i++) {
+        boundTextures[i] = null;
+      }
+      BaseTexture._globalBatch = TICK;
+    }
+    buildDrawCalls(texArray, start, finish) {
+      const {
+        _bufferedElements: elements,
+        _attributeBuffer,
+        _indexBuffer,
+        vertexSize
+      } = this;
+      const drawCalls = _BatchRenderer._drawCallPool;
+      let dcIndex = this._dcIndex;
+      let aIndex = this._aIndex;
+      let iIndex = this._iIndex;
+      let drawCall = drawCalls[dcIndex];
+      drawCall.start = this._iIndex;
+      drawCall.texArray = texArray;
+      for (let i = start; i < finish; ++i) {
+        const sprite = elements[i];
+        const tex = sprite._texture.baseTexture;
+        const spriteBlendMode = premultiplyBlendMode[tex.alphaMode ? 1 : 0][sprite.blendMode];
+        elements[i] = null;
+        if (start < i && drawCall.blend !== spriteBlendMode) {
+          drawCall.size = iIndex - drawCall.start;
+          start = i;
+          drawCall = drawCalls[++dcIndex];
+          drawCall.texArray = texArray;
+          drawCall.start = iIndex;
+        }
+        this.packInterleavedGeometry(sprite, _attributeBuffer, _indexBuffer, aIndex, iIndex);
+        aIndex += sprite.vertexData.length / 2 * vertexSize;
+        iIndex += sprite.indices.length;
+        drawCall.blend = spriteBlendMode;
+      }
+      if (start < finish) {
+        drawCall.size = iIndex - drawCall.start;
+        ++dcIndex;
+      }
+      this._dcIndex = dcIndex;
+      this._aIndex = aIndex;
+      this._iIndex = iIndex;
+    }
+    bindAndClearTexArray(texArray) {
+      const textureSystem = this.renderer.texture;
+      for (let j = 0; j < texArray.count; j++) {
+        textureSystem.bind(texArray.elements[j], texArray.ids[j]);
+        texArray.elements[j] = null;
+      }
+      texArray.count = 0;
+    }
+    updateGeometry() {
+      const {
+        _packedGeometries: packedGeometries,
+        _attributeBuffer: attributeBuffer,
+        _indexBuffer: indexBuffer
+      } = this;
+      if (!_BatchRenderer.canUploadSameBuffer) {
+        if (this._packedGeometryPoolSize <= this._flushId) {
+          this._packedGeometryPoolSize++;
+          packedGeometries[this._flushId] = new this.geometryClass();
+        }
+        packedGeometries[this._flushId]._buffer.update(attributeBuffer.rawBinaryData);
+        packedGeometries[this._flushId]._indexBuffer.update(indexBuffer);
+        this.renderer.geometry.bind(packedGeometries[this._flushId]);
+        this.renderer.geometry.updateBuffers();
+        this._flushId++;
+      } else {
+        packedGeometries[this._flushId]._buffer.update(attributeBuffer.rawBinaryData);
+        packedGeometries[this._flushId]._indexBuffer.update(indexBuffer);
+        this.renderer.geometry.updateBuffers();
+      }
+    }
+    drawBatches() {
+      const dcCount = this._dcIndex;
+      const { gl, state: stateSystem } = this.renderer;
+      const drawCalls = _BatchRenderer._drawCallPool;
+      let curTexArray = null;
+      for (let i = 0; i < dcCount; i++) {
+        const { texArray, type, size, start, blend } = drawCalls[i];
+        if (curTexArray !== texArray) {
+          curTexArray = texArray;
+          this.bindAndClearTexArray(texArray);
+        }
+        this.state.blendMode = blend;
+        stateSystem.set(this.state);
+        gl.drawElements(type, size, gl.UNSIGNED_SHORT, start * 2);
+      }
+    }
+    flush() {
+      if (this._vertexCount === 0) {
+        return;
+      }
+      this._attributeBuffer = this.getAttributeBuffer(this._vertexCount);
+      this._indexBuffer = this.getIndexBuffer(this._indexCount);
+      this._aIndex = 0;
+      this._iIndex = 0;
+      this._dcIndex = 0;
+      this.buildTexturesAndDrawCalls();
+      this.updateGeometry();
+      this.drawBatches();
+      this._bufferSize = 0;
+      this._vertexCount = 0;
+      this._indexCount = 0;
+    }
+    start() {
+      this.renderer.state.set(this.state);
+      this.renderer.texture.ensureSamplerType(this.maxTextures);
+      this.renderer.shader.bind(this._shader);
+      if (_BatchRenderer.canUploadSameBuffer) {
+        this.renderer.geometry.bind(this._packedGeometries[this._flushId]);
+      }
+    }
+    stop() {
+      this.flush();
+    }
+    destroy() {
+      for (let i = 0; i < this._packedGeometryPoolSize; i++) {
+        if (this._packedGeometries[i]) {
+          this._packedGeometries[i].destroy();
+        }
+      }
+      this.renderer.off("prerender", this.onPrerender, this);
+      this._aBuffers = null;
+      this._iBuffers = null;
+      this._packedGeometries = null;
+      this._attributeBuffer = null;
+      this._indexBuffer = null;
+      if (this._shader) {
+        this._shader.destroy();
+        this._shader = null;
+      }
+      super.destroy();
+    }
+    getAttributeBuffer(size) {
+      const roundedP2 = nextPow2(Math.ceil(size / 8));
+      const roundedSizeIndex = log2(roundedP2);
+      const roundedSize = roundedP2 * 8;
+      if (this._aBuffers.length <= roundedSizeIndex) {
+        this._iBuffers.length = roundedSizeIndex + 1;
+      }
+      let buffer = this._aBuffers[roundedSize];
+      if (!buffer) {
+        this._aBuffers[roundedSize] = buffer = new ViewableBuffer(roundedSize * this.vertexSize * 4);
+      }
+      return buffer;
+    }
+    getIndexBuffer(size) {
+      const roundedP2 = nextPow2(Math.ceil(size / 12));
+      const roundedSizeIndex = log2(roundedP2);
+      const roundedSize = roundedP2 * 12;
+      if (this._iBuffers.length <= roundedSizeIndex) {
+        this._iBuffers.length = roundedSizeIndex + 1;
+      }
+      let buffer = this._iBuffers[roundedSizeIndex];
+      if (!buffer) {
+        this._iBuffers[roundedSizeIndex] = buffer = new Uint16Array(roundedSize);
+      }
+      return buffer;
+    }
+    packInterleavedGeometry(element, attributeBuffer, indexBuffer, aIndex, iIndex) {
+      const {
+        uint32View,
+        float32View
+      } = attributeBuffer;
+      const packedVertices = aIndex / this.vertexSize;
+      const uvs = element.uvs;
+      const indicies = element.indices;
+      const vertexData = element.vertexData;
+      const textureId = element._texture.baseTexture._batchLocation;
+      const alpha = Math.min(element.worldAlpha, 1);
+      const argb = Color.shared.setValue(element._tintRGB).toPremultiplied(alpha, element._texture.baseTexture.alphaMode > 0);
+      for (let i = 0; i < vertexData.length; i += 2) {
+        float32View[aIndex++] = vertexData[i];
+        float32View[aIndex++] = vertexData[i + 1];
+        float32View[aIndex++] = uvs[i];
+        float32View[aIndex++] = uvs[i + 1];
+        uint32View[aIndex++] = argb;
+        float32View[aIndex++] = textureId;
+      }
+      for (let i = 0; i < indicies.length; i++) {
+        indexBuffer[iIndex++] = packedVertices + indicies[i];
+      }
+    }
+  };
+  let BatchRenderer = _BatchRenderer;
+  BatchRenderer.defaultBatchSize = 4096;
+  BatchRenderer.extension = {
+    name: "batch",
+    type: ExtensionType.RendererPlugin
+  };
+  BatchRenderer._drawCallPool = [];
+  BatchRenderer._textureArrayPool = [];
+  extensions$1.add(BatchRenderer);
+
+  var defaultFragment = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n   gl_FragColor = texture2D(uSampler, vTextureCoord);\n}\n";
+
+  var defaultVertex$1 = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";
+
+  const _Filter = class extends Shader {
+    constructor(vertexSrc, fragmentSrc, uniforms) {
+      const program = Program.from(vertexSrc || _Filter.defaultVertexSrc, fragmentSrc || _Filter.defaultFragmentSrc);
+      super(program, uniforms);
+      this.padding = 0;
+      this.resolution = _Filter.defaultResolution;
+      this.multisample = _Filter.defaultMultisample;
+      this.enabled = true;
+      this.autoFit = true;
+      this.state = new State();
+    }
+    apply(filterManager, input, output, clearMode, _currentState) {
+      filterManager.applyFilter(this, input, output, clearMode);
+    }
+    get blendMode() {
+      return this.state.blendMode;
+    }
+    set blendMode(value) {
+      this.state.blendMode = value;
+    }
+    get resolution() {
+      return this._resolution;
+    }
+    set resolution(value) {
+      this._resolution = value;
+    }
+    static get defaultVertexSrc() {
+      return defaultVertex$1;
+    }
+    static get defaultFragmentSrc() {
+      return defaultFragment;
+    }
+  };
+  let Filter = _Filter;
+  Filter.defaultResolution = 1;
+  Filter.defaultMultisample = MSAA_QUALITY.NONE;
+
+  class BackgroundSystem {
+    constructor() {
+      this.clearBeforeRender = true;
+      this._backgroundColor = new Color(0);
+      this.alpha = 1;
+    }
+    init(options) {
+      this.clearBeforeRender = options.clearBeforeRender;
+      const { backgroundColor, background, backgroundAlpha } = options;
+      const color = background ?? backgroundColor;
+      if (color !== void 0) {
+        this.color = color;
+      }
+      this.alpha = backgroundAlpha;
+    }
+    get color() {
+      return this._backgroundColor.value;
+    }
+    set color(value) {
+      this._backgroundColor.setValue(value);
+    }
+    get alpha() {
+      return this._backgroundColor.alpha;
+    }
+    set alpha(value) {
+      this._backgroundColor.setAlpha(value);
+    }
+    get backgroundColor() {
+      return this._backgroundColor;
+    }
+    destroy() {
+    }
+  }
+  BackgroundSystem.defaultOptions = {
+    backgroundAlpha: 1,
+    backgroundColor: 0,
+    clearBeforeRender: true
+  };
+  BackgroundSystem.extension = {
+    type: [
+      ExtensionType.RendererSystem,
+      ExtensionType.CanvasRendererSystem
+    ],
+    name: "background"
+  };
+  extensions$1.add(BackgroundSystem);
+
+  class BatchSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.emptyRenderer = new ObjectRenderer(renderer);
+      this.currentRenderer = this.emptyRenderer;
+    }
+    setObjectRenderer(objectRenderer) {
+      if (this.currentRenderer === objectRenderer) {
+        return;
+      }
+      this.currentRenderer.stop();
+      this.currentRenderer = objectRenderer;
+      this.currentRenderer.start();
+    }
+    flush() {
+      this.setObjectRenderer(this.emptyRenderer);
+    }
+    reset() {
+      this.setObjectRenderer(this.emptyRenderer);
+    }
+    copyBoundTextures(arr, maxTextures) {
+      const { boundTextures } = this.renderer.texture;
+      for (let i = maxTextures - 1; i >= 0; --i) {
+        arr[i] = boundTextures[i] || null;
+        if (arr[i]) {
+          arr[i]._batchLocation = i;
+        }
+      }
+    }
+    boundArray(texArray, boundTextures, batchId, maxTextures) {
+      const { elements, ids, count } = texArray;
+      let j = 0;
+      for (let i = 0; i < count; i++) {
+        const tex = elements[i];
+        const loc = tex._batchLocation;
+        if (loc >= 0 && loc < maxTextures && boundTextures[loc] === tex) {
+          ids[i] = loc;
+          continue;
+        }
+        while (j < maxTextures) {
+          const bound = boundTextures[j];
+          if (bound && bound._batchEnabled === batchId && bound._batchLocation === j) {
+            j++;
+            continue;
+          }
+          ids[i] = j;
+          tex._batchLocation = j;
+          boundTextures[j] = tex;
+          break;
+        }
+      }
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  BatchSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "batch"
+  };
+  extensions$1.add(BatchSystem);
+
+  let CONTEXT_UID_COUNTER = 0;
+  class ContextSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.webGLVersion = 1;
+      this.extensions = {};
+      this.supports = {
+        uint32Indices: false
+      };
+      this.handleContextLost = this.handleContextLost.bind(this);
+      this.handleContextRestored = this.handleContextRestored.bind(this);
+    }
+    get isLost() {
+      return !this.gl || this.gl.isContextLost();
+    }
+    contextChange(gl) {
+      this.gl = gl;
+      this.renderer.gl = gl;
+      this.renderer.CONTEXT_UID = CONTEXT_UID_COUNTER++;
+    }
+    init(options) {
+      if (options.context) {
+        this.initFromContext(options.context);
+      } else {
+        const alpha = this.renderer.background.alpha < 1;
+        const premultipliedAlpha = options.premultipliedAlpha;
+        this.preserveDrawingBuffer = options.preserveDrawingBuffer;
+        this.useContextAlpha = options.useContextAlpha;
+        this.powerPreference = options.powerPreference;
+        this.initFromOptions({
+          alpha,
+          premultipliedAlpha,
+          antialias: options.antialias,
+          stencil: true,
+          preserveDrawingBuffer: options.preserveDrawingBuffer,
+          powerPreference: options.powerPreference
+        });
+      }
+    }
+    initFromContext(gl) {
+      this.gl = gl;
+      this.validateContext(gl);
+      this.renderer.gl = gl;
+      this.renderer.CONTEXT_UID = CONTEXT_UID_COUNTER++;
+      this.renderer.runners.contextChange.emit(gl);
+      const view = this.renderer.view;
+      if (view.addEventListener !== void 0) {
+        view.addEventListener("webglcontextlost", this.handleContextLost, false);
+        view.addEventListener("webglcontextrestored", this.handleContextRestored, false);
+      }
+    }
+    initFromOptions(options) {
+      const gl = this.createContext(this.renderer.view, options);
+      this.initFromContext(gl);
+    }
+    createContext(canvas, options) {
+      let gl;
+      if (settings.PREFER_ENV >= ENV.WEBGL2) {
+        gl = canvas.getContext("webgl2", options);
+      }
+      if (gl) {
+        this.webGLVersion = 2;
+      } else {
+        this.webGLVersion = 1;
+        gl = canvas.getContext("webgl", options) || canvas.getContext("experimental-webgl", options);
+        if (!gl) {
+          throw new Error("This browser does not support WebGL. Try using the canvas renderer");
+        }
+      }
+      this.gl = gl;
+      this.getExtensions();
+      return this.gl;
+    }
+    getExtensions() {
+      const { gl } = this;
+      const common = {
+        loseContext: gl.getExtension("WEBGL_lose_context"),
+        anisotropicFiltering: gl.getExtension("EXT_texture_filter_anisotropic"),
+        floatTextureLinear: gl.getExtension("OES_texture_float_linear"),
+        s3tc: gl.getExtension("WEBGL_compressed_texture_s3tc"),
+        s3tc_sRGB: gl.getExtension("WEBGL_compressed_texture_s3tc_srgb"),
+        etc: gl.getExtension("WEBGL_compressed_texture_etc"),
+        etc1: gl.getExtension("WEBGL_compressed_texture_etc1"),
+        pvrtc: gl.getExtension("WEBGL_compressed_texture_pvrtc") || gl.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc"),
+        atc: gl.getExtension("WEBGL_compressed_texture_atc"),
+        astc: gl.getExtension("WEBGL_compressed_texture_astc")
+      };
+      if (this.webGLVersion === 1) {
+        Object.assign(this.extensions, common, {
+          drawBuffers: gl.getExtension("WEBGL_draw_buffers"),
+          depthTexture: gl.getExtension("WEBGL_depth_texture"),
+          vertexArrayObject: gl.getExtension("OES_vertex_array_object") || gl.getExtension("MOZ_OES_vertex_array_object") || gl.getExtension("WEBKIT_OES_vertex_array_object"),
+          uint32ElementIndex: gl.getExtension("OES_element_index_uint"),
+          floatTexture: gl.getExtension("OES_texture_float"),
+          floatTextureLinear: gl.getExtension("OES_texture_float_linear"),
+          textureHalfFloat: gl.getExtension("OES_texture_half_float"),
+          textureHalfFloatLinear: gl.getExtension("OES_texture_half_float_linear")
+        });
+      } else if (this.webGLVersion === 2) {
+        Object.assign(this.extensions, common, {
+          colorBufferFloat: gl.getExtension("EXT_color_buffer_float")
+        });
+      }
+    }
+    handleContextLost(event) {
+      event.preventDefault();
+      setTimeout(() => {
+        if (this.gl.isContextLost() && this.extensions.loseContext) {
+          this.extensions.loseContext.restoreContext();
+        }
+      }, 0);
+    }
+    handleContextRestored() {
+      this.renderer.runners.contextChange.emit(this.gl);
+    }
+    destroy() {
+      const view = this.renderer.view;
+      this.renderer = null;
+      if (view.removeEventListener !== void 0) {
+        view.removeEventListener("webglcontextlost", this.handleContextLost);
+        view.removeEventListener("webglcontextrestored", this.handleContextRestored);
+      }
+      this.gl.useProgram(null);
+      if (this.extensions.loseContext) {
+        this.extensions.loseContext.loseContext();
+      }
+    }
+    postrender() {
+      if (this.renderer.objectRenderer.renderingToScreen) {
+        this.gl.flush();
+      }
+    }
+    validateContext(gl) {
+      const attributes = gl.getContextAttributes();
+      const isWebGl2 = "WebGL2RenderingContext" in globalThis && gl instanceof globalThis.WebGL2RenderingContext;
+      if (isWebGl2) {
+        this.webGLVersion = 2;
+      }
+      if (attributes && !attributes.stencil) {
+        console.warn("Provided WebGL context does not have a stencil buffer, masks may not render correctly");
+      }
+      const hasuint32 = isWebGl2 || !!gl.getExtension("OES_element_index_uint");
+      this.supports.uint32Indices = hasuint32;
+      if (!hasuint32) {
+        console.warn("Provided WebGL context does not support 32 index buffer, complex graphics may not render correctly");
+      }
+    }
+  }
+  ContextSystem.defaultOptions = {
+    context: null,
+    antialias: false,
+    premultipliedAlpha: true,
+    preserveDrawingBuffer: false,
+    powerPreference: "default"
+  };
+  ContextSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "context"
+  };
+  extensions$1.add(ContextSystem);
+
+  class DepthResource extends BufferResource {
+    upload(renderer, baseTexture, glTexture) {
+      const gl = renderer.gl;
+      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === ALPHA_MODES.UNPACK);
+      const width = baseTexture.realWidth;
+      const height = baseTexture.realHeight;
+      if (glTexture.width === width && glTexture.height === height) {
+        gl.texSubImage2D(baseTexture.target, 0, 0, 0, width, height, baseTexture.format, glTexture.type, this.data);
+      } else {
+        glTexture.width = width;
+        glTexture.height = height;
+        gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, width, height, 0, baseTexture.format, glTexture.type, this.data);
+      }
+      return true;
+    }
+  }
+
+  class Framebuffer {
+    constructor(width, height) {
+      this.width = Math.round(width || 100);
+      this.height = Math.round(height || 100);
+      this.stencil = false;
+      this.depth = false;
+      this.dirtyId = 0;
+      this.dirtyFormat = 0;
+      this.dirtySize = 0;
+      this.depthTexture = null;
+      this.colorTextures = [];
+      this.glFramebuffers = {};
+      this.disposeRunner = new Runner("disposeFramebuffer");
+      this.multisample = MSAA_QUALITY.NONE;
+    }
+    get colorTexture() {
+      return this.colorTextures[0];
+    }
+    addColorTexture(index = 0, texture) {
+      this.colorTextures[index] = texture || new BaseTexture(null, {
+        scaleMode: SCALE_MODES.NEAREST,
+        resolution: 1,
+        mipmap: MIPMAP_MODES.OFF,
+        width: this.width,
+        height: this.height
+      });
+      this.dirtyId++;
+      this.dirtyFormat++;
+      return this;
+    }
+    addDepthTexture(texture) {
+      this.depthTexture = texture || new BaseTexture(new DepthResource(null, { width: this.width, height: this.height }), {
+        scaleMode: SCALE_MODES.NEAREST,
+        resolution: 1,
+        width: this.width,
+        height: this.height,
+        mipmap: MIPMAP_MODES.OFF,
+        format: FORMATS.DEPTH_COMPONENT,
+        type: TYPES.UNSIGNED_SHORT
+      });
+      this.dirtyId++;
+      this.dirtyFormat++;
+      return this;
+    }
+    enableDepth() {
+      this.depth = true;
+      this.dirtyId++;
+      this.dirtyFormat++;
+      return this;
+    }
+    enableStencil() {
+      this.stencil = true;
+      this.dirtyId++;
+      this.dirtyFormat++;
+      return this;
+    }
+    resize(width, height) {
+      width = Math.round(width);
+      height = Math.round(height);
+      if (width === this.width && height === this.height)
+        return;
+      this.width = width;
+      this.height = height;
+      this.dirtyId++;
+      this.dirtySize++;
+      for (let i = 0; i < this.colorTextures.length; i++) {
+        const texture = this.colorTextures[i];
+        const resolution = texture.resolution;
+        texture.setSize(width / resolution, height / resolution);
+      }
+      if (this.depthTexture) {
+        const resolution = this.depthTexture.resolution;
+        this.depthTexture.setSize(width / resolution, height / resolution);
+      }
+    }
+    dispose() {
+      this.disposeRunner.emit(this, false);
+    }
+    destroyDepthTexture() {
+      if (this.depthTexture) {
+        this.depthTexture.destroy();
+        this.depthTexture = null;
+        ++this.dirtyId;
+        ++this.dirtyFormat;
+      }
+    }
+  }
+
+  class BaseRenderTexture extends BaseTexture {
+    constructor(options = {}) {
+      if (typeof options === "number") {
+        const width = arguments[0];
+        const height = arguments[1];
+        const scaleMode = arguments[2];
+        const resolution = arguments[3];
+        options = { width, height, scaleMode, resolution };
+      }
+      options.width = options.width || 100;
+      options.height = options.height || 100;
+      options.multisample ?? (options.multisample = MSAA_QUALITY.NONE);
+      super(null, options);
+      this.mipmap = MIPMAP_MODES.OFF;
+      this.valid = true;
+      this._clear = new Color([0, 0, 0, 0]);
+      this.framebuffer = new Framebuffer(this.realWidth, this.realHeight).addColorTexture(0, this);
+      this.framebuffer.multisample = options.multisample;
+      this.maskStack = [];
+      this.filterStack = [{}];
+    }
+    set clearColor(value) {
+      this._clear.setValue(value);
+    }
+    get clearColor() {
+      return this._clear.value;
+    }
+    get clear() {
+      return this._clear;
+    }
+    resize(desiredWidth, desiredHeight) {
+      this.framebuffer.resize(desiredWidth * this.resolution, desiredHeight * this.resolution);
+      this.setRealSize(this.framebuffer.width, this.framebuffer.height);
+    }
+    dispose() {
+      this.framebuffer.dispose();
+      super.dispose();
+    }
+    destroy() {
+      super.destroy();
+      this.framebuffer.destroyDepthTexture();
+      this.framebuffer = null;
+    }
+  }
+
+  class BaseImageResource extends Resource {
+    constructor(source) {
+      const sourceAny = source;
+      const width = sourceAny.naturalWidth || sourceAny.videoWidth || sourceAny.width;
+      const height = sourceAny.naturalHeight || sourceAny.videoHeight || sourceAny.height;
+      super(width, height);
+      this.source = source;
+      this.noSubImage = false;
+    }
+    static crossOrigin(element, url, crossorigin) {
+      if (crossorigin === void 0 && !url.startsWith("data:")) {
+        element.crossOrigin = determineCrossOrigin(url);
+      } else if (crossorigin !== false) {
+        element.crossOrigin = typeof crossorigin === "string" ? crossorigin : "anonymous";
+      }
+    }
+    upload(renderer, baseTexture, glTexture, source) {
+      const gl = renderer.gl;
+      const width = baseTexture.realWidth;
+      const height = baseTexture.realHeight;
+      source = source || this.source;
+      if (typeof HTMLImageElement !== "undefined" && source instanceof HTMLImageElement) {
+        if (!source.complete || source.naturalWidth === 0) {
+          return false;
+        }
+      } else if (typeof HTMLVideoElement !== "undefined" && source instanceof HTMLVideoElement) {
+        if (source.readyState <= 1 && source.buffered.length === 0) {
+          return false;
+        }
+      }
+      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === ALPHA_MODES.UNPACK);
+      if (!this.noSubImage && baseTexture.target === gl.TEXTURE_2D && glTexture.width === width && glTexture.height === height) {
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, baseTexture.format, glTexture.type, source);
+      } else {
+        glTexture.width = width;
+        glTexture.height = height;
+        gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, baseTexture.format, glTexture.type, source);
+      }
+      return true;
+    }
+    update() {
+      if (this.destroyed) {
+        return;
+      }
+      const source = this.source;
+      const width = source.naturalWidth || source.videoWidth || source.width;
+      const height = source.naturalHeight || source.videoHeight || source.height;
+      this.resize(width, height);
+      super.update();
+    }
+    dispose() {
+      this.source = null;
+    }
+  }
+
+  class ImageResource extends BaseImageResource {
+    constructor(source, options) {
+      options = options || {};
+      if (typeof source === "string") {
+        const imageElement = new Image();
+        BaseImageResource.crossOrigin(imageElement, source, options.crossorigin);
+        imageElement.src = source;
+        source = imageElement;
+      }
+      super(source);
+      if (!source.complete && !!this._width && !!this._height) {
+        this._width = 0;
+        this._height = 0;
+      }
+      this.url = source.src;
+      this._process = null;
+      this.preserveBitmap = false;
+      this.createBitmap = (options.createBitmap ?? settings.CREATE_IMAGE_BITMAP) && !!globalThis.createImageBitmap;
+      this.alphaMode = typeof options.alphaMode === "number" ? options.alphaMode : null;
+      this.bitmap = null;
+      this._load = null;
+      if (options.autoLoad !== false) {
+        this.load();
+      }
+    }
+    load(createBitmap) {
+      if (this._load) {
+        return this._load;
+      }
+      if (createBitmap !== void 0) {
+        this.createBitmap = createBitmap;
+      }
+      this._load = new Promise((resolve, reject) => {
+        const source = this.source;
+        this.url = source.src;
+        const completed = () => {
+          if (this.destroyed) {
+            return;
+          }
+          source.onload = null;
+          source.onerror = null;
+          this.resize(source.width, source.height);
+          this._load = null;
+          if (this.createBitmap) {
+            resolve(this.process());
+          } else {
+            resolve(this);
+          }
+        };
+        if (source.complete && source.src) {
+          completed();
+        } else {
+          source.onload = completed;
+          source.onerror = (event) => {
+            reject(event);
+            this.onError.emit(event);
+          };
+        }
+      });
+      return this._load;
+    }
+    process() {
+      const source = this.source;
+      if (this._process !== null) {
+        return this._process;
+      }
+      if (this.bitmap !== null || !globalThis.createImageBitmap) {
+        return Promise.resolve(this);
+      }
+      const createImageBitmap = globalThis.createImageBitmap;
+      const cors = !source.crossOrigin || source.crossOrigin === "anonymous";
+      this._process = fetch(source.src, {
+        mode: cors ? "cors" : "no-cors"
+      }).then((r) => r.blob()).then((blob) => createImageBitmap(blob, 0, 0, source.width, source.height, {
+        premultiplyAlpha: this.alphaMode === null || this.alphaMode === ALPHA_MODES.UNPACK ? "premultiply" : "none"
+      })).then((bitmap) => {
+        if (this.destroyed) {
+          return Promise.reject();
+        }
+        this.bitmap = bitmap;
+        this.update();
+        this._process = null;
+        return Promise.resolve(this);
+      });
+      return this._process;
+    }
+    upload(renderer, baseTexture, glTexture) {
+      if (typeof this.alphaMode === "number") {
+        baseTexture.alphaMode = this.alphaMode;
+      }
+      if (!this.createBitmap) {
+        return super.upload(renderer, baseTexture, glTexture);
+      }
+      if (!this.bitmap) {
+        this.process();
+        if (!this.bitmap) {
+          return false;
+        }
+      }
+      super.upload(renderer, baseTexture, glTexture, this.bitmap);
+      if (!this.preserveBitmap) {
+        let flag = true;
+        const glTextures = baseTexture._glTextures;
+        for (const key in glTextures) {
+          const otherTex = glTextures[key];
+          if (otherTex !== glTexture && otherTex.dirtyId !== baseTexture.dirtyId) {
+            flag = false;
+            break;
+          }
+        }
+        if (flag) {
+          if (this.bitmap.close) {
+            this.bitmap.close();
+          }
+          this.bitmap = null;
+        }
+      }
+      return true;
+    }
+    dispose() {
+      this.source.onload = null;
+      this.source.onerror = null;
+      super.dispose();
+      if (this.bitmap) {
+        this.bitmap.close();
+        this.bitmap = null;
+      }
+      this._process = null;
+      this._load = null;
+    }
+    static test(source) {
+      return typeof HTMLImageElement !== "undefined" && (typeof source === "string" || source instanceof HTMLImageElement);
+    }
+  }
+
+  class TextureUvs {
+    constructor() {
+      this.x0 = 0;
+      this.y0 = 0;
+      this.x1 = 1;
+      this.y1 = 0;
+      this.x2 = 1;
+      this.y2 = 1;
+      this.x3 = 0;
+      this.y3 = 1;
+      this.uvsFloat32 = new Float32Array(8);
+    }
+    set(frame, baseFrame, rotate) {
+      const tw = baseFrame.width;
+      const th = baseFrame.height;
+      if (rotate) {
+        const w2 = frame.width / 2 / tw;
+        const h2 = frame.height / 2 / th;
+        const cX = frame.x / tw + w2;
+        const cY = frame.y / th + h2;
+        rotate = groupD8.add(rotate, groupD8.NW);
+        this.x0 = cX + w2 * groupD8.uX(rotate);
+        this.y0 = cY + h2 * groupD8.uY(rotate);
+        rotate = groupD8.add(rotate, 2);
+        this.x1 = cX + w2 * groupD8.uX(rotate);
+        this.y1 = cY + h2 * groupD8.uY(rotate);
+        rotate = groupD8.add(rotate, 2);
+        this.x2 = cX + w2 * groupD8.uX(rotate);
+        this.y2 = cY + h2 * groupD8.uY(rotate);
+        rotate = groupD8.add(rotate, 2);
+        this.x3 = cX + w2 * groupD8.uX(rotate);
+        this.y3 = cY + h2 * groupD8.uY(rotate);
+      } else {
+        this.x0 = frame.x / tw;
+        this.y0 = frame.y / th;
+        this.x1 = (frame.x + frame.width) / tw;
+        this.y1 = frame.y / th;
+        this.x2 = (frame.x + frame.width) / tw;
+        this.y2 = (frame.y + frame.height) / th;
+        this.x3 = frame.x / tw;
+        this.y3 = (frame.y + frame.height) / th;
+      }
+      this.uvsFloat32[0] = this.x0;
+      this.uvsFloat32[1] = this.y0;
+      this.uvsFloat32[2] = this.x1;
+      this.uvsFloat32[3] = this.y1;
+      this.uvsFloat32[4] = this.x2;
+      this.uvsFloat32[5] = this.y2;
+      this.uvsFloat32[6] = this.x3;
+      this.uvsFloat32[7] = this.y3;
+    }
+    toString() {
+      return `[@pixi/core:TextureUvs x0=${this.x0} y0=${this.y0} x1=${this.x1} y1=${this.y1} x2=${this.x2} y2=${this.y2} x3=${this.x3} y3=${this.y3}]`;
+    }
+  }
+
+  const DEFAULT_UVS = new TextureUvs();
+  function removeAllHandlers(tex) {
+    tex.destroy = function _emptyDestroy() {
+    };
+    tex.on = function _emptyOn() {
+    };
+    tex.once = function _emptyOnce() {
+    };
+    tex.emit = function _emptyEmit() {
+    };
+  }
+  class Texture extends eventemitter3 {
+    constructor(baseTexture, frame, orig, trim, rotate, anchor, borders) {
+      super();
+      this.noFrame = false;
+      if (!frame) {
+        this.noFrame = true;
+        frame = new Rectangle(0, 0, 1, 1);
+      }
+      if (baseTexture instanceof Texture) {
+        baseTexture = baseTexture.baseTexture;
+      }
+      this.baseTexture = baseTexture;
+      this._frame = frame;
+      this.trim = trim;
+      this.valid = false;
+      this._uvs = DEFAULT_UVS;
+      this.uvMatrix = null;
+      this.orig = orig || frame;
+      this._rotate = Number(rotate || 0);
+      if (rotate === true) {
+        this._rotate = 2;
+      } else if (this._rotate % 2 !== 0) {
+        throw new Error("attempt to use diamond-shaped UVs. If you are sure, set rotation manually");
+      }
+      this.defaultAnchor = anchor ? new Point(anchor.x, anchor.y) : new Point(0, 0);
+      this.defaultBorders = borders;
+      this._updateID = 0;
+      this.textureCacheIds = [];
+      if (!baseTexture.valid) {
+        baseTexture.once("loaded", this.onBaseTextureUpdated, this);
+      } else if (this.noFrame) {
+        if (baseTexture.valid) {
+          this.onBaseTextureUpdated(baseTexture);
+        }
+      } else {
+        this.frame = frame;
+      }
+      if (this.noFrame) {
+        baseTexture.on("update", this.onBaseTextureUpdated, this);
+      }
+    }
+    update() {
+      if (this.baseTexture.resource) {
+        this.baseTexture.resource.update();
+      }
+    }
+    onBaseTextureUpdated(baseTexture) {
+      if (this.noFrame) {
+        if (!this.baseTexture.valid) {
+          return;
+        }
+        this._frame.width = baseTexture.width;
+        this._frame.height = baseTexture.height;
+        this.valid = true;
+        this.updateUvs();
+      } else {
+        this.frame = this._frame;
+      }
+      this.emit("update", this);
+    }
+    destroy(destroyBase) {
+      if (this.baseTexture) {
+        if (destroyBase) {
+          const { resource } = this.baseTexture;
+          if (resource?.url && TextureCache[resource.url]) {
+            Texture.removeFromCache(resource.url);
+          }
+          this.baseTexture.destroy();
+        }
+        this.baseTexture.off("loaded", this.onBaseTextureUpdated, this);
+        this.baseTexture.off("update", this.onBaseTextureUpdated, this);
+        this.baseTexture = null;
+      }
+      this._frame = null;
+      this._uvs = null;
+      this.trim = null;
+      this.orig = null;
+      this.valid = false;
+      Texture.removeFromCache(this);
+      this.textureCacheIds = null;
+    }
+    clone() {
+      const clonedFrame = this._frame.clone();
+      const clonedOrig = this._frame === this.orig ? clonedFrame : this.orig.clone();
+      const clonedTexture = new Texture(this.baseTexture, !this.noFrame && clonedFrame, clonedOrig, this.trim?.clone(), this.rotate, this.defaultAnchor, this.defaultBorders);
+      if (this.noFrame) {
+        clonedTexture._frame = clonedFrame;
+      }
+      return clonedTexture;
+    }
+    updateUvs() {
+      if (this._uvs === DEFAULT_UVS) {
+        this._uvs = new TextureUvs();
+      }
+      this._uvs.set(this._frame, this.baseTexture, this.rotate);
+      this._updateID++;
+    }
+    static from(source, options = {}, strict = settings.STRICT_TEXTURE_CACHE) {
+      const isFrame = typeof source === "string";
+      let cacheId = null;
+      if (isFrame) {
+        cacheId = source;
+      } else if (source instanceof BaseTexture) {
+        if (!source.cacheId) {
+          const prefix = options?.pixiIdPrefix || "pixiid";
+          source.cacheId = `${prefix}-${uid()}`;
+          BaseTexture.addToCache(source, source.cacheId);
+        }
+        cacheId = source.cacheId;
+      } else {
+        if (!source._pixiId) {
+          const prefix = options?.pixiIdPrefix || "pixiid";
+          source._pixiId = `${prefix}_${uid()}`;
+        }
+        cacheId = source._pixiId;
+      }
+      let texture = TextureCache[cacheId];
+      if (isFrame && strict && !texture) {
+        throw new Error(`The cacheId "${cacheId}" does not exist in TextureCache.`);
+      }
+      if (!texture && !(source instanceof BaseTexture)) {
+        if (!options.resolution) {
+          options.resolution = getResolutionOfUrl(source);
+        }
+        texture = new Texture(new BaseTexture(source, options));
+        texture.baseTexture.cacheId = cacheId;
+        BaseTexture.addToCache(texture.baseTexture, cacheId);
+        Texture.addToCache(texture, cacheId);
+      } else if (!texture && source instanceof BaseTexture) {
+        texture = new Texture(source);
+        Texture.addToCache(texture, cacheId);
+      }
+      return texture;
+    }
+    static fromURL(url, options) {
+      const resourceOptions = Object.assign({ autoLoad: false }, options?.resourceOptions);
+      const texture = Texture.from(url, Object.assign({ resourceOptions }, options), false);
+      const resource = texture.baseTexture.resource;
+      if (texture.baseTexture.valid) {
+        return Promise.resolve(texture);
+      }
+      return resource.load().then(() => Promise.resolve(texture));
+    }
+    static fromBuffer(buffer, width, height, options) {
+      return new Texture(BaseTexture.fromBuffer(buffer, width, height, options));
+    }
+    static fromLoader(source, imageUrl, name, options) {
+      const baseTexture = new BaseTexture(source, Object.assign({
+        scaleMode: BaseTexture.defaultOptions.scaleMode,
+        resolution: getResolutionOfUrl(imageUrl)
+      }, options));
+      const { resource } = baseTexture;
+      if (resource instanceof ImageResource) {
+        resource.url = imageUrl;
+      }
+      const texture = new Texture(baseTexture);
+      if (!name) {
+        name = imageUrl;
+      }
+      BaseTexture.addToCache(texture.baseTexture, name);
+      Texture.addToCache(texture, name);
+      if (name !== imageUrl) {
+        BaseTexture.addToCache(texture.baseTexture, imageUrl);
+        Texture.addToCache(texture, imageUrl);
+      }
+      if (texture.baseTexture.valid) {
+        return Promise.resolve(texture);
+      }
+      return new Promise((resolve) => {
+        texture.baseTexture.once("loaded", () => resolve(texture));
+      });
+    }
+    static addToCache(texture, id) {
+      if (id) {
+        if (!texture.textureCacheIds.includes(id)) {
+          texture.textureCacheIds.push(id);
+        }
+        if (TextureCache[id] && TextureCache[id] !== texture) {
+          console.warn(`Texture added to the cache with an id [${id}] that already had an entry`);
+        }
+        TextureCache[id] = texture;
+      }
+    }
+    static removeFromCache(texture) {
+      if (typeof texture === "string") {
+        const textureFromCache = TextureCache[texture];
+        if (textureFromCache) {
+          const index = textureFromCache.textureCacheIds.indexOf(texture);
+          if (index > -1) {
+            textureFromCache.textureCacheIds.splice(index, 1);
+          }
+          delete TextureCache[texture];
+          return textureFromCache;
+        }
+      } else if (texture?.textureCacheIds) {
+        for (let i = 0; i < texture.textureCacheIds.length; ++i) {
+          if (TextureCache[texture.textureCacheIds[i]] === texture) {
+            delete TextureCache[texture.textureCacheIds[i]];
+          }
+        }
+        texture.textureCacheIds.length = 0;
+        return texture;
+      }
+      return null;
+    }
+    get resolution() {
+      return this.baseTexture.resolution;
+    }
+    get frame() {
+      return this._frame;
+    }
+    set frame(frame) {
+      this._frame = frame;
+      this.noFrame = false;
+      const { x, y, width, height } = frame;
+      const xNotFit = x + width > this.baseTexture.width;
+      const yNotFit = y + height > this.baseTexture.height;
+      if (xNotFit || yNotFit) {
+        const relationship = xNotFit && yNotFit ? "and" : "or";
+        const errorX = `X: ${x} + ${width} = ${x + width} > ${this.baseTexture.width}`;
+        const errorY = `Y: ${y} + ${height} = ${y + height} > ${this.baseTexture.height}`;
+        throw new Error(`Texture Error: frame does not fit inside the base Texture dimensions: ${errorX} ${relationship} ${errorY}`);
+      }
+      this.valid = width && height && this.baseTexture.valid;
+      if (!this.trim && !this.rotate) {
+        this.orig = frame;
+      }
+      if (this.valid) {
+        this.updateUvs();
+      }
+    }
+    get rotate() {
+      return this._rotate;
+    }
+    set rotate(rotate) {
+      this._rotate = rotate;
+      if (this.valid) {
+        this.updateUvs();
+      }
+    }
+    get width() {
+      return this.orig.width;
+    }
+    get height() {
+      return this.orig.height;
+    }
+    castToBaseTexture() {
+      return this.baseTexture;
+    }
+    static get EMPTY() {
+      if (!Texture._EMPTY) {
+        Texture._EMPTY = new Texture(new BaseTexture());
+        removeAllHandlers(Texture._EMPTY);
+        removeAllHandlers(Texture._EMPTY.baseTexture);
+      }
+      return Texture._EMPTY;
+    }
+    static get WHITE() {
+      if (!Texture._WHITE) {
+        const canvas = settings.ADAPTER.createCanvas(16, 16);
+        const context = canvas.getContext("2d");
+        canvas.width = 16;
+        canvas.height = 16;
+        context.fillStyle = "white";
+        context.fillRect(0, 0, 16, 16);
+        Texture._WHITE = new Texture(BaseTexture.from(canvas));
+        removeAllHandlers(Texture._WHITE);
+        removeAllHandlers(Texture._WHITE.baseTexture);
+      }
+      return Texture._WHITE;
+    }
+  }
+
+  class RenderTexture extends Texture {
+    constructor(baseRenderTexture, frame) {
+      super(baseRenderTexture, frame);
+      this.valid = true;
+      this.filterFrame = null;
+      this.filterPoolKey = null;
+      this.updateUvs();
+    }
+    get framebuffer() {
+      return this.baseTexture.framebuffer;
+    }
+    get multisample() {
+      return this.framebuffer.multisample;
+    }
+    set multisample(value) {
+      this.framebuffer.multisample = value;
+    }
+    resize(desiredWidth, desiredHeight, resizeBaseTexture = true) {
+      const resolution = this.baseTexture.resolution;
+      const width = Math.round(desiredWidth * resolution) / resolution;
+      const height = Math.round(desiredHeight * resolution) / resolution;
+      this.valid = width > 0 && height > 0;
+      this._frame.width = this.orig.width = width;
+      this._frame.height = this.orig.height = height;
+      if (resizeBaseTexture) {
+        this.baseTexture.resize(width, height);
+      }
+      this.updateUvs();
+    }
+    setResolution(resolution) {
+      const { baseTexture } = this;
+      if (baseTexture.resolution === resolution) {
+        return;
+      }
+      baseTexture.setResolution(resolution);
+      this.resize(baseTexture.width, baseTexture.height, false);
+    }
+    static create(options) {
+      return new RenderTexture(new BaseRenderTexture(options));
+    }
+  }
+
+  class RenderTexturePool {
+    constructor(textureOptions) {
+      this.texturePool = {};
+      this.textureOptions = textureOptions || {};
+      this.enableFullScreen = false;
+      this._pixelsWidth = 0;
+      this._pixelsHeight = 0;
+    }
+    createTexture(realWidth, realHeight, multisample = MSAA_QUALITY.NONE) {
+      const baseRenderTexture = new BaseRenderTexture(Object.assign({
+        width: realWidth,
+        height: realHeight,
+        resolution: 1,
+        multisample
+      }, this.textureOptions));
+      return new RenderTexture(baseRenderTexture);
+    }
+    getOptimalTexture(minWidth, minHeight, resolution = 1, multisample = MSAA_QUALITY.NONE) {
+      let key;
+      minWidth = Math.ceil(minWidth * resolution - 1e-6);
+      minHeight = Math.ceil(minHeight * resolution - 1e-6);
+      if (!this.enableFullScreen || minWidth !== this._pixelsWidth || minHeight !== this._pixelsHeight) {
+        minWidth = nextPow2(minWidth);
+        minHeight = nextPow2(minHeight);
+        key = ((minWidth & 65535) << 16 | minHeight & 65535) >>> 0;
+        if (multisample > 1) {
+          key += multisample * 4294967296;
+        }
+      } else {
+        key = multisample > 1 ? -multisample : -1;
+      }
+      if (!this.texturePool[key]) {
+        this.texturePool[key] = [];
+      }
+      let renderTexture = this.texturePool[key].pop();
+      if (!renderTexture) {
+        renderTexture = this.createTexture(minWidth, minHeight, multisample);
+      }
+      renderTexture.filterPoolKey = key;
+      renderTexture.setResolution(resolution);
+      return renderTexture;
+    }
+    getFilterTexture(input, resolution, multisample) {
+      const filterTexture = this.getOptimalTexture(input.width, input.height, resolution || input.resolution, multisample || MSAA_QUALITY.NONE);
+      filterTexture.filterFrame = input.filterFrame;
+      return filterTexture;
+    }
+    returnTexture(renderTexture) {
+      const key = renderTexture.filterPoolKey;
+      renderTexture.filterFrame = null;
+      this.texturePool[key].push(renderTexture);
+    }
+    returnFilterTexture(renderTexture) {
+      this.returnTexture(renderTexture);
+    }
+    clear(destroyTextures) {
+      destroyTextures = destroyTextures !== false;
+      if (destroyTextures) {
+        for (const i in this.texturePool) {
+          const textures = this.texturePool[i];
+          if (textures) {
+            for (let j = 0; j < textures.length; j++) {
+              textures[j].destroy(true);
+            }
+          }
+        }
+      }
+      this.texturePool = {};
+    }
+    setScreenSize(size) {
+      if (size.width === this._pixelsWidth && size.height === this._pixelsHeight) {
+        return;
+      }
+      this.enableFullScreen = size.width > 0 && size.height > 0;
+      for (const i in this.texturePool) {
+        if (!(Number(i) < 0)) {
+          continue;
+        }
+        const textures = this.texturePool[i];
+        if (textures) {
+          for (let j = 0; j < textures.length; j++) {
+            textures[j].destroy(true);
+          }
+        }
+        this.texturePool[i] = [];
+      }
+      this._pixelsWidth = size.width;
+      this._pixelsHeight = size.height;
+    }
+  }
+  RenderTexturePool.SCREEN_KEY = -1;
+
+  class Quad extends Geometry {
+    constructor() {
+      super();
+      this.addAttribute("aVertexPosition", new Float32Array([
+        0,
+        0,
+        1,
+        0,
+        1,
+        1,
+        0,
+        1
+      ])).addIndex([0, 1, 3, 2]);
+    }
+  }
+
+  class QuadUv extends Geometry {
+    constructor() {
+      super();
+      this.vertices = new Float32Array([
+        -1,
+        -1,
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        1
+      ]);
+      this.uvs = new Float32Array([
+        0,
+        0,
+        1,
+        0,
+        1,
+        1,
+        0,
+        1
+      ]);
+      this.vertexBuffer = new Buffer(this.vertices);
+      this.uvBuffer = new Buffer(this.uvs);
+      this.addAttribute("aVertexPosition", this.vertexBuffer).addAttribute("aTextureCoord", this.uvBuffer).addIndex([0, 1, 2, 0, 2, 3]);
+    }
+    map(targetTextureFrame, destinationFrame) {
+      let x = 0;
+      let y = 0;
+      this.uvs[0] = x;
+      this.uvs[1] = y;
+      this.uvs[2] = x + destinationFrame.width / targetTextureFrame.width;
+      this.uvs[3] = y;
+      this.uvs[4] = x + destinationFrame.width / targetTextureFrame.width;
+      this.uvs[5] = y + destinationFrame.height / targetTextureFrame.height;
+      this.uvs[6] = x;
+      this.uvs[7] = y + destinationFrame.height / targetTextureFrame.height;
+      x = destinationFrame.x;
+      y = destinationFrame.y;
+      this.vertices[0] = x;
+      this.vertices[1] = y;
+      this.vertices[2] = x + destinationFrame.width;
+      this.vertices[3] = y;
+      this.vertices[4] = x + destinationFrame.width;
+      this.vertices[5] = y + destinationFrame.height;
+      this.vertices[6] = x;
+      this.vertices[7] = y + destinationFrame.height;
+      this.invalidate();
+      return this;
+    }
+    invalidate() {
+      this.vertexBuffer._updateID++;
+      this.uvBuffer._updateID++;
+      return this;
+    }
+  }
+
+  class FilterState {
+    constructor() {
+      this.renderTexture = null;
+      this.target = null;
+      this.legacy = false;
+      this.resolution = 1;
+      this.multisample = MSAA_QUALITY.NONE;
+      this.sourceFrame = new Rectangle();
+      this.destinationFrame = new Rectangle();
+      this.bindingSourceFrame = new Rectangle();
+      this.bindingDestinationFrame = new Rectangle();
+      this.filters = [];
+      this.transform = null;
+    }
+    clear() {
+      this.target = null;
+      this.filters = null;
+      this.renderTexture = null;
+    }
+  }
+
+  const tempPoints = [new Point(), new Point(), new Point(), new Point()];
+  const tempMatrix$4 = new Matrix();
+  class FilterSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.defaultFilterStack = [{}];
+      this.texturePool = new RenderTexturePool();
+      this.statePool = [];
+      this.quad = new Quad();
+      this.quadUv = new QuadUv();
+      this.tempRect = new Rectangle();
+      this.activeState = {};
+      this.globalUniforms = new UniformGroup({
+        outputFrame: new Rectangle(),
+        inputSize: new Float32Array(4),
+        inputPixel: new Float32Array(4),
+        inputClamp: new Float32Array(4),
+        resolution: 1,
+        filterArea: new Float32Array(4),
+        filterClamp: new Float32Array(4)
+      }, true);
+      this.forceClear = false;
+      this.useMaxPadding = false;
+    }
+    init() {
+      this.texturePool.setScreenSize(this.renderer.view);
+    }
+    push(target, filters) {
+      const renderer = this.renderer;
+      const filterStack = this.defaultFilterStack;
+      const state = this.statePool.pop() || new FilterState();
+      const renderTextureSystem = this.renderer.renderTexture;
+      let resolution = filters[0].resolution;
+      let multisample = filters[0].multisample;
+      let padding = filters[0].padding;
+      let autoFit = filters[0].autoFit;
+      let legacy = filters[0].legacy ?? true;
+      for (let i = 1; i < filters.length; i++) {
+        const filter = filters[i];
+        resolution = Math.min(resolution, filter.resolution);
+        multisample = Math.min(multisample, filter.multisample);
+        padding = this.useMaxPadding ? Math.max(padding, filter.padding) : padding + filter.padding;
+        autoFit = autoFit && filter.autoFit;
+        legacy = legacy || (filter.legacy ?? true);
+      }
+      if (filterStack.length === 1) {
+        this.defaultFilterStack[0].renderTexture = renderTextureSystem.current;
+      }
+      filterStack.push(state);
+      state.resolution = resolution;
+      state.multisample = multisample;
+      state.legacy = legacy;
+      state.target = target;
+      state.sourceFrame.copyFrom(target.filterArea || target.getBounds(true));
+      state.sourceFrame.pad(padding);
+      const sourceFrameProjected = this.tempRect.copyFrom(renderTextureSystem.sourceFrame);
+      if (renderer.projection.transform) {
+        this.transformAABB(tempMatrix$4.copyFrom(renderer.projection.transform).invert(), sourceFrameProjected);
+      }
+      if (autoFit) {
+        state.sourceFrame.fit(sourceFrameProjected);
+        if (state.sourceFrame.width <= 0 || state.sourceFrame.height <= 0) {
+          state.sourceFrame.width = 0;
+          state.sourceFrame.height = 0;
+        }
+      } else if (!state.sourceFrame.intersects(sourceFrameProjected)) {
+        state.sourceFrame.width = 0;
+        state.sourceFrame.height = 0;
+      }
+      this.roundFrame(state.sourceFrame, renderTextureSystem.current ? renderTextureSystem.current.resolution : renderer.resolution, renderTextureSystem.sourceFrame, renderTextureSystem.destinationFrame, renderer.projection.transform);
+      state.renderTexture = this.getOptimalFilterTexture(state.sourceFrame.width, state.sourceFrame.height, resolution, multisample);
+      state.filters = filters;
+      state.destinationFrame.width = state.renderTexture.width;
+      state.destinationFrame.height = state.renderTexture.height;
+      const destinationFrame = this.tempRect;
+      destinationFrame.x = 0;
+      destinationFrame.y = 0;
+      destinationFrame.width = state.sourceFrame.width;
+      destinationFrame.height = state.sourceFrame.height;
+      state.renderTexture.filterFrame = state.sourceFrame;
+      state.bindingSourceFrame.copyFrom(renderTextureSystem.sourceFrame);
+      state.bindingDestinationFrame.copyFrom(renderTextureSystem.destinationFrame);
+      state.transform = renderer.projection.transform;
+      renderer.projection.transform = null;
+      renderTextureSystem.bind(state.renderTexture, state.sourceFrame, destinationFrame);
+      renderer.framebuffer.clear(0, 0, 0, 0);
+    }
+    pop() {
+      const filterStack = this.defaultFilterStack;
+      const state = filterStack.pop();
+      const filters = state.filters;
+      this.activeState = state;
+      const globalUniforms = this.globalUniforms.uniforms;
+      globalUniforms.outputFrame = state.sourceFrame;
+      globalUniforms.resolution = state.resolution;
+      const inputSize = globalUniforms.inputSize;
+      const inputPixel = globalUniforms.inputPixel;
+      const inputClamp = globalUniforms.inputClamp;
+      inputSize[0] = state.destinationFrame.width;
+      inputSize[1] = state.destinationFrame.height;
+      inputSize[2] = 1 / inputSize[0];
+      inputSize[3] = 1 / inputSize[1];
+      inputPixel[0] = Math.round(inputSize[0] * state.resolution);
+      inputPixel[1] = Math.round(inputSize[1] * state.resolution);
+      inputPixel[2] = 1 / inputPixel[0];
+      inputPixel[3] = 1 / inputPixel[1];
+      inputClamp[0] = 0.5 * inputPixel[2];
+      inputClamp[1] = 0.5 * inputPixel[3];
+      inputClamp[2] = state.sourceFrame.width * inputSize[2] - 0.5 * inputPixel[2];
+      inputClamp[3] = state.sourceFrame.height * inputSize[3] - 0.5 * inputPixel[3];
+      if (state.legacy) {
+        const filterArea = globalUniforms.filterArea;
+        filterArea[0] = state.destinationFrame.width;
+        filterArea[1] = state.destinationFrame.height;
+        filterArea[2] = state.sourceFrame.x;
+        filterArea[3] = state.sourceFrame.y;
+        globalUniforms.filterClamp = globalUniforms.inputClamp;
+      }
+      this.globalUniforms.update();
+      const lastState = filterStack[filterStack.length - 1];
+      this.renderer.framebuffer.blit();
+      if (filters.length === 1) {
+        filters[0].apply(this, state.renderTexture, lastState.renderTexture, CLEAR_MODES.BLEND, state);
+        this.returnFilterTexture(state.renderTexture);
+      } else {
+        let flip = state.renderTexture;
+        let flop = this.getOptimalFilterTexture(flip.width, flip.height, state.resolution);
+        flop.filterFrame = flip.filterFrame;
+        let i = 0;
+        for (i = 0; i < filters.length - 1; ++i) {
+          if (i === 1 && state.multisample > 1) {
+            flop = this.getOptimalFilterTexture(flip.width, flip.height, state.resolution);
+            flop.filterFrame = flip.filterFrame;
+          }
+          filters[i].apply(this, flip, flop, CLEAR_MODES.CLEAR, state);
+          const t = flip;
+          flip = flop;
+          flop = t;
+        }
+        filters[i].apply(this, flip, lastState.renderTexture, CLEAR_MODES.BLEND, state);
+        if (i > 1 && state.multisample > 1) {
+          this.returnFilterTexture(state.renderTexture);
+        }
+        this.returnFilterTexture(flip);
+        this.returnFilterTexture(flop);
+      }
+      state.clear();
+      this.statePool.push(state);
+    }
+    bindAndClear(filterTexture, clearMode = CLEAR_MODES.CLEAR) {
+      const {
+        renderTexture: renderTextureSystem,
+        state: stateSystem
+      } = this.renderer;
+      if (filterTexture === this.defaultFilterStack[this.defaultFilterStack.length - 1].renderTexture) {
+        this.renderer.projection.transform = this.activeState.transform;
+      } else {
+        this.renderer.projection.transform = null;
+      }
+      if (filterTexture?.filterFrame) {
+        const destinationFrame = this.tempRect;
+        destinationFrame.x = 0;
+        destinationFrame.y = 0;
+        destinationFrame.width = filterTexture.filterFrame.width;
+        destinationFrame.height = filterTexture.filterFrame.height;
+        renderTextureSystem.bind(filterTexture, filterTexture.filterFrame, destinationFrame);
+      } else if (filterTexture !== this.defaultFilterStack[this.defaultFilterStack.length - 1].renderTexture) {
+        renderTextureSystem.bind(filterTexture);
+      } else {
+        this.renderer.renderTexture.bind(filterTexture, this.activeState.bindingSourceFrame, this.activeState.bindingDestinationFrame);
+      }
+      const autoClear = stateSystem.stateId & 1 || this.forceClear;
+      if (clearMode === CLEAR_MODES.CLEAR || clearMode === CLEAR_MODES.BLIT && autoClear) {
+        this.renderer.framebuffer.clear(0, 0, 0, 0);
+      }
+    }
+    applyFilter(filter, input, output, clearMode) {
+      const renderer = this.renderer;
+      renderer.state.set(filter.state);
+      this.bindAndClear(output, clearMode);
+      filter.uniforms.uSampler = input;
+      filter.uniforms.filterGlobals = this.globalUniforms;
+      renderer.shader.bind(filter);
+      filter.legacy = !!filter.program.attributeData.aTextureCoord;
+      if (filter.legacy) {
+        this.quadUv.map(input._frame, input.filterFrame);
+        renderer.geometry.bind(this.quadUv);
+        renderer.geometry.draw(DRAW_MODES.TRIANGLES);
+      } else {
+        renderer.geometry.bind(this.quad);
+        renderer.geometry.draw(DRAW_MODES.TRIANGLE_STRIP);
+      }
+    }
+    calculateSpriteMatrix(outputMatrix, sprite) {
+      const { sourceFrame, destinationFrame } = this.activeState;
+      const { orig } = sprite._texture;
+      const mappedMatrix = outputMatrix.set(destinationFrame.width, 0, 0, destinationFrame.height, sourceFrame.x, sourceFrame.y);
+      const worldTransform = sprite.worldTransform.copyTo(Matrix.TEMP_MATRIX);
+      worldTransform.invert();
+      mappedMatrix.prepend(worldTransform);
+      mappedMatrix.scale(1 / orig.width, 1 / orig.height);
+      mappedMatrix.translate(sprite.anchor.x, sprite.anchor.y);
+      return mappedMatrix;
+    }
+    destroy() {
+      this.renderer = null;
+      this.texturePool.clear(false);
+    }
+    getOptimalFilterTexture(minWidth, minHeight, resolution = 1, multisample = MSAA_QUALITY.NONE) {
+      return this.texturePool.getOptimalTexture(minWidth, minHeight, resolution, multisample);
+    }
+    getFilterTexture(input, resolution, multisample) {
+      if (typeof input === "number") {
+        const swap = input;
+        input = resolution;
+        resolution = swap;
+      }
+      input = input || this.activeState.renderTexture;
+      const filterTexture = this.texturePool.getOptimalTexture(input.width, input.height, resolution || input.resolution, multisample || MSAA_QUALITY.NONE);
+      filterTexture.filterFrame = input.filterFrame;
+      return filterTexture;
+    }
+    returnFilterTexture(renderTexture) {
+      this.texturePool.returnTexture(renderTexture);
+    }
+    emptyPool() {
+      this.texturePool.clear(true);
+    }
+    resize() {
+      this.texturePool.setScreenSize(this.renderer.view);
+    }
+    transformAABB(matrix, rect) {
+      const lt = tempPoints[0];
+      const lb = tempPoints[1];
+      const rt = tempPoints[2];
+      const rb = tempPoints[3];
+      lt.set(rect.left, rect.top);
+      lb.set(rect.left, rect.bottom);
+      rt.set(rect.right, rect.top);
+      rb.set(rect.right, rect.bottom);
+      matrix.apply(lt, lt);
+      matrix.apply(lb, lb);
+      matrix.apply(rt, rt);
+      matrix.apply(rb, rb);
+      const x0 = Math.min(lt.x, lb.x, rt.x, rb.x);
+      const y0 = Math.min(lt.y, lb.y, rt.y, rb.y);
+      const x1 = Math.max(lt.x, lb.x, rt.x, rb.x);
+      const y1 = Math.max(lt.y, lb.y, rt.y, rb.y);
+      rect.x = x0;
+      rect.y = y0;
+      rect.width = x1 - x0;
+      rect.height = y1 - y0;
+    }
+    roundFrame(frame, resolution, bindingSourceFrame, bindingDestinationFrame, transform) {
+      if (frame.width <= 0 || frame.height <= 0 || bindingSourceFrame.width <= 0 || bindingSourceFrame.height <= 0) {
+        return;
+      }
+      if (transform) {
+        const { a, b, c, d } = transform;
+        if ((Math.abs(b) > 1e-4 || Math.abs(c) > 1e-4) && (Math.abs(a) > 1e-4 || Math.abs(d) > 1e-4)) {
+          return;
+        }
+      }
+      transform = transform ? tempMatrix$4.copyFrom(transform) : tempMatrix$4.identity();
+      transform.translate(-bindingSourceFrame.x, -bindingSourceFrame.y).scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height).translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
+      this.transformAABB(transform, frame);
+      frame.ceil(resolution);
+      this.transformAABB(transform.invert(), frame);
+    }
+  }
+  FilterSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "filter"
+  };
+  extensions$1.add(FilterSystem);
+
+  class GLFramebuffer {
+    constructor(framebuffer) {
+      this.framebuffer = framebuffer;
+      this.stencil = null;
+      this.dirtyId = -1;
+      this.dirtyFormat = -1;
+      this.dirtySize = -1;
+      this.multisample = MSAA_QUALITY.NONE;
+      this.msaaBuffer = null;
+      this.blitFramebuffer = null;
+      this.mipLevel = 0;
+    }
+  }
+
+  const tempRectangle = new Rectangle();
+  class FramebufferSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.managedFramebuffers = [];
+      this.unknownFramebuffer = new Framebuffer(10, 10);
+      this.msaaSamples = null;
+    }
+    contextChange() {
+      this.disposeAll(true);
+      const gl = this.gl = this.renderer.gl;
+      this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+      this.current = this.unknownFramebuffer;
+      this.viewport = new Rectangle();
+      this.hasMRT = true;
+      this.writeDepthTexture = true;
+      if (this.renderer.context.webGLVersion === 1) {
+        let nativeDrawBuffersExtension = this.renderer.context.extensions.drawBuffers;
+        let nativeDepthTextureExtension = this.renderer.context.extensions.depthTexture;
+        if (settings.PREFER_ENV === ENV.WEBGL_LEGACY) {
+          nativeDrawBuffersExtension = null;
+          nativeDepthTextureExtension = null;
+        }
+        if (nativeDrawBuffersExtension) {
+          gl.drawBuffers = (activeTextures) => nativeDrawBuffersExtension.drawBuffersWEBGL(activeTextures);
+        } else {
+          this.hasMRT = false;
+          gl.drawBuffers = () => {
+          };
+        }
+        if (!nativeDepthTextureExtension) {
+          this.writeDepthTexture = false;
+        }
+      } else {
+        this.msaaSamples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA8, gl.SAMPLES);
+      }
+    }
+    bind(framebuffer, frame, mipLevel = 0) {
+      const { gl } = this;
+      if (framebuffer) {
+        const fbo = framebuffer.glFramebuffers[this.CONTEXT_UID] || this.initFramebuffer(framebuffer);
+        if (this.current !== framebuffer) {
+          this.current = framebuffer;
+          gl.bindFramebuffer(gl.FRAMEBUFFER, fbo.framebuffer);
+        }
+        if (fbo.mipLevel !== mipLevel) {
+          framebuffer.dirtyId++;
+          framebuffer.dirtyFormat++;
+          fbo.mipLevel = mipLevel;
+        }
+        if (fbo.dirtyId !== framebuffer.dirtyId) {
+          fbo.dirtyId = framebuffer.dirtyId;
+          if (fbo.dirtyFormat !== framebuffer.dirtyFormat) {
+            fbo.dirtyFormat = framebuffer.dirtyFormat;
+            fbo.dirtySize = framebuffer.dirtySize;
+            this.updateFramebuffer(framebuffer, mipLevel);
+          } else if (fbo.dirtySize !== framebuffer.dirtySize) {
+            fbo.dirtySize = framebuffer.dirtySize;
+            this.resizeFramebuffer(framebuffer);
+          }
+        }
+        for (let i = 0; i < framebuffer.colorTextures.length; i++) {
+          const tex = framebuffer.colorTextures[i];
+          this.renderer.texture.unbind(tex.parentTextureArray || tex);
+        }
+        if (framebuffer.depthTexture) {
+          this.renderer.texture.unbind(framebuffer.depthTexture);
+        }
+        if (frame) {
+          const mipWidth = frame.width >> mipLevel;
+          const mipHeight = frame.height >> mipLevel;
+          const scale = mipWidth / frame.width;
+          this.setViewport(frame.x * scale, frame.y * scale, mipWidth, mipHeight);
+        } else {
+          const mipWidth = framebuffer.width >> mipLevel;
+          const mipHeight = framebuffer.height >> mipLevel;
+          this.setViewport(0, 0, mipWidth, mipHeight);
+        }
+      } else {
+        if (this.current) {
+          this.current = null;
+          gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        }
+        if (frame) {
+          this.setViewport(frame.x, frame.y, frame.width, frame.height);
+        } else {
+          this.setViewport(0, 0, this.renderer.width, this.renderer.height);
+        }
+      }
+    }
+    setViewport(x, y, width, height) {
+      const v = this.viewport;
+      x = Math.round(x);
+      y = Math.round(y);
+      width = Math.round(width);
+      height = Math.round(height);
+      if (v.width !== width || v.height !== height || v.x !== x || v.y !== y) {
+        v.x = x;
+        v.y = y;
+        v.width = width;
+        v.height = height;
+        this.gl.viewport(x, y, width, height);
+      }
+    }
+    get size() {
+      if (this.current) {
+        return { x: 0, y: 0, width: this.current.width, height: this.current.height };
+      }
+      return { x: 0, y: 0, width: this.renderer.width, height: this.renderer.height };
+    }
+    clear(r, g, b, a, mask = BUFFER_BITS.COLOR | BUFFER_BITS.DEPTH) {
+      const { gl } = this;
+      gl.clearColor(r, g, b, a);
+      gl.clear(mask);
+    }
+    initFramebuffer(framebuffer) {
+      const { gl } = this;
+      const fbo = new GLFramebuffer(gl.createFramebuffer());
+      fbo.multisample = this.detectSamples(framebuffer.multisample);
+      framebuffer.glFramebuffers[this.CONTEXT_UID] = fbo;
+      this.managedFramebuffers.push(framebuffer);
+      framebuffer.disposeRunner.add(this);
+      return fbo;
+    }
+    resizeFramebuffer(framebuffer) {
+      const { gl } = this;
+      const fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+      if (fbo.stencil) {
+        gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.stencil);
+        if (fbo.msaaBuffer) {
+          gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, framebuffer.width, framebuffer.height);
+        } else {
+          gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, framebuffer.width, framebuffer.height);
+        }
+      }
+      const colorTextures = framebuffer.colorTextures;
+      let count = colorTextures.length;
+      if (!gl.drawBuffers) {
+        count = Math.min(count, 1);
+      }
+      for (let i = 0; i < count; i++) {
+        const texture = colorTextures[i];
+        const parentTexture = texture.parentTextureArray || texture;
+        this.renderer.texture.bind(parentTexture, 0);
+        if (i === 0 && fbo.msaaBuffer) {
+          gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.msaaBuffer);
+          gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, parentTexture._glTextures[this.CONTEXT_UID].internalFormat, framebuffer.width, framebuffer.height);
+        }
+      }
+      if (framebuffer.depthTexture && this.writeDepthTexture) {
+        this.renderer.texture.bind(framebuffer.depthTexture, 0);
+      }
+    }
+    updateFramebuffer(framebuffer, mipLevel) {
+      const { gl } = this;
+      const fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+      const colorTextures = framebuffer.colorTextures;
+      let count = colorTextures.length;
+      if (!gl.drawBuffers) {
+        count = Math.min(count, 1);
+      }
+      if (fbo.multisample > 1 && this.canMultisampleFramebuffer(framebuffer)) {
+        fbo.msaaBuffer = fbo.msaaBuffer || gl.createRenderbuffer();
+      } else if (fbo.msaaBuffer) {
+        gl.deleteRenderbuffer(fbo.msaaBuffer);
+        fbo.msaaBuffer = null;
+        if (fbo.blitFramebuffer) {
+          fbo.blitFramebuffer.dispose();
+          fbo.blitFramebuffer = null;
+        }
+      }
+      const activeTextures = [];
+      for (let i = 0; i < count; i++) {
+        const texture = colorTextures[i];
+        const parentTexture = texture.parentTextureArray || texture;
+        this.renderer.texture.bind(parentTexture, 0);
+        if (i === 0 && fbo.msaaBuffer) {
+          gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.msaaBuffer);
+          gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, parentTexture._glTextures[this.CONTEXT_UID].internalFormat, framebuffer.width, framebuffer.height);
+          gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, fbo.msaaBuffer);
+        } else {
+          gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, texture.target, parentTexture._glTextures[this.CONTEXT_UID].texture, mipLevel);
+          activeTextures.push(gl.COLOR_ATTACHMENT0 + i);
+        }
+      }
+      if (activeTextures.length > 1) {
+        gl.drawBuffers(activeTextures);
+      }
+      if (framebuffer.depthTexture) {
+        const writeDepthTexture = this.writeDepthTexture;
+        if (writeDepthTexture) {
+          const depthTexture = framebuffer.depthTexture;
+          this.renderer.texture.bind(depthTexture, 0);
+          gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, depthTexture._glTextures[this.CONTEXT_UID].texture, mipLevel);
+        }
+      }
+      if ((framebuffer.stencil || framebuffer.depth) && !(framebuffer.depthTexture && this.writeDepthTexture)) {
+        fbo.stencil = fbo.stencil || gl.createRenderbuffer();
+        gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.stencil);
+        if (fbo.msaaBuffer) {
+          gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, framebuffer.width, framebuffer.height);
+        } else {
+          gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, framebuffer.width, framebuffer.height);
+        }
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, fbo.stencil);
+      } else if (fbo.stencil) {
+        gl.deleteRenderbuffer(fbo.stencil);
+        fbo.stencil = null;
+      }
+    }
+    canMultisampleFramebuffer(framebuffer) {
+      return this.renderer.context.webGLVersion !== 1 && framebuffer.colorTextures.length <= 1 && !framebuffer.depthTexture;
+    }
+    detectSamples(samples) {
+      const { msaaSamples } = this;
+      let res = MSAA_QUALITY.NONE;
+      if (samples <= 1 || msaaSamples === null) {
+        return res;
+      }
+      for (let i = 0; i < msaaSamples.length; i++) {
+        if (msaaSamples[i] <= samples) {
+          res = msaaSamples[i];
+          break;
+        }
+      }
+      if (res === 1) {
+        res = MSAA_QUALITY.NONE;
+      }
+      return res;
+    }
+    blit(framebuffer, sourcePixels, destPixels) {
+      const { current, renderer, gl, CONTEXT_UID } = this;
+      if (renderer.context.webGLVersion !== 2) {
+        return;
+      }
+      if (!current) {
+        return;
+      }
+      const fbo = current.glFramebuffers[CONTEXT_UID];
+      if (!fbo) {
+        return;
+      }
+      if (!framebuffer) {
+        if (!fbo.msaaBuffer) {
+          return;
+        }
+        const colorTexture = current.colorTextures[0];
+        if (!colorTexture) {
+          return;
+        }
+        if (!fbo.blitFramebuffer) {
+          fbo.blitFramebuffer = new Framebuffer(current.width, current.height);
+          fbo.blitFramebuffer.addColorTexture(0, colorTexture);
+        }
+        framebuffer = fbo.blitFramebuffer;
+        if (framebuffer.colorTextures[0] !== colorTexture) {
+          framebuffer.colorTextures[0] = colorTexture;
+          framebuffer.dirtyId++;
+          framebuffer.dirtyFormat++;
+        }
+        if (framebuffer.width !== current.width || framebuffer.height !== current.height) {
+          framebuffer.width = current.width;
+          framebuffer.height = current.height;
+          framebuffer.dirtyId++;
+          framebuffer.dirtySize++;
+        }
+      }
+      if (!sourcePixels) {
+        sourcePixels = tempRectangle;
+        sourcePixels.width = current.width;
+        sourcePixels.height = current.height;
+      }
+      if (!destPixels) {
+        destPixels = sourcePixels;
+      }
+      const sameSize = sourcePixels.width === destPixels.width && sourcePixels.height === destPixels.height;
+      this.bind(framebuffer);
+      gl.bindFramebuffer(gl.READ_FRAMEBUFFER, fbo.framebuffer);
+      gl.blitFramebuffer(sourcePixels.left, sourcePixels.top, sourcePixels.right, sourcePixels.bottom, destPixels.left, destPixels.top, destPixels.right, destPixels.bottom, gl.COLOR_BUFFER_BIT, sameSize ? gl.NEAREST : gl.LINEAR);
+      gl.bindFramebuffer(gl.READ_FRAMEBUFFER, framebuffer.glFramebuffers[this.CONTEXT_UID].framebuffer);
+    }
+    disposeFramebuffer(framebuffer, contextLost) {
+      const fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+      const gl = this.gl;
+      if (!fbo) {
+        return;
+      }
+      delete framebuffer.glFramebuffers[this.CONTEXT_UID];
+      const index = this.managedFramebuffers.indexOf(framebuffer);
+      if (index >= 0) {
+        this.managedFramebuffers.splice(index, 1);
+      }
+      framebuffer.disposeRunner.remove(this);
+      if (!contextLost) {
+        gl.deleteFramebuffer(fbo.framebuffer);
+        if (fbo.msaaBuffer) {
+          gl.deleteRenderbuffer(fbo.msaaBuffer);
+        }
+        if (fbo.stencil) {
+          gl.deleteRenderbuffer(fbo.stencil);
+        }
+      }
+      if (fbo.blitFramebuffer) {
+        this.disposeFramebuffer(fbo.blitFramebuffer, contextLost);
+      }
+    }
+    disposeAll(contextLost) {
+      const list = this.managedFramebuffers;
+      this.managedFramebuffers = [];
+      for (let i = 0; i < list.length; i++) {
+        this.disposeFramebuffer(list[i], contextLost);
+      }
+    }
+    forceStencil() {
+      const framebuffer = this.current;
+      if (!framebuffer) {
+        return;
+      }
+      const fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
+      if (!fbo || fbo.stencil) {
+        return;
+      }
+      framebuffer.stencil = true;
+      const w = framebuffer.width;
+      const h = framebuffer.height;
+      const gl = this.gl;
+      const stencil = gl.createRenderbuffer();
+      gl.bindRenderbuffer(gl.RENDERBUFFER, stencil);
+      if (fbo.msaaBuffer) {
+        gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, w, h);
+      } else {
+        gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, w, h);
+      }
+      fbo.stencil = stencil;
+      gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, stencil);
+    }
+    reset() {
+      this.current = this.unknownFramebuffer;
+      this.viewport = new Rectangle();
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  FramebufferSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "framebuffer"
+  };
+  extensions$1.add(FramebufferSystem);
+
+  const byteSizeMap = { 5126: 4, 5123: 2, 5121: 1 };
+  class GeometrySystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this._activeGeometry = null;
+      this._activeVao = null;
+      this.hasVao = true;
+      this.hasInstance = true;
+      this.canUseUInt32ElementIndex = false;
+      this.managedGeometries = {};
+    }
+    contextChange() {
+      this.disposeAll(true);
+      const gl = this.gl = this.renderer.gl;
+      const context = this.renderer.context;
+      this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+      if (context.webGLVersion !== 2) {
+        let nativeVaoExtension = this.renderer.context.extensions.vertexArrayObject;
+        if (settings.PREFER_ENV === ENV.WEBGL_LEGACY) {
+          nativeVaoExtension = null;
+        }
+        if (nativeVaoExtension) {
+          gl.createVertexArray = () => nativeVaoExtension.createVertexArrayOES();
+          gl.bindVertexArray = (vao) => nativeVaoExtension.bindVertexArrayOES(vao);
+          gl.deleteVertexArray = (vao) => nativeVaoExtension.deleteVertexArrayOES(vao);
+        } else {
+          this.hasVao = false;
+          gl.createVertexArray = () => null;
+          gl.bindVertexArray = () => null;
+          gl.deleteVertexArray = () => null;
+        }
+      }
+      if (context.webGLVersion !== 2) {
+        const instanceExt = gl.getExtension("ANGLE_instanced_arrays");
+        if (instanceExt) {
+          gl.vertexAttribDivisor = (a, b) => instanceExt.vertexAttribDivisorANGLE(a, b);
+          gl.drawElementsInstanced = (a, b, c, d, e) => instanceExt.drawElementsInstancedANGLE(a, b, c, d, e);
+          gl.drawArraysInstanced = (a, b, c, d) => instanceExt.drawArraysInstancedANGLE(a, b, c, d);
+        } else {
+          this.hasInstance = false;
+        }
+      }
+      this.canUseUInt32ElementIndex = context.webGLVersion === 2 || !!context.extensions.uint32ElementIndex;
+    }
+    bind(geometry, shader) {
+      shader = shader || this.renderer.shader.shader;
+      const { gl } = this;
+      let vaos = geometry.glVertexArrayObjects[this.CONTEXT_UID];
+      let incRefCount = false;
+      if (!vaos) {
+        this.managedGeometries[geometry.id] = geometry;
+        geometry.disposeRunner.add(this);
+        geometry.glVertexArrayObjects[this.CONTEXT_UID] = vaos = {};
+        incRefCount = true;
+      }
+      const vao = vaos[shader.program.id] || this.initGeometryVao(geometry, shader, incRefCount);
+      this._activeGeometry = geometry;
+      if (this._activeVao !== vao) {
+        this._activeVao = vao;
+        if (this.hasVao) {
+          gl.bindVertexArray(vao);
+        } else {
+          this.activateVao(geometry, shader.program);
+        }
+      }
+      this.updateBuffers();
+    }
+    reset() {
+      this.unbind();
+    }
+    updateBuffers() {
+      const geometry = this._activeGeometry;
+      const bufferSystem = this.renderer.buffer;
+      for (let i = 0; i < geometry.buffers.length; i++) {
+        const buffer = geometry.buffers[i];
+        bufferSystem.update(buffer);
+      }
+    }
+    checkCompatibility(geometry, program) {
+      const geometryAttributes = geometry.attributes;
+      const shaderAttributes = program.attributeData;
+      for (const j in shaderAttributes) {
+        if (!geometryAttributes[j]) {
+          throw new Error(`shader and geometry incompatible, geometry missing the "${j}" attribute`);
+        }
+      }
+    }
+    getSignature(geometry, program) {
+      const attribs = geometry.attributes;
+      const shaderAttributes = program.attributeData;
+      const strings = ["g", geometry.id];
+      for (const i in attribs) {
+        if (shaderAttributes[i]) {
+          strings.push(i, shaderAttributes[i].location);
+        }
+      }
+      return strings.join("-");
+    }
+    initGeometryVao(geometry, shader, incRefCount = true) {
+      const gl = this.gl;
+      const CONTEXT_UID = this.CONTEXT_UID;
+      const bufferSystem = this.renderer.buffer;
+      const program = shader.program;
+      if (!program.glPrograms[CONTEXT_UID]) {
+        this.renderer.shader.generateProgram(shader);
+      }
+      this.checkCompatibility(geometry, program);
+      const signature = this.getSignature(geometry, program);
+      const vaoObjectHash = geometry.glVertexArrayObjects[this.CONTEXT_UID];
+      let vao = vaoObjectHash[signature];
+      if (vao) {
+        vaoObjectHash[program.id] = vao;
+        return vao;
+      }
+      const buffers = geometry.buffers;
+      const attributes = geometry.attributes;
+      const tempStride = {};
+      const tempStart = {};
+      for (const j in buffers) {
+        tempStride[j] = 0;
+        tempStart[j] = 0;
+      }
+      for (const j in attributes) {
+        if (!attributes[j].size && program.attributeData[j]) {
+          attributes[j].size = program.attributeData[j].size;
+        } else if (!attributes[j].size) {
+          console.warn(`PIXI Geometry attribute '${j}' size cannot be determined (likely the bound shader does not have the attribute)`);
+        }
+        tempStride[attributes[j].buffer] += attributes[j].size * byteSizeMap[attributes[j].type];
+      }
+      for (const j in attributes) {
+        const attribute = attributes[j];
+        const attribSize = attribute.size;
+        if (attribute.stride === void 0) {
+          if (tempStride[attribute.buffer] === attribSize * byteSizeMap[attribute.type]) {
+            attribute.stride = 0;
+          } else {
+            attribute.stride = tempStride[attribute.buffer];
+          }
+        }
+        if (attribute.start === void 0) {
+          attribute.start = tempStart[attribute.buffer];
+          tempStart[attribute.buffer] += attribSize * byteSizeMap[attribute.type];
+        }
+      }
+      vao = gl.createVertexArray();
+      gl.bindVertexArray(vao);
+      for (let i = 0; i < buffers.length; i++) {
+        const buffer = buffers[i];
+        bufferSystem.bind(buffer);
+        if (incRefCount) {
+          buffer._glBuffers[CONTEXT_UID].refCount++;
+        }
+      }
+      this.activateVao(geometry, program);
+      vaoObjectHash[program.id] = vao;
+      vaoObjectHash[signature] = vao;
+      gl.bindVertexArray(null);
+      bufferSystem.unbind(BUFFER_TYPE.ARRAY_BUFFER);
+      return vao;
+    }
+    disposeGeometry(geometry, contextLost) {
+      if (!this.managedGeometries[geometry.id]) {
+        return;
+      }
+      delete this.managedGeometries[geometry.id];
+      const vaos = geometry.glVertexArrayObjects[this.CONTEXT_UID];
+      const gl = this.gl;
+      const buffers = geometry.buffers;
+      const bufferSystem = this.renderer?.buffer;
+      geometry.disposeRunner.remove(this);
+      if (!vaos) {
+        return;
+      }
+      if (bufferSystem) {
+        for (let i = 0; i < buffers.length; i++) {
+          const buf = buffers[i]._glBuffers[this.CONTEXT_UID];
+          if (buf) {
+            buf.refCount--;
+            if (buf.refCount === 0 && !contextLost) {
+              bufferSystem.dispose(buffers[i], contextLost);
+            }
+          }
+        }
+      }
+      if (!contextLost) {
+        for (const vaoId in vaos) {
+          if (vaoId[0] === "g") {
+            const vao = vaos[vaoId];
+            if (this._activeVao === vao) {
+              this.unbind();
+            }
+            gl.deleteVertexArray(vao);
+          }
+        }
+      }
+      delete geometry.glVertexArrayObjects[this.CONTEXT_UID];
+    }
+    disposeAll(contextLost) {
+      const all = Object.keys(this.managedGeometries);
+      for (let i = 0; i < all.length; i++) {
+        this.disposeGeometry(this.managedGeometries[all[i]], contextLost);
+      }
+    }
+    activateVao(geometry, program) {
+      const gl = this.gl;
+      const CONTEXT_UID = this.CONTEXT_UID;
+      const bufferSystem = this.renderer.buffer;
+      const buffers = geometry.buffers;
+      const attributes = geometry.attributes;
+      if (geometry.indexBuffer) {
+        bufferSystem.bind(geometry.indexBuffer);
+      }
+      let lastBuffer = null;
+      for (const j in attributes) {
+        const attribute = attributes[j];
+        const buffer = buffers[attribute.buffer];
+        const glBuffer = buffer._glBuffers[CONTEXT_UID];
+        if (program.attributeData[j]) {
+          if (lastBuffer !== glBuffer) {
+            bufferSystem.bind(buffer);
+            lastBuffer = glBuffer;
+          }
+          const location = program.attributeData[j].location;
+          gl.enableVertexAttribArray(location);
+          gl.vertexAttribPointer(location, attribute.size, attribute.type || gl.FLOAT, attribute.normalized, attribute.stride, attribute.start);
+          if (attribute.instance) {
+            if (this.hasInstance) {
+              gl.vertexAttribDivisor(location, attribute.divisor);
+            } else {
+              throw new Error("geometry error, GPU Instancing is not supported on this device");
+            }
+          }
+        }
+      }
+    }
+    draw(type, size, start, instanceCount) {
+      const { gl } = this;
+      const geometry = this._activeGeometry;
+      if (geometry.indexBuffer) {
+        const byteSize = geometry.indexBuffer.data.BYTES_PER_ELEMENT;
+        const glType = byteSize === 2 ? gl.UNSIGNED_SHORT : gl.UNSIGNED_INT;
+        if (byteSize === 2 || byteSize === 4 && this.canUseUInt32ElementIndex) {
+          if (geometry.instanced) {
+            gl.drawElementsInstanced(type, size || geometry.indexBuffer.data.length, glType, (start || 0) * byteSize, instanceCount || 1);
+          } else {
+            gl.drawElements(type, size || geometry.indexBuffer.data.length, glType, (start || 0) * byteSize);
+          }
+        } else {
+          console.warn("unsupported index buffer type: uint32");
+        }
+      } else if (geometry.instanced) {
+        gl.drawArraysInstanced(type, start, size || geometry.getSize(), instanceCount || 1);
+      } else {
+        gl.drawArrays(type, start, size || geometry.getSize());
+      }
+      return this;
+    }
+    unbind() {
+      this.gl.bindVertexArray(null);
+      this._activeVao = null;
+      this._activeGeometry = null;
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  GeometrySystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "geometry"
+  };
+  extensions$1.add(GeometrySystem);
+
+  const tempMat$1 = new Matrix();
+  class TextureMatrix {
+    constructor(texture, clampMargin) {
+      this._texture = texture;
+      this.mapCoord = new Matrix();
+      this.uClampFrame = new Float32Array(4);
+      this.uClampOffset = new Float32Array(2);
+      this._textureID = -1;
+      this._updateID = 0;
+      this.clampOffset = 0;
+      this.clampMargin = typeof clampMargin === "undefined" ? 0.5 : clampMargin;
+      this.isSimple = false;
+    }
+    get texture() {
+      return this._texture;
+    }
+    set texture(value) {
+      this._texture = value;
+      this._textureID = -1;
+    }
+    multiplyUvs(uvs, out) {
+      if (out === void 0) {
+        out = uvs;
+      }
+      const mat = this.mapCoord;
+      for (let i = 0; i < uvs.length; i += 2) {
+        const x = uvs[i];
+        const y = uvs[i + 1];
+        out[i] = x * mat.a + y * mat.c + mat.tx;
+        out[i + 1] = x * mat.b + y * mat.d + mat.ty;
+      }
+      return out;
+    }
+    update(forceUpdate) {
+      const tex = this._texture;
+      if (!tex || !tex.valid) {
+        return false;
+      }
+      if (!forceUpdate && this._textureID === tex._updateID) {
+        return false;
+      }
+      this._textureID = tex._updateID;
+      this._updateID++;
+      const uvs = tex._uvs;
+      this.mapCoord.set(uvs.x1 - uvs.x0, uvs.y1 - uvs.y0, uvs.x3 - uvs.x0, uvs.y3 - uvs.y0, uvs.x0, uvs.y0);
+      const orig = tex.orig;
+      const trim = tex.trim;
+      if (trim) {
+        tempMat$1.set(orig.width / trim.width, 0, 0, orig.height / trim.height, -trim.x / trim.width, -trim.y / trim.height);
+        this.mapCoord.append(tempMat$1);
+      }
+      const texBase = tex.baseTexture;
+      const frame = this.uClampFrame;
+      const margin = this.clampMargin / texBase.resolution;
+      const offset = this.clampOffset;
+      frame[0] = (tex._frame.x + margin + offset) / texBase.width;
+      frame[1] = (tex._frame.y + margin + offset) / texBase.height;
+      frame[2] = (tex._frame.x + tex._frame.width - margin + offset) / texBase.width;
+      frame[3] = (tex._frame.y + tex._frame.height - margin + offset) / texBase.height;
+      this.uClampOffset[0] = offset / texBase.realWidth;
+      this.uClampOffset[1] = offset / texBase.realHeight;
+      this.isSimple = tex._frame.width === texBase.width && tex._frame.height === texBase.height && tex.rotate === 0;
+      return true;
+    }
+  }
+
+  var fragment$7 = "varying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform sampler2D mask;\nuniform float alpha;\nuniform float npmAlpha;\nuniform vec4 maskClamp;\n\nvoid main(void)\n{\n    float clip = step(3.5,\n        step(maskClamp.x, vMaskCoord.x) +\n        step(maskClamp.y, vMaskCoord.y) +\n        step(vMaskCoord.x, maskClamp.z) +\n        step(vMaskCoord.y, maskClamp.w));\n\n    vec4 original = texture2D(uSampler, vTextureCoord);\n    vec4 masky = texture2D(mask, vMaskCoord);\n    float alphaMul = 1.0 - npmAlpha * (1.0 - masky.a);\n\n    original *= (alphaMul * masky.r * alpha * clip);\n\n    gl_FragColor = original;\n}\n";
+
+  var vertex$4 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 otherMatrix;\n\nvarying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;\n}\n";
+
+  class SpriteMaskFilter extends Filter {
+    constructor(vertexSrc, fragmentSrc, uniforms) {
+      let sprite = null;
+      if (typeof vertexSrc !== "string" && fragmentSrc === void 0 && uniforms === void 0) {
+        sprite = vertexSrc;
+        vertexSrc = void 0;
+        fragmentSrc = void 0;
+        uniforms = void 0;
+      }
+      super(vertexSrc || vertex$4, fragmentSrc || fragment$7, uniforms);
+      this.maskSprite = sprite;
+      this.maskMatrix = new Matrix();
+    }
+    get maskSprite() {
+      return this._maskSprite;
+    }
+    set maskSprite(value) {
+      this._maskSprite = value;
+      if (this._maskSprite) {
+        this._maskSprite.renderable = false;
+      }
+    }
+    apply(filterManager, input, output, clearMode) {
+      const maskSprite = this._maskSprite;
+      const tex = maskSprite._texture;
+      if (!tex.valid) {
+        return;
+      }
+      if (!tex.uvMatrix) {
+        tex.uvMatrix = new TextureMatrix(tex, 0);
+      }
+      tex.uvMatrix.update();
+      this.uniforms.npmAlpha = tex.baseTexture.alphaMode ? 0 : 1;
+      this.uniforms.mask = tex;
+      this.uniforms.otherMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, maskSprite).prepend(tex.uvMatrix.mapCoord);
+      this.uniforms.alpha = maskSprite.worldAlpha;
+      this.uniforms.maskClamp = tex.uvMatrix.uClampFrame;
+      filterManager.applyFilter(this, input, output, clearMode);
+    }
+  }
+
+  class MaskData {
+    constructor(maskObject = null) {
+      this.type = MASK_TYPES.NONE;
+      this.autoDetect = true;
+      this.maskObject = maskObject || null;
+      this.pooled = false;
+      this.isMaskData = true;
+      this.resolution = null;
+      this.multisample = Filter.defaultMultisample;
+      this.enabled = true;
+      this.colorMask = 15;
+      this._filters = null;
+      this._stencilCounter = 0;
+      this._scissorCounter = 0;
+      this._scissorRect = null;
+      this._scissorRectLocal = null;
+      this._colorMask = 15;
+      this._target = null;
+    }
+    get filter() {
+      return this._filters ? this._filters[0] : null;
+    }
+    set filter(value) {
+      if (value) {
+        if (this._filters) {
+          this._filters[0] = value;
+        } else {
+          this._filters = [value];
+        }
+      } else {
+        this._filters = null;
+      }
+    }
+    reset() {
+      if (this.pooled) {
+        this.maskObject = null;
+        this.type = MASK_TYPES.NONE;
+        this.autoDetect = true;
+      }
+      this._target = null;
+      this._scissorRectLocal = null;
+    }
+    copyCountersOrReset(maskAbove) {
+      if (maskAbove) {
+        this._stencilCounter = maskAbove._stencilCounter;
+        this._scissorCounter = maskAbove._scissorCounter;
+        this._scissorRect = maskAbove._scissorRect;
+      } else {
+        this._stencilCounter = 0;
+        this._scissorCounter = 0;
+        this._scissorRect = null;
+      }
+    }
+  }
+
+  class MaskSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.enableScissor = true;
+      this.alphaMaskPool = [];
+      this.maskDataPool = [];
+      this.maskStack = [];
+      this.alphaMaskIndex = 0;
+    }
+    setMaskStack(maskStack) {
+      this.maskStack = maskStack;
+      this.renderer.scissor.setMaskStack(maskStack);
+      this.renderer.stencil.setMaskStack(maskStack);
+    }
+    push(target, maskDataOrTarget) {
+      let maskData = maskDataOrTarget;
+      if (!maskData.isMaskData) {
+        const d = this.maskDataPool.pop() || new MaskData();
+        d.pooled = true;
+        d.maskObject = maskDataOrTarget;
+        maskData = d;
+      }
+      const maskAbove = this.maskStack.length !== 0 ? this.maskStack[this.maskStack.length - 1] : null;
+      maskData.copyCountersOrReset(maskAbove);
+      maskData._colorMask = maskAbove ? maskAbove._colorMask : 15;
+      if (maskData.autoDetect) {
+        this.detect(maskData);
+      }
+      maskData._target = target;
+      if (maskData.type !== MASK_TYPES.SPRITE) {
+        this.maskStack.push(maskData);
+      }
+      if (maskData.enabled) {
+        switch (maskData.type) {
+          case MASK_TYPES.SCISSOR:
+            this.renderer.scissor.push(maskData);
+            break;
+          case MASK_TYPES.STENCIL:
+            this.renderer.stencil.push(maskData);
+            break;
+          case MASK_TYPES.SPRITE:
+            maskData.copyCountersOrReset(null);
+            this.pushSpriteMask(maskData);
+            break;
+          case MASK_TYPES.COLOR:
+            this.pushColorMask(maskData);
+            break;
+          default:
+            break;
+        }
+      }
+      if (maskData.type === MASK_TYPES.SPRITE) {
+        this.maskStack.push(maskData);
+      }
+    }
+    pop(target) {
+      const maskData = this.maskStack.pop();
+      if (!maskData || maskData._target !== target) {
+        return;
+      }
+      if (maskData.enabled) {
+        switch (maskData.type) {
+          case MASK_TYPES.SCISSOR:
+            this.renderer.scissor.pop(maskData);
+            break;
+          case MASK_TYPES.STENCIL:
+            this.renderer.stencil.pop(maskData.maskObject);
+            break;
+          case MASK_TYPES.SPRITE:
+            this.popSpriteMask(maskData);
+            break;
+          case MASK_TYPES.COLOR:
+            this.popColorMask(maskData);
+            break;
+          default:
+            break;
+        }
+      }
+      maskData.reset();
+      if (maskData.pooled) {
+        this.maskDataPool.push(maskData);
+      }
+      if (this.maskStack.length !== 0) {
+        const maskCurrent = this.maskStack[this.maskStack.length - 1];
+        if (maskCurrent.type === MASK_TYPES.SPRITE && maskCurrent._filters) {
+          maskCurrent._filters[0].maskSprite = maskCurrent.maskObject;
+        }
+      }
+    }
+    detect(maskData) {
+      const maskObject = maskData.maskObject;
+      if (!maskObject) {
+        maskData.type = MASK_TYPES.COLOR;
+      } else if (maskObject.isSprite) {
+        maskData.type = MASK_TYPES.SPRITE;
+      } else if (this.enableScissor && this.renderer.scissor.testScissor(maskData)) {
+        maskData.type = MASK_TYPES.SCISSOR;
+      } else {
+        maskData.type = MASK_TYPES.STENCIL;
+      }
+    }
+    pushSpriteMask(maskData) {
+      const { maskObject } = maskData;
+      const target = maskData._target;
+      let alphaMaskFilter = maskData._filters;
+      if (!alphaMaskFilter) {
+        alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex];
+        if (!alphaMaskFilter) {
+          alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex] = [new SpriteMaskFilter()];
+        }
+      }
+      const renderer = this.renderer;
+      const renderTextureSystem = renderer.renderTexture;
+      let resolution;
+      let multisample;
+      if (renderTextureSystem.current) {
+        const renderTexture = renderTextureSystem.current;
+        resolution = maskData.resolution || renderTexture.resolution;
+        multisample = maskData.multisample ?? renderTexture.multisample;
+      } else {
+        resolution = maskData.resolution || renderer.resolution;
+        multisample = maskData.multisample ?? renderer.multisample;
+      }
+      alphaMaskFilter[0].resolution = resolution;
+      alphaMaskFilter[0].multisample = multisample;
+      alphaMaskFilter[0].maskSprite = maskObject;
+      const stashFilterArea = target.filterArea;
+      target.filterArea = maskObject.getBounds(true);
+      renderer.filter.push(target, alphaMaskFilter);
+      target.filterArea = stashFilterArea;
+      if (!maskData._filters) {
+        this.alphaMaskIndex++;
+      }
+    }
+    popSpriteMask(maskData) {
+      this.renderer.filter.pop();
+      if (maskData._filters) {
+        maskData._filters[0].maskSprite = null;
+      } else {
+        this.alphaMaskIndex--;
+        this.alphaMaskPool[this.alphaMaskIndex][0].maskSprite = null;
+      }
+    }
+    pushColorMask(maskData) {
+      const currColorMask = maskData._colorMask;
+      const nextColorMask = maskData._colorMask = currColorMask & maskData.colorMask;
+      if (nextColorMask !== currColorMask) {
+        this.renderer.gl.colorMask((nextColorMask & 1) !== 0, (nextColorMask & 2) !== 0, (nextColorMask & 4) !== 0, (nextColorMask & 8) !== 0);
+      }
+    }
+    popColorMask(maskData) {
+      const currColorMask = maskData._colorMask;
+      const nextColorMask = this.maskStack.length > 0 ? this.maskStack[this.maskStack.length - 1]._colorMask : 15;
+      if (nextColorMask !== currColorMask) {
+        this.renderer.gl.colorMask((nextColorMask & 1) !== 0, (nextColorMask & 2) !== 0, (nextColorMask & 4) !== 0, (nextColorMask & 8) !== 0);
+      }
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  MaskSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "mask"
+  };
+  extensions$1.add(MaskSystem);
+
+  class AbstractMaskSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.maskStack = [];
+      this.glConst = 0;
+    }
+    getStackLength() {
+      return this.maskStack.length;
+    }
+    setMaskStack(maskStack) {
+      const { gl } = this.renderer;
+      const curStackLen = this.getStackLength();
+      this.maskStack = maskStack;
+      const newStackLen = this.getStackLength();
+      if (newStackLen !== curStackLen) {
+        if (newStackLen === 0) {
+          gl.disable(this.glConst);
+        } else {
+          gl.enable(this.glConst);
+          this._useCurrent();
+        }
+      }
+    }
+    _useCurrent() {
+    }
+    destroy() {
+      this.renderer = null;
+      this.maskStack = null;
+    }
+  }
+
+  const tempMatrix$3 = new Matrix();
+  const rectPool = [];
+  const _ScissorSystem = class extends AbstractMaskSystem {
+    constructor(renderer) {
+      super(renderer);
+      this.glConst = settings.ADAPTER.getWebGLRenderingContext().SCISSOR_TEST;
+    }
+    getStackLength() {
+      const maskData = this.maskStack[this.maskStack.length - 1];
+      if (maskData) {
+        return maskData._scissorCounter;
+      }
+      return 0;
+    }
+    calcScissorRect(maskData) {
+      if (maskData._scissorRectLocal) {
+        return;
+      }
+      const prevData = maskData._scissorRect;
+      const { maskObject } = maskData;
+      const { renderer } = this;
+      const renderTextureSystem = renderer.renderTexture;
+      const rect = maskObject.getBounds(true, rectPool.pop() ?? new Rectangle());
+      this.roundFrameToPixels(rect, renderTextureSystem.current ? renderTextureSystem.current.resolution : renderer.resolution, renderTextureSystem.sourceFrame, renderTextureSystem.destinationFrame, renderer.projection.transform);
+      if (prevData) {
+        rect.fit(prevData);
+      }
+      maskData._scissorRectLocal = rect;
+    }
+    static isMatrixRotated(matrix) {
+      if (!matrix) {
+        return false;
+      }
+      const { a, b, c, d } = matrix;
+      return (Math.abs(b) > 1e-4 || Math.abs(c) > 1e-4) && (Math.abs(a) > 1e-4 || Math.abs(d) > 1e-4);
+    }
+    testScissor(maskData) {
+      const { maskObject } = maskData;
+      if (!maskObject.isFastRect || !maskObject.isFastRect()) {
+        return false;
+      }
+      if (_ScissorSystem.isMatrixRotated(maskObject.worldTransform)) {
+        return false;
+      }
+      if (_ScissorSystem.isMatrixRotated(this.renderer.projection.transform)) {
+        return false;
+      }
+      this.calcScissorRect(maskData);
+      const rect = maskData._scissorRectLocal;
+      return rect.width > 0 && rect.height > 0;
+    }
+    roundFrameToPixels(frame, resolution, bindingSourceFrame, bindingDestinationFrame, transform) {
+      if (_ScissorSystem.isMatrixRotated(transform)) {
+        return;
+      }
+      transform = transform ? tempMatrix$3.copyFrom(transform) : tempMatrix$3.identity();
+      transform.translate(-bindingSourceFrame.x, -bindingSourceFrame.y).scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height).translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
+      this.renderer.filter.transformAABB(transform, frame);
+      frame.fit(bindingDestinationFrame);
+      frame.x = Math.round(frame.x * resolution);
+      frame.y = Math.round(frame.y * resolution);
+      frame.width = Math.round(frame.width * resolution);
+      frame.height = Math.round(frame.height * resolution);
+    }
+    push(maskData) {
+      if (!maskData._scissorRectLocal) {
+        this.calcScissorRect(maskData);
+      }
+      const { gl } = this.renderer;
+      if (!maskData._scissorRect) {
+        gl.enable(gl.SCISSOR_TEST);
+      }
+      maskData._scissorCounter++;
+      maskData._scissorRect = maskData._scissorRectLocal;
+      this._useCurrent();
+    }
+    pop(maskData) {
+      const { gl } = this.renderer;
+      if (maskData) {
+        rectPool.push(maskData._scissorRectLocal);
+      }
+      if (this.getStackLength() > 0) {
+        this._useCurrent();
+      } else {
+        gl.disable(gl.SCISSOR_TEST);
+      }
+    }
+    _useCurrent() {
+      const rect = this.maskStack[this.maskStack.length - 1]._scissorRect;
+      let y;
+      if (this.renderer.renderTexture.current) {
+        y = rect.y;
+      } else {
+        y = this.renderer.height - rect.height - rect.y;
+      }
+      this.renderer.gl.scissor(rect.x, y, rect.width, rect.height);
+    }
+  };
+  let ScissorSystem = _ScissorSystem;
+  ScissorSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "scissor"
+  };
+  extensions$1.add(ScissorSystem);
+
+  class StencilSystem extends AbstractMaskSystem {
+    constructor(renderer) {
+      super(renderer);
+      this.glConst = settings.ADAPTER.getWebGLRenderingContext().STENCIL_TEST;
+    }
+    getStackLength() {
+      const maskData = this.maskStack[this.maskStack.length - 1];
+      if (maskData) {
+        return maskData._stencilCounter;
+      }
+      return 0;
+    }
+    push(maskData) {
+      const maskObject = maskData.maskObject;
+      const { gl } = this.renderer;
+      const prevMaskCount = maskData._stencilCounter;
+      if (prevMaskCount === 0) {
+        this.renderer.framebuffer.forceStencil();
+        gl.clearStencil(0);
+        gl.clear(gl.STENCIL_BUFFER_BIT);
+        gl.enable(gl.STENCIL_TEST);
+      }
+      maskData._stencilCounter++;
+      const colorMask = maskData._colorMask;
+      if (colorMask !== 0) {
+        maskData._colorMask = 0;
+        gl.colorMask(false, false, false, false);
+      }
+      gl.stencilFunc(gl.EQUAL, prevMaskCount, 4294967295);
+      gl.stencilOp(gl.KEEP, gl.KEEP, gl.INCR);
+      maskObject.renderable = true;
+      maskObject.render(this.renderer);
+      this.renderer.batch.flush();
+      maskObject.renderable = false;
+      if (colorMask !== 0) {
+        maskData._colorMask = colorMask;
+        gl.colorMask((colorMask & 1) !== 0, (colorMask & 2) !== 0, (colorMask & 4) !== 0, (colorMask & 8) !== 0);
+      }
+      this._useCurrent();
+    }
+    pop(maskObject) {
+      const gl = this.renderer.gl;
+      if (this.getStackLength() === 0) {
+        gl.disable(gl.STENCIL_TEST);
+      } else {
+        const maskData = this.maskStack.length !== 0 ? this.maskStack[this.maskStack.length - 1] : null;
+        const colorMask = maskData ? maskData._colorMask : 15;
+        if (colorMask !== 0) {
+          maskData._colorMask = 0;
+          gl.colorMask(false, false, false, false);
+        }
+        gl.stencilOp(gl.KEEP, gl.KEEP, gl.DECR);
+        maskObject.renderable = true;
+        maskObject.render(this.renderer);
+        this.renderer.batch.flush();
+        maskObject.renderable = false;
+        if (colorMask !== 0) {
+          maskData._colorMask = colorMask;
+          gl.colorMask((colorMask & 1) !== 0, (colorMask & 2) !== 0, (colorMask & 4) !== 0, (colorMask & 8) !== 0);
+        }
+        this._useCurrent();
+      }
+    }
+    _useCurrent() {
+      const gl = this.renderer.gl;
+      gl.stencilFunc(gl.EQUAL, this.getStackLength(), 4294967295);
+      gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+    }
+  }
+  StencilSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "stencil"
+  };
+  extensions$1.add(StencilSystem);
+
+  class PluginSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.plugins = {};
+      Object.defineProperties(this.plugins, {
+        extract: {
+          enumerable: false,
+          get() {
+            deprecation$1("7.0.0", "renderer.plugins.extract has moved to renderer.extract");
+            return renderer.extract;
+          }
+        },
+        prepare: {
+          enumerable: false,
+          get() {
+            deprecation$1("7.0.0", "renderer.plugins.prepare has moved to renderer.prepare");
+            return renderer.prepare;
+          }
+        },
+        interaction: {
+          enumerable: false,
+          get() {
+            deprecation$1("7.0.0", "renderer.plugins.interaction has been deprecated, use renderer.events");
+            return renderer.events;
+          }
+        }
+      });
+    }
+    init() {
+      const staticMap = this.rendererPlugins;
+      for (const o in staticMap) {
+        this.plugins[o] = new staticMap[o](this.renderer);
+      }
+    }
+    destroy() {
+      for (const o in this.plugins) {
+        this.plugins[o].destroy();
+        this.plugins[o] = null;
+      }
+    }
+  }
+  PluginSystem.extension = {
+    type: [
+      ExtensionType.RendererSystem,
+      ExtensionType.CanvasRendererSystem
+    ],
+    name: "_plugin"
+  };
+  extensions$1.add(PluginSystem);
+
+  class ProjectionSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.destinationFrame = null;
+      this.sourceFrame = null;
+      this.defaultFrame = null;
+      this.projectionMatrix = new Matrix();
+      this.transform = null;
+    }
+    update(destinationFrame, sourceFrame, resolution, root) {
+      this.destinationFrame = destinationFrame || this.destinationFrame || this.defaultFrame;
+      this.sourceFrame = sourceFrame || this.sourceFrame || destinationFrame;
+      this.calculateProjection(this.destinationFrame, this.sourceFrame, resolution, root);
+      if (this.transform) {
+        this.projectionMatrix.append(this.transform);
+      }
+      const renderer = this.renderer;
+      renderer.globalUniforms.uniforms.projectionMatrix = this.projectionMatrix;
+      renderer.globalUniforms.update();
+      if (renderer.shader.shader) {
+        renderer.shader.syncUniformGroup(renderer.shader.shader.uniforms.globals);
+      }
+    }
+    calculateProjection(_destinationFrame, sourceFrame, _resolution, root) {
+      const pm = this.projectionMatrix;
+      const sign = !root ? 1 : -1;
+      pm.identity();
+      pm.a = 1 / sourceFrame.width * 2;
+      pm.d = sign * (1 / sourceFrame.height * 2);
+      pm.tx = -1 - sourceFrame.x * pm.a;
+      pm.ty = -sign - sourceFrame.y * pm.d;
+    }
+    setTransform(_matrix) {
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  ProjectionSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "projection"
+  };
+  extensions$1.add(ProjectionSystem);
+
+  const tempTransform = new Transform();
+  class GenerateTextureSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this._tempMatrix = new Matrix();
+    }
+    generateTexture(displayObject, options) {
+      const { region: manualRegion, ...textureOptions } = options || {};
+      const region = manualRegion || displayObject.getLocalBounds(null, true);
+      if (region.width === 0)
+        region.width = 1;
+      if (region.height === 0)
+        region.height = 1;
+      const renderTexture = RenderTexture.create({
+        width: region.width,
+        height: region.height,
+        ...textureOptions
+      });
+      this._tempMatrix.tx = -region.x;
+      this._tempMatrix.ty = -region.y;
+      const transform = displayObject.transform;
+      displayObject.transform = tempTransform;
+      this.renderer.render(displayObject, {
+        renderTexture,
+        transform: this._tempMatrix,
+        skipUpdateTransform: !!displayObject.parent,
+        blit: true
+      });
+      displayObject.transform = transform;
+      return renderTexture;
+    }
+    destroy() {
+    }
+  }
+  GenerateTextureSystem.extension = {
+    type: [
+      ExtensionType.RendererSystem,
+      ExtensionType.CanvasRendererSystem
+    ],
+    name: "textureGenerator"
+  };
+  extensions$1.add(GenerateTextureSystem);
+
+  const tempRect = new Rectangle();
+  const tempRect2 = new Rectangle();
+  class RenderTextureSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.defaultMaskStack = [];
+      this.current = null;
+      this.sourceFrame = new Rectangle();
+      this.destinationFrame = new Rectangle();
+      this.viewportFrame = new Rectangle();
+    }
+    contextChange() {
+      const attributes = this.renderer?.gl.getContextAttributes();
+      this._rendererPremultipliedAlpha = !!(attributes && attributes.alpha && attributes.premultipliedAlpha);
+    }
+    bind(renderTexture = null, sourceFrame, destinationFrame) {
+      const renderer = this.renderer;
+      this.current = renderTexture;
+      let baseTexture;
+      let framebuffer;
+      let resolution;
+      if (renderTexture) {
+        baseTexture = renderTexture.baseTexture;
+        resolution = baseTexture.resolution;
+        if (!sourceFrame) {
+          tempRect.width = renderTexture.frame.width;
+          tempRect.height = renderTexture.frame.height;
+          sourceFrame = tempRect;
+        }
+        if (!destinationFrame) {
+          tempRect2.x = renderTexture.frame.x;
+          tempRect2.y = renderTexture.frame.y;
+          tempRect2.width = sourceFrame.width;
+          tempRect2.height = sourceFrame.height;
+          destinationFrame = tempRect2;
+        }
+        framebuffer = baseTexture.framebuffer;
+      } else {
+        resolution = renderer.resolution;
+        if (!sourceFrame) {
+          tempRect.width = renderer._view.screen.width;
+          tempRect.height = renderer._view.screen.height;
+          sourceFrame = tempRect;
+        }
+        if (!destinationFrame) {
+          destinationFrame = tempRect;
+          destinationFrame.width = sourceFrame.width;
+          destinationFrame.height = sourceFrame.height;
+        }
+      }
+      const viewportFrame = this.viewportFrame;
+      viewportFrame.x = destinationFrame.x * resolution;
+      viewportFrame.y = destinationFrame.y * resolution;
+      viewportFrame.width = destinationFrame.width * resolution;
+      viewportFrame.height = destinationFrame.height * resolution;
+      if (!renderTexture) {
+        viewportFrame.y = renderer.view.height - (viewportFrame.y + viewportFrame.height);
+      }
+      viewportFrame.ceil();
+      this.renderer.framebuffer.bind(framebuffer, viewportFrame);
+      this.renderer.projection.update(destinationFrame, sourceFrame, resolution, !framebuffer);
+      if (renderTexture) {
+        this.renderer.mask.setMaskStack(baseTexture.maskStack);
+      } else {
+        this.renderer.mask.setMaskStack(this.defaultMaskStack);
+      }
+      this.sourceFrame.copyFrom(sourceFrame);
+      this.destinationFrame.copyFrom(destinationFrame);
+    }
+    clear(clearColor, mask) {
+      const fallbackColor = this.current ? this.current.baseTexture.clear : this.renderer.background.backgroundColor;
+      const color = Color.shared.setValue(clearColor ? clearColor : fallbackColor);
+      if (this.current && this.current.baseTexture.alphaMode > 0 || !this.current && this._rendererPremultipliedAlpha) {
+        color.premultiply(color.alpha);
+      }
+      const destinationFrame = this.destinationFrame;
+      const baseFrame = this.current ? this.current.baseTexture : this.renderer._view.screen;
+      const clearMask = destinationFrame.width !== baseFrame.width || destinationFrame.height !== baseFrame.height;
+      if (clearMask) {
+        let { x, y, width, height } = this.viewportFrame;
+        x = Math.round(x);
+        y = Math.round(y);
+        width = Math.round(width);
+        height = Math.round(height);
+        this.renderer.gl.enable(this.renderer.gl.SCISSOR_TEST);
+        this.renderer.gl.scissor(x, y, width, height);
+      }
+      this.renderer.framebuffer.clear(color.red, color.green, color.blue, color.alpha, mask);
+      if (clearMask) {
+        this.renderer.scissor.pop();
+      }
+    }
+    resize() {
+      this.bind(null);
+    }
+    reset() {
+      this.bind(null);
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  RenderTextureSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "renderTexture"
+  };
+  extensions$1.add(RenderTextureSystem);
+
+  class IGLUniformData {
+  }
+  class GLProgram {
+    constructor(program, uniformData) {
+      this.program = program;
+      this.uniformData = uniformData;
+      this.uniformGroups = {};
+      this.uniformDirtyGroups = {};
+      this.uniformBufferBindings = {};
+    }
+    destroy() {
+      this.uniformData = null;
+      this.uniformGroups = null;
+      this.uniformDirtyGroups = null;
+      this.uniformBufferBindings = null;
+      this.program = null;
+    }
+  }
+
+  function getAttributeData(program, gl) {
+    const attributes = {};
+    const totalAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+    for (let i = 0; i < totalAttributes; i++) {
+      const attribData = gl.getActiveAttrib(program, i);
+      if (attribData.name.startsWith("gl_")) {
+        continue;
+      }
+      const type = mapType(gl, attribData.type);
+      const data = {
+        type,
+        name: attribData.name,
+        size: mapSize(type),
+        location: gl.getAttribLocation(program, attribData.name)
+      };
+      attributes[attribData.name] = data;
+    }
+    return attributes;
+  }
+
+  function getUniformData(program, gl) {
+    const uniforms = {};
+    const totalUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+    for (let i = 0; i < totalUniforms; i++) {
+      const uniformData = gl.getActiveUniform(program, i);
+      const name = uniformData.name.replace(/\[.*?\]$/, "");
+      const isArray = !!uniformData.name.match(/\[.*?\]$/);
+      const type = mapType(gl, uniformData.type);
+      uniforms[name] = {
+        name,
+        index: i,
+        type,
+        size: uniformData.size,
+        isArray,
+        value: defaultValue(type, uniformData.size)
+      };
+    }
+    return uniforms;
+  }
+
+  function generateProgram(gl, program) {
+    const glVertShader = compileShader(gl, gl.VERTEX_SHADER, program.vertexSrc);
+    const glFragShader = compileShader(gl, gl.FRAGMENT_SHADER, program.fragmentSrc);
+    const webGLProgram = gl.createProgram();
+    gl.attachShader(webGLProgram, glVertShader);
+    gl.attachShader(webGLProgram, glFragShader);
+    const transformFeedbackVaryings = program.extra?.transformFeedbackVaryings;
+    if (transformFeedbackVaryings) {
+      if (typeof gl.transformFeedbackVaryings !== "function") {
+        console.warn(`TransformFeedback is not supported but TransformFeedbackVaryings are given.`);
+      } else {
+        gl.transformFeedbackVaryings(webGLProgram, transformFeedbackVaryings.names, transformFeedbackVaryings.bufferMode === "separate" ? gl.SEPARATE_ATTRIBS : gl.INTERLEAVED_ATTRIBS);
+      }
+    }
+    gl.linkProgram(webGLProgram);
+    if (!gl.getProgramParameter(webGLProgram, gl.LINK_STATUS)) {
+      logProgramError(gl, webGLProgram, glVertShader, glFragShader);
+    }
+    program.attributeData = getAttributeData(webGLProgram, gl);
+    program.uniformData = getUniformData(webGLProgram, gl);
+    if (!/^[ \t]*#[ \t]*version[ \t]+300[ \t]+es[ \t]*$/m.test(program.vertexSrc)) {
+      const keys = Object.keys(program.attributeData);
+      keys.sort((a, b) => a > b ? 1 : -1);
+      for (let i = 0; i < keys.length; i++) {
+        program.attributeData[keys[i]].location = i;
+        gl.bindAttribLocation(webGLProgram, i, keys[i]);
+      }
+      gl.linkProgram(webGLProgram);
+    }
+    gl.deleteShader(glVertShader);
+    gl.deleteShader(glFragShader);
+    const uniformData = {};
+    for (const i in program.uniformData) {
+      const data = program.uniformData[i];
+      uniformData[i] = {
+        location: gl.getUniformLocation(webGLProgram, i),
+        value: defaultValue(data.type, data.size)
+      };
+    }
+    const glProgram = new GLProgram(webGLProgram, uniformData);
+    return glProgram;
+  }
+
+  function uboUpdate(_ud, _uv, _renderer, _syncData, buffer) {
+    _renderer.buffer.update(buffer);
+  }
+  const UBO_TO_SINGLE_SETTERS = {
+    float: `
+        data[offset] = v;
+    `,
+    vec2: `
+        data[offset] = v[0];
+        data[offset+1] = v[1];
+    `,
+    vec3: `
+        data[offset] = v[0];
+        data[offset+1] = v[1];
+        data[offset+2] = v[2];
+
+    `,
+    vec4: `
+        data[offset] = v[0];
+        data[offset+1] = v[1];
+        data[offset+2] = v[2];
+        data[offset+3] = v[3];
+    `,
+    mat2: `
+        data[offset] = v[0];
+        data[offset+1] = v[1];
+
+        data[offset+4] = v[2];
+        data[offset+5] = v[3];
+    `,
+    mat3: `
+        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];
+    `,
+    mat4: `
+        for(var i = 0; i < 16; i++)
+        {
+            data[offset + i] = v[i];
+        }
+    `
+  };
+  const GLSL_TO_STD40_SIZE = {
+    float: 4,
+    vec2: 8,
+    vec3: 12,
+    vec4: 16,
+    int: 4,
+    ivec2: 8,
+    ivec3: 12,
+    ivec4: 16,
+    uint: 4,
+    uvec2: 8,
+    uvec3: 12,
+    uvec4: 16,
+    bool: 4,
+    bvec2: 8,
+    bvec3: 12,
+    bvec4: 16,
+    mat2: 16 * 2,
+    mat3: 16 * 3,
+    mat4: 16 * 4
+  };
+  function createUBOElements(uniformData) {
+    const uboElements = uniformData.map((data) => ({
+      data,
+      offset: 0,
+      dataLen: 0,
+      dirty: 0
+    }));
+    let size = 0;
+    let chunkSize = 0;
+    let offset = 0;
+    for (let i = 0; i < uboElements.length; i++) {
+      const uboElement = uboElements[i];
+      size = GLSL_TO_STD40_SIZE[uboElement.data.type];
+      if (uboElement.data.size > 1) {
+        size = Math.max(size, 16) * uboElement.data.size;
+      }
+      uboElement.dataLen = size;
+      if (chunkSize % size !== 0 && chunkSize < 16) {
+        const lineUpValue = chunkSize % size % 16;
+        chunkSize += lineUpValue;
+        offset += lineUpValue;
+      }
+      if (chunkSize + size > 16) {
+        offset = Math.ceil(offset / 16) * 16;
+        uboElement.offset = offset;
+        offset += size;
+        chunkSize = size;
+      } else {
+        uboElement.offset = offset;
+        chunkSize += size;
+        offset += size;
+      }
+    }
+    offset = Math.ceil(offset / 16) * 16;
+    return { uboElements, size: offset };
+  }
+  function getUBOData(uniforms, uniformData) {
+    const usedUniformDatas = [];
+    for (const i in uniforms) {
+      if (uniformData[i]) {
+        usedUniformDatas.push(uniformData[i]);
+      }
+    }
+    usedUniformDatas.sort((a, b) => a.index - b.index);
+    return usedUniformDatas;
+  }
+  function generateUniformBufferSync(group, uniformData) {
+    if (!group.autoManage) {
+      return { size: 0, syncFunc: uboUpdate };
+    }
+    const usedUniformDatas = getUBOData(group.uniforms, uniformData);
+    const { uboElements, size } = createUBOElements(usedUniformDatas);
+    const funcFragments = [`
+    var v = null;
+    var v2 = null;
+    var cv = null;
+    var t = 0;
+    var gl = renderer.gl
+    var index = 0;
+    var data = buffer.data;
+    `];
+    for (let i = 0; i < uboElements.length; i++) {
+      const uboElement = uboElements[i];
+      const uniform = group.uniforms[uboElement.data.name];
+      const name = uboElement.data.name;
+      let parsed = false;
+      for (let j = 0; j < uniformParsers.length; j++) {
+        const uniformParser = uniformParsers[j];
+        if (uniformParser.codeUbo && uniformParser.test(uboElement.data, uniform)) {
+          funcFragments.push(`offset = ${uboElement.offset / 4};`, uniformParsers[j].codeUbo(uboElement.data.name, uniform));
+          parsed = true;
+          break;
+        }
+      }
+      if (!parsed) {
+        if (uboElement.data.size > 1) {
+          const size2 = mapSize(uboElement.data.type);
+          const rowSize = Math.max(GLSL_TO_STD40_SIZE[uboElement.data.type] / 16, 1);
+          const elementSize = size2 / rowSize;
+          const remainder = (4 - elementSize % 4) % 4;
+          funcFragments.push(`
+                cv = ud.${name}.value;
+                v = uv.${name};
+                offset = ${uboElement.offset / 4};
+
+                t = 0;
+
+                for(var i=0; i < ${uboElement.data.size * rowSize}; i++)
+                {
+                    for(var j = 0; j < ${elementSize}; j++)
+                    {
+                        data[offset++] = v[t++];
+                    }
+                    offset += ${remainder};
+                }
+
+                `);
+        } else {
+          const template = UBO_TO_SINGLE_SETTERS[uboElement.data.type];
+          funcFragments.push(`
+                cv = ud.${name}.value;
+                v = uv.${name};
+                offset = ${uboElement.offset / 4};
+                ${template};
+                `);
+        }
+      }
+    }
+    funcFragments.push(`
+       renderer.buffer.update(buffer);
+    `);
+    return {
+      size,
+      syncFunc: new Function("ud", "uv", "renderer", "syncData", "buffer", funcFragments.join("\n"))
+    };
+  }
+
+  let UID = 0;
+  const defaultSyncData = { textureCount: 0, uboCount: 0 };
+  class ShaderSystem {
+    constructor(renderer) {
+      this.destroyed = false;
+      this.renderer = renderer;
+      this.systemCheck();
+      this.gl = null;
+      this.shader = null;
+      this.program = null;
+      this.cache = {};
+      this._uboCache = {};
+      this.id = UID++;
+    }
+    systemCheck() {
+      if (!unsafeEvalSupported()) {
+        throw new Error("Current environment does not allow unsafe-eval, please use @pixi/unsafe-eval module to enable support.");
+      }
+    }
+    contextChange(gl) {
+      this.gl = gl;
+      this.reset();
+    }
+    bind(shader, dontSync) {
+      shader.disposeRunner.add(this);
+      shader.uniforms.globals = this.renderer.globalUniforms;
+      const program = shader.program;
+      const glProgram = program.glPrograms[this.renderer.CONTEXT_UID] || this.generateProgram(shader);
+      this.shader = shader;
+      if (this.program !== program) {
+        this.program = program;
+        this.gl.useProgram(glProgram.program);
+      }
+      if (!dontSync) {
+        defaultSyncData.textureCount = 0;
+        defaultSyncData.uboCount = 0;
+        this.syncUniformGroup(shader.uniformGroup, defaultSyncData);
+      }
+      return glProgram;
+    }
+    setUniforms(uniforms) {
+      const shader = this.shader.program;
+      const glProgram = shader.glPrograms[this.renderer.CONTEXT_UID];
+      shader.syncUniforms(glProgram.uniformData, uniforms, this.renderer);
+    }
+    syncUniformGroup(group, syncData) {
+      const glProgram = this.getGlProgram();
+      if (!group.static || group.dirtyId !== glProgram.uniformDirtyGroups[group.id]) {
+        glProgram.uniformDirtyGroups[group.id] = group.dirtyId;
+        this.syncUniforms(group, glProgram, syncData);
+      }
+    }
+    syncUniforms(group, glProgram, syncData) {
+      const syncFunc = group.syncUniforms[this.shader.program.id] || this.createSyncGroups(group);
+      syncFunc(glProgram.uniformData, group.uniforms, this.renderer, syncData);
+    }
+    createSyncGroups(group) {
+      const id = this.getSignature(group, this.shader.program.uniformData, "u");
+      if (!this.cache[id]) {
+        this.cache[id] = generateUniformsSync(group, this.shader.program.uniformData);
+      }
+      group.syncUniforms[this.shader.program.id] = this.cache[id];
+      return group.syncUniforms[this.shader.program.id];
+    }
+    syncUniformBufferGroup(group, name) {
+      const glProgram = this.getGlProgram();
+      if (!group.static || group.dirtyId !== 0 || !glProgram.uniformGroups[group.id]) {
+        group.dirtyId = 0;
+        const syncFunc = glProgram.uniformGroups[group.id] || this.createSyncBufferGroup(group, glProgram, name);
+        group.buffer.update();
+        syncFunc(glProgram.uniformData, group.uniforms, this.renderer, defaultSyncData, group.buffer);
+      }
+      this.renderer.buffer.bindBufferBase(group.buffer, glProgram.uniformBufferBindings[name]);
+    }
+    createSyncBufferGroup(group, glProgram, name) {
+      const { gl } = this.renderer;
+      this.renderer.buffer.bind(group.buffer);
+      const uniformBlockIndex = this.gl.getUniformBlockIndex(glProgram.program, name);
+      glProgram.uniformBufferBindings[name] = this.shader.uniformBindCount;
+      gl.uniformBlockBinding(glProgram.program, uniformBlockIndex, this.shader.uniformBindCount);
+      this.shader.uniformBindCount++;
+      const id = this.getSignature(group, this.shader.program.uniformData, "ubo");
+      let uboData = this._uboCache[id];
+      if (!uboData) {
+        uboData = this._uboCache[id] = generateUniformBufferSync(group, this.shader.program.uniformData);
+      }
+      if (group.autoManage) {
+        const data = new Float32Array(uboData.size / 4);
+        group.buffer.update(data);
+      }
+      glProgram.uniformGroups[group.id] = uboData.syncFunc;
+      return glProgram.uniformGroups[group.id];
+    }
+    getSignature(group, uniformData, preFix) {
+      const uniforms = group.uniforms;
+      const strings = [`${preFix}-`];
+      for (const i in uniforms) {
+        strings.push(i);
+        if (uniformData[i]) {
+          strings.push(uniformData[i].type);
+        }
+      }
+      return strings.join("-");
+    }
+    getGlProgram() {
+      if (this.shader) {
+        return this.shader.program.glPrograms[this.renderer.CONTEXT_UID];
+      }
+      return null;
+    }
+    generateProgram(shader) {
+      const gl = this.gl;
+      const program = shader.program;
+      const glProgram = generateProgram(gl, program);
+      program.glPrograms[this.renderer.CONTEXT_UID] = glProgram;
+      return glProgram;
+    }
+    reset() {
+      this.program = null;
+      this.shader = null;
+    }
+    disposeShader(shader) {
+      if (this.shader === shader) {
+        this.shader = null;
+      }
+    }
+    destroy() {
+      this.renderer = null;
+      this.destroyed = true;
+    }
+  }
+  ShaderSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "shader"
+  };
+  extensions$1.add(ShaderSystem);
+
+  class StartupSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    run(options) {
+      const { renderer } = this;
+      renderer.runners.init.emit(renderer.options);
+      if (options.hello) {
+        console.log(`PixiJS ${"7.2.4"} - ${renderer.rendererLogId} - https://pixijs.com`);
+      }
+      renderer.resize(renderer.screen.width, renderer.screen.height);
+    }
+    destroy() {
+    }
+  }
+  StartupSystem.defaultOptions = {
+    hello: false
+  };
+  StartupSystem.extension = {
+    type: [
+      ExtensionType.RendererSystem,
+      ExtensionType.CanvasRendererSystem
+    ],
+    name: "startup"
+  };
+  extensions$1.add(StartupSystem);
+
+  function mapWebGLBlendModesToPixi(gl, array = []) {
+    array[BLEND_MODES.NORMAL] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.ADD] = [gl.ONE, gl.ONE];
+    array[BLEND_MODES.MULTIPLY] = [gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.SCREEN] = [gl.ONE, gl.ONE_MINUS_SRC_COLOR, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.OVERLAY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.DARKEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.LIGHTEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.COLOR_DODGE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.COLOR_BURN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.HARD_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.SOFT_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.DIFFERENCE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.EXCLUSION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.HUE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.SATURATION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.COLOR] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.LUMINOSITY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.NONE] = [0, 0];
+    array[BLEND_MODES.NORMAL_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.ADD_NPM] = [gl.SRC_ALPHA, gl.ONE, gl.ONE, gl.ONE];
+    array[BLEND_MODES.SCREEN_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_COLOR, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.SRC_IN] = [gl.DST_ALPHA, gl.ZERO];
+    array[BLEND_MODES.SRC_OUT] = [gl.ONE_MINUS_DST_ALPHA, gl.ZERO];
+    array[BLEND_MODES.SRC_ATOP] = [gl.DST_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.DST_OVER] = [gl.ONE_MINUS_DST_ALPHA, gl.ONE];
+    array[BLEND_MODES.DST_IN] = [gl.ZERO, gl.SRC_ALPHA];
+    array[BLEND_MODES.DST_OUT] = [gl.ZERO, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.DST_ATOP] = [gl.ONE_MINUS_DST_ALPHA, gl.SRC_ALPHA];
+    array[BLEND_MODES.XOR] = [gl.ONE_MINUS_DST_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
+    array[BLEND_MODES.SUBTRACT] = [gl.ONE, gl.ONE, gl.ONE, gl.ONE, gl.FUNC_REVERSE_SUBTRACT, gl.FUNC_ADD];
+    return array;
+  }
+
+  const BLEND = 0;
+  const OFFSET = 1;
+  const CULLING = 2;
+  const DEPTH_TEST = 3;
+  const WINDING = 4;
+  const DEPTH_MASK = 5;
+  const _StateSystem = class {
+    constructor() {
+      this.gl = null;
+      this.stateId = 0;
+      this.polygonOffset = 0;
+      this.blendMode = BLEND_MODES.NONE;
+      this._blendEq = false;
+      this.map = [];
+      this.map[BLEND] = this.setBlend;
+      this.map[OFFSET] = this.setOffset;
+      this.map[CULLING] = this.setCullFace;
+      this.map[DEPTH_TEST] = this.setDepthTest;
+      this.map[WINDING] = this.setFrontFace;
+      this.map[DEPTH_MASK] = this.setDepthMask;
+      this.checks = [];
+      this.defaultState = new State();
+      this.defaultState.blend = true;
+    }
+    contextChange(gl) {
+      this.gl = gl;
+      this.blendModes = mapWebGLBlendModesToPixi(gl);
+      this.set(this.defaultState);
+      this.reset();
+    }
+    set(state) {
+      state = state || this.defaultState;
+      if (this.stateId !== state.data) {
+        let diff = this.stateId ^ state.data;
+        let i = 0;
+        while (diff) {
+          if (diff & 1) {
+            this.map[i].call(this, !!(state.data & 1 << i));
+          }
+          diff = diff >> 1;
+          i++;
+        }
+        this.stateId = state.data;
+      }
+      for (let i = 0; i < this.checks.length; i++) {
+        this.checks[i](this, state);
+      }
+    }
+    forceState(state) {
+      state = state || this.defaultState;
+      for (let i = 0; i < this.map.length; i++) {
+        this.map[i].call(this, !!(state.data & 1 << i));
+      }
+      for (let i = 0; i < this.checks.length; i++) {
+        this.checks[i](this, state);
+      }
+      this.stateId = state.data;
+    }
+    setBlend(value) {
+      this.updateCheck(_StateSystem.checkBlendMode, value);
+      this.gl[value ? "enable" : "disable"](this.gl.BLEND);
+    }
+    setOffset(value) {
+      this.updateCheck(_StateSystem.checkPolygonOffset, value);
+      this.gl[value ? "enable" : "disable"](this.gl.POLYGON_OFFSET_FILL);
+    }
+    setDepthTest(value) {
+      this.gl[value ? "enable" : "disable"](this.gl.DEPTH_TEST);
+    }
+    setDepthMask(value) {
+      this.gl.depthMask(value);
+    }
+    setCullFace(value) {
+      this.gl[value ? "enable" : "disable"](this.gl.CULL_FACE);
+    }
+    setFrontFace(value) {
+      this.gl.frontFace(this.gl[value ? "CW" : "CCW"]);
+    }
+    setBlendMode(value) {
+      if (value === this.blendMode) {
+        return;
+      }
+      this.blendMode = value;
+      const mode = this.blendModes[value];
+      const gl = this.gl;
+      if (mode.length === 2) {
+        gl.blendFunc(mode[0], mode[1]);
+      } else {
+        gl.blendFuncSeparate(mode[0], mode[1], mode[2], mode[3]);
+      }
+      if (mode.length === 6) {
+        this._blendEq = true;
+        gl.blendEquationSeparate(mode[4], mode[5]);
+      } else if (this._blendEq) {
+        this._blendEq = false;
+        gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD);
+      }
+    }
+    setPolygonOffset(value, scale) {
+      this.gl.polygonOffset(value, scale);
+    }
+    reset() {
+      this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, false);
+      this.forceState(this.defaultState);
+      this._blendEq = true;
+      this.blendMode = -1;
+      this.setBlendMode(0);
+    }
+    updateCheck(func, value) {
+      const index = this.checks.indexOf(func);
+      if (value && index === -1) {
+        this.checks.push(func);
+      } else if (!value && index !== -1) {
+        this.checks.splice(index, 1);
+      }
+    }
+    static checkBlendMode(system, state) {
+      system.setBlendMode(state.blendMode);
+    }
+    static checkPolygonOffset(system, state) {
+      system.setPolygonOffset(1, state.polygonOffset);
+    }
+    destroy() {
+      this.gl = null;
+    }
+  };
+  let StateSystem = _StateSystem;
+  StateSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "state"
+  };
+  extensions$1.add(StateSystem);
+
+  class SystemManager extends eventemitter3 {
+    constructor() {
+      super(...arguments);
+      this.runners = {};
+      this._systemsHash = {};
+    }
+    setup(config) {
+      this.addRunners(...config.runners);
+      const priority = (config.priority ?? []).filter((key) => config.systems[key]);
+      const orderByPriority = [
+        ...priority,
+        ...Object.keys(config.systems).filter((key) => !priority.includes(key))
+      ];
+      for (const i of orderByPriority) {
+        this.addSystem(config.systems[i], i);
+      }
+    }
+    addRunners(...runnerIds) {
+      runnerIds.forEach((runnerId) => {
+        this.runners[runnerId] = new Runner(runnerId);
+      });
+    }
+    addSystem(ClassRef, name) {
+      const system = new ClassRef(this);
+      if (this[name]) {
+        throw new Error(`Whoops! The name "${name}" is already in use`);
+      }
+      this[name] = system;
+      this._systemsHash[name] = system;
+      for (const i in this.runners) {
+        this.runners[i].add(system);
+      }
+      return this;
+    }
+    emitWithCustomOptions(runner, options) {
+      const systemHashKeys = Object.keys(this._systemsHash);
+      runner.items.forEach((system) => {
+        const systemName = systemHashKeys.find((systemId) => this._systemsHash[systemId] === system);
+        system[runner.name](options[systemName]);
+      });
+    }
+    destroy() {
+      Object.values(this.runners).forEach((runner) => {
+        runner.destroy();
+      });
+      this._systemsHash = {};
+    }
+  }
+
+  const _TextureGCSystem = class {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.count = 0;
+      this.checkCount = 0;
+      this.maxIdle = _TextureGCSystem.defaultMaxIdle;
+      this.checkCountMax = _TextureGCSystem.defaultCheckCountMax;
+      this.mode = _TextureGCSystem.defaultMode;
+    }
+    postrender() {
+      if (!this.renderer.objectRenderer.renderingToScreen) {
+        return;
+      }
+      this.count++;
+      if (this.mode === GC_MODES.MANUAL) {
+        return;
+      }
+      this.checkCount++;
+      if (this.checkCount > this.checkCountMax) {
+        this.checkCount = 0;
+        this.run();
+      }
+    }
+    run() {
+      const tm = this.renderer.texture;
+      const managedTextures = tm.managedTextures;
+      let wasRemoved = false;
+      for (let i = 0; i < managedTextures.length; i++) {
+        const texture = managedTextures[i];
+        if (!texture.framebuffer && this.count - texture.touched > this.maxIdle) {
+          tm.destroyTexture(texture, true);
+          managedTextures[i] = null;
+          wasRemoved = true;
+        }
+      }
+      if (wasRemoved) {
+        let j = 0;
+        for (let i = 0; i < managedTextures.length; i++) {
+          if (managedTextures[i] !== null) {
+            managedTextures[j++] = managedTextures[i];
+          }
+        }
+        managedTextures.length = j;
+      }
+    }
+    unload(displayObject) {
+      const tm = this.renderer.texture;
+      const texture = displayObject._texture;
+      if (texture && !texture.framebuffer) {
+        tm.destroyTexture(texture);
+      }
+      for (let i = displayObject.children.length - 1; i >= 0; i--) {
+        this.unload(displayObject.children[i]);
+      }
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  };
+  let TextureGCSystem = _TextureGCSystem;
+  TextureGCSystem.defaultMode = GC_MODES.AUTO;
+  TextureGCSystem.defaultMaxIdle = 60 * 60;
+  TextureGCSystem.defaultCheckCountMax = 60 * 10;
+  TextureGCSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "textureGC"
+  };
+  extensions$1.add(TextureGCSystem);
+
+  class GLTexture {
+    constructor(texture) {
+      this.texture = texture;
+      this.width = -1;
+      this.height = -1;
+      this.dirtyId = -1;
+      this.dirtyStyleId = -1;
+      this.mipmap = false;
+      this.wrapMode = 33071;
+      this.type = TYPES.UNSIGNED_BYTE;
+      this.internalFormat = FORMATS.RGBA;
+      this.samplerType = 0;
+    }
+  }
+
+  function mapTypeAndFormatToInternalFormat(gl) {
+    let table;
+    if ("WebGL2RenderingContext" in globalThis && gl instanceof globalThis.WebGL2RenderingContext) {
+      table = {
+        [TYPES.UNSIGNED_BYTE]: {
+          [FORMATS.RGBA]: gl.RGBA8,
+          [FORMATS.RGB]: gl.RGB8,
+          [FORMATS.RG]: gl.RG8,
+          [FORMATS.RED]: gl.R8,
+          [FORMATS.RGBA_INTEGER]: gl.RGBA8UI,
+          [FORMATS.RGB_INTEGER]: gl.RGB8UI,
+          [FORMATS.RG_INTEGER]: gl.RG8UI,
+          [FORMATS.RED_INTEGER]: gl.R8UI,
+          [FORMATS.ALPHA]: gl.ALPHA,
+          [FORMATS.LUMINANCE]: gl.LUMINANCE,
+          [FORMATS.LUMINANCE_ALPHA]: gl.LUMINANCE_ALPHA
+        },
+        [TYPES.BYTE]: {
+          [FORMATS.RGBA]: gl.RGBA8_SNORM,
+          [FORMATS.RGB]: gl.RGB8_SNORM,
+          [FORMATS.RG]: gl.RG8_SNORM,
+          [FORMATS.RED]: gl.R8_SNORM,
+          [FORMATS.RGBA_INTEGER]: gl.RGBA8I,
+          [FORMATS.RGB_INTEGER]: gl.RGB8I,
+          [FORMATS.RG_INTEGER]: gl.RG8I,
+          [FORMATS.RED_INTEGER]: gl.R8I
+        },
+        [TYPES.UNSIGNED_SHORT]: {
+          [FORMATS.RGBA_INTEGER]: gl.RGBA16UI,
+          [FORMATS.RGB_INTEGER]: gl.RGB16UI,
+          [FORMATS.RG_INTEGER]: gl.RG16UI,
+          [FORMATS.RED_INTEGER]: gl.R16UI,
+          [FORMATS.DEPTH_COMPONENT]: gl.DEPTH_COMPONENT16
+        },
+        [TYPES.SHORT]: {
+          [FORMATS.RGBA_INTEGER]: gl.RGBA16I,
+          [FORMATS.RGB_INTEGER]: gl.RGB16I,
+          [FORMATS.RG_INTEGER]: gl.RG16I,
+          [FORMATS.RED_INTEGER]: gl.R16I
+        },
+        [TYPES.UNSIGNED_INT]: {
+          [FORMATS.RGBA_INTEGER]: gl.RGBA32UI,
+          [FORMATS.RGB_INTEGER]: gl.RGB32UI,
+          [FORMATS.RG_INTEGER]: gl.RG32UI,
+          [FORMATS.RED_INTEGER]: gl.R32UI,
+          [FORMATS.DEPTH_COMPONENT]: gl.DEPTH_COMPONENT24
+        },
+        [TYPES.INT]: {
+          [FORMATS.RGBA_INTEGER]: gl.RGBA32I,
+          [FORMATS.RGB_INTEGER]: gl.RGB32I,
+          [FORMATS.RG_INTEGER]: gl.RG32I,
+          [FORMATS.RED_INTEGER]: gl.R32I
+        },
+        [TYPES.FLOAT]: {
+          [FORMATS.RGBA]: gl.RGBA32F,
+          [FORMATS.RGB]: gl.RGB32F,
+          [FORMATS.RG]: gl.RG32F,
+          [FORMATS.RED]: gl.R32F,
+          [FORMATS.DEPTH_COMPONENT]: gl.DEPTH_COMPONENT32F
+        },
+        [TYPES.HALF_FLOAT]: {
+          [FORMATS.RGBA]: gl.RGBA16F,
+          [FORMATS.RGB]: gl.RGB16F,
+          [FORMATS.RG]: gl.RG16F,
+          [FORMATS.RED]: gl.R16F
+        },
+        [TYPES.UNSIGNED_SHORT_5_6_5]: {
+          [FORMATS.RGB]: gl.RGB565
+        },
+        [TYPES.UNSIGNED_SHORT_4_4_4_4]: {
+          [FORMATS.RGBA]: gl.RGBA4
+        },
+        [TYPES.UNSIGNED_SHORT_5_5_5_1]: {
+          [FORMATS.RGBA]: gl.RGB5_A1
+        },
+        [TYPES.UNSIGNED_INT_2_10_10_10_REV]: {
+          [FORMATS.RGBA]: gl.RGB10_A2,
+          [FORMATS.RGBA_INTEGER]: gl.RGB10_A2UI
+        },
+        [TYPES.UNSIGNED_INT_10F_11F_11F_REV]: {
+          [FORMATS.RGB]: gl.R11F_G11F_B10F
+        },
+        [TYPES.UNSIGNED_INT_5_9_9_9_REV]: {
+          [FORMATS.RGB]: gl.RGB9_E5
+        },
+        [TYPES.UNSIGNED_INT_24_8]: {
+          [FORMATS.DEPTH_STENCIL]: gl.DEPTH24_STENCIL8
+        },
+        [TYPES.FLOAT_32_UNSIGNED_INT_24_8_REV]: {
+          [FORMATS.DEPTH_STENCIL]: gl.DEPTH32F_STENCIL8
+        }
+      };
+    } else {
+      table = {
+        [TYPES.UNSIGNED_BYTE]: {
+          [FORMATS.RGBA]: gl.RGBA,
+          [FORMATS.RGB]: gl.RGB,
+          [FORMATS.ALPHA]: gl.ALPHA,
+          [FORMATS.LUMINANCE]: gl.LUMINANCE,
+          [FORMATS.LUMINANCE_ALPHA]: gl.LUMINANCE_ALPHA
+        },
+        [TYPES.UNSIGNED_SHORT_5_6_5]: {
+          [FORMATS.RGB]: gl.RGB
+        },
+        [TYPES.UNSIGNED_SHORT_4_4_4_4]: {
+          [FORMATS.RGBA]: gl.RGBA
+        },
+        [TYPES.UNSIGNED_SHORT_5_5_5_1]: {
+          [FORMATS.RGBA]: gl.RGBA
+        }
+      };
+    }
+    return table;
+  }
+
+  class TextureSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.boundTextures = [];
+      this.currentLocation = -1;
+      this.managedTextures = [];
+      this._unknownBoundTextures = false;
+      this.unknownTexture = new BaseTexture();
+      this.hasIntegerTextures = false;
+    }
+    contextChange() {
+      const gl = this.gl = this.renderer.gl;
+      this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+      this.webGLVersion = this.renderer.context.webGLVersion;
+      this.internalFormats = mapTypeAndFormatToInternalFormat(gl);
+      const maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
+      this.boundTextures.length = maxTextures;
+      for (let i = 0; i < maxTextures; i++) {
+        this.boundTextures[i] = null;
+      }
+      this.emptyTextures = {};
+      const emptyTexture2D = new GLTexture(gl.createTexture());
+      gl.bindTexture(gl.TEXTURE_2D, emptyTexture2D.texture);
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4));
+      this.emptyTextures[gl.TEXTURE_2D] = emptyTexture2D;
+      this.emptyTextures[gl.TEXTURE_CUBE_MAP] = new GLTexture(gl.createTexture());
+      gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.emptyTextures[gl.TEXTURE_CUBE_MAP].texture);
+      for (let i = 0; i < 6; i++) {
+        gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+      }
+      gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+      for (let i = 0; i < this.boundTextures.length; i++) {
+        this.bind(null, i);
+      }
+    }
+    bind(texture, location = 0) {
+      const { gl } = this;
+      texture = texture?.castToBaseTexture();
+      if (texture?.valid && !texture.parentTextureArray) {
+        texture.touched = this.renderer.textureGC.count;
+        const glTexture = texture._glTextures[this.CONTEXT_UID] || this.initTexture(texture);
+        if (this.boundTextures[location] !== texture) {
+          if (this.currentLocation !== location) {
+            this.currentLocation = location;
+            gl.activeTexture(gl.TEXTURE0 + location);
+          }
+          gl.bindTexture(texture.target, glTexture.texture);
+        }
+        if (glTexture.dirtyId !== texture.dirtyId) {
+          if (this.currentLocation !== location) {
+            this.currentLocation = location;
+            gl.activeTexture(gl.TEXTURE0 + location);
+          }
+          this.updateTexture(texture);
+        } else if (glTexture.dirtyStyleId !== texture.dirtyStyleId) {
+          this.updateTextureStyle(texture);
+        }
+        this.boundTextures[location] = texture;
+      } else {
+        if (this.currentLocation !== location) {
+          this.currentLocation = location;
+          gl.activeTexture(gl.TEXTURE0 + location);
+        }
+        gl.bindTexture(gl.TEXTURE_2D, this.emptyTextures[gl.TEXTURE_2D].texture);
+        this.boundTextures[location] = null;
+      }
+    }
+    reset() {
+      this._unknownBoundTextures = true;
+      this.hasIntegerTextures = false;
+      this.currentLocation = -1;
+      for (let i = 0; i < this.boundTextures.length; i++) {
+        this.boundTextures[i] = this.unknownTexture;
+      }
+    }
+    unbind(texture) {
+      const { gl, boundTextures } = this;
+      if (this._unknownBoundTextures) {
+        this._unknownBoundTextures = false;
+        for (let i = 0; i < boundTextures.length; i++) {
+          if (boundTextures[i] === this.unknownTexture) {
+            this.bind(null, i);
+          }
+        }
+      }
+      for (let i = 0; i < boundTextures.length; i++) {
+        if (boundTextures[i] === texture) {
+          if (this.currentLocation !== i) {
+            gl.activeTexture(gl.TEXTURE0 + i);
+            this.currentLocation = i;
+          }
+          gl.bindTexture(texture.target, this.emptyTextures[texture.target].texture);
+          boundTextures[i] = null;
+        }
+      }
+    }
+    ensureSamplerType(maxTextures) {
+      const { boundTextures, hasIntegerTextures, CONTEXT_UID } = this;
+      if (!hasIntegerTextures) {
+        return;
+      }
+      for (let i = maxTextures - 1; i >= 0; --i) {
+        const tex = boundTextures[i];
+        if (tex) {
+          const glTexture = tex._glTextures[CONTEXT_UID];
+          if (glTexture.samplerType !== SAMPLER_TYPES.FLOAT) {
+            this.renderer.texture.unbind(tex);
+          }
+        }
+      }
+    }
+    initTexture(texture) {
+      const glTexture = new GLTexture(this.gl.createTexture());
+      glTexture.dirtyId = -1;
+      texture._glTextures[this.CONTEXT_UID] = glTexture;
+      this.managedTextures.push(texture);
+      texture.on("dispose", this.destroyTexture, this);
+      return glTexture;
+    }
+    initTextureType(texture, glTexture) {
+      glTexture.internalFormat = this.internalFormats[texture.type]?.[texture.format] ?? texture.format;
+      if (this.webGLVersion === 2 && texture.type === TYPES.HALF_FLOAT) {
+        glTexture.type = this.gl.HALF_FLOAT;
+      } else {
+        glTexture.type = texture.type;
+      }
+    }
+    updateTexture(texture) {
+      const glTexture = texture._glTextures[this.CONTEXT_UID];
+      if (!glTexture) {
+        return;
+      }
+      const renderer = this.renderer;
+      this.initTextureType(texture, glTexture);
+      if (texture.resource?.upload(renderer, texture, glTexture)) {
+        if (glTexture.samplerType !== SAMPLER_TYPES.FLOAT) {
+          this.hasIntegerTextures = true;
+        }
+      } else {
+        const width = texture.realWidth;
+        const height = texture.realHeight;
+        const gl = renderer.gl;
+        if (glTexture.width !== width || glTexture.height !== height || glTexture.dirtyId < 0) {
+          glTexture.width = width;
+          glTexture.height = height;
+          gl.texImage2D(texture.target, 0, glTexture.internalFormat, width, height, 0, texture.format, glTexture.type, null);
+        }
+      }
+      if (texture.dirtyStyleId !== glTexture.dirtyStyleId) {
+        this.updateTextureStyle(texture);
+      }
+      glTexture.dirtyId = texture.dirtyId;
+    }
+    destroyTexture(texture, skipRemove) {
+      const { gl } = this;
+      texture = texture.castToBaseTexture();
+      if (texture._glTextures[this.CONTEXT_UID]) {
+        this.unbind(texture);
+        gl.deleteTexture(texture._glTextures[this.CONTEXT_UID].texture);
+        texture.off("dispose", this.destroyTexture, this);
+        delete texture._glTextures[this.CONTEXT_UID];
+        if (!skipRemove) {
+          const i = this.managedTextures.indexOf(texture);
+          if (i !== -1) {
+            removeItems(this.managedTextures, i, 1);
+          }
+        }
+      }
+    }
+    updateTextureStyle(texture) {
+      const glTexture = texture._glTextures[this.CONTEXT_UID];
+      if (!glTexture) {
+        return;
+      }
+      if ((texture.mipmap === MIPMAP_MODES.POW2 || this.webGLVersion !== 2) && !texture.isPowerOfTwo) {
+        glTexture.mipmap = false;
+      } else {
+        glTexture.mipmap = texture.mipmap >= 1;
+      }
+      if (this.webGLVersion !== 2 && !texture.isPowerOfTwo) {
+        glTexture.wrapMode = WRAP_MODES.CLAMP;
+      } else {
+        glTexture.wrapMode = texture.wrapMode;
+      }
+      if (texture.resource?.style(this.renderer, texture, glTexture)) {
+      } else {
+        this.setStyle(texture, glTexture);
+      }
+      glTexture.dirtyStyleId = texture.dirtyStyleId;
+    }
+    setStyle(texture, glTexture) {
+      const gl = this.gl;
+      if (glTexture.mipmap && texture.mipmap !== MIPMAP_MODES.ON_MANUAL) {
+        gl.generateMipmap(texture.target);
+      }
+      gl.texParameteri(texture.target, gl.TEXTURE_WRAP_S, glTexture.wrapMode);
+      gl.texParameteri(texture.target, gl.TEXTURE_WRAP_T, glTexture.wrapMode);
+      if (glTexture.mipmap) {
+        gl.texParameteri(texture.target, gl.TEXTURE_MIN_FILTER, texture.scaleMode === SCALE_MODES.LINEAR ? gl.LINEAR_MIPMAP_LINEAR : gl.NEAREST_MIPMAP_NEAREST);
+        const anisotropicExt = this.renderer.context.extensions.anisotropicFiltering;
+        if (anisotropicExt && texture.anisotropicLevel > 0 && texture.scaleMode === SCALE_MODES.LINEAR) {
+          const level = Math.min(texture.anisotropicLevel, gl.getParameter(anisotropicExt.MAX_TEXTURE_MAX_ANISOTROPY_EXT));
+          gl.texParameterf(texture.target, anisotropicExt.TEXTURE_MAX_ANISOTROPY_EXT, level);
+        }
+      } else {
+        gl.texParameteri(texture.target, gl.TEXTURE_MIN_FILTER, texture.scaleMode === SCALE_MODES.LINEAR ? gl.LINEAR : gl.NEAREST);
+      }
+      gl.texParameteri(texture.target, gl.TEXTURE_MAG_FILTER, texture.scaleMode === SCALE_MODES.LINEAR ? gl.LINEAR : gl.NEAREST);
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  TextureSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "texture"
+  };
+  extensions$1.add(TextureSystem);
+
+  class TransformFeedbackSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    contextChange() {
+      this.gl = this.renderer.gl;
+      this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+    }
+    bind(transformFeedback) {
+      const { gl, CONTEXT_UID } = this;
+      const glTransformFeedback = transformFeedback._glTransformFeedbacks[CONTEXT_UID] || this.createGLTransformFeedback(transformFeedback);
+      gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, glTransformFeedback);
+    }
+    unbind() {
+      const { gl } = this;
+      gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+    }
+    beginTransformFeedback(drawMode, shader) {
+      const { gl, renderer } = this;
+      if (shader) {
+        renderer.shader.bind(shader);
+      }
+      gl.beginTransformFeedback(drawMode);
+    }
+    endTransformFeedback() {
+      const { gl } = this;
+      gl.endTransformFeedback();
+    }
+    createGLTransformFeedback(tf) {
+      const { gl, renderer, CONTEXT_UID } = this;
+      const glTransformFeedback = gl.createTransformFeedback();
+      tf._glTransformFeedbacks[CONTEXT_UID] = glTransformFeedback;
+      gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, glTransformFeedback);
+      for (let i = 0; i < tf.buffers.length; i++) {
+        const buffer = tf.buffers[i];
+        if (!buffer)
+          continue;
+        renderer.buffer.update(buffer);
+        buffer._glBuffers[CONTEXT_UID].refCount++;
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, i, buffer._glBuffers[CONTEXT_UID].buffer || null);
+      }
+      gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+      tf.disposeRunner.add(this);
+      return glTransformFeedback;
+    }
+    disposeTransformFeedback(tf, contextLost) {
+      const glTF = tf._glTransformFeedbacks[this.CONTEXT_UID];
+      const gl = this.gl;
+      tf.disposeRunner.remove(this);
+      const bufferSystem = this.renderer.buffer;
+      if (bufferSystem) {
+        for (let i = 0; i < tf.buffers.length; i++) {
+          const buffer = tf.buffers[i];
+          if (!buffer)
+            continue;
+          const buf = buffer._glBuffers[this.CONTEXT_UID];
+          if (buf) {
+            buf.refCount--;
+            if (buf.refCount === 0 && !contextLost) {
+              bufferSystem.dispose(buffer, contextLost);
+            }
+          }
+        }
+      }
+      if (!glTF) {
+        return;
+      }
+      if (!contextLost) {
+        gl.deleteTransformFeedback(glTF);
+      }
+      delete tf._glTransformFeedbacks[this.CONTEXT_UID];
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  TransformFeedbackSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "transformFeedback"
+  };
+  extensions$1.add(TransformFeedbackSystem);
+
+  class ViewSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    init(options) {
+      this.screen = new Rectangle(0, 0, options.width, options.height);
+      this.element = options.view || settings.ADAPTER.createCanvas();
+      this.resolution = options.resolution || settings.RESOLUTION;
+      this.autoDensity = !!options.autoDensity;
+    }
+    resizeView(desiredScreenWidth, desiredScreenHeight) {
+      this.element.width = Math.round(desiredScreenWidth * this.resolution);
+      this.element.height = Math.round(desiredScreenHeight * this.resolution);
+      const screenWidth = this.element.width / this.resolution;
+      const screenHeight = this.element.height / this.resolution;
+      this.screen.width = screenWidth;
+      this.screen.height = screenHeight;
+      if (this.autoDensity) {
+        this.element.style.width = `${screenWidth}px`;
+        this.element.style.height = `${screenHeight}px`;
+      }
+      this.renderer.emit("resize", screenWidth, screenHeight);
+      this.renderer.runners.resize.emit(this.screen.width, this.screen.height);
+    }
+    destroy(removeView) {
+      if (removeView) {
+        this.element.parentNode?.removeChild(this.element);
+      }
+      this.renderer = null;
+      this.element = null;
+      this.screen = null;
+    }
+  }
+  ViewSystem.defaultOptions = {
+    width: 800,
+    height: 600,
+    resolution: settings.RESOLUTION,
+    autoDensity: false
+  };
+  ViewSystem.extension = {
+    type: [
+      ExtensionType.RendererSystem,
+      ExtensionType.CanvasRendererSystem
+    ],
+    name: "_view"
+  };
+  extensions$1.add(ViewSystem);
+
+  settings.PREFER_ENV = ENV.WEBGL2;
+  settings.STRICT_TEXTURE_CACHE = false;
+  settings.RENDER_OPTIONS = {
+    ...ContextSystem.defaultOptions,
+    ...BackgroundSystem.defaultOptions,
+    ...ViewSystem.defaultOptions,
+    ...StartupSystem.defaultOptions
+  };
+  Object.defineProperties(settings, {
+    WRAP_MODE: {
+      get() {
+        return BaseTexture.defaultOptions.wrapMode;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.WRAP_MODE is deprecated, use BaseTexture.defaultOptions.wrapMode");
+        BaseTexture.defaultOptions.wrapMode = value;
+      }
+    },
+    SCALE_MODE: {
+      get() {
+        return BaseTexture.defaultOptions.scaleMode;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.SCALE_MODE is deprecated, use BaseTexture.defaultOptions.scaleMode");
+        BaseTexture.defaultOptions.scaleMode = value;
+      }
+    },
+    MIPMAP_TEXTURES: {
+      get() {
+        return BaseTexture.defaultOptions.mipmap;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.MIPMAP_TEXTURES is deprecated, use BaseTexture.defaultOptions.mipmap");
+        BaseTexture.defaultOptions.mipmap = value;
+      }
+    },
+    ANISOTROPIC_LEVEL: {
+      get() {
+        return BaseTexture.defaultOptions.anisotropicLevel;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.ANISOTROPIC_LEVEL is deprecated, use BaseTexture.defaultOptions.anisotropicLevel");
+        BaseTexture.defaultOptions.anisotropicLevel = value;
+      }
+    },
+    FILTER_RESOLUTION: {
+      get() {
+        deprecation$1("7.1.0", "settings.FILTER_RESOLUTION is deprecated, use Filter.defaultResolution");
+        return Filter.defaultResolution;
+      },
+      set(value) {
+        Filter.defaultResolution = value;
+      }
+    },
+    FILTER_MULTISAMPLE: {
+      get() {
+        deprecation$1("7.1.0", "settings.FILTER_MULTISAMPLE is deprecated, use Filter.defaultMultisample");
+        return Filter.defaultMultisample;
+      },
+      set(value) {
+        Filter.defaultMultisample = value;
+      }
+    },
+    SPRITE_MAX_TEXTURES: {
+      get() {
+        return BatchRenderer.defaultMaxTextures;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.SPRITE_MAX_TEXTURES is deprecated, use BatchRenderer.defaultMaxTextures");
+        BatchRenderer.defaultMaxTextures = value;
+      }
+    },
+    SPRITE_BATCH_SIZE: {
+      get() {
+        return BatchRenderer.defaultBatchSize;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.SPRITE_BATCH_SIZE is deprecated, use BatchRenderer.defaultBatchSize");
+        BatchRenderer.defaultBatchSize = value;
+      }
+    },
+    CAN_UPLOAD_SAME_BUFFER: {
+      get() {
+        return BatchRenderer.canUploadSameBuffer;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.CAN_UPLOAD_SAME_BUFFER is deprecated, use BatchRenderer.canUploadSameBuffer");
+        BatchRenderer.canUploadSameBuffer = value;
+      }
+    },
+    GC_MODE: {
+      get() {
+        return TextureGCSystem.defaultMode;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.GC_MODE is deprecated, use TextureGCSystem.defaultMode");
+        TextureGCSystem.defaultMode = value;
+      }
+    },
+    GC_MAX_IDLE: {
+      get() {
+        return TextureGCSystem.defaultMaxIdle;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.GC_MAX_IDLE is deprecated, use TextureGCSystem.defaultMaxIdle");
+        TextureGCSystem.defaultMaxIdle = value;
+      }
+    },
+    GC_MAX_CHECK_COUNT: {
+      get() {
+        return TextureGCSystem.defaultCheckCountMax;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.GC_MAX_CHECK_COUNT is deprecated, use TextureGCSystem.defaultCheckCountMax");
+        TextureGCSystem.defaultCheckCountMax = value;
+      }
+    },
+    PRECISION_VERTEX: {
+      get() {
+        return Program.defaultVertexPrecision;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.PRECISION_VERTEX is deprecated, use Program.defaultVertexPrecision");
+        Program.defaultVertexPrecision = value;
+      }
+    },
+    PRECISION_FRAGMENT: {
+      get() {
+        return Program.defaultFragmentPrecision;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.PRECISION_FRAGMENT is deprecated, use Program.defaultFragmentPrecision");
+        Program.defaultFragmentPrecision = value;
+      }
+    }
+  });
+
+  var UPDATE_PRIORITY = /* @__PURE__ */ ((UPDATE_PRIORITY2) => {
+    UPDATE_PRIORITY2[UPDATE_PRIORITY2["INTERACTION"] = 50] = "INTERACTION";
+    UPDATE_PRIORITY2[UPDATE_PRIORITY2["HIGH"] = 25] = "HIGH";
+    UPDATE_PRIORITY2[UPDATE_PRIORITY2["NORMAL"] = 0] = "NORMAL";
+    UPDATE_PRIORITY2[UPDATE_PRIORITY2["LOW"] = -25] = "LOW";
+    UPDATE_PRIORITY2[UPDATE_PRIORITY2["UTILITY"] = -50] = "UTILITY";
+    return UPDATE_PRIORITY2;
+  })(UPDATE_PRIORITY || {});
+
+  class TickerListener {
+    constructor(fn, context = null, priority = 0, once = false) {
+      this.next = null;
+      this.previous = null;
+      this._destroyed = false;
+      this.fn = fn;
+      this.context = context;
+      this.priority = priority;
+      this.once = once;
+    }
+    match(fn, context = null) {
+      return this.fn === fn && this.context === context;
+    }
+    emit(deltaTime) {
+      if (this.fn) {
+        if (this.context) {
+          this.fn.call(this.context, deltaTime);
+        } else {
+          this.fn(deltaTime);
+        }
+      }
+      const redirect = this.next;
+      if (this.once) {
+        this.destroy(true);
+      }
+      if (this._destroyed) {
+        this.next = null;
+      }
+      return redirect;
+    }
+    connect(previous) {
+      this.previous = previous;
+      if (previous.next) {
+        previous.next.previous = this;
+      }
+      this.next = previous.next;
+      previous.next = this;
+    }
+    destroy(hard = false) {
+      this._destroyed = true;
+      this.fn = null;
+      this.context = null;
+      if (this.previous) {
+        this.previous.next = this.next;
+      }
+      if (this.next) {
+        this.next.previous = this.previous;
+      }
+      const redirect = this.next;
+      this.next = hard ? null : redirect;
+      this.previous = null;
+      return redirect;
+    }
+  }
+
+  const _Ticker = class {
+    constructor() {
+      this.autoStart = false;
+      this.deltaTime = 1;
+      this.lastTime = -1;
+      this.speed = 1;
+      this.started = false;
+      this._requestId = null;
+      this._maxElapsedMS = 100;
+      this._minElapsedMS = 0;
+      this._protected = false;
+      this._lastFrame = -1;
+      this._head = new TickerListener(null, null, Infinity);
+      this.deltaMS = 1 / _Ticker.targetFPMS;
+      this.elapsedMS = 1 / _Ticker.targetFPMS;
+      this._tick = (time) => {
+        this._requestId = null;
+        if (this.started) {
+          this.update(time);
+          if (this.started && this._requestId === null && this._head.next) {
+            this._requestId = requestAnimationFrame(this._tick);
+          }
+        }
+      };
+    }
+    _requestIfNeeded() {
+      if (this._requestId === null && this._head.next) {
+        this.lastTime = performance.now();
+        this._lastFrame = this.lastTime;
+        this._requestId = requestAnimationFrame(this._tick);
+      }
+    }
+    _cancelIfNeeded() {
+      if (this._requestId !== null) {
+        cancelAnimationFrame(this._requestId);
+        this._requestId = null;
+      }
+    }
+    _startIfPossible() {
+      if (this.started) {
+        this._requestIfNeeded();
+      } else if (this.autoStart) {
+        this.start();
+      }
+    }
+    add(fn, context, priority = UPDATE_PRIORITY.NORMAL) {
+      return this._addListener(new TickerListener(fn, context, priority));
+    }
+    addOnce(fn, context, priority = UPDATE_PRIORITY.NORMAL) {
+      return this._addListener(new TickerListener(fn, context, priority, true));
+    }
+    _addListener(listener) {
+      let current = this._head.next;
+      let previous = this._head;
+      if (!current) {
+        listener.connect(previous);
+      } else {
+        while (current) {
+          if (listener.priority > current.priority) {
+            listener.connect(previous);
+            break;
+          }
+          previous = current;
+          current = current.next;
+        }
+        if (!listener.previous) {
+          listener.connect(previous);
+        }
+      }
+      this._startIfPossible();
+      return this;
+    }
+    remove(fn, context) {
+      let listener = this._head.next;
+      while (listener) {
+        if (listener.match(fn, context)) {
+          listener = listener.destroy();
+        } else {
+          listener = listener.next;
+        }
+      }
+      if (!this._head.next) {
+        this._cancelIfNeeded();
+      }
+      return this;
+    }
+    get count() {
+      if (!this._head) {
+        return 0;
+      }
+      let count = 0;
+      let current = this._head;
+      while (current = current.next) {
+        count++;
+      }
+      return count;
+    }
+    start() {
+      if (!this.started) {
+        this.started = true;
+        this._requestIfNeeded();
+      }
+    }
+    stop() {
+      if (this.started) {
+        this.started = false;
+        this._cancelIfNeeded();
+      }
+    }
+    destroy() {
+      if (!this._protected) {
+        this.stop();
+        let listener = this._head.next;
+        while (listener) {
+          listener = listener.destroy(true);
+        }
+        this._head.destroy();
+        this._head = null;
+      }
+    }
+    update(currentTime = performance.now()) {
+      let elapsedMS;
+      if (currentTime > this.lastTime) {
+        elapsedMS = this.elapsedMS = currentTime - this.lastTime;
+        if (elapsedMS > this._maxElapsedMS) {
+          elapsedMS = this._maxElapsedMS;
+        }
+        elapsedMS *= this.speed;
+        if (this._minElapsedMS) {
+          const delta = currentTime - this._lastFrame | 0;
+          if (delta < this._minElapsedMS) {
+            return;
+          }
+          this._lastFrame = currentTime - delta % this._minElapsedMS;
+        }
+        this.deltaMS = elapsedMS;
+        this.deltaTime = this.deltaMS * _Ticker.targetFPMS;
+        const head = this._head;
+        let listener = head.next;
+        while (listener) {
+          listener = listener.emit(this.deltaTime);
+        }
+        if (!head.next) {
+          this._cancelIfNeeded();
+        }
+      } else {
+        this.deltaTime = this.deltaMS = this.elapsedMS = 0;
+      }
+      this.lastTime = currentTime;
+    }
+    get FPS() {
+      return 1e3 / this.elapsedMS;
+    }
+    get minFPS() {
+      return 1e3 / this._maxElapsedMS;
+    }
+    set minFPS(fps) {
+      const minFPS = Math.min(this.maxFPS, fps);
+      const minFPMS = Math.min(Math.max(0, minFPS) / 1e3, _Ticker.targetFPMS);
+      this._maxElapsedMS = 1 / minFPMS;
+    }
+    get maxFPS() {
+      if (this._minElapsedMS) {
+        return Math.round(1e3 / this._minElapsedMS);
+      }
+      return 0;
+    }
+    set maxFPS(fps) {
+      if (fps === 0) {
+        this._minElapsedMS = 0;
+      } else {
+        const maxFPS = Math.max(this.minFPS, fps);
+        this._minElapsedMS = 1 / (maxFPS / 1e3);
+      }
+    }
+    static get shared() {
+      if (!_Ticker._shared) {
+        const shared = _Ticker._shared = new _Ticker();
+        shared.autoStart = true;
+        shared._protected = true;
+      }
+      return _Ticker._shared;
+    }
+    static get system() {
+      if (!_Ticker._system) {
+        const system = _Ticker._system = new _Ticker();
+        system.autoStart = true;
+        system._protected = true;
+      }
+      return _Ticker._system;
+    }
+  };
+  let Ticker = _Ticker;
+  Ticker.targetFPMS = 0.06;
+
+  Object.defineProperties(settings, {
+    TARGET_FPMS: {
+      get() {
+        return Ticker.targetFPMS;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.TARGET_FPMS is deprecated, use Ticker.targetFPMS");
+        Ticker.targetFPMS = value;
+      }
+    }
+  });
+
+  class TickerPlugin {
+    static init(options) {
+      options = Object.assign({
+        autoStart: true,
+        sharedTicker: false
+      }, options);
+      Object.defineProperty(this, "ticker", {
+        set(ticker) {
+          if (this._ticker) {
+            this._ticker.remove(this.render, this);
+          }
+          this._ticker = ticker;
+          if (ticker) {
+            ticker.add(this.render, this, UPDATE_PRIORITY.LOW);
+          }
+        },
+        get() {
+          return this._ticker;
+        }
+      });
+      this.stop = () => {
+        this._ticker.stop();
+      };
+      this.start = () => {
+        this._ticker.start();
+      };
+      this._ticker = null;
+      this.ticker = options.sharedTicker ? Ticker.shared : new Ticker();
+      if (options.autoStart) {
+        this.start();
+      }
+    }
+    static destroy() {
+      if (this._ticker) {
+        const oldTicker = this._ticker;
+        this.ticker = null;
+        oldTicker.destroy();
+      }
+    }
+  }
+  TickerPlugin.extension = ExtensionType.Application;
+  extensions$1.add(TickerPlugin);
+
+  const renderers = [];
+  extensions$1.handleByList(ExtensionType.Renderer, renderers);
+  function autoDetectRenderer(options) {
+    for (const RendererType of renderers) {
+      if (RendererType.test(options)) {
+        return new RendererType(options);
+      }
+    }
+    throw new Error("Unable to auto-detect a suitable renderer.");
+  }
+
+  var $defaultVertex = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n}";
+
+  var $defaultFilterVertex = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";
+
+  const defaultVertex = $defaultVertex;
+  const defaultFilterVertex = $defaultFilterVertex;
+
+  class MultisampleSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    contextChange(gl) {
+      let samples;
+      if (this.renderer.context.webGLVersion === 1) {
+        const framebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        samples = gl.getParameter(gl.SAMPLES);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+      } else {
+        const framebuffer = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+        samples = gl.getParameter(gl.SAMPLES);
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, framebuffer);
+      }
+      if (samples >= MSAA_QUALITY.HIGH) {
+        this.multisample = MSAA_QUALITY.HIGH;
+      } else if (samples >= MSAA_QUALITY.MEDIUM) {
+        this.multisample = MSAA_QUALITY.MEDIUM;
+      } else if (samples >= MSAA_QUALITY.LOW) {
+        this.multisample = MSAA_QUALITY.LOW;
+      } else {
+        this.multisample = MSAA_QUALITY.NONE;
+      }
+    }
+    destroy() {
+    }
+  }
+  MultisampleSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "_multisample"
+  };
+  extensions$1.add(MultisampleSystem);
+
+  class GLBuffer {
+    constructor(buffer) {
+      this.buffer = buffer || null;
+      this.updateID = -1;
+      this.byteLength = -1;
+      this.refCount = 0;
+    }
+  }
+
+  class BufferSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+      this.managedBuffers = {};
+      this.boundBufferBases = {};
+    }
+    destroy() {
+      this.renderer = null;
+    }
+    contextChange() {
+      this.disposeAll(true);
+      this.gl = this.renderer.gl;
+      this.CONTEXT_UID = this.renderer.CONTEXT_UID;
+    }
+    bind(buffer) {
+      const { gl, CONTEXT_UID } = this;
+      const glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
+      gl.bindBuffer(buffer.type, glBuffer.buffer);
+    }
+    unbind(type) {
+      const { gl } = this;
+      gl.bindBuffer(type, null);
+    }
+    bindBufferBase(buffer, index) {
+      const { gl, CONTEXT_UID } = this;
+      if (this.boundBufferBases[index] !== buffer) {
+        const glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
+        this.boundBufferBases[index] = buffer;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, index, glBuffer.buffer);
+      }
+    }
+    bindBufferRange(buffer, index, offset) {
+      const { gl, CONTEXT_UID } = this;
+      offset = offset || 0;
+      const glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
+      gl.bindBufferRange(gl.UNIFORM_BUFFER, index || 0, glBuffer.buffer, offset * 256, 256);
+    }
+    update(buffer) {
+      const { gl, CONTEXT_UID } = this;
+      const glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
+      if (buffer._updateID === glBuffer.updateID) {
+        return;
+      }
+      glBuffer.updateID = buffer._updateID;
+      gl.bindBuffer(buffer.type, glBuffer.buffer);
+      if (glBuffer.byteLength >= buffer.data.byteLength) {
+        gl.bufferSubData(buffer.type, 0, buffer.data);
+      } else {
+        const drawType = buffer.static ? gl.STATIC_DRAW : gl.DYNAMIC_DRAW;
+        glBuffer.byteLength = buffer.data.byteLength;
+        gl.bufferData(buffer.type, buffer.data, drawType);
+      }
+    }
+    dispose(buffer, contextLost) {
+      if (!this.managedBuffers[buffer.id]) {
+        return;
+      }
+      delete this.managedBuffers[buffer.id];
+      const glBuffer = buffer._glBuffers[this.CONTEXT_UID];
+      const gl = this.gl;
+      buffer.disposeRunner.remove(this);
+      if (!glBuffer) {
+        return;
+      }
+      if (!contextLost) {
+        gl.deleteBuffer(glBuffer.buffer);
+      }
+      delete buffer._glBuffers[this.CONTEXT_UID];
+    }
+    disposeAll(contextLost) {
+      const all = Object.keys(this.managedBuffers);
+      for (let i = 0; i < all.length; i++) {
+        this.dispose(this.managedBuffers[all[i]], contextLost);
+      }
+    }
+    createGLBuffer(buffer) {
+      const { CONTEXT_UID, gl } = this;
+      buffer._glBuffers[CONTEXT_UID] = new GLBuffer(gl.createBuffer());
+      this.managedBuffers[buffer.id] = buffer;
+      buffer.disposeRunner.add(this);
+      return buffer._glBuffers[CONTEXT_UID];
+    }
+  }
+  BufferSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "buffer"
+  };
+  extensions$1.add(BufferSystem);
+
+  class ObjectRendererSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    render(displayObject, options) {
+      const renderer = this.renderer;
+      let renderTexture;
+      let clear;
+      let transform;
+      let skipUpdateTransform;
+      if (options) {
+        renderTexture = options.renderTexture;
+        clear = options.clear;
+        transform = options.transform;
+        skipUpdateTransform = options.skipUpdateTransform;
+      }
+      this.renderingToScreen = !renderTexture;
+      renderer.runners.prerender.emit();
+      renderer.emit("prerender");
+      renderer.projection.transform = transform;
+      if (renderer.context.isLost) {
+        return;
+      }
+      if (!renderTexture) {
+        this.lastObjectRendered = displayObject;
+      }
+      if (!skipUpdateTransform) {
+        const cacheParent = displayObject.enableTempParent();
+        displayObject.updateTransform();
+        displayObject.disableTempParent(cacheParent);
+      }
+      renderer.renderTexture.bind(renderTexture);
+      renderer.batch.currentRenderer.start();
+      if (clear ?? renderer.background.clearBeforeRender) {
+        renderer.renderTexture.clear();
+      }
+      displayObject.render(renderer);
+      renderer.batch.currentRenderer.flush();
+      if (renderTexture) {
+        if (options.blit) {
+          renderer.framebuffer.blit();
+        }
+        renderTexture.baseTexture.update();
+      }
+      renderer.runners.postrender.emit();
+      renderer.projection.transform = null;
+      renderer.emit("postrender");
+    }
+    destroy() {
+      this.renderer = null;
+      this.lastObjectRendered = null;
+    }
+  }
+  ObjectRendererSystem.extension = {
+    type: ExtensionType.RendererSystem,
+    name: "objectRenderer"
+  };
+  extensions$1.add(ObjectRendererSystem);
+
+  const _Renderer = class extends SystemManager {
+    constructor(options) {
+      super();
+      this.type = RENDERER_TYPE.WEBGL;
+      options = Object.assign({}, settings.RENDER_OPTIONS, options);
+      this.gl = null;
+      this.CONTEXT_UID = 0;
+      this.globalUniforms = new UniformGroup({
+        projectionMatrix: new Matrix()
+      }, true);
+      const systemConfig = {
+        runners: [
+          "init",
+          "destroy",
+          "contextChange",
+          "resolutionChange",
+          "reset",
+          "update",
+          "postrender",
+          "prerender",
+          "resize"
+        ],
+        systems: _Renderer.__systems,
+        priority: [
+          "_view",
+          "textureGenerator",
+          "background",
+          "_plugin",
+          "startup",
+          "context",
+          "state",
+          "texture",
+          "buffer",
+          "geometry",
+          "framebuffer",
+          "transformFeedback",
+          "mask",
+          "scissor",
+          "stencil",
+          "projection",
+          "textureGC",
+          "filter",
+          "renderTexture",
+          "batch",
+          "objectRenderer",
+          "_multisample"
+        ]
+      };
+      this.setup(systemConfig);
+      if ("useContextAlpha" in options) {
+        deprecation$1("7.0.0", "options.useContextAlpha is deprecated, use options.premultipliedAlpha and options.backgroundAlpha instead");
+        options.premultipliedAlpha = options.useContextAlpha && options.useContextAlpha !== "notMultiplied";
+        options.backgroundAlpha = options.useContextAlpha === false ? 1 : options.backgroundAlpha;
+      }
+      this._plugin.rendererPlugins = _Renderer.__plugins;
+      this.options = options;
+      this.startup.run(this.options);
+    }
+    static test(options) {
+      if (options?.forceCanvas) {
+        return false;
+      }
+      return isWebGLSupported();
+    }
+    render(displayObject, options) {
+      this.objectRenderer.render(displayObject, options);
+    }
+    resize(desiredScreenWidth, desiredScreenHeight) {
+      this._view.resizeView(desiredScreenWidth, desiredScreenHeight);
+    }
+    reset() {
+      this.runners.reset.emit();
+      return this;
+    }
+    clear() {
+      this.renderTexture.bind();
+      this.renderTexture.clear();
+    }
+    destroy(removeView = false) {
+      this.runners.destroy.items.reverse();
+      this.emitWithCustomOptions(this.runners.destroy, {
+        _view: removeView
+      });
+      super.destroy();
+    }
+    get plugins() {
+      return this._plugin.plugins;
+    }
+    get multisample() {
+      return this._multisample.multisample;
+    }
+    get width() {
+      return this._view.element.width;
+    }
+    get height() {
+      return this._view.element.height;
+    }
+    get resolution() {
+      return this._view.resolution;
+    }
+    set resolution(value) {
+      this._view.resolution = value;
+      this.runners.resolutionChange.emit(value);
+    }
+    get autoDensity() {
+      return this._view.autoDensity;
+    }
+    get view() {
+      return this._view.element;
+    }
+    get screen() {
+      return this._view.screen;
+    }
+    get lastObjectRendered() {
+      return this.objectRenderer.lastObjectRendered;
+    }
+    get renderingToScreen() {
+      return this.objectRenderer.renderingToScreen;
+    }
+    get rendererLogId() {
+      return `WebGL ${this.context.webGLVersion}`;
+    }
+    get clearBeforeRender() {
+      deprecation$1("7.0.0", "renderer.clearBeforeRender has been deprecated, please use renderer.background.clearBeforeRender instead.");
+      return this.background.clearBeforeRender;
+    }
+    get useContextAlpha() {
+      deprecation$1("7.0.0", "renderer.useContextAlpha has been deprecated, please use renderer.context.premultipliedAlpha instead.");
+      return this.context.useContextAlpha;
+    }
+    get preserveDrawingBuffer() {
+      deprecation$1("7.0.0", "renderer.preserveDrawingBuffer has been deprecated, we cannot truly know this unless pixi created the context");
+      return this.context.preserveDrawingBuffer;
+    }
+    get backgroundColor() {
+      deprecation$1("7.0.0", "renderer.backgroundColor has been deprecated, use renderer.background.color instead.");
+      return this.background.color;
+    }
+    set backgroundColor(value) {
+      deprecation$1("7.0.0", "renderer.backgroundColor has been deprecated, use renderer.background.color instead.");
+      this.background.color = value;
+    }
+    get backgroundAlpha() {
+      deprecation$1("7.0.0", "renderer.backgroundAlpha has been deprecated, use renderer.background.alpha instead.");
+      return this.background.alpha;
+    }
+    set backgroundAlpha(value) {
+      deprecation$1("7.0.0", "renderer.backgroundAlpha has been deprecated, use renderer.background.alpha instead.");
+      this.background.alpha = value;
+    }
+    get powerPreference() {
+      deprecation$1("7.0.0", "renderer.powerPreference has been deprecated, we can only know this if pixi creates the context");
+      return this.context.powerPreference;
+    }
+    generateTexture(displayObject, options) {
+      return this.textureGenerator.generateTexture(displayObject, options);
+    }
+  };
+  let Renderer = _Renderer;
+  Renderer.extension = {
+    type: ExtensionType.Renderer,
+    priority: 1
+  };
+  Renderer.__plugins = {};
+  Renderer.__systems = {};
+  extensions$1.handleByMap(ExtensionType.RendererPlugin, Renderer.__plugins);
+  extensions$1.handleByMap(ExtensionType.RendererSystem, Renderer.__systems);
+  extensions$1.add(Renderer);
+
+  class AbstractMultiResource extends Resource {
+    constructor(length, options) {
+      const { width, height } = options || {};
+      super(width, height);
+      this.items = [];
+      this.itemDirtyIds = [];
+      for (let i = 0; i < length; i++) {
+        const partTexture = new BaseTexture();
+        this.items.push(partTexture);
+        this.itemDirtyIds.push(-2);
+      }
+      this.length = length;
+      this._load = null;
+      this.baseTexture = null;
+    }
+    initFromArray(resources, options) {
+      for (let i = 0; i < this.length; i++) {
+        if (!resources[i]) {
+          continue;
+        }
+        if (resources[i].castToBaseTexture) {
+          this.addBaseTextureAt(resources[i].castToBaseTexture(), i);
+        } else if (resources[i] instanceof Resource) {
+          this.addResourceAt(resources[i], i);
+        } else {
+          this.addResourceAt(autoDetectResource(resources[i], options), i);
+        }
+      }
+    }
+    dispose() {
+      for (let i = 0, len = this.length; i < len; i++) {
+        this.items[i].destroy();
+      }
+      this.items = null;
+      this.itemDirtyIds = null;
+      this._load = null;
+    }
+    addResourceAt(resource, index) {
+      if (!this.items[index]) {
+        throw new Error(`Index ${index} is out of bounds`);
+      }
+      if (resource.valid && !this.valid) {
+        this.resize(resource.width, resource.height);
+      }
+      this.items[index].setResource(resource);
+      return this;
+    }
+    bind(baseTexture) {
+      if (this.baseTexture !== null) {
+        throw new Error("Only one base texture per TextureArray is allowed");
+      }
+      super.bind(baseTexture);
+      for (let i = 0; i < this.length; i++) {
+        this.items[i].parentTextureArray = baseTexture;
+        this.items[i].on("update", baseTexture.update, baseTexture);
+      }
+    }
+    unbind(baseTexture) {
+      super.unbind(baseTexture);
+      for (let i = 0; i < this.length; i++) {
+        this.items[i].parentTextureArray = null;
+        this.items[i].off("update", baseTexture.update, baseTexture);
+      }
+    }
+    load() {
+      if (this._load) {
+        return this._load;
+      }
+      const resources = this.items.map((item) => item.resource).filter((item) => item);
+      const promises = resources.map((item) => item.load());
+      this._load = Promise.all(promises).then(() => {
+        const { realWidth, realHeight } = this.items[0];
+        this.resize(realWidth, realHeight);
+        return Promise.resolve(this);
+      });
+      return this._load;
+    }
+  }
+
+  class ArrayResource extends AbstractMultiResource {
+    constructor(source, options) {
+      const { width, height } = options || {};
+      let urls;
+      let length;
+      if (Array.isArray(source)) {
+        urls = source;
+        length = source.length;
+      } else {
+        length = source;
+      }
+      super(length, { width, height });
+      if (urls) {
+        this.initFromArray(urls, options);
+      }
+    }
+    addBaseTextureAt(baseTexture, index) {
+      if (baseTexture.resource) {
+        this.addResourceAt(baseTexture.resource, index);
+      } else {
+        throw new Error("ArrayResource does not support RenderTexture");
+      }
+      return this;
+    }
+    bind(baseTexture) {
+      super.bind(baseTexture);
+      baseTexture.target = TARGETS.TEXTURE_2D_ARRAY;
+    }
+    upload(renderer, texture, glTexture) {
+      const { length, itemDirtyIds, items } = this;
+      const { gl } = renderer;
+      if (glTexture.dirtyId < 0) {
+        gl.texImage3D(gl.TEXTURE_2D_ARRAY, 0, glTexture.internalFormat, this._width, this._height, length, 0, texture.format, glTexture.type, null);
+      }
+      for (let i = 0; i < length; i++) {
+        const item = items[i];
+        if (itemDirtyIds[i] < item.dirtyId) {
+          itemDirtyIds[i] = item.dirtyId;
+          if (item.valid) {
+            gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, 0, 0, 0, i, item.resource.width, item.resource.height, 1, texture.format, glTexture.type, item.resource.source);
+          }
+        }
+      }
+      return true;
+    }
+  }
+
+  class CanvasResource extends BaseImageResource {
+    constructor(source) {
+      super(source);
+    }
+    static test(source) {
+      const { OffscreenCanvas } = globalThis;
+      if (OffscreenCanvas && source instanceof OffscreenCanvas) {
+        return true;
+      }
+      return globalThis.HTMLCanvasElement && source instanceof HTMLCanvasElement;
+    }
+  }
+
+  const _CubeResource = class extends AbstractMultiResource {
+    constructor(source, options) {
+      const { width, height, autoLoad, linkBaseTexture } = options || {};
+      if (source && source.length !== _CubeResource.SIDES) {
+        throw new Error(`Invalid length. Got ${source.length}, expected 6`);
+      }
+      super(6, { width, height });
+      for (let i = 0; i < _CubeResource.SIDES; i++) {
+        this.items[i].target = TARGETS.TEXTURE_CUBE_MAP_POSITIVE_X + i;
+      }
+      this.linkBaseTexture = linkBaseTexture !== false;
+      if (source) {
+        this.initFromArray(source, options);
+      }
+      if (autoLoad !== false) {
+        this.load();
+      }
+    }
+    bind(baseTexture) {
+      super.bind(baseTexture);
+      baseTexture.target = TARGETS.TEXTURE_CUBE_MAP;
+    }
+    addBaseTextureAt(baseTexture, index, linkBaseTexture) {
+      if (linkBaseTexture === void 0) {
+        linkBaseTexture = this.linkBaseTexture;
+      }
+      if (!this.items[index]) {
+        throw new Error(`Index ${index} is out of bounds`);
+      }
+      if (!this.linkBaseTexture || baseTexture.parentTextureArray || Object.keys(baseTexture._glTextures).length > 0) {
+        if (baseTexture.resource) {
+          this.addResourceAt(baseTexture.resource, index);
+        } else {
+          throw new Error(`CubeResource does not support copying of renderTexture.`);
+        }
+      } else {
+        baseTexture.target = TARGETS.TEXTURE_CUBE_MAP_POSITIVE_X + index;
+        baseTexture.parentTextureArray = this.baseTexture;
+        this.items[index] = baseTexture;
+      }
+      if (baseTexture.valid && !this.valid) {
+        this.resize(baseTexture.realWidth, baseTexture.realHeight);
+      }
+      this.items[index] = baseTexture;
+      return this;
+    }
+    upload(renderer, _baseTexture, glTexture) {
+      const dirty = this.itemDirtyIds;
+      for (let i = 0; i < _CubeResource.SIDES; i++) {
+        const side = this.items[i];
+        if (dirty[i] < side.dirtyId || glTexture.dirtyId < _baseTexture.dirtyId) {
+          if (side.valid && side.resource) {
+            side.resource.upload(renderer, side, glTexture);
+            dirty[i] = side.dirtyId;
+          } else if (dirty[i] < -1) {
+            renderer.gl.texImage2D(side.target, 0, glTexture.internalFormat, _baseTexture.realWidth, _baseTexture.realHeight, 0, _baseTexture.format, glTexture.type, null);
+            dirty[i] = -1;
+          }
+        }
+      }
+      return true;
+    }
+    static test(source) {
+      return Array.isArray(source) && source.length === _CubeResource.SIDES;
+    }
+  };
+  let CubeResource = _CubeResource;
+  CubeResource.SIDES = 6;
+
+  class ImageBitmapResource extends BaseImageResource {
+    constructor(source, options) {
+      options = options || {};
+      let baseSource;
+      let url;
+      if (typeof source === "string") {
+        baseSource = ImageBitmapResource.EMPTY;
+        url = source;
+      } else {
+        baseSource = source;
+        url = null;
+      }
+      super(baseSource);
+      this.url = url;
+      this.crossOrigin = options.crossOrigin ?? true;
+      this.alphaMode = typeof options.alphaMode === "number" ? options.alphaMode : null;
+      this._load = null;
+      if (options.autoLoad !== false) {
+        this.load();
+      }
+    }
+    load() {
+      if (this._load) {
+        return this._load;
+      }
+      this._load = new Promise(async (resolve, reject) => {
+        if (this.url === null) {
+          resolve(this);
+          return;
+        }
+        try {
+          const response = await settings.ADAPTER.fetch(this.url, {
+            mode: this.crossOrigin ? "cors" : "no-cors"
+          });
+          if (this.destroyed)
+            return;
+          const imageBlob = await response.blob();
+          if (this.destroyed)
+            return;
+          const imageBitmap = await createImageBitmap(imageBlob, {
+            premultiplyAlpha: this.alphaMode === null || this.alphaMode === ALPHA_MODES.UNPACK ? "premultiply" : "none"
+          });
+          if (this.destroyed)
+            return;
+          this.source = imageBitmap;
+          this.update();
+          resolve(this);
+        } catch (e) {
+          if (this.destroyed)
+            return;
+          reject(e);
+          this.onError.emit(e);
+        }
+      });
+      return this._load;
+    }
+    upload(renderer, baseTexture, glTexture) {
+      if (!(this.source instanceof ImageBitmap)) {
+        this.load();
+        return false;
+      }
+      if (typeof this.alphaMode === "number") {
+        baseTexture.alphaMode = this.alphaMode;
+      }
+      return super.upload(renderer, baseTexture, glTexture);
+    }
+    dispose() {
+      if (this.source instanceof ImageBitmap) {
+        this.source.close();
+      }
+      super.dispose();
+      this._load = null;
+    }
+    static test(source) {
+      return !!globalThis.createImageBitmap && typeof ImageBitmap !== "undefined" && (typeof source === "string" || source instanceof ImageBitmap);
+    }
+    static get EMPTY() {
+      ImageBitmapResource._EMPTY = ImageBitmapResource._EMPTY ?? settings.ADAPTER.createCanvas(0, 0);
+      return ImageBitmapResource._EMPTY;
+    }
+  }
+
+  const _SVGResource = class extends BaseImageResource {
+    constructor(sourceBase64, options) {
+      options = options || {};
+      super(settings.ADAPTER.createCanvas());
+      this._width = 0;
+      this._height = 0;
+      this.svg = sourceBase64;
+      this.scale = options.scale || 1;
+      this._overrideWidth = options.width;
+      this._overrideHeight = options.height;
+      this._resolve = null;
+      this._crossorigin = options.crossorigin;
+      this._load = null;
+      if (options.autoLoad !== false) {
+        this.load();
+      }
+    }
+    load() {
+      if (this._load) {
+        return this._load;
+      }
+      this._load = new Promise((resolve) => {
+        this._resolve = () => {
+          this.resize(this.source.width, this.source.height);
+          resolve(this);
+        };
+        if (_SVGResource.SVG_XML.test(this.svg.trim())) {
+          if (!btoa) {
+            throw new Error("Your browser doesn't support base64 conversions.");
+          }
+          this.svg = `data:image/svg+xml;base64,${btoa(unescape(encodeURIComponent(this.svg)))}`;
+        }
+        this._loadSvg();
+      });
+      return this._load;
+    }
+    _loadSvg() {
+      const tempImage = new Image();
+      BaseImageResource.crossOrigin(tempImage, this.svg, this._crossorigin);
+      tempImage.src = this.svg;
+      tempImage.onerror = (event) => {
+        if (!this._resolve) {
+          return;
+        }
+        tempImage.onerror = null;
+        this.onError.emit(event);
+      };
+      tempImage.onload = () => {
+        if (!this._resolve) {
+          return;
+        }
+        const svgWidth = tempImage.width;
+        const svgHeight = tempImage.height;
+        if (!svgWidth || !svgHeight) {
+          throw new Error("The SVG image must have width and height defined (in pixels), canvas API needs them.");
+        }
+        let width = svgWidth * this.scale;
+        let height = svgHeight * this.scale;
+        if (this._overrideWidth || this._overrideHeight) {
+          width = this._overrideWidth || this._overrideHeight / svgHeight * svgWidth;
+          height = this._overrideHeight || this._overrideWidth / svgWidth * svgHeight;
+        }
+        width = Math.round(width);
+        height = Math.round(height);
+        const canvas = this.source;
+        canvas.width = width;
+        canvas.height = height;
+        canvas._pixiId = `canvas_${uid()}`;
+        canvas.getContext("2d").drawImage(tempImage, 0, 0, svgWidth, svgHeight, 0, 0, width, height);
+        this._resolve();
+        this._resolve = null;
+      };
+    }
+    static getSize(svgString) {
+      const sizeMatch = _SVGResource.SVG_SIZE.exec(svgString);
+      const size = {};
+      if (sizeMatch) {
+        size[sizeMatch[1]] = Math.round(parseFloat(sizeMatch[3]));
+        size[sizeMatch[5]] = Math.round(parseFloat(sizeMatch[7]));
+      }
+      return size;
+    }
+    dispose() {
+      super.dispose();
+      this._resolve = null;
+      this._crossorigin = null;
+    }
+    static test(source, extension) {
+      return extension === "svg" || typeof source === "string" && source.startsWith("data:image/svg+xml") || typeof source === "string" && _SVGResource.SVG_XML.test(source);
+    }
+  };
+  let SVGResource = _SVGResource;
+  SVGResource.SVG_XML = /^(<\?xml[^?]+\?>)?\s*(<!--[^(-->)]*-->)?\s*\<svg/m;
+  SVGResource.SVG_SIZE = /<svg[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*>/i;
+
+  const _VideoResource = class extends BaseImageResource {
+    constructor(source, options) {
+      options = options || {};
+      if (!(source instanceof HTMLVideoElement)) {
+        const videoElement = document.createElement("video");
+        videoElement.setAttribute("preload", "auto");
+        videoElement.setAttribute("webkit-playsinline", "");
+        videoElement.setAttribute("playsinline", "");
+        if (typeof source === "string") {
+          source = [source];
+        }
+        const firstSrc = source[0].src || source[0];
+        BaseImageResource.crossOrigin(videoElement, firstSrc, options.crossorigin);
+        for (let i = 0; i < source.length; ++i) {
+          const sourceElement = document.createElement("source");
+          let { src, mime } = source[i];
+          src = src || source[i];
+          const baseSrc = src.split("?").shift().toLowerCase();
+          const ext = baseSrc.slice(baseSrc.lastIndexOf(".") + 1);
+          mime = mime || _VideoResource.MIME_TYPES[ext] || `video/${ext}`;
+          sourceElement.src = src;
+          sourceElement.type = mime;
+          videoElement.appendChild(sourceElement);
+        }
+        source = videoElement;
+      }
+      super(source);
+      this.noSubImage = true;
+      this._autoUpdate = true;
+      this._isConnectedToTicker = false;
+      this._updateFPS = options.updateFPS || 0;
+      this._msToNextUpdate = 0;
+      this.autoPlay = options.autoPlay !== false;
+      this._load = null;
+      this._resolve = null;
+      this._onCanPlay = this._onCanPlay.bind(this);
+      this._onError = this._onError.bind(this);
+      if (options.autoLoad !== false) {
+        this.load();
+      }
+    }
+    update(_deltaTime = 0) {
+      if (!this.destroyed) {
+        const elapsedMS = Ticker.shared.elapsedMS * this.source.playbackRate;
+        this._msToNextUpdate = Math.floor(this._msToNextUpdate - elapsedMS);
+        if (!this._updateFPS || this._msToNextUpdate <= 0) {
+          super.update();
+          this._msToNextUpdate = this._updateFPS ? Math.floor(1e3 / this._updateFPS) : 0;
+        }
+      }
+    }
+    load() {
+      if (this._load) {
+        return this._load;
+      }
+      const source = this.source;
+      if ((source.readyState === source.HAVE_ENOUGH_DATA || source.readyState === source.HAVE_FUTURE_DATA) && source.width && source.height) {
+        source.complete = true;
+      }
+      source.addEventListener("play", this._onPlayStart.bind(this));
+      source.addEventListener("pause", this._onPlayStop.bind(this));
+      if (!this._isSourceReady()) {
+        source.addEventListener("canplay", this._onCanPlay);
+        source.addEventListener("canplaythrough", this._onCanPlay);
+        source.addEventListener("error", this._onError, true);
+      } else {
+        this._onCanPlay();
+      }
+      this._load = new Promise((resolve) => {
+        if (this.valid) {
+          resolve(this);
+        } else {
+          this._resolve = resolve;
+          source.load();
+        }
+      });
+      return this._load;
+    }
+    _onError(event) {
+      this.source.removeEventListener("error", this._onError, true);
+      this.onError.emit(event);
+    }
+    _isSourcePlaying() {
+      const source = this.source;
+      return !source.paused && !source.ended && this._isSourceReady();
+    }
+    _isSourceReady() {
+      const source = this.source;
+      return source.readyState > 2;
+    }
+    _onPlayStart() {
+      if (!this.valid) {
+        this._onCanPlay();
+      }
+      if (this.autoUpdate && !this._isConnectedToTicker) {
+        Ticker.shared.add(this.update, this);
+        this._isConnectedToTicker = true;
+      }
+    }
+    _onPlayStop() {
+      if (this._isConnectedToTicker) {
+        Ticker.shared.remove(this.update, this);
+        this._isConnectedToTicker = false;
+      }
+    }
+    _onCanPlay() {
+      const source = this.source;
+      source.removeEventListener("canplay", this._onCanPlay);
+      source.removeEventListener("canplaythrough", this._onCanPlay);
+      const valid = this.valid;
+      this.resize(source.videoWidth, source.videoHeight);
+      if (!valid && this._resolve) {
+        this._resolve(this);
+        this._resolve = null;
+      }
+      if (this._isSourcePlaying()) {
+        this._onPlayStart();
+      } else if (this.autoPlay) {
+        source.play();
+      }
+    }
+    dispose() {
+      if (this._isConnectedToTicker) {
+        Ticker.shared.remove(this.update, this);
+        this._isConnectedToTicker = false;
+      }
+      const source = this.source;
+      if (source) {
+        source.removeEventListener("error", this._onError, true);
+        source.pause();
+        source.src = "";
+        source.load();
+      }
+      super.dispose();
+    }
+    get autoUpdate() {
+      return this._autoUpdate;
+    }
+    set autoUpdate(value) {
+      if (value !== this._autoUpdate) {
+        this._autoUpdate = value;
+        if (!this._autoUpdate && this._isConnectedToTicker) {
+          Ticker.shared.remove(this.update, this);
+          this._isConnectedToTicker = false;
+        } else if (this._autoUpdate && !this._isConnectedToTicker && this._isSourcePlaying()) {
+          Ticker.shared.add(this.update, this);
+          this._isConnectedToTicker = true;
+        }
+      }
+    }
+    get updateFPS() {
+      return this._updateFPS;
+    }
+    set updateFPS(value) {
+      if (value !== this._updateFPS) {
+        this._updateFPS = value;
+      }
+    }
+    static test(source, extension) {
+      return globalThis.HTMLVideoElement && source instanceof HTMLVideoElement || _VideoResource.TYPES.includes(extension);
+    }
+  };
+  let VideoResource = _VideoResource;
+  VideoResource.TYPES = ["mp4", "m4v", "webm", "ogg", "ogv", "h264", "avi", "mov"];
+  VideoResource.MIME_TYPES = {
+    ogv: "video/ogg",
+    mov: "video/quicktime",
+    m4v: "video/mp4"
+  };
+
+  INSTALLED.push(ImageBitmapResource, ImageResource, CanvasResource, VideoResource, SVGResource, BufferResource, CubeResource, ArrayResource);
+
+  class TransformFeedback {
+    constructor() {
+      this._glTransformFeedbacks = {};
+      this.buffers = [];
+      this.disposeRunner = new Runner("disposeTransformFeedback");
+    }
+    bindBuffer(index, buffer) {
+      this.buffers[index] = buffer;
+    }
+    destroy() {
+      this.disposeRunner.emit(this, false);
+    }
+  }
+
+  const VERSION = "7.2.4";
+
+  BaseTexture.prototype.getDrawableSource = function getDrawableSource() {
+    const resource = this.resource;
+    return resource ? resource.bitmap || resource.source : null;
+  };
+  BaseRenderTexture.prototype._canvasRenderTarget = null;
+  Texture.prototype.patternCache = null;
+  Texture.prototype.tintCache = null;
+
+  let canUseNewCanvasBlendModesValue;
+  function createColoredCanvas(color) {
+    const canvas = settings.ADAPTER.createCanvas(6, 1);
+    const context = canvas.getContext("2d");
+    context.fillStyle = color;
+    context.fillRect(0, 0, 6, 1);
+    return canvas;
+  }
+  function canUseNewCanvasBlendModes() {
+    if (typeof document === "undefined") {
+      return false;
+    }
+    if (canUseNewCanvasBlendModesValue !== void 0) {
+      return canUseNewCanvasBlendModesValue;
+    }
+    const magenta = createColoredCanvas("#ff00ff");
+    const yellow = createColoredCanvas("#ffff00");
+    const canvas = settings.ADAPTER.createCanvas(6, 1);
+    const context = canvas.getContext("2d");
+    context.globalCompositeOperation = "multiply";
+    context.drawImage(magenta, 0, 0);
+    context.drawImage(yellow, 2, 0);
+    const imageData = context.getImageData(2, 0, 1, 1);
+    if (!imageData) {
+      canUseNewCanvasBlendModesValue = false;
+    } else {
+      const data = imageData.data;
+      canUseNewCanvasBlendModesValue = data[0] === 255 && data[1] === 0 && data[2] === 0;
+    }
+    return canUseNewCanvasBlendModesValue;
+  }
+
+  function mapCanvasBlendModesToPixi(array = []) {
+    if (canUseNewCanvasBlendModes()) {
+      array[BLEND_MODES.NORMAL] = "source-over";
+      array[BLEND_MODES.ADD] = "lighter";
+      array[BLEND_MODES.MULTIPLY] = "multiply";
+      array[BLEND_MODES.SCREEN] = "screen";
+      array[BLEND_MODES.OVERLAY] = "overlay";
+      array[BLEND_MODES.DARKEN] = "darken";
+      array[BLEND_MODES.LIGHTEN] = "lighten";
+      array[BLEND_MODES.COLOR_DODGE] = "color-dodge";
+      array[BLEND_MODES.COLOR_BURN] = "color-burn";
+      array[BLEND_MODES.HARD_LIGHT] = "hard-light";
+      array[BLEND_MODES.SOFT_LIGHT] = "soft-light";
+      array[BLEND_MODES.DIFFERENCE] = "difference";
+      array[BLEND_MODES.EXCLUSION] = "exclusion";
+      array[BLEND_MODES.HUE] = "hue";
+      array[BLEND_MODES.SATURATION] = "saturation";
+      array[BLEND_MODES.COLOR] = "color";
+      array[BLEND_MODES.LUMINOSITY] = "luminosity";
+    } else {
+      array[BLEND_MODES.NORMAL] = "source-over";
+      array[BLEND_MODES.ADD] = "lighter";
+      array[BLEND_MODES.MULTIPLY] = "source-over";
+      array[BLEND_MODES.SCREEN] = "source-over";
+      array[BLEND_MODES.OVERLAY] = "source-over";
+      array[BLEND_MODES.DARKEN] = "source-over";
+      array[BLEND_MODES.LIGHTEN] = "source-over";
+      array[BLEND_MODES.COLOR_DODGE] = "source-over";
+      array[BLEND_MODES.COLOR_BURN] = "source-over";
+      array[BLEND_MODES.HARD_LIGHT] = "source-over";
+      array[BLEND_MODES.SOFT_LIGHT] = "source-over";
+      array[BLEND_MODES.DIFFERENCE] = "source-over";
+      array[BLEND_MODES.EXCLUSION] = "source-over";
+      array[BLEND_MODES.HUE] = "source-over";
+      array[BLEND_MODES.SATURATION] = "source-over";
+      array[BLEND_MODES.COLOR] = "source-over";
+      array[BLEND_MODES.LUMINOSITY] = "source-over";
+    }
+    array[BLEND_MODES.NORMAL_NPM] = array[BLEND_MODES.NORMAL];
+    array[BLEND_MODES.ADD_NPM] = array[BLEND_MODES.ADD];
+    array[BLEND_MODES.SCREEN_NPM] = array[BLEND_MODES.SCREEN];
+    array[BLEND_MODES.SRC_IN] = "source-in";
+    array[BLEND_MODES.SRC_OUT] = "source-out";
+    array[BLEND_MODES.SRC_ATOP] = "source-atop";
+    array[BLEND_MODES.DST_OVER] = "destination-over";
+    array[BLEND_MODES.DST_IN] = "destination-in";
+    array[BLEND_MODES.DST_OUT] = "destination-out";
+    array[BLEND_MODES.DST_ATOP] = "destination-atop";
+    array[BLEND_MODES.XOR] = "xor";
+    array[BLEND_MODES.SUBTRACT] = "source-over";
+    return array;
+  }
+
+  const tempMatrix$2 = new Matrix();
+  class CanvasContextSystem {
+    constructor(renderer) {
+      this.activeResolution = 1;
+      this.smoothProperty = "imageSmoothingEnabled";
+      this.blendModes = mapCanvasBlendModesToPixi();
+      this._activeBlendMode = null;
+      this._projTransform = null;
+      this._outerBlend = false;
+      this.renderer = renderer;
+    }
+    init() {
+      const alpha = this.renderer.background.alpha < 1;
+      this.rootContext = this.renderer.view.getContext("2d", { alpha });
+      this.activeContext = this.rootContext;
+      if (!this.rootContext.imageSmoothingEnabled) {
+        const rc = this.rootContext;
+        if (rc.webkitImageSmoothingEnabled) {
+          this.smoothProperty = "webkitImageSmoothingEnabled";
+        } else if (rc.mozImageSmoothingEnabled) {
+          this.smoothProperty = "mozImageSmoothingEnabled";
+        } else if (rc.oImageSmoothingEnabled) {
+          this.smoothProperty = "oImageSmoothingEnabled";
+        } else if (rc.msImageSmoothingEnabled) {
+          this.smoothProperty = "msImageSmoothingEnabled";
+        }
+      }
+    }
+    setContextTransform(transform, roundPixels, localResolution) {
+      let mat = transform;
+      const proj = this._projTransform;
+      const contextResolution = this.activeResolution;
+      localResolution = localResolution || contextResolution;
+      if (proj) {
+        mat = tempMatrix$2;
+        mat.copyFrom(transform);
+        mat.prepend(proj);
+      }
+      if (roundPixels) {
+        this.activeContext.setTransform(mat.a * localResolution, mat.b * localResolution, mat.c * localResolution, mat.d * localResolution, mat.tx * contextResolution | 0, mat.ty * contextResolution | 0);
+      } else {
+        this.activeContext.setTransform(mat.a * localResolution, mat.b * localResolution, mat.c * localResolution, mat.d * localResolution, mat.tx * contextResolution, mat.ty * contextResolution);
+      }
+    }
+    clear(clearColor, alpha) {
+      const { activeContext: context, renderer } = this;
+      const fillColor = clearColor ? Color.shared.setValue(clearColor) : this.renderer.background.backgroundColor;
+      context.clearRect(0, 0, renderer.width, renderer.height);
+      if (clearColor) {
+        context.globalAlpha = alpha ?? this.renderer.background.alpha;
+        context.fillStyle = fillColor.toHex();
+        context.fillRect(0, 0, renderer.width, renderer.height);
+        context.globalAlpha = 1;
+      }
+    }
+    setBlendMode(blendMode, readyForOuterBlend) {
+      const outerBlend = blendMode === BLEND_MODES.SRC_IN || blendMode === BLEND_MODES.SRC_OUT || blendMode === BLEND_MODES.DST_IN || blendMode === BLEND_MODES.DST_ATOP;
+      if (!readyForOuterBlend && outerBlend) {
+        blendMode = BLEND_MODES.NORMAL;
+      }
+      if (this._activeBlendMode === blendMode) {
+        return;
+      }
+      this._activeBlendMode = blendMode;
+      this._outerBlend = outerBlend;
+      this.activeContext.globalCompositeOperation = this.blendModes[blendMode];
+    }
+    resize() {
+      if (this.smoothProperty) {
+        this.rootContext[this.smoothProperty] = BaseTexture.defaultOptions.scaleMode === SCALE_MODES.LINEAR;
+      }
+    }
+    invalidateBlendMode() {
+      this._activeBlendMode = this.blendModes.indexOf(this.activeContext.globalCompositeOperation);
+    }
+    destroy() {
+      this.renderer = null;
+      this.rootContext = null;
+      this.activeContext = null;
+      this.smoothProperty = null;
+    }
+  }
+  CanvasContextSystem.extension = {
+    type: ExtensionType.CanvasRendererSystem,
+    name: "canvasContext"
+  };
+  extensions$1.add(CanvasContextSystem);
+
+  class CanvasMaskSystem {
+    constructor(renderer) {
+      this._foundShapes = [];
+      this.renderer = renderer;
+    }
+    pushMask(maskData) {
+      const renderer = this.renderer;
+      const maskObject = maskData.maskObject || maskData;
+      renderer.canvasContext.activeContext.save();
+      const foundShapes = this._foundShapes;
+      this.recursiveFindShapes(maskObject, foundShapes);
+      if (foundShapes.length > 0) {
+        const context = renderer.canvasContext.activeContext;
+        context.beginPath();
+        for (let i = 0; i < foundShapes.length; i++) {
+          const shape = foundShapes[i];
+          const transform = shape.transform.worldTransform;
+          this.renderer.canvasContext.setContextTransform(transform);
+          this.renderGraphicsShape(shape);
+        }
+        foundShapes.length = 0;
+        context.clip();
+      }
+    }
+    recursiveFindShapes(container, out) {
+      if (container.geometry && container.geometry.graphicsData) {
+        out.push(container);
+      }
+      const { children } = container;
+      if (children) {
+        for (let i = 0; i < children.length; i++) {
+          this.recursiveFindShapes(children[i], out);
+        }
+      }
+    }
+    renderGraphicsShape(graphics) {
+      graphics.finishPoly();
+      const context = this.renderer.canvasContext.activeContext;
+      const graphicsData = graphics.geometry.graphicsData;
+      const len = graphicsData.length;
+      if (len === 0) {
+        return;
+      }
+      for (let i = 0; i < len; i++) {
+        const data = graphicsData[i];
+        const shape = data.shape;
+        if (shape.type === SHAPES.POLY) {
+          let points = shape.points;
+          const holes = data.holes;
+          let outerArea;
+          let innerArea;
+          let px;
+          let py;
+          context.moveTo(points[0], points[1]);
+          for (let j = 1; j < points.length / 2; j++) {
+            context.lineTo(points[j * 2], points[j * 2 + 1]);
+          }
+          if (holes.length > 0) {
+            outerArea = 0;
+            px = points[0];
+            py = points[1];
+            for (let j = 2; j + 2 < points.length; j += 2) {
+              outerArea += (points[j] - px) * (points[j + 3] - py) - (points[j + 2] - px) * (points[j + 1] - py);
+            }
+            for (let k = 0; k < holes.length; k++) {
+              points = holes[k].shape.points;
+              if (!points) {
+                continue;
+              }
+              innerArea = 0;
+              px = points[0];
+              py = points[1];
+              for (let j = 2; j + 2 < points.length; j += 2) {
+                innerArea += (points[j] - px) * (points[j + 3] - py) - (points[j + 2] - px) * (points[j + 1] - py);
+              }
+              if (innerArea * outerArea < 0) {
+                context.moveTo(points[0], points[1]);
+                for (let j = 2; j < points.length; j += 2) {
+                  context.lineTo(points[j], points[j + 1]);
+                }
+              } else {
+                context.moveTo(points[points.length - 2], points[points.length - 1]);
+                for (let j = points.length - 4; j >= 0; j -= 2) {
+                  context.lineTo(points[j], points[j + 1]);
+                }
+              }
+              if (holes[k].shape.closeStroke) {
+                context.closePath();
+              }
+            }
+          }
+          if (points[0] === points[points.length - 2] && points[1] === points[points.length - 1]) {
+            context.closePath();
+          }
+        } else if (shape.type === SHAPES.RECT) {
+          context.rect(shape.x, shape.y, shape.width, shape.height);
+          context.closePath();
+        } else if (shape.type === SHAPES.CIRC) {
+          context.arc(shape.x, shape.y, shape.radius, 0, 2 * Math.PI);
+          context.closePath();
+        } else if (shape.type === SHAPES.ELIP) {
+          const w = shape.width * 2;
+          const h = shape.height * 2;
+          const x = shape.x - w / 2;
+          const y = shape.y - h / 2;
+          const kappa = 0.5522848;
+          const ox = w / 2 * kappa;
+          const oy = h / 2 * kappa;
+          const xe = x + w;
+          const ye = y + h;
+          const xm = x + w / 2;
+          const ym = y + h / 2;
+          context.moveTo(x, ym);
+          context.bezierCurveTo(x, ym - oy, xm - ox, y, xm, y);
+          context.bezierCurveTo(xm + ox, y, xe, ym - oy, xe, ym);
+          context.bezierCurveTo(xe, ym + oy, xm + ox, ye, xm, ye);
+          context.bezierCurveTo(xm - ox, ye, x, ym + oy, x, ym);
+          context.closePath();
+        } else if (shape.type === SHAPES.RREC) {
+          const rx = shape.x;
+          const ry = shape.y;
+          const width = shape.width;
+          const height = shape.height;
+          let radius = shape.radius;
+          const maxRadius = Math.min(width, height) / 2;
+          radius = radius > maxRadius ? maxRadius : radius;
+          context.moveTo(rx, ry + radius);
+          context.lineTo(rx, ry + height - radius);
+          context.quadraticCurveTo(rx, ry + height, rx + radius, ry + height);
+          context.lineTo(rx + width - radius, ry + height);
+          context.quadraticCurveTo(rx + width, ry + height, rx + width, ry + height - radius);
+          context.lineTo(rx + width, ry + radius);
+          context.quadraticCurveTo(rx + width, ry, rx + width - radius, ry);
+          context.lineTo(rx + radius, ry);
+          context.quadraticCurveTo(rx, ry, rx, ry + radius);
+          context.closePath();
+        }
+      }
+    }
+    popMask(renderer) {
+      renderer.canvasContext.activeContext.restore();
+      renderer.canvasContext.invalidateBlendMode();
+    }
+    destroy() {
+    }
+  }
+  CanvasMaskSystem.extension = {
+    type: ExtensionType.CanvasRendererSystem,
+    name: "mask"
+  };
+  extensions$1.add(CanvasMaskSystem);
+
+  class CanvasObjectRendererSystem {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    render(displayObject, options) {
+      const renderer = this.renderer;
+      if (!renderer.view) {
+        return;
+      }
+      const _context = renderer.canvasContext;
+      let renderTexture;
+      let clear;
+      let transform;
+      let skipUpdateTransform;
+      if (options) {
+        renderTexture = options.renderTexture;
+        clear = options.clear;
+        transform = options.transform;
+        skipUpdateTransform = options.skipUpdateTransform;
+      }
+      this.renderingToScreen = !renderTexture;
+      renderer.emit("prerender");
+      const rootResolution = renderer.resolution;
+      if (renderTexture) {
+        renderTexture = renderTexture.castToBaseTexture();
+        if (!renderTexture._canvasRenderTarget) {
+          renderTexture._canvasRenderTarget = new CanvasRenderTarget(renderTexture.width, renderTexture.height, renderTexture.resolution);
+          renderTexture.resource = new CanvasResource(renderTexture._canvasRenderTarget.canvas);
+          renderTexture.valid = true;
+        }
+        _context.activeContext = renderTexture._canvasRenderTarget.context;
+        renderer.canvasContext.activeResolution = renderTexture._canvasRenderTarget.resolution;
+      } else {
+        _context.activeContext = _context.rootContext;
+        _context.activeResolution = rootResolution;
+      }
+      const context2D = _context.activeContext;
+      _context._projTransform = transform || null;
+      if (!renderTexture) {
+        this.lastObjectRendered = displayObject;
+      }
+      if (!skipUpdateTransform) {
+        const cacheParent = displayObject.enableTempParent();
+        displayObject.updateTransform();
+        displayObject.disableTempParent(cacheParent);
+      }
+      context2D.save();
+      context2D.setTransform(1, 0, 0, 1, 0, 0);
+      context2D.globalAlpha = 1;
+      _context._activeBlendMode = BLEND_MODES.NORMAL;
+      _context._outerBlend = false;
+      context2D.globalCompositeOperation = _context.blendModes[BLEND_MODES.NORMAL];
+      if (clear ?? renderer.background.clearBeforeRender) {
+        if (this.renderingToScreen) {
+          context2D.clearRect(0, 0, renderer.width, renderer.height);
+          const background = renderer.background;
+          if (background.alpha > 0) {
+            context2D.globalAlpha = background.backgroundColor.alpha;
+            context2D.fillStyle = background.backgroundColor.toHex();
+            context2D.fillRect(0, 0, renderer.width, renderer.height);
+            context2D.globalAlpha = 1;
+          }
+        } else {
+          renderTexture = renderTexture;
+          renderTexture._canvasRenderTarget.clear();
+          if (renderTexture.clear.alpha > 0) {
+            context2D.globalAlpha = renderTexture.clear.alpha;
+            context2D.fillStyle = renderTexture.clear.toHex();
+            context2D.fillRect(0, 0, renderTexture.realWidth, renderTexture.realHeight);
+            context2D.globalAlpha = 1;
+          }
+        }
+      }
+      const tempContext = _context.activeContext;
+      _context.activeContext = context2D;
+      displayObject.renderCanvas(renderer);
+      _context.activeContext = tempContext;
+      context2D.restore();
+      _context.activeResolution = rootResolution;
+      _context._projTransform = null;
+      renderer.emit("postrender");
+    }
+    destroy() {
+      this.lastObjectRendered = null;
+      this.render = null;
+    }
+  }
+  CanvasObjectRendererSystem.extension = {
+    type: ExtensionType.CanvasRendererSystem,
+    name: "objectRenderer"
+  };
+  extensions$1.add(CanvasObjectRendererSystem);
+
+  const { deprecation } = utils;
+  const _CanvasRenderer = class extends SystemManager {
+    constructor(options) {
+      super();
+      this.type = RENDERER_TYPE.CANVAS;
+      this.rendererLogId = "Canvas";
+      options = Object.assign({}, settings.RENDER_OPTIONS, options);
+      const systemConfig = {
+        runners: [
+          "init",
+          "destroy",
+          "contextChange",
+          "resolutionChange",
+          "reset",
+          "update",
+          "postrender",
+          "prerender",
+          "resize"
+        ],
+        systems: _CanvasRenderer.__systems,
+        priority: [
+          "textureGenerator",
+          "background",
+          "_view",
+          "_plugin",
+          "startup",
+          "mask",
+          "canvasContext",
+          "objectRenderer"
+        ]
+      };
+      this.setup(systemConfig);
+      if ("useContextAlpha" in options) {
+        deprecation("7.0.0", "options.useContextAlpha is deprecated, use options.backgroundAlpha instead");
+        options.backgroundAlpha = options.useContextAlpha === false ? 1 : options.backgroundAlpha;
+      }
+      this._plugin.rendererPlugins = _CanvasRenderer.__plugins;
+      this.options = options;
+      this.startup.run(this.options);
+    }
+    static test() {
+      return true;
+    }
+    generateTexture(displayObject, options) {
+      return this.textureGenerator.generateTexture(displayObject, options);
+    }
+    reset() {
+    }
+    render(displayObject, options) {
+      this.objectRenderer.render(displayObject, options);
+    }
+    clear() {
+      this.canvasContext.clear();
+    }
+    destroy(removeView) {
+      this.runners.destroy.items.reverse();
+      this.emitWithCustomOptions(this.runners.destroy, {
+        _view: removeView
+      });
+      super.destroy();
+    }
+    get plugins() {
+      return this._plugin.plugins;
+    }
+    resize(desiredScreenWidth, desiredScreenHeight) {
+      this._view.resizeView(desiredScreenWidth, desiredScreenHeight);
+    }
+    get width() {
+      return this._view.element.width;
+    }
+    get height() {
+      return this._view.element.height;
+    }
+    get resolution() {
+      return this._view.resolution;
+    }
+    set resolution(value) {
+      this._view.resolution = value;
+      this.runners.resolutionChange.emit(value);
+    }
+    get autoDensity() {
+      return this._view.autoDensity;
+    }
+    get view() {
+      return this._view.element;
+    }
+    get screen() {
+      return this._view.screen;
+    }
+    get lastObjectRendered() {
+      return this.objectRenderer.lastObjectRendered;
+    }
+    get renderingToScreen() {
+      return this.objectRenderer.renderingToScreen;
+    }
+    get clearBeforeRender() {
+      return this.background.clearBeforeRender;
+    }
+    get blendModes() {
+      deprecation("7.0.0", "renderer.blendModes has been deprecated, please use renderer.canvasContext.blendModes instead");
+      return this.canvasContext.blendModes;
+    }
+    get maskManager() {
+      deprecation("7.0.0", "renderer.maskManager has been deprecated, please use renderer.mask instead");
+      return this.mask;
+    }
+    get refresh() {
+      deprecation("7.0.0", "renderer.refresh has been deprecated");
+      return true;
+    }
+    get rootContext() {
+      deprecation("7.0.0", "renderer.rootContext has been deprecated, please use renderer.canvasContext.rootContext instead");
+      return this.canvasContext.rootContext;
+    }
+    get context() {
+      deprecation("7.0.0", "renderer.context has been deprecated, please use renderer.canvasContext.activeContext instead");
+      return this.canvasContext.activeContext;
+    }
+    get smoothProperty() {
+      deprecation("7.0.0", "renderer.smoothProperty has been deprecated, please use renderer.canvasContext.smoothProperty instead");
+      return this.canvasContext.smoothProperty;
+    }
+    setBlendMode(blendMode, readyForOuterBlend) {
+      deprecation("7.0.0", "renderer.setBlendMode has been deprecated, use renderer.canvasContext.setBlendMode instead");
+      this.canvasContext.setBlendMode(blendMode, readyForOuterBlend);
+    }
+    invalidateBlendMode() {
+      deprecation("7.0.0", "renderer.invalidateBlendMode has been deprecated, use renderer.canvasContext.invalidateBlendMode instead");
+      this.canvasContext.invalidateBlendMode();
+    }
+    setContextTransform(transform, roundPixels, localResolution) {
+      deprecation("7.0.0", "renderer.setContextTransform has been deprecated, use renderer.canvasContext.setContextTransform instead");
+      this.canvasContext.setContextTransform(transform, roundPixels, localResolution);
+    }
+    get backgroundColor() {
+      deprecation("7.0.0", "renderer.backgroundColor has been deprecated, use renderer.background.color instead.");
+      return this.background.color;
+    }
+    set backgroundColor(value) {
+      deprecation("7.0.0", "renderer.backgroundColor has been deprecated, use renderer.background.color instead.");
+      this.background.color = value;
+    }
+    get backgroundAlpha() {
+      deprecation("7.0.0", "renderer.backgroundAlpha has been deprecated, use renderer.background.alpha instead.");
+      return this.background.alpha;
+    }
+    set backgroundAlpha(value) {
+      deprecation("7.0.0", "renderer.backgroundAlpha has been deprecated, use renderer.background.alpha instead.");
+      this.background.alpha = value;
+    }
+    get preserveDrawingBuffer() {
+      deprecation("7.0.0", "renderer.preserveDrawingBuffer has been deprecated");
+      return false;
+    }
+    get useContextAlpha() {
+      deprecation("7.0.0", "renderer.useContextAlpha has been deprecated");
+      return false;
+    }
+  };
+  let CanvasRenderer = _CanvasRenderer;
+  CanvasRenderer.extension = {
+    type: ExtensionType.Renderer,
+    priority: 0
+  };
+  CanvasRenderer.__plugins = {};
+  CanvasRenderer.__systems = {};
+  extensions$1.handleByMap(ExtensionType.CanvasRendererPlugin, CanvasRenderer.__plugins);
+  extensions$1.handleByMap(ExtensionType.CanvasRendererSystem, CanvasRenderer.__systems);
+  extensions$1.add(CanvasRenderer);
+
+  const canvasUtils = {
+    canvas: null,
+    getTintedCanvas: (sprite, color) => {
+      const texture = sprite.texture;
+      color = canvasUtils.roundColor(color);
+      const stringColor = `#${`00000${(color | 0).toString(16)}`.slice(-6)}`;
+      texture.tintCache = texture.tintCache || {};
+      const cachedCanvas = texture.tintCache[stringColor];
+      let canvas;
+      if (cachedCanvas) {
+        if (cachedCanvas.tintId === texture._updateID) {
+          return texture.tintCache[stringColor];
+        }
+        canvas = texture.tintCache[stringColor];
+      } else {
+        canvas = settings.ADAPTER.createCanvas();
+      }
+      canvasUtils.tintMethod(texture, color, canvas);
+      canvas.tintId = texture._updateID;
+      if (canvasUtils.convertTintToImage && canvas.toDataURL !== void 0) {
+        const tintImage = new Image();
+        tintImage.src = canvas.toDataURL();
+        texture.tintCache[stringColor] = tintImage;
+      } else {
+        texture.tintCache[stringColor] = canvas;
+      }
+      return canvas;
+    },
+    getTintedPattern: (texture, color) => {
+      color = canvasUtils.roundColor(color);
+      const stringColor = `#${`00000${(color | 0).toString(16)}`.slice(-6)}`;
+      texture.patternCache = texture.patternCache || {};
+      let pattern = texture.patternCache[stringColor];
+      if (pattern?.tintId === texture._updateID) {
+        return pattern;
+      }
+      if (!canvasUtils.canvas) {
+        canvasUtils.canvas = settings.ADAPTER.createCanvas();
+      }
+      canvasUtils.tintMethod(texture, color, canvasUtils.canvas);
+      pattern = canvasUtils.canvas.getContext("2d").createPattern(canvasUtils.canvas, "repeat");
+      pattern.tintId = texture._updateID;
+      texture.patternCache[stringColor] = pattern;
+      return pattern;
+    },
+    tintWithMultiply: (texture, color, canvas) => {
+      const context = canvas.getContext("2d");
+      const crop = texture._frame.clone();
+      const resolution = texture.baseTexture.resolution;
+      crop.x *= resolution;
+      crop.y *= resolution;
+      crop.width *= resolution;
+      crop.height *= resolution;
+      canvas.width = Math.ceil(crop.width);
+      canvas.height = Math.ceil(crop.height);
+      context.save();
+      context.fillStyle = `#${`00000${(color | 0).toString(16)}`.slice(-6)}`;
+      context.fillRect(0, 0, crop.width, crop.height);
+      context.globalCompositeOperation = "multiply";
+      const source = texture.baseTexture.getDrawableSource();
+      context.drawImage(source, crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
+      context.globalCompositeOperation = "destination-atop";
+      context.drawImage(source, crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
+      context.restore();
+    },
+    tintWithOverlay: (texture, color, canvas) => {
+      const context = canvas.getContext("2d");
+      const crop = texture._frame.clone();
+      const resolution = texture.baseTexture.resolution;
+      crop.x *= resolution;
+      crop.y *= resolution;
+      crop.width *= resolution;
+      crop.height *= resolution;
+      canvas.width = Math.ceil(crop.width);
+      canvas.height = Math.ceil(crop.height);
+      context.save();
+      context.globalCompositeOperation = "copy";
+      context.fillStyle = `#${`00000${(color | 0).toString(16)}`.slice(-6)}`;
+      context.fillRect(0, 0, crop.width, crop.height);
+      context.globalCompositeOperation = "destination-atop";
+      context.drawImage(texture.baseTexture.getDrawableSource(), crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
+      context.restore();
+    },
+    tintWithPerPixel: (texture, color, canvas) => {
+      const context = canvas.getContext("2d");
+      const crop = texture._frame.clone();
+      const resolution = texture.baseTexture.resolution;
+      crop.x *= resolution;
+      crop.y *= resolution;
+      crop.width *= resolution;
+      crop.height *= resolution;
+      canvas.width = Math.ceil(crop.width);
+      canvas.height = Math.ceil(crop.height);
+      context.save();
+      context.globalCompositeOperation = "copy";
+      context.drawImage(texture.baseTexture.getDrawableSource(), crop.x, crop.y, crop.width, crop.height, 0, 0, crop.width, crop.height);
+      context.restore();
+      const [r, g, b] = Color.shared.setValue(color).toArray();
+      const pixelData = context.getImageData(0, 0, crop.width, crop.height);
+      const pixels = pixelData.data;
+      for (let i = 0; i < pixels.length; i += 4) {
+        pixels[i + 0] *= r;
+        pixels[i + 1] *= g;
+        pixels[i + 2] *= b;
+      }
+      context.putImageData(pixelData, 0, 0);
+    },
+    roundColor: (color) => Color.shared.setValue(color).round(canvasUtils.cacheStepsPerColorChannel).toNumber(),
+    cacheStepsPerColorChannel: 8,
+    convertTintToImage: false,
+    canUseMultiply: canUseNewCanvasBlendModes(),
+    tintMethod: null
+  };
+  canvasUtils.tintMethod = canvasUtils.canUseMultiply ? canvasUtils.tintWithMultiply : canvasUtils.tintWithPerPixel;
+
+  class Bounds {
+    constructor() {
+      this.minX = Infinity;
+      this.minY = Infinity;
+      this.maxX = -Infinity;
+      this.maxY = -Infinity;
+      this.rect = null;
+      this.updateID = -1;
+    }
+    isEmpty() {
+      return this.minX > this.maxX || this.minY > this.maxY;
+    }
+    clear() {
+      this.minX = Infinity;
+      this.minY = Infinity;
+      this.maxX = -Infinity;
+      this.maxY = -Infinity;
+    }
+    getRectangle(rect) {
+      if (this.minX > this.maxX || this.minY > this.maxY) {
+        return Rectangle.EMPTY;
+      }
+      rect = rect || new Rectangle(0, 0, 1, 1);
+      rect.x = this.minX;
+      rect.y = this.minY;
+      rect.width = this.maxX - this.minX;
+      rect.height = this.maxY - this.minY;
+      return rect;
+    }
+    addPoint(point) {
+      this.minX = Math.min(this.minX, point.x);
+      this.maxX = Math.max(this.maxX, point.x);
+      this.minY = Math.min(this.minY, point.y);
+      this.maxY = Math.max(this.maxY, point.y);
+    }
+    addPointMatrix(matrix, point) {
+      const { a, b, c, d, tx, ty } = matrix;
+      const x = a * point.x + c * point.y + tx;
+      const y = b * point.x + d * point.y + ty;
+      this.minX = Math.min(this.minX, x);
+      this.maxX = Math.max(this.maxX, x);
+      this.minY = Math.min(this.minY, y);
+      this.maxY = Math.max(this.maxY, y);
+    }
+    addQuad(vertices) {
+      let minX = this.minX;
+      let minY = this.minY;
+      let maxX = this.maxX;
+      let maxY = this.maxY;
+      let x = vertices[0];
+      let y = vertices[1];
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      x = vertices[2];
+      y = vertices[3];
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      x = vertices[4];
+      y = vertices[5];
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      x = vertices[6];
+      y = vertices[7];
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      this.minX = minX;
+      this.minY = minY;
+      this.maxX = maxX;
+      this.maxY = maxY;
+    }
+    addFrame(transform, x0, y0, x1, y1) {
+      this.addFrameMatrix(transform.worldTransform, x0, y0, x1, y1);
+    }
+    addFrameMatrix(matrix, x0, y0, x1, y1) {
+      const a = matrix.a;
+      const b = matrix.b;
+      const c = matrix.c;
+      const d = matrix.d;
+      const tx = matrix.tx;
+      const ty = matrix.ty;
+      let minX = this.minX;
+      let minY = this.minY;
+      let maxX = this.maxX;
+      let maxY = this.maxY;
+      let x = a * x0 + c * y0 + tx;
+      let y = b * x0 + d * y0 + ty;
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      x = a * x1 + c * y0 + tx;
+      y = b * x1 + d * y0 + ty;
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      x = a * x0 + c * y1 + tx;
+      y = b * x0 + d * y1 + ty;
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      x = a * x1 + c * y1 + tx;
+      y = b * x1 + d * y1 + ty;
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      this.minX = minX;
+      this.minY = minY;
+      this.maxX = maxX;
+      this.maxY = maxY;
+    }
+    addVertexData(vertexData, beginOffset, endOffset) {
+      let minX = this.minX;
+      let minY = this.minY;
+      let maxX = this.maxX;
+      let maxY = this.maxY;
+      for (let i = beginOffset; i < endOffset; i += 2) {
+        const x = vertexData[i];
+        const y = vertexData[i + 1];
+        minX = x < minX ? x : minX;
+        minY = y < minY ? y : minY;
+        maxX = x > maxX ? x : maxX;
+        maxY = y > maxY ? y : maxY;
+      }
+      this.minX = minX;
+      this.minY = minY;
+      this.maxX = maxX;
+      this.maxY = maxY;
+    }
+    addVertices(transform, vertices, beginOffset, endOffset) {
+      this.addVerticesMatrix(transform.worldTransform, vertices, beginOffset, endOffset);
+    }
+    addVerticesMatrix(matrix, vertices, beginOffset, endOffset, padX = 0, padY = padX) {
+      const a = matrix.a;
+      const b = matrix.b;
+      const c = matrix.c;
+      const d = matrix.d;
+      const tx = matrix.tx;
+      const ty = matrix.ty;
+      let minX = this.minX;
+      let minY = this.minY;
+      let maxX = this.maxX;
+      let maxY = this.maxY;
+      for (let i = beginOffset; i < endOffset; i += 2) {
+        const rawX = vertices[i];
+        const rawY = vertices[i + 1];
+        const x = a * rawX + c * rawY + tx;
+        const y = d * rawY + b * rawX + ty;
+        minX = Math.min(minX, x - padX);
+        maxX = Math.max(maxX, x + padX);
+        minY = Math.min(minY, y - padY);
+        maxY = Math.max(maxY, y + padY);
+      }
+      this.minX = minX;
+      this.minY = minY;
+      this.maxX = maxX;
+      this.maxY = maxY;
+    }
+    addBounds(bounds) {
+      const minX = this.minX;
+      const minY = this.minY;
+      const maxX = this.maxX;
+      const maxY = this.maxY;
+      this.minX = bounds.minX < minX ? bounds.minX : minX;
+      this.minY = bounds.minY < minY ? bounds.minY : minY;
+      this.maxX = bounds.maxX > maxX ? bounds.maxX : maxX;
+      this.maxY = bounds.maxY > maxY ? bounds.maxY : maxY;
+    }
+    addBoundsMask(bounds, mask) {
+      const _minX = bounds.minX > mask.minX ? bounds.minX : mask.minX;
+      const _minY = bounds.minY > mask.minY ? bounds.minY : mask.minY;
+      const _maxX = bounds.maxX < mask.maxX ? bounds.maxX : mask.maxX;
+      const _maxY = bounds.maxY < mask.maxY ? bounds.maxY : mask.maxY;
+      if (_minX <= _maxX && _minY <= _maxY) {
+        const minX = this.minX;
+        const minY = this.minY;
+        const maxX = this.maxX;
+        const maxY = this.maxY;
+        this.minX = _minX < minX ? _minX : minX;
+        this.minY = _minY < minY ? _minY : minY;
+        this.maxX = _maxX > maxX ? _maxX : maxX;
+        this.maxY = _maxY > maxY ? _maxY : maxY;
+      }
+    }
+    addBoundsMatrix(bounds, matrix) {
+      this.addFrameMatrix(matrix, bounds.minX, bounds.minY, bounds.maxX, bounds.maxY);
+    }
+    addBoundsArea(bounds, area) {
+      const _minX = bounds.minX > area.x ? bounds.minX : area.x;
+      const _minY = bounds.minY > area.y ? bounds.minY : area.y;
+      const _maxX = bounds.maxX < area.x + area.width ? bounds.maxX : area.x + area.width;
+      const _maxY = bounds.maxY < area.y + area.height ? bounds.maxY : area.y + area.height;
+      if (_minX <= _maxX && _minY <= _maxY) {
+        const minX = this.minX;
+        const minY = this.minY;
+        const maxX = this.maxX;
+        const maxY = this.maxY;
+        this.minX = _minX < minX ? _minX : minX;
+        this.minY = _minY < minY ? _minY : minY;
+        this.maxX = _maxX > maxX ? _maxX : maxX;
+        this.maxY = _maxY > maxY ? _maxY : maxY;
+      }
+    }
+    pad(paddingX = 0, paddingY = paddingX) {
+      if (!this.isEmpty()) {
+        this.minX -= paddingX;
+        this.maxX += paddingX;
+        this.minY -= paddingY;
+        this.maxY += paddingY;
+      }
+    }
+    addFramePad(x0, y0, x1, y1, padX, padY) {
+      x0 -= padX;
+      y0 -= padY;
+      x1 += padX;
+      y1 += padY;
+      this.minX = this.minX < x0 ? this.minX : x0;
+      this.maxX = this.maxX > x1 ? this.maxX : x1;
+      this.minY = this.minY < y0 ? this.minY : y0;
+      this.maxY = this.maxY > y1 ? this.maxY : y1;
+    }
+  }
+
+  class DisplayObject extends eventemitter3 {
+    constructor() {
+      super();
+      this.tempDisplayObjectParent = null;
+      this.transform = new Transform();
+      this.alpha = 1;
+      this.visible = true;
+      this.renderable = true;
+      this.cullable = false;
+      this.cullArea = null;
+      this.parent = null;
+      this.worldAlpha = 1;
+      this._lastSortedIndex = 0;
+      this._zIndex = 0;
+      this.filterArea = null;
+      this.filters = null;
+      this._enabledFilters = null;
+      this._bounds = new Bounds();
+      this._localBounds = null;
+      this._boundsID = 0;
+      this._boundsRect = null;
+      this._localBoundsRect = null;
+      this._mask = null;
+      this._maskRefCount = 0;
+      this._destroyed = false;
+      this.isSprite = false;
+      this.isMask = false;
+    }
+    static mixin(source) {
+      const keys = Object.keys(source);
+      for (let i = 0; i < keys.length; ++i) {
+        const propertyName = keys[i];
+        Object.defineProperty(DisplayObject.prototype, propertyName, Object.getOwnPropertyDescriptor(source, propertyName));
+      }
+    }
+    get destroyed() {
+      return this._destroyed;
+    }
+    _recursivePostUpdateTransform() {
+      if (this.parent) {
+        this.parent._recursivePostUpdateTransform();
+        this.transform.updateTransform(this.parent.transform);
+      } else {
+        this.transform.updateTransform(this._tempDisplayObjectParent.transform);
+      }
+    }
+    updateTransform() {
+      this._boundsID++;
+      this.transform.updateTransform(this.parent.transform);
+      this.worldAlpha = this.alpha * this.parent.worldAlpha;
+    }
+    getBounds(skipUpdate, rect) {
+      if (!skipUpdate) {
+        if (!this.parent) {
+          this.parent = this._tempDisplayObjectParent;
+          this.updateTransform();
+          this.parent = null;
+        } else {
+          this._recursivePostUpdateTransform();
+          this.updateTransform();
+        }
+      }
+      if (this._bounds.updateID !== this._boundsID) {
+        this.calculateBounds();
+        this._bounds.updateID = this._boundsID;
+      }
+      if (!rect) {
+        if (!this._boundsRect) {
+          this._boundsRect = new Rectangle();
+        }
+        rect = this._boundsRect;
+      }
+      return this._bounds.getRectangle(rect);
+    }
+    getLocalBounds(rect) {
+      if (!rect) {
+        if (!this._localBoundsRect) {
+          this._localBoundsRect = new Rectangle();
+        }
+        rect = this._localBoundsRect;
+      }
+      if (!this._localBounds) {
+        this._localBounds = new Bounds();
+      }
+      const transformRef = this.transform;
+      const parentRef = this.parent;
+      this.parent = null;
+      this.transform = this._tempDisplayObjectParent.transform;
+      const worldBounds = this._bounds;
+      const worldBoundsID = this._boundsID;
+      this._bounds = this._localBounds;
+      const bounds = this.getBounds(false, rect);
+      this.parent = parentRef;
+      this.transform = transformRef;
+      this._bounds = worldBounds;
+      this._bounds.updateID += this._boundsID - worldBoundsID;
+      return bounds;
+    }
+    toGlobal(position, point, skipUpdate = false) {
+      if (!skipUpdate) {
+        this._recursivePostUpdateTransform();
+        if (!this.parent) {
+          this.parent = this._tempDisplayObjectParent;
+          this.displayObjectUpdateTransform();
+          this.parent = null;
+        } else {
+          this.displayObjectUpdateTransform();
+        }
+      }
+      return this.worldTransform.apply(position, point);
+    }
+    toLocal(position, from, point, skipUpdate) {
+      if (from) {
+        position = from.toGlobal(position, point, skipUpdate);
+      }
+      if (!skipUpdate) {
+        this._recursivePostUpdateTransform();
+        if (!this.parent) {
+          this.parent = this._tempDisplayObjectParent;
+          this.displayObjectUpdateTransform();
+          this.parent = null;
+        } else {
+          this.displayObjectUpdateTransform();
+        }
+      }
+      return this.worldTransform.applyInverse(position, point);
+    }
+    setParent(container) {
+      if (!container || !container.addChild) {
+        throw new Error("setParent: Argument must be a Container");
+      }
+      container.addChild(this);
+      return container;
+    }
+    removeFromParent() {
+      this.parent?.removeChild(this);
+    }
+    setTransform(x = 0, y = 0, scaleX = 1, scaleY = 1, rotation = 0, skewX = 0, skewY = 0, pivotX = 0, pivotY = 0) {
+      this.position.x = x;
+      this.position.y = y;
+      this.scale.x = !scaleX ? 1 : scaleX;
+      this.scale.y = !scaleY ? 1 : scaleY;
+      this.rotation = rotation;
+      this.skew.x = skewX;
+      this.skew.y = skewY;
+      this.pivot.x = pivotX;
+      this.pivot.y = pivotY;
+      return this;
+    }
+    destroy(_options) {
+      this.removeFromParent();
+      this._destroyed = true;
+      this.transform = null;
+      this.parent = null;
+      this._bounds = null;
+      this.mask = null;
+      this.cullArea = null;
+      this.filters = null;
+      this.filterArea = null;
+      this.hitArea = null;
+      this.eventMode = "auto";
+      this.interactiveChildren = false;
+      this.emit("destroyed");
+      this.removeAllListeners();
+    }
+    get _tempDisplayObjectParent() {
+      if (this.tempDisplayObjectParent === null) {
+        this.tempDisplayObjectParent = new TemporaryDisplayObject();
+      }
+      return this.tempDisplayObjectParent;
+    }
+    enableTempParent() {
+      const myParent = this.parent;
+      this.parent = this._tempDisplayObjectParent;
+      return myParent;
+    }
+    disableTempParent(cacheParent) {
+      this.parent = cacheParent;
+    }
+    get x() {
+      return this.position.x;
+    }
+    set x(value) {
+      this.transform.position.x = value;
+    }
+    get y() {
+      return this.position.y;
+    }
+    set y(value) {
+      this.transform.position.y = value;
+    }
+    get worldTransform() {
+      return this.transform.worldTransform;
+    }
+    get localTransform() {
+      return this.transform.localTransform;
+    }
+    get position() {
+      return this.transform.position;
+    }
+    set position(value) {
+      this.transform.position.copyFrom(value);
+    }
+    get scale() {
+      return this.transform.scale;
+    }
+    set scale(value) {
+      this.transform.scale.copyFrom(value);
+    }
+    get pivot() {
+      return this.transform.pivot;
+    }
+    set pivot(value) {
+      this.transform.pivot.copyFrom(value);
+    }
+    get skew() {
+      return this.transform.skew;
+    }
+    set skew(value) {
+      this.transform.skew.copyFrom(value);
+    }
+    get rotation() {
+      return this.transform.rotation;
+    }
+    set rotation(value) {
+      this.transform.rotation = value;
+    }
+    get angle() {
+      return this.transform.rotation * RAD_TO_DEG;
+    }
+    set angle(value) {
+      this.transform.rotation = value * DEG_TO_RAD;
+    }
+    get zIndex() {
+      return this._zIndex;
+    }
+    set zIndex(value) {
+      this._zIndex = value;
+      if (this.parent) {
+        this.parent.sortDirty = true;
+      }
+    }
+    get worldVisible() {
+      let item = this;
+      do {
+        if (!item.visible) {
+          return false;
+        }
+        item = item.parent;
+      } while (item);
+      return true;
+    }
+    get mask() {
+      return this._mask;
+    }
+    set mask(value) {
+      if (this._mask === value) {
+        return;
+      }
+      if (this._mask) {
+        const maskObject = this._mask.isMaskData ? this._mask.maskObject : this._mask;
+        if (maskObject) {
+          maskObject._maskRefCount--;
+          if (maskObject._maskRefCount === 0) {
+            maskObject.renderable = true;
+            maskObject.isMask = false;
+          }
+        }
+      }
+      this._mask = value;
+      if (this._mask) {
+        const maskObject = this._mask.isMaskData ? this._mask.maskObject : this._mask;
+        if (maskObject) {
+          if (maskObject._maskRefCount === 0) {
+            maskObject.renderable = false;
+            maskObject.isMask = true;
+          }
+          maskObject._maskRefCount++;
+        }
+      }
+    }
+  }
+  class TemporaryDisplayObject extends DisplayObject {
+    constructor() {
+      super(...arguments);
+      this.sortDirty = null;
+    }
+  }
+  DisplayObject.prototype.displayObjectUpdateTransform = DisplayObject.prototype.updateTransform;
+
+  const tempMatrix$1 = new Matrix();
+  function sortChildren(a, b) {
+    if (a.zIndex === b.zIndex) {
+      return a._lastSortedIndex - b._lastSortedIndex;
+    }
+    return a.zIndex - b.zIndex;
+  }
+  const _Container = class extends DisplayObject {
+    constructor() {
+      super();
+      this.children = [];
+      this.sortableChildren = _Container.defaultSortableChildren;
+      this.sortDirty = false;
+    }
+    onChildrenChange(_length) {
+    }
+    addChild(...children) {
+      if (children.length > 1) {
+        for (let i = 0; i < children.length; i++) {
+          this.addChild(children[i]);
+        }
+      } else {
+        const child = children[0];
+        if (child.parent) {
+          child.parent.removeChild(child);
+        }
+        child.parent = this;
+        this.sortDirty = true;
+        child.transform._parentID = -1;
+        this.children.push(child);
+        this._boundsID++;
+        this.onChildrenChange(this.children.length - 1);
+        this.emit("childAdded", child, this, this.children.length - 1);
+        child.emit("added", this);
+      }
+      return children[0];
+    }
+    addChildAt(child, index) {
+      if (index < 0 || index > this.children.length) {
+        throw new Error(`${child}addChildAt: The index ${index} supplied is out of bounds ${this.children.length}`);
+      }
+      if (child.parent) {
+        child.parent.removeChild(child);
+      }
+      child.parent = this;
+      this.sortDirty = true;
+      child.transform._parentID = -1;
+      this.children.splice(index, 0, child);
+      this._boundsID++;
+      this.onChildrenChange(index);
+      child.emit("added", this);
+      this.emit("childAdded", child, this, index);
+      return child;
+    }
+    swapChildren(child, child2) {
+      if (child === child2) {
+        return;
+      }
+      const index1 = this.getChildIndex(child);
+      const index2 = this.getChildIndex(child2);
+      this.children[index1] = child2;
+      this.children[index2] = child;
+      this.onChildrenChange(index1 < index2 ? index1 : index2);
+    }
+    getChildIndex(child) {
+      const index = this.children.indexOf(child);
+      if (index === -1) {
+        throw new Error("The supplied DisplayObject must be a child of the caller");
+      }
+      return index;
+    }
+    setChildIndex(child, index) {
+      if (index < 0 || index >= this.children.length) {
+        throw new Error(`The index ${index} supplied is out of bounds ${this.children.length}`);
+      }
+      const currentIndex = this.getChildIndex(child);
+      removeItems(this.children, currentIndex, 1);
+      this.children.splice(index, 0, child);
+      this.onChildrenChange(index);
+    }
+    getChildAt(index) {
+      if (index < 0 || index >= this.children.length) {
+        throw new Error(`getChildAt: Index (${index}) does not exist.`);
+      }
+      return this.children[index];
+    }
+    removeChild(...children) {
+      if (children.length > 1) {
+        for (let i = 0; i < children.length; i++) {
+          this.removeChild(children[i]);
+        }
+      } else {
+        const child = children[0];
+        const index = this.children.indexOf(child);
+        if (index === -1)
+          return null;
+        child.parent = null;
+        child.transform._parentID = -1;
+        removeItems(this.children, index, 1);
+        this._boundsID++;
+        this.onChildrenChange(index);
+        child.emit("removed", this);
+        this.emit("childRemoved", child, this, index);
+      }
+      return children[0];
+    }
+    removeChildAt(index) {
+      const child = this.getChildAt(index);
+      child.parent = null;
+      child.transform._parentID = -1;
+      removeItems(this.children, index, 1);
+      this._boundsID++;
+      this.onChildrenChange(index);
+      child.emit("removed", this);
+      this.emit("childRemoved", child, this, index);
+      return child;
+    }
+    removeChildren(beginIndex = 0, endIndex = this.children.length) {
+      const begin = beginIndex;
+      const end = endIndex;
+      const range = end - begin;
+      let removed;
+      if (range > 0 && range <= end) {
+        removed = this.children.splice(begin, range);
+        for (let i = 0; i < removed.length; ++i) {
+          removed[i].parent = null;
+          if (removed[i].transform) {
+            removed[i].transform._parentID = -1;
+          }
+        }
+        this._boundsID++;
+        this.onChildrenChange(beginIndex);
+        for (let i = 0; i < removed.length; ++i) {
+          removed[i].emit("removed", this);
+          this.emit("childRemoved", removed[i], this, i);
+        }
+        return removed;
+      } else if (range === 0 && this.children.length === 0) {
+        return [];
+      }
+      throw new RangeError("removeChildren: numeric values are outside the acceptable range.");
+    }
+    sortChildren() {
+      let sortRequired = false;
+      for (let i = 0, j = this.children.length; i < j; ++i) {
+        const child = this.children[i];
+        child._lastSortedIndex = i;
+        if (!sortRequired && child.zIndex !== 0) {
+          sortRequired = true;
+        }
+      }
+      if (sortRequired && this.children.length > 1) {
+        this.children.sort(sortChildren);
+      }
+      this.sortDirty = false;
+    }
+    updateTransform() {
+      if (this.sortableChildren && this.sortDirty) {
+        this.sortChildren();
+      }
+      this._boundsID++;
+      this.transform.updateTransform(this.parent.transform);
+      this.worldAlpha = this.alpha * this.parent.worldAlpha;
+      for (let i = 0, j = this.children.length; i < j; ++i) {
+        const child = this.children[i];
+        if (child.visible) {
+          child.updateTransform();
+        }
+      }
+    }
+    calculateBounds() {
+      this._bounds.clear();
+      this._calculateBounds();
+      for (let i = 0; i < this.children.length; i++) {
+        const child = this.children[i];
+        if (!child.visible || !child.renderable) {
+          continue;
+        }
+        child.calculateBounds();
+        if (child._mask) {
+          const maskObject = child._mask.isMaskData ? child._mask.maskObject : child._mask;
+          if (maskObject) {
+            maskObject.calculateBounds();
+            this._bounds.addBoundsMask(child._bounds, maskObject._bounds);
+          } else {
+            this._bounds.addBounds(child._bounds);
+          }
+        } else if (child.filterArea) {
+          this._bounds.addBoundsArea(child._bounds, child.filterArea);
+        } else {
+          this._bounds.addBounds(child._bounds);
+        }
+      }
+      this._bounds.updateID = this._boundsID;
+    }
+    getLocalBounds(rect, skipChildrenUpdate = false) {
+      const result = super.getLocalBounds(rect);
+      if (!skipChildrenUpdate) {
+        for (let i = 0, j = this.children.length; i < j; ++i) {
+          const child = this.children[i];
+          if (child.visible) {
+            child.updateTransform();
+          }
+        }
+      }
+      return result;
+    }
+    _calculateBounds() {
+    }
+    _renderWithCulling(renderer) {
+      const sourceFrame = renderer.renderTexture.sourceFrame;
+      if (!(sourceFrame.width > 0 && sourceFrame.height > 0)) {
+        return;
+      }
+      let bounds;
+      let transform;
+      if (this.cullArea) {
+        bounds = this.cullArea;
+        transform = this.worldTransform;
+      } else if (this._render !== _Container.prototype._render) {
+        bounds = this.getBounds(true);
+      }
+      const projectionTransform = renderer.projection.transform;
+      if (projectionTransform) {
+        if (transform) {
+          transform = tempMatrix$1.copyFrom(transform);
+          transform.prepend(projectionTransform);
+        } else {
+          transform = projectionTransform;
+        }
+      }
+      if (bounds && sourceFrame.intersects(bounds, transform)) {
+        this._render(renderer);
+      } else if (this.cullArea) {
+        return;
+      }
+      for (let i = 0, j = this.children.length; i < j; ++i) {
+        const child = this.children[i];
+        const childCullable = child.cullable;
+        child.cullable = childCullable || !this.cullArea;
+        child.render(renderer);
+        child.cullable = childCullable;
+      }
+    }
+    render(renderer) {
+      if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
+        return;
+      }
+      if (this._mask || this.filters?.length) {
+        this.renderAdvanced(renderer);
+      } else if (this.cullable) {
+        this._renderWithCulling(renderer);
+      } else {
+        this._render(renderer);
+        for (let i = 0, j = this.children.length; i < j; ++i) {
+          this.children[i].render(renderer);
+        }
+      }
+    }
+    renderAdvanced(renderer) {
+      const filters = this.filters;
+      const mask = this._mask;
+      if (filters) {
+        if (!this._enabledFilters) {
+          this._enabledFilters = [];
+        }
+        this._enabledFilters.length = 0;
+        for (let i = 0; i < filters.length; i++) {
+          if (filters[i].enabled) {
+            this._enabledFilters.push(filters[i]);
+          }
+        }
+      }
+      const flush = filters && this._enabledFilters?.length || mask && (!mask.isMaskData || mask.enabled && (mask.autoDetect || mask.type !== MASK_TYPES.NONE));
+      if (flush) {
+        renderer.batch.flush();
+      }
+      if (filters && this._enabledFilters?.length) {
+        renderer.filter.push(this, this._enabledFilters);
+      }
+      if (mask) {
+        renderer.mask.push(this, this._mask);
+      }
+      if (this.cullable) {
+        this._renderWithCulling(renderer);
+      } else {
+        this._render(renderer);
+        for (let i = 0, j = this.children.length; i < j; ++i) {
+          this.children[i].render(renderer);
+        }
+      }
+      if (flush) {
+        renderer.batch.flush();
+      }
+      if (mask) {
+        renderer.mask.pop(this);
+      }
+      if (filters && this._enabledFilters?.length) {
+        renderer.filter.pop();
+      }
+    }
+    _render(_renderer) {
+    }
+    destroy(options) {
+      super.destroy();
+      this.sortDirty = false;
+      const destroyChildren = typeof options === "boolean" ? options : options?.children;
+      const oldChildren = this.removeChildren(0, this.children.length);
+      if (destroyChildren) {
+        for (let i = 0; i < oldChildren.length; ++i) {
+          oldChildren[i].destroy(options);
+        }
+      }
+    }
+    get width() {
+      return this.scale.x * this.getLocalBounds().width;
+    }
+    set width(value) {
+      const width = this.getLocalBounds().width;
+      if (width !== 0) {
+        this.scale.x = value / width;
+      } else {
+        this.scale.x = 1;
+      }
+      this._width = value;
+    }
+    get height() {
+      return this.scale.y * this.getLocalBounds().height;
+    }
+    set height(value) {
+      const height = this.getLocalBounds().height;
+      if (height !== 0) {
+        this.scale.y = value / height;
+      } else {
+        this.scale.y = 1;
+      }
+      this._height = value;
+    }
+  };
+  let Container = _Container;
+  Container.defaultSortableChildren = false;
+  Container.prototype.containerUpdateTransform = Container.prototype.updateTransform;
+
+  Object.defineProperties(settings, {
+    SORTABLE_CHILDREN: {
+      get() {
+        return Container.defaultSortableChildren;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.SORTABLE_CHILDREN is deprecated, use Container.defaultSortableChildren");
+        Container.defaultSortableChildren = value;
+      }
+    }
+  });
+
+  const tempPoint$2 = new Point();
+  const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+  class Sprite extends Container {
+    constructor(texture) {
+      super();
+      this._anchor = new ObservablePoint(this._onAnchorUpdate, this, texture ? texture.defaultAnchor.x : 0, texture ? texture.defaultAnchor.y : 0);
+      this._texture = null;
+      this._width = 0;
+      this._height = 0;
+      this._tintColor = new Color(16777215);
+      this._tintRGB = null;
+      this.tint = 16777215;
+      this.blendMode = BLEND_MODES.NORMAL;
+      this._cachedTint = 16777215;
+      this.uvs = null;
+      this.texture = texture || Texture.EMPTY;
+      this.vertexData = new Float32Array(8);
+      this.vertexTrimmedData = null;
+      this._transformID = -1;
+      this._textureID = -1;
+      this._transformTrimmedID = -1;
+      this._textureTrimmedID = -1;
+      this.indices = indices;
+      this.pluginName = "batch";
+      this.isSprite = true;
+      this._roundPixels = settings.ROUND_PIXELS;
+    }
+    _onTextureUpdate() {
+      this._textureID = -1;
+      this._textureTrimmedID = -1;
+      this._cachedTint = 16777215;
+      if (this._width) {
+        this.scale.x = sign(this.scale.x) * this._width / this._texture.orig.width;
+      }
+      if (this._height) {
+        this.scale.y = sign(this.scale.y) * this._height / this._texture.orig.height;
+      }
+    }
+    _onAnchorUpdate() {
+      this._transformID = -1;
+      this._transformTrimmedID = -1;
+    }
+    calculateVertices() {
+      const texture = this._texture;
+      if (this._transformID === this.transform._worldID && this._textureID === texture._updateID) {
+        return;
+      }
+      if (this._textureID !== texture._updateID) {
+        this.uvs = this._texture._uvs.uvsFloat32;
+      }
+      this._transformID = this.transform._worldID;
+      this._textureID = texture._updateID;
+      const wt = this.transform.worldTransform;
+      const a = wt.a;
+      const b = wt.b;
+      const c = wt.c;
+      const d = wt.d;
+      const tx = wt.tx;
+      const ty = wt.ty;
+      const vertexData = this.vertexData;
+      const trim = texture.trim;
+      const orig = texture.orig;
+      const anchor = this._anchor;
+      let w0 = 0;
+      let w1 = 0;
+      let h0 = 0;
+      let h1 = 0;
+      if (trim) {
+        w1 = trim.x - anchor._x * orig.width;
+        w0 = w1 + trim.width;
+        h1 = trim.y - anchor._y * orig.height;
+        h0 = h1 + trim.height;
+      } else {
+        w1 = -anchor._x * orig.width;
+        w0 = w1 + orig.width;
+        h1 = -anchor._y * orig.height;
+        h0 = h1 + orig.height;
+      }
+      vertexData[0] = a * w1 + c * h1 + tx;
+      vertexData[1] = d * h1 + b * w1 + ty;
+      vertexData[2] = a * w0 + c * h1 + tx;
+      vertexData[3] = d * h1 + b * w0 + ty;
+      vertexData[4] = a * w0 + c * h0 + tx;
+      vertexData[5] = d * h0 + b * w0 + ty;
+      vertexData[6] = a * w1 + c * h0 + tx;
+      vertexData[7] = d * h0 + b * w1 + ty;
+      if (this._roundPixels) {
+        const resolution = settings.RESOLUTION;
+        for (let i = 0; i < vertexData.length; ++i) {
+          vertexData[i] = Math.round(vertexData[i] * resolution) / resolution;
+        }
+      }
+    }
+    calculateTrimmedVertices() {
+      if (!this.vertexTrimmedData) {
+        this.vertexTrimmedData = new Float32Array(8);
+      } else if (this._transformTrimmedID === this.transform._worldID && this._textureTrimmedID === this._texture._updateID) {
+        return;
+      }
+      this._transformTrimmedID = this.transform._worldID;
+      this._textureTrimmedID = this._texture._updateID;
+      const texture = this._texture;
+      const vertexData = this.vertexTrimmedData;
+      const orig = texture.orig;
+      const anchor = this._anchor;
+      const wt = this.transform.worldTransform;
+      const a = wt.a;
+      const b = wt.b;
+      const c = wt.c;
+      const d = wt.d;
+      const tx = wt.tx;
+      const ty = wt.ty;
+      const w1 = -anchor._x * orig.width;
+      const w0 = w1 + orig.width;
+      const h1 = -anchor._y * orig.height;
+      const h0 = h1 + orig.height;
+      vertexData[0] = a * w1 + c * h1 + tx;
+      vertexData[1] = d * h1 + b * w1 + ty;
+      vertexData[2] = a * w0 + c * h1 + tx;
+      vertexData[3] = d * h1 + b * w0 + ty;
+      vertexData[4] = a * w0 + c * h0 + tx;
+      vertexData[5] = d * h0 + b * w0 + ty;
+      vertexData[6] = a * w1 + c * h0 + tx;
+      vertexData[7] = d * h0 + b * w1 + ty;
+    }
+    _render(renderer) {
+      this.calculateVertices();
+      renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
+      renderer.plugins[this.pluginName].render(this);
+    }
+    _calculateBounds() {
+      const trim = this._texture.trim;
+      const orig = this._texture.orig;
+      if (!trim || trim.width === orig.width && trim.height === orig.height) {
+        this.calculateVertices();
+        this._bounds.addQuad(this.vertexData);
+      } else {
+        this.calculateTrimmedVertices();
+        this._bounds.addQuad(this.vertexTrimmedData);
+      }
+    }
+    getLocalBounds(rect) {
+      if (this.children.length === 0) {
+        if (!this._localBounds) {
+          this._localBounds = new Bounds();
+        }
+        this._localBounds.minX = this._texture.orig.width * -this._anchor._x;
+        this._localBounds.minY = this._texture.orig.height * -this._anchor._y;
+        this._localBounds.maxX = this._texture.orig.width * (1 - this._anchor._x);
+        this._localBounds.maxY = this._texture.orig.height * (1 - this._anchor._y);
+        if (!rect) {
+          if (!this._localBoundsRect) {
+            this._localBoundsRect = new Rectangle();
+          }
+          rect = this._localBoundsRect;
+        }
+        return this._localBounds.getRectangle(rect);
+      }
+      return super.getLocalBounds.call(this, rect);
+    }
+    containsPoint(point) {
+      this.worldTransform.applyInverse(point, tempPoint$2);
+      const width = this._texture.orig.width;
+      const height = this._texture.orig.height;
+      const x1 = -width * this.anchor.x;
+      let y1 = 0;
+      if (tempPoint$2.x >= x1 && tempPoint$2.x < x1 + width) {
+        y1 = -height * this.anchor.y;
+        if (tempPoint$2.y >= y1 && tempPoint$2.y < y1 + height) {
+          return true;
+        }
+      }
+      return false;
+    }
+    destroy(options) {
+      super.destroy(options);
+      this._texture.off("update", this._onTextureUpdate, this);
+      this._anchor = null;
+      const destroyTexture = typeof options === "boolean" ? options : options?.texture;
+      if (destroyTexture) {
+        const destroyBaseTexture = typeof options === "boolean" ? options : options?.baseTexture;
+        this._texture.destroy(!!destroyBaseTexture);
+      }
+      this._texture = null;
+    }
+    static from(source, options) {
+      const texture = source instanceof Texture ? source : Texture.from(source, options);
+      return new Sprite(texture);
+    }
+    set roundPixels(value) {
+      if (this._roundPixels !== value) {
+        this._transformID = -1;
+      }
+      this._roundPixels = value;
+    }
+    get roundPixels() {
+      return this._roundPixels;
+    }
+    get width() {
+      return Math.abs(this.scale.x) * this._texture.orig.width;
+    }
+    set width(value) {
+      const s = sign(this.scale.x) || 1;
+      this.scale.x = s * value / this._texture.orig.width;
+      this._width = value;
+    }
+    get height() {
+      return Math.abs(this.scale.y) * this._texture.orig.height;
+    }
+    set height(value) {
+      const s = sign(this.scale.y) || 1;
+      this.scale.y = s * value / this._texture.orig.height;
+      this._height = value;
+    }
+    get anchor() {
+      return this._anchor;
+    }
+    set anchor(value) {
+      this._anchor.copyFrom(value);
+    }
+    get tint() {
+      return this._tintColor.value;
+    }
+    set tint(value) {
+      this._tintColor.setValue(value);
+      this._tintRGB = this._tintColor.toLittleEndianNumber();
+    }
+    get tintValue() {
+      return this._tintColor.toNumber();
+    }
+    get texture() {
+      return this._texture;
+    }
+    set texture(value) {
+      if (this._texture === value) {
+        return;
+      }
+      if (this._texture) {
+        this._texture.off("update", this._onTextureUpdate, this);
+      }
+      this._texture = value || Texture.EMPTY;
+      this._cachedTint = 16777215;
+      this._textureID = -1;
+      this._textureTrimmedID = -1;
+      if (value) {
+        if (value.baseTexture.valid) {
+          this._onTextureUpdate();
+        } else {
+          value.once("update", this._onTextureUpdate, this);
+        }
+      }
+    }
+  }
+
+  const tempPoint$1 = new Point();
+  class TilingSprite extends Sprite {
+    constructor(texture, width = 100, height = 100) {
+      super(texture);
+      this.tileTransform = new Transform();
+      this._width = width;
+      this._height = height;
+      this.uvMatrix = this.texture.uvMatrix || new TextureMatrix(texture);
+      this.pluginName = "tilingSprite";
+      this.uvRespectAnchor = false;
+    }
+    get clampMargin() {
+      return this.uvMatrix.clampMargin;
+    }
+    set clampMargin(value) {
+      this.uvMatrix.clampMargin = value;
+      this.uvMatrix.update(true);
+    }
+    get tileScale() {
+      return this.tileTransform.scale;
+    }
+    set tileScale(value) {
+      this.tileTransform.scale.copyFrom(value);
+    }
+    get tilePosition() {
+      return this.tileTransform.position;
+    }
+    set tilePosition(value) {
+      this.tileTransform.position.copyFrom(value);
+    }
+    _onTextureUpdate() {
+      if (this.uvMatrix) {
+        this.uvMatrix.texture = this._texture;
+      }
+      this._cachedTint = 16777215;
+    }
+    _render(renderer) {
+      const texture = this._texture;
+      if (!texture || !texture.valid) {
+        return;
+      }
+      this.tileTransform.updateLocalTransform();
+      this.uvMatrix.update();
+      renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
+      renderer.plugins[this.pluginName].render(this);
+    }
+    _calculateBounds() {
+      const minX = this._width * -this._anchor._x;
+      const minY = this._height * -this._anchor._y;
+      const maxX = this._width * (1 - this._anchor._x);
+      const maxY = this._height * (1 - this._anchor._y);
+      this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);
+    }
+    getLocalBounds(rect) {
+      if (this.children.length === 0) {
+        this._bounds.minX = this._width * -this._anchor._x;
+        this._bounds.minY = this._height * -this._anchor._y;
+        this._bounds.maxX = this._width * (1 - this._anchor._x);
+        this._bounds.maxY = this._height * (1 - this._anchor._y);
+        if (!rect) {
+          if (!this._localBoundsRect) {
+            this._localBoundsRect = new Rectangle();
+          }
+          rect = this._localBoundsRect;
+        }
+        return this._bounds.getRectangle(rect);
+      }
+      return super.getLocalBounds.call(this, rect);
+    }
+    containsPoint(point) {
+      this.worldTransform.applyInverse(point, tempPoint$1);
+      const width = this._width;
+      const height = this._height;
+      const x1 = -width * this.anchor._x;
+      if (tempPoint$1.x >= x1 && tempPoint$1.x < x1 + width) {
+        const y1 = -height * this.anchor._y;
+        if (tempPoint$1.y >= y1 && tempPoint$1.y < y1 + height) {
+          return true;
+        }
+      }
+      return false;
+    }
+    destroy(options) {
+      super.destroy(options);
+      this.tileTransform = null;
+      this.uvMatrix = null;
+    }
+    static from(source, options) {
+      const texture = source instanceof Texture ? source : Texture.from(source, options);
+      return new TilingSprite(texture, options.width, options.height);
+    }
+    get width() {
+      return this._width;
+    }
+    set width(value) {
+      this._width = value;
+    }
+    get height() {
+      return this._height;
+    }
+    set height(value) {
+      this._height = value;
+    }
+  }
+
+  var gl2FragmentSrc = "#version 300 es\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nin vec2 vTextureCoord;\n\nout vec4 fragmentColor;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\nuniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;\n\nvoid main(void)\n{\n    vec2 coord = vTextureCoord + ceil(uClampOffset - vTextureCoord);\n    coord = (uMapCoord * vec3(coord, 1.0)).xy;\n    vec2 unclamped = coord;\n    coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);\n\n    vec4 texSample = texture(uSampler, coord, unclamped == coord ? 0.0f : -32.0f);// lod-bias very negative to force lod 0\n\n    fragmentColor = texSample * uColor;\n}\n";
+
+  var gl2VertexSrc = "#version 300 es\n#define SHADER_NAME Tiling-Sprite-300\n\nprecision lowp float;\n\nin vec2 aVertexPosition;\nin vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nout vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n";
+
+  var gl1FragmentSrc = "#version 100\n#ifdef GL_EXT_shader_texture_lod\n    #extension GL_EXT_shader_texture_lod : enable\n#endif\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\nuniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;\n\nvoid main(void)\n{\n    vec2 coord = vTextureCoord + ceil(uClampOffset - vTextureCoord);\n    coord = (uMapCoord * vec3(coord, 1.0)).xy;\n    vec2 unclamped = coord;\n    coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);\n\n    #ifdef GL_EXT_shader_texture_lod\n        vec4 texSample = unclamped == coord\n            ? texture2D(uSampler, coord) \n            : texture2DLodEXT(uSampler, coord, 0);\n    #else\n        vec4 texSample = texture2D(uSampler, coord);\n    #endif\n\n    gl_FragColor = texSample * uColor;\n}\n";
+
+  var gl1VertexSrc = "#version 100\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n";
+
+  var fragmentSimpleSrc = "#version 100\n#define SHADER_NAME Tiling-Sprite-Simple-100\n\nprecision lowp float;\n\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\n\nvoid main(void)\n{\n    vec4 texSample = texture2D(uSampler, vTextureCoord);\n    gl_FragColor = texSample * uColor;\n}\n";
+
+  const tempMat = new Matrix();
+  class TilingSpriteRenderer extends ObjectRenderer {
+    constructor(renderer) {
+      super(renderer);
+      renderer.runners.contextChange.add(this);
+      this.quad = new QuadUv();
+      this.state = State.for2d();
+    }
+    contextChange() {
+      const renderer = this.renderer;
+      const uniforms = { globals: renderer.globalUniforms };
+      this.simpleShader = Shader.from(gl1VertexSrc, fragmentSimpleSrc, uniforms);
+      this.shader = renderer.context.webGLVersion > 1 ? Shader.from(gl2VertexSrc, gl2FragmentSrc, uniforms) : Shader.from(gl1VertexSrc, gl1FragmentSrc, uniforms);
+    }
+    render(ts) {
+      const renderer = this.renderer;
+      const quad = this.quad;
+      let vertices = quad.vertices;
+      vertices[0] = vertices[6] = ts._width * -ts.anchor.x;
+      vertices[1] = vertices[3] = ts._height * -ts.anchor.y;
+      vertices[2] = vertices[4] = ts._width * (1 - ts.anchor.x);
+      vertices[5] = vertices[7] = ts._height * (1 - ts.anchor.y);
+      const anchorX = ts.uvRespectAnchor ? ts.anchor.x : 0;
+      const anchorY = ts.uvRespectAnchor ? ts.anchor.y : 0;
+      vertices = quad.uvs;
+      vertices[0] = vertices[6] = -anchorX;
+      vertices[1] = vertices[3] = -anchorY;
+      vertices[2] = vertices[4] = 1 - anchorX;
+      vertices[5] = vertices[7] = 1 - anchorY;
+      quad.invalidate();
+      const tex = ts._texture;
+      const baseTex = tex.baseTexture;
+      const premultiplied = baseTex.alphaMode > 0;
+      const lt = ts.tileTransform.localTransform;
+      const uv = ts.uvMatrix;
+      let isSimple = baseTex.isPowerOfTwo && tex.frame.width === baseTex.width && tex.frame.height === baseTex.height;
+      if (isSimple) {
+        if (!baseTex._glTextures[renderer.CONTEXT_UID]) {
+          if (baseTex.wrapMode === WRAP_MODES.CLAMP) {
+            baseTex.wrapMode = WRAP_MODES.REPEAT;
+          }
+        } else {
+          isSimple = baseTex.wrapMode !== WRAP_MODES.CLAMP;
+        }
+      }
+      const shader = isSimple ? this.simpleShader : this.shader;
+      const w = tex.width;
+      const h = tex.height;
+      const W = ts._width;
+      const H = ts._height;
+      tempMat.set(lt.a * w / W, lt.b * w / H, lt.c * h / W, lt.d * h / H, lt.tx / W, lt.ty / H);
+      tempMat.invert();
+      if (isSimple) {
+        tempMat.prepend(uv.mapCoord);
+      } else {
+        shader.uniforms.uMapCoord = uv.mapCoord.toArray(true);
+        shader.uniforms.uClampFrame = uv.uClampFrame;
+        shader.uniforms.uClampOffset = uv.uClampOffset;
+      }
+      shader.uniforms.uTransform = tempMat.toArray(true);
+      shader.uniforms.uColor = Color.shared.setValue(ts.tint).premultiply(ts.worldAlpha, premultiplied).toArray(shader.uniforms.uColor);
+      shader.uniforms.translationMatrix = ts.transform.worldTransform.toArray(true);
+      shader.uniforms.uSampler = tex;
+      renderer.shader.bind(shader);
+      renderer.geometry.bind(quad);
+      this.state.blendMode = correctBlendMode(ts.blendMode, premultiplied);
+      renderer.state.set(this.state);
+      renderer.geometry.draw(this.renderer.gl.TRIANGLES, 6, 0);
+    }
+  }
+  TilingSpriteRenderer.extension = {
+    name: "tilingSprite",
+    type: ExtensionType.RendererPlugin
+  };
+  extensions$1.add(TilingSpriteRenderer);
+
+  const worldMatrix = new Matrix();
+  const patternMatrix = new Matrix();
+  const patternRect = [new Point(), new Point(), new Point(), new Point()];
+  TilingSprite.prototype._renderCanvas = function _renderCanvas(renderer) {
+    const texture = this._texture;
+    if (!texture.baseTexture.valid) {
+      return;
+    }
+    const context = renderer.canvasContext.activeContext;
+    const transform = this.worldTransform;
+    const baseTexture = texture.baseTexture;
+    const source = baseTexture.getDrawableSource();
+    const baseTextureResolution = baseTexture.resolution;
+    if (this._textureID !== this._texture._updateID || this._cachedTint !== this.tintValue) {
+      this._textureID = this._texture._updateID;
+      const tempCanvas = new CanvasRenderTarget(texture._frame.width, texture._frame.height, baseTextureResolution);
+      if (this.tintValue !== 16777215) {
+        this._tintedCanvas = canvasUtils.getTintedCanvas(this, this.tintValue);
+        tempCanvas.context.drawImage(this._tintedCanvas, 0, 0);
+      } else {
+        tempCanvas.context.drawImage(source, -texture._frame.x * baseTextureResolution, -texture._frame.y * baseTextureResolution);
+      }
+      this._cachedTint = this.tintValue;
+      this._canvasPattern = tempCanvas.context.createPattern(tempCanvas.canvas, "repeat");
+    }
+    context.globalAlpha = this.worldAlpha;
+    renderer.canvasContext.setBlendMode(this.blendMode);
+    this.tileTransform.updateLocalTransform();
+    const lt = this.tileTransform.localTransform;
+    const W = this._width;
+    const H = this._height;
+    worldMatrix.identity();
+    patternMatrix.copyFrom(lt);
+    if (!this.uvRespectAnchor) {
+      patternMatrix.translate(-this.anchor.x * W, -this.anchor.y * H);
+    }
+    patternMatrix.scale(1 / baseTextureResolution, 1 / baseTextureResolution);
+    worldMatrix.prepend(patternMatrix);
+    worldMatrix.prepend(transform);
+    renderer.canvasContext.setContextTransform(worldMatrix);
+    context.fillStyle = this._canvasPattern;
+    const lx = this.anchor.x * -W;
+    const ly = this.anchor.y * -H;
+    patternRect[0].set(lx, ly);
+    patternRect[1].set(lx + W, ly);
+    patternRect[2].set(lx + W, ly + H);
+    patternRect[3].set(lx, ly + H);
+    for (let i = 0; i < 4; i++) {
+      patternMatrix.applyInverse(patternRect[i], patternRect[i]);
+    }
+    context.beginPath();
+    context.moveTo(patternRect[0].x, patternRect[0].y);
+    for (let i = 1; i < 4; i++) {
+      context.lineTo(patternRect[i].x, patternRect[i].y);
+    }
+    context.closePath();
+    context.fill();
+  };
+
+  class ParticleContainer extends Container {
+    constructor(maxSize = 1500, properties, batchSize = 16384, autoResize = false) {
+      super();
+      const maxBatchSize = 16384;
+      if (batchSize > maxBatchSize) {
+        batchSize = maxBatchSize;
+      }
+      this._properties = [false, true, false, false, false];
+      this._maxSize = maxSize;
+      this._batchSize = batchSize;
+      this._buffers = null;
+      this._bufferUpdateIDs = [];
+      this._updateID = 0;
+      this.interactiveChildren = false;
+      this.blendMode = BLEND_MODES.NORMAL;
+      this.autoResize = autoResize;
+      this.roundPixels = true;
+      this.baseTexture = null;
+      this.setProperties(properties);
+      this._tintColor = new Color(0);
+      this.tintRgb = new Float32Array(3);
+      this.tint = 16777215;
+    }
+    setProperties(properties) {
+      if (properties) {
+        this._properties[0] = "vertices" in properties || "scale" in properties ? !!properties.vertices || !!properties.scale : this._properties[0];
+        this._properties[1] = "position" in properties ? !!properties.position : this._properties[1];
+        this._properties[2] = "rotation" in properties ? !!properties.rotation : this._properties[2];
+        this._properties[3] = "uvs" in properties ? !!properties.uvs : this._properties[3];
+        this._properties[4] = "tint" in properties || "alpha" in properties ? !!properties.tint || !!properties.alpha : this._properties[4];
+      }
+    }
+    updateTransform() {
+      this.displayObjectUpdateTransform();
+    }
+    get tint() {
+      return this._tintColor.value;
+    }
+    set tint(value) {
+      this._tintColor.setValue(value);
+      this._tintColor.toRgbArray(this.tintRgb);
+    }
+    render(renderer) {
+      if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable) {
+        return;
+      }
+      if (!this.baseTexture) {
+        this.baseTexture = this.children[0]._texture.baseTexture;
+        if (!this.baseTexture.valid) {
+          this.baseTexture.once("update", () => this.onChildrenChange(0));
+        }
+      }
+      renderer.batch.setObjectRenderer(renderer.plugins.particle);
+      renderer.plugins.particle.render(this);
+    }
+    onChildrenChange(smallestChildIndex) {
+      const bufferIndex = Math.floor(smallestChildIndex / this._batchSize);
+      while (this._bufferUpdateIDs.length < bufferIndex) {
+        this._bufferUpdateIDs.push(0);
+      }
+      this._bufferUpdateIDs[bufferIndex] = ++this._updateID;
+    }
+    dispose() {
+      if (this._buffers) {
+        for (let i = 0; i < this._buffers.length; ++i) {
+          this._buffers[i].destroy();
+        }
+        this._buffers = null;
+      }
+    }
+    destroy(options) {
+      super.destroy(options);
+      this.dispose();
+      this._properties = null;
+      this._buffers = null;
+      this._bufferUpdateIDs = null;
+    }
+  }
+
+  class ParticleBuffer {
+    constructor(properties, dynamicPropertyFlags, size) {
+      this.geometry = new Geometry();
+      this.indexBuffer = null;
+      this.size = size;
+      this.dynamicProperties = [];
+      this.staticProperties = [];
+      for (let i = 0; i < properties.length; ++i) {
+        let property = properties[i];
+        property = {
+          attributeName: property.attributeName,
+          size: property.size,
+          uploadFunction: property.uploadFunction,
+          type: property.type || TYPES.FLOAT,
+          offset: property.offset
+        };
+        if (dynamicPropertyFlags[i]) {
+          this.dynamicProperties.push(property);
+        } else {
+          this.staticProperties.push(property);
+        }
+      }
+      this.staticStride = 0;
+      this.staticBuffer = null;
+      this.staticData = null;
+      this.staticDataUint32 = null;
+      this.dynamicStride = 0;
+      this.dynamicBuffer = null;
+      this.dynamicData = null;
+      this.dynamicDataUint32 = null;
+      this._updateID = 0;
+      this.initBuffers();
+    }
+    initBuffers() {
+      const geometry = this.geometry;
+      let dynamicOffset = 0;
+      this.indexBuffer = new Buffer(createIndicesForQuads(this.size), true, true);
+      geometry.addIndex(this.indexBuffer);
+      this.dynamicStride = 0;
+      for (let i = 0; i < this.dynamicProperties.length; ++i) {
+        const property = this.dynamicProperties[i];
+        property.offset = dynamicOffset;
+        dynamicOffset += property.size;
+        this.dynamicStride += property.size;
+      }
+      const dynBuffer = new ArrayBuffer(this.size * this.dynamicStride * 4 * 4);
+      this.dynamicData = new Float32Array(dynBuffer);
+      this.dynamicDataUint32 = new Uint32Array(dynBuffer);
+      this.dynamicBuffer = new Buffer(this.dynamicData, false, false);
+      let staticOffset = 0;
+      this.staticStride = 0;
+      for (let i = 0; i < this.staticProperties.length; ++i) {
+        const property = this.staticProperties[i];
+        property.offset = staticOffset;
+        staticOffset += property.size;
+        this.staticStride += property.size;
+      }
+      const statBuffer = new ArrayBuffer(this.size * this.staticStride * 4 * 4);
+      this.staticData = new Float32Array(statBuffer);
+      this.staticDataUint32 = new Uint32Array(statBuffer);
+      this.staticBuffer = new Buffer(this.staticData, true, false);
+      for (let i = 0; i < this.dynamicProperties.length; ++i) {
+        const property = this.dynamicProperties[i];
+        geometry.addAttribute(property.attributeName, this.dynamicBuffer, 0, property.type === TYPES.UNSIGNED_BYTE, property.type, this.dynamicStride * 4, property.offset * 4);
+      }
+      for (let i = 0; i < this.staticProperties.length; ++i) {
+        const property = this.staticProperties[i];
+        geometry.addAttribute(property.attributeName, this.staticBuffer, 0, property.type === TYPES.UNSIGNED_BYTE, property.type, this.staticStride * 4, property.offset * 4);
+      }
+    }
+    uploadDynamic(children, startIndex, amount) {
+      for (let i = 0; i < this.dynamicProperties.length; i++) {
+        const property = this.dynamicProperties[i];
+        property.uploadFunction(children, startIndex, amount, property.type === TYPES.UNSIGNED_BYTE ? this.dynamicDataUint32 : this.dynamicData, this.dynamicStride, property.offset);
+      }
+      this.dynamicBuffer._updateID++;
+    }
+    uploadStatic(children, startIndex, amount) {
+      for (let i = 0; i < this.staticProperties.length; i++) {
+        const property = this.staticProperties[i];
+        property.uploadFunction(children, startIndex, amount, property.type === TYPES.UNSIGNED_BYTE ? this.staticDataUint32 : this.staticData, this.staticStride, property.offset);
+      }
+      this.staticBuffer._updateID++;
+    }
+    destroy() {
+      this.indexBuffer = null;
+      this.dynamicProperties = null;
+      this.dynamicBuffer = null;
+      this.dynamicData = null;
+      this.dynamicDataUint32 = null;
+      this.staticProperties = null;
+      this.staticBuffer = null;
+      this.staticData = null;
+      this.staticDataUint32 = null;
+      this.geometry.destroy();
+    }
+  }
+
+  var fragment$6 = "varying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n    vec4 color = texture2D(uSampler, vTextureCoord) * vColor;\n    gl_FragColor = color;\n}";
+
+  var vertex$3 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\n\nattribute vec2 aPositionCoord;\nattribute float aRotation;\n\nuniform mat3 translationMatrix;\nuniform vec4 uColor;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nvoid main(void){\n    float x = (aVertexPosition.x) * cos(aRotation) - (aVertexPosition.y) * sin(aRotation);\n    float y = (aVertexPosition.x) * sin(aRotation) + (aVertexPosition.y) * cos(aRotation);\n\n    vec2 v = vec2(x, y);\n    v = v + aPositionCoord;\n\n    gl_Position = vec4((translationMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vColor = aColor * uColor;\n}\n";
+
+  class ParticleRenderer extends ObjectRenderer {
+    constructor(renderer) {
+      super(renderer);
+      this.shader = null;
+      this.properties = null;
+      this.tempMatrix = new Matrix();
+      this.properties = [
+        {
+          attributeName: "aVertexPosition",
+          size: 2,
+          uploadFunction: this.uploadVertices,
+          offset: 0
+        },
+        {
+          attributeName: "aPositionCoord",
+          size: 2,
+          uploadFunction: this.uploadPosition,
+          offset: 0
+        },
+        {
+          attributeName: "aRotation",
+          size: 1,
+          uploadFunction: this.uploadRotation,
+          offset: 0
+        },
+        {
+          attributeName: "aTextureCoord",
+          size: 2,
+          uploadFunction: this.uploadUvs,
+          offset: 0
+        },
+        {
+          attributeName: "aColor",
+          size: 1,
+          type: TYPES.UNSIGNED_BYTE,
+          uploadFunction: this.uploadTint,
+          offset: 0
+        }
+      ];
+      this.shader = Shader.from(vertex$3, fragment$6, {});
+      this.state = State.for2d();
+    }
+    render(container) {
+      const children = container.children;
+      const maxSize = container._maxSize;
+      const batchSize = container._batchSize;
+      const renderer = this.renderer;
+      let totalChildren = children.length;
+      if (totalChildren === 0) {
+        return;
+      } else if (totalChildren > maxSize && !container.autoResize) {
+        totalChildren = maxSize;
+      }
+      let buffers = container._buffers;
+      if (!buffers) {
+        buffers = container._buffers = this.generateBuffers(container);
+      }
+      const baseTexture = children[0]._texture.baseTexture;
+      const premultiplied = baseTexture.alphaMode > 0;
+      this.state.blendMode = correctBlendMode(container.blendMode, premultiplied);
+      renderer.state.set(this.state);
+      const gl = renderer.gl;
+      const m = container.worldTransform.copyTo(this.tempMatrix);
+      m.prepend(renderer.globalUniforms.uniforms.projectionMatrix);
+      this.shader.uniforms.translationMatrix = m.toArray(true);
+      this.shader.uniforms.uColor = Color.shared.setValue(container.tintRgb).premultiply(container.worldAlpha, premultiplied).toArray(this.shader.uniforms.uColor);
+      this.shader.uniforms.uSampler = baseTexture;
+      this.renderer.shader.bind(this.shader);
+      let updateStatic = false;
+      for (let i = 0, j = 0; i < totalChildren; i += batchSize, j += 1) {
+        let amount = totalChildren - i;
+        if (amount > batchSize) {
+          amount = batchSize;
+        }
+        if (j >= buffers.length) {
+          buffers.push(this._generateOneMoreBuffer(container));
+        }
+        const buffer = buffers[j];
+        buffer.uploadDynamic(children, i, amount);
+        const bid = container._bufferUpdateIDs[j] || 0;
+        updateStatic = updateStatic || buffer._updateID < bid;
+        if (updateStatic) {
+          buffer._updateID = container._updateID;
+          buffer.uploadStatic(children, i, amount);
+        }
+        renderer.geometry.bind(buffer.geometry);
+        gl.drawElements(gl.TRIANGLES, amount * 6, gl.UNSIGNED_SHORT, 0);
+      }
+    }
+    generateBuffers(container) {
+      const buffers = [];
+      const size = container._maxSize;
+      const batchSize = container._batchSize;
+      const dynamicPropertyFlags = container._properties;
+      for (let i = 0; i < size; i += batchSize) {
+        buffers.push(new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize));
+      }
+      return buffers;
+    }
+    _generateOneMoreBuffer(container) {
+      const batchSize = container._batchSize;
+      const dynamicPropertyFlags = container._properties;
+      return new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize);
+    }
+    uploadVertices(children, startIndex, amount, array, stride, offset) {
+      let w0 = 0;
+      let w1 = 0;
+      let h0 = 0;
+      let h1 = 0;
+      for (let i = 0; i < amount; ++i) {
+        const sprite = children[startIndex + i];
+        const texture = sprite._texture;
+        const sx = sprite.scale.x;
+        const sy = sprite.scale.y;
+        const trim = texture.trim;
+        const orig = texture.orig;
+        if (trim) {
+          w1 = trim.x - sprite.anchor.x * orig.width;
+          w0 = w1 + trim.width;
+          h1 = trim.y - sprite.anchor.y * orig.height;
+          h0 = h1 + trim.height;
+        } else {
+          w0 = orig.width * (1 - sprite.anchor.x);
+          w1 = orig.width * -sprite.anchor.x;
+          h0 = orig.height * (1 - sprite.anchor.y);
+          h1 = orig.height * -sprite.anchor.y;
+        }
+        array[offset] = w1 * sx;
+        array[offset + 1] = h1 * sy;
+        array[offset + stride] = w0 * sx;
+        array[offset + stride + 1] = h1 * sy;
+        array[offset + stride * 2] = w0 * sx;
+        array[offset + stride * 2 + 1] = h0 * sy;
+        array[offset + stride * 3] = w1 * sx;
+        array[offset + stride * 3 + 1] = h0 * sy;
+        offset += stride * 4;
+      }
+    }
+    uploadPosition(children, startIndex, amount, array, stride, offset) {
+      for (let i = 0; i < amount; i++) {
+        const spritePosition = children[startIndex + i].position;
+        array[offset] = spritePosition.x;
+        array[offset + 1] = spritePosition.y;
+        array[offset + stride] = spritePosition.x;
+        array[offset + stride + 1] = spritePosition.y;
+        array[offset + stride * 2] = spritePosition.x;
+        array[offset + stride * 2 + 1] = spritePosition.y;
+        array[offset + stride * 3] = spritePosition.x;
+        array[offset + stride * 3 + 1] = spritePosition.y;
+        offset += stride * 4;
+      }
+    }
+    uploadRotation(children, startIndex, amount, array, stride, offset) {
+      for (let i = 0; i < amount; i++) {
+        const spriteRotation = children[startIndex + i].rotation;
+        array[offset] = spriteRotation;
+        array[offset + stride] = spriteRotation;
+        array[offset + stride * 2] = spriteRotation;
+        array[offset + stride * 3] = spriteRotation;
+        offset += stride * 4;
+      }
+    }
+    uploadUvs(children, startIndex, amount, array, stride, offset) {
+      for (let i = 0; i < amount; ++i) {
+        const textureUvs = children[startIndex + i]._texture._uvs;
+        if (textureUvs) {
+          array[offset] = textureUvs.x0;
+          array[offset + 1] = textureUvs.y0;
+          array[offset + stride] = textureUvs.x1;
+          array[offset + stride + 1] = textureUvs.y1;
+          array[offset + stride * 2] = textureUvs.x2;
+          array[offset + stride * 2 + 1] = textureUvs.y2;
+          array[offset + stride * 3] = textureUvs.x3;
+          array[offset + stride * 3 + 1] = textureUvs.y3;
+          offset += stride * 4;
+        } else {
+          array[offset] = 0;
+          array[offset + 1] = 0;
+          array[offset + stride] = 0;
+          array[offset + stride + 1] = 0;
+          array[offset + stride * 2] = 0;
+          array[offset + stride * 2 + 1] = 0;
+          array[offset + stride * 3] = 0;
+          array[offset + stride * 3 + 1] = 0;
+          offset += stride * 4;
+        }
+      }
+    }
+    uploadTint(children, startIndex, amount, array, stride, offset) {
+      for (let i = 0; i < amount; ++i) {
+        const sprite = children[startIndex + i];
+        const result = Color.shared.setValue(sprite._tintRGB).toPremultiplied(sprite.alpha, sprite.texture.baseTexture.alphaMode > 0);
+        array[offset] = result;
+        array[offset + stride] = result;
+        array[offset + stride * 2] = result;
+        array[offset + stride * 3] = result;
+        offset += stride * 4;
+      }
+    }
+    destroy() {
+      super.destroy();
+      if (this.shader) {
+        this.shader.destroy();
+        this.shader = null;
+      }
+      this.tempMatrix = null;
+    }
+  }
+  ParticleRenderer.extension = {
+    name: "particle",
+    type: ExtensionType.RendererPlugin
+  };
+  extensions$1.add(ParticleRenderer);
+
+  ParticleContainer.prototype.renderCanvas = function renderCanvas(renderer) {
+    if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable) {
+      return;
+    }
+    const context = renderer.canvasContext.activeContext;
+    const transform = this.worldTransform;
+    let isRotated = true;
+    let positionX = 0;
+    let positionY = 0;
+    let finalWidth = 0;
+    let finalHeight = 0;
+    renderer.canvasContext.setBlendMode(this.blendMode);
+    context.globalAlpha = this.worldAlpha;
+    this.displayObjectUpdateTransform();
+    for (let i = 0; i < this.children.length; ++i) {
+      const child = this.children[i];
+      if (!child.visible) {
+        continue;
+      }
+      if (!child._texture.valid) {
+        continue;
+      }
+      const frame = child._texture.frame;
+      context.globalAlpha = this.worldAlpha * child.alpha;
+      if (child.rotation % (Math.PI * 2) === 0) {
+        if (isRotated) {
+          renderer.canvasContext.setContextTransform(transform, false, 1);
+          isRotated = false;
+        }
+        positionX = child.anchor.x * (-frame.width * child.scale.x) + child.position.x + 0.5;
+        positionY = child.anchor.y * (-frame.height * child.scale.y) + child.position.y + 0.5;
+        finalWidth = frame.width * child.scale.x;
+        finalHeight = frame.height * child.scale.y;
+      } else {
+        if (!isRotated) {
+          isRotated = true;
+        }
+        child.displayObjectUpdateTransform();
+        const childTransform = child.worldTransform;
+        renderer.canvasContext.setContextTransform(childTransform, this.roundPixels, 1);
+        positionX = child.anchor.x * -frame.width + 0.5;
+        positionY = child.anchor.y * -frame.height + 0.5;
+        finalWidth = frame.width;
+        finalHeight = frame.height;
+      }
+      const resolution = child._texture.baseTexture.resolution;
+      const contextResolution = renderer.canvasContext.activeResolution;
+      context.drawImage(child._texture.baseTexture.getDrawableSource(), frame.x * resolution, frame.y * resolution, frame.width * resolution, frame.height * resolution, positionX * contextResolution, positionY * contextResolution, finalWidth * contextResolution, finalHeight * contextResolution);
+    }
+  };
+
+  Container.prototype._renderCanvas = function _renderCanvas(_renderer) {
+  };
+  Container.prototype.renderCanvas = function renderCanvas(renderer) {
+    if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
+      return;
+    }
+    if (this._mask) {
+      renderer.mask.pushMask(this._mask);
+    }
+    this._renderCanvas(renderer);
+    for (let i = 0, j = this.children.length; i < j; ++i) {
+      this.children[i].renderCanvas(renderer);
+    }
+    if (this._mask) {
+      renderer.mask.popMask(renderer);
+    }
+  };
+
+  DisplayObject.prototype.renderCanvas = function renderCanvas(_renderer) {
+  };
+
+  var TEXT_GRADIENT = /* @__PURE__ */ ((TEXT_GRADIENT2) => {
+    TEXT_GRADIENT2[TEXT_GRADIENT2["LINEAR_VERTICAL"] = 0] = "LINEAR_VERTICAL";
+    TEXT_GRADIENT2[TEXT_GRADIENT2["LINEAR_HORIZONTAL"] = 1] = "LINEAR_HORIZONTAL";
+    return TEXT_GRADIENT2;
+  })(TEXT_GRADIENT || {});
+
+  const contextSettings = {
+    willReadFrequently: true
+  };
+  const _TextMetrics = class {
+    static get experimentalLetterSpacingSupported() {
+      let result = _TextMetrics._experimentalLetterSpacingSupported;
+      if (result !== void 0) {
+        const proto = settings.ADAPTER.getCanvasRenderingContext2D().prototype;
+        result = _TextMetrics._experimentalLetterSpacingSupported = "letterSpacing" in proto || "textLetterSpacing" in proto;
+      }
+      return result;
+    }
+    constructor(text, style, width, height, lines, lineWidths, lineHeight, maxLineWidth, fontProperties) {
+      this.text = text;
+      this.style = style;
+      this.width = width;
+      this.height = height;
+      this.lines = lines;
+      this.lineWidths = lineWidths;
+      this.lineHeight = lineHeight;
+      this.maxLineWidth = maxLineWidth;
+      this.fontProperties = fontProperties;
+    }
+    static measureText(text, style, wordWrap, canvas = _TextMetrics._canvas) {
+      wordWrap = wordWrap === void 0 || wordWrap === null ? style.wordWrap : wordWrap;
+      const font = style.toFontString();
+      const fontProperties = _TextMetrics.measureFont(font);
+      if (fontProperties.fontSize === 0) {
+        fontProperties.fontSize = style.fontSize;
+        fontProperties.ascent = style.fontSize;
+      }
+      const context = canvas.getContext("2d", contextSettings);
+      context.font = font;
+      const outputText = wordWrap ? _TextMetrics.wordWrap(text, style, canvas) : text;
+      const lines = outputText.split(/(?:\r\n|\r|\n)/);
+      const lineWidths = new Array(lines.length);
+      let maxLineWidth = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const lineWidth = _TextMetrics._measureText(lines[i], style.letterSpacing, context);
+        lineWidths[i] = lineWidth;
+        maxLineWidth = Math.max(maxLineWidth, lineWidth);
+      }
+      let width = maxLineWidth + style.strokeThickness;
+      if (style.dropShadow) {
+        width += style.dropShadowDistance;
+      }
+      const lineHeight = style.lineHeight || fontProperties.fontSize + style.strokeThickness;
+      let height = Math.max(lineHeight, fontProperties.fontSize + style.strokeThickness * 2) + (lines.length - 1) * (lineHeight + style.leading);
+      if (style.dropShadow) {
+        height += style.dropShadowDistance;
+      }
+      return new _TextMetrics(text, style, width, height, lines, lineWidths, lineHeight + style.leading, maxLineWidth, fontProperties);
+    }
+    static _measureText(text, letterSpacing, context) {
+      let useExperimentalLetterSpacing = false;
+      if (_TextMetrics.experimentalLetterSpacingSupported) {
+        if (_TextMetrics.experimentalLetterSpacing) {
+          context.letterSpacing = `${letterSpacing}px`;
+          context.textLetterSpacing = `${letterSpacing}px`;
+          useExperimentalLetterSpacing = true;
+        } else {
+          context.letterSpacing = "0px";
+          context.textLetterSpacing = "0px";
+        }
+      }
+      let width = context.measureText(text).width;
+      if (width > 0) {
+        if (useExperimentalLetterSpacing) {
+          width -= letterSpacing;
+        } else {
+          width += (_TextMetrics.graphemeSegmenter(text).length - 1) * letterSpacing;
+        }
+      }
+      return width;
+    }
+    static wordWrap(text, style, canvas = _TextMetrics._canvas) {
+      const context = canvas.getContext("2d", contextSettings);
+      let width = 0;
+      let line = "";
+      let lines = "";
+      const cache = /* @__PURE__ */ Object.create(null);
+      const { letterSpacing, whiteSpace } = style;
+      const collapseSpaces = _TextMetrics.collapseSpaces(whiteSpace);
+      const collapseNewlines = _TextMetrics.collapseNewlines(whiteSpace);
+      let canPrependSpaces = !collapseSpaces;
+      const wordWrapWidth = style.wordWrapWidth + letterSpacing;
+      const tokens = _TextMetrics.tokenize(text);
+      for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i];
+        if (_TextMetrics.isNewline(token)) {
+          if (!collapseNewlines) {
+            lines += _TextMetrics.addLine(line);
+            canPrependSpaces = !collapseSpaces;
+            line = "";
+            width = 0;
+            continue;
+          }
+          token = " ";
+        }
+        if (collapseSpaces) {
+          const currIsBreakingSpace = _TextMetrics.isBreakingSpace(token);
+          const lastIsBreakingSpace = _TextMetrics.isBreakingSpace(line[line.length - 1]);
+          if (currIsBreakingSpace && lastIsBreakingSpace) {
+            continue;
+          }
+        }
+        const tokenWidth = _TextMetrics.getFromCache(token, letterSpacing, cache, context);
+        if (tokenWidth > wordWrapWidth) {
+          if (line !== "") {
+            lines += _TextMetrics.addLine(line);
+            line = "";
+            width = 0;
+          }
+          if (_TextMetrics.canBreakWords(token, style.breakWords)) {
+            const characters = _TextMetrics.wordWrapSplit(token);
+            for (let j = 0; j < characters.length; j++) {
+              let char = characters[j];
+              let lastChar = char;
+              let k = 1;
+              while (characters[j + k]) {
+                const nextChar = characters[j + k];
+                if (!_TextMetrics.canBreakChars(lastChar, nextChar, token, j, style.breakWords)) {
+                  char += nextChar;
+                } else {
+                  break;
+                }
+                lastChar = nextChar;
+                k++;
+              }
+              j += k - 1;
+              const characterWidth = _TextMetrics.getFromCache(char, letterSpacing, cache, context);
+              if (characterWidth + width > wordWrapWidth) {
+                lines += _TextMetrics.addLine(line);
+                canPrependSpaces = false;
+                line = "";
+                width = 0;
+              }
+              line += char;
+              width += characterWidth;
+            }
+          } else {
+            if (line.length > 0) {
+              lines += _TextMetrics.addLine(line);
+              line = "";
+              width = 0;
+            }
+            const isLastToken = i === tokens.length - 1;
+            lines += _TextMetrics.addLine(token, !isLastToken);
+            canPrependSpaces = false;
+            line = "";
+            width = 0;
+          }
+        } else {
+          if (tokenWidth + width > wordWrapWidth) {
+            canPrependSpaces = false;
+            lines += _TextMetrics.addLine(line);
+            line = "";
+            width = 0;
+          }
+          if (line.length > 0 || !_TextMetrics.isBreakingSpace(token) || canPrependSpaces) {
+            line += token;
+            width += tokenWidth;
+          }
+        }
+      }
+      lines += _TextMetrics.addLine(line, false);
+      return lines;
+    }
+    static addLine(line, newLine = true) {
+      line = _TextMetrics.trimRight(line);
+      line = newLine ? `${line}
+` : line;
+      return line;
+    }
+    static getFromCache(key, letterSpacing, cache, context) {
+      let width = cache[key];
+      if (typeof width !== "number") {
+        width = _TextMetrics._measureText(key, letterSpacing, context) + letterSpacing;
+        cache[key] = width;
+      }
+      return width;
+    }
+    static collapseSpaces(whiteSpace) {
+      return whiteSpace === "normal" || whiteSpace === "pre-line";
+    }
+    static collapseNewlines(whiteSpace) {
+      return whiteSpace === "normal";
+    }
+    static trimRight(text) {
+      if (typeof text !== "string") {
+        return "";
+      }
+      for (let i = text.length - 1; i >= 0; i--) {
+        const char = text[i];
+        if (!_TextMetrics.isBreakingSpace(char)) {
+          break;
+        }
+        text = text.slice(0, -1);
+      }
+      return text;
+    }
+    static isNewline(char) {
+      if (typeof char !== "string") {
+        return false;
+      }
+      return _TextMetrics._newlines.includes(char.charCodeAt(0));
+    }
+    static isBreakingSpace(char, _nextChar) {
+      if (typeof char !== "string") {
+        return false;
+      }
+      return _TextMetrics._breakingSpaces.includes(char.charCodeAt(0));
+    }
+    static tokenize(text) {
+      const tokens = [];
+      let token = "";
+      if (typeof text !== "string") {
+        return tokens;
+      }
+      for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        const nextChar = text[i + 1];
+        if (_TextMetrics.isBreakingSpace(char, nextChar) || _TextMetrics.isNewline(char)) {
+          if (token !== "") {
+            tokens.push(token);
+            token = "";
+          }
+          tokens.push(char);
+          continue;
+        }
+        token += char;
+      }
+      if (token !== "") {
+        tokens.push(token);
+      }
+      return tokens;
+    }
+    static canBreakWords(_token, breakWords) {
+      return breakWords;
+    }
+    static canBreakChars(_char, _nextChar, _token, _index, _breakWords) {
+      return true;
+    }
+    static wordWrapSplit(token) {
+      return _TextMetrics.graphemeSegmenter(token);
+    }
+    static measureFont(font) {
+      if (_TextMetrics._fonts[font]) {
+        return _TextMetrics._fonts[font];
+      }
+      const properties = {
+        ascent: 0,
+        descent: 0,
+        fontSize: 0
+      };
+      const canvas = _TextMetrics._canvas;
+      const context = _TextMetrics._context;
+      context.font = font;
+      const metricsString = _TextMetrics.METRICS_STRING + _TextMetrics.BASELINE_SYMBOL;
+      const width = Math.ceil(context.measureText(metricsString).width);
+      let baseline = Math.ceil(context.measureText(_TextMetrics.BASELINE_SYMBOL).width);
+      const height = Math.ceil(_TextMetrics.HEIGHT_MULTIPLIER * baseline);
+      baseline = baseline * _TextMetrics.BASELINE_MULTIPLIER | 0;
+      if (width === 0 || height === 0) {
+        _TextMetrics._fonts[font] = properties;
+        return properties;
+      }
+      canvas.width = width;
+      canvas.height = height;
+      context.fillStyle = "#f00";
+      context.fillRect(0, 0, width, height);
+      context.font = font;
+      context.textBaseline = "alphabetic";
+      context.fillStyle = "#000";
+      context.fillText(metricsString, 0, baseline);
+      const imagedata = context.getImageData(0, 0, width, height).data;
+      const pixels = imagedata.length;
+      const line = width * 4;
+      let i = 0;
+      let idx = 0;
+      let stop = false;
+      for (i = 0; i < baseline; ++i) {
+        for (let j = 0; j < line; j += 4) {
+          if (imagedata[idx + j] !== 255) {
+            stop = true;
+            break;
+          }
+        }
+        if (!stop) {
+          idx += line;
+        } else {
+          break;
+        }
+      }
+      properties.ascent = baseline - i;
+      idx = pixels - line;
+      stop = false;
+      for (i = height; i > baseline; --i) {
+        for (let j = 0; j < line; j += 4) {
+          if (imagedata[idx + j] !== 255) {
+            stop = true;
+            break;
+          }
+        }
+        if (!stop) {
+          idx -= line;
+        } else {
+          break;
+        }
+      }
+      properties.descent = i - baseline;
+      properties.fontSize = properties.ascent + properties.descent;
+      _TextMetrics._fonts[font] = properties;
+      return properties;
+    }
+    static clearMetrics(font = "") {
+      if (font) {
+        delete _TextMetrics._fonts[font];
+      } else {
+        _TextMetrics._fonts = {};
+      }
+    }
+    static get _canvas() {
+      if (!_TextMetrics.__canvas) {
+        let canvas;
+        try {
+          const c = new OffscreenCanvas(0, 0);
+          const context = c.getContext("2d", contextSettings);
+          if (context?.measureText) {
+            _TextMetrics.__canvas = c;
+            return c;
+          }
+          canvas = settings.ADAPTER.createCanvas();
+        } catch (ex) {
+          canvas = settings.ADAPTER.createCanvas();
+        }
+        canvas.width = canvas.height = 10;
+        _TextMetrics.__canvas = canvas;
+      }
+      return _TextMetrics.__canvas;
+    }
+    static get _context() {
+      if (!_TextMetrics.__context) {
+        _TextMetrics.__context = _TextMetrics._canvas.getContext("2d", contextSettings);
+      }
+      return _TextMetrics.__context;
+    }
+  };
+  let TextMetrics = _TextMetrics;
+  TextMetrics.METRICS_STRING = "|\xC9q\xC5";
+  TextMetrics.BASELINE_SYMBOL = "M";
+  TextMetrics.BASELINE_MULTIPLIER = 1.4;
+  TextMetrics.HEIGHT_MULTIPLIER = 2;
+  TextMetrics.graphemeSegmenter = (() => {
+    if (typeof Intl?.Segmenter === "function") {
+      const segmenter = new Intl.Segmenter();
+      return (s) => [...segmenter.segment(s)].map((x) => x.segment);
+    }
+    return (s) => [...s];
+  })();
+  TextMetrics.experimentalLetterSpacing = false;
+  TextMetrics._fonts = {};
+  TextMetrics._newlines = [
+    10,
+    13
+  ];
+  TextMetrics._breakingSpaces = [
+    9,
+    32,
+    8192,
+    8193,
+    8194,
+    8195,
+    8196,
+    8197,
+    8198,
+    8200,
+    8201,
+    8202,
+    8287,
+    12288
+  ];
+
+  const genericFontFamilies = [
+    "serif",
+    "sans-serif",
+    "monospace",
+    "cursive",
+    "fantasy",
+    "system-ui"
+  ];
+  const _TextStyle = class {
+    constructor(style) {
+      this.styleID = 0;
+      this.reset();
+      deepCopyProperties(this, style, style);
+    }
+    clone() {
+      const clonedProperties = {};
+      deepCopyProperties(clonedProperties, this, _TextStyle.defaultStyle);
+      return new _TextStyle(clonedProperties);
+    }
+    reset() {
+      deepCopyProperties(this, _TextStyle.defaultStyle, _TextStyle.defaultStyle);
+    }
+    get align() {
+      return this._align;
+    }
+    set align(align) {
+      if (this._align !== align) {
+        this._align = align;
+        this.styleID++;
+      }
+    }
+    get breakWords() {
+      return this._breakWords;
+    }
+    set breakWords(breakWords) {
+      if (this._breakWords !== breakWords) {
+        this._breakWords = breakWords;
+        this.styleID++;
+      }
+    }
+    get dropShadow() {
+      return this._dropShadow;
+    }
+    set dropShadow(dropShadow) {
+      if (this._dropShadow !== dropShadow) {
+        this._dropShadow = dropShadow;
+        this.styleID++;
+      }
+    }
+    get dropShadowAlpha() {
+      return this._dropShadowAlpha;
+    }
+    set dropShadowAlpha(dropShadowAlpha) {
+      if (this._dropShadowAlpha !== dropShadowAlpha) {
+        this._dropShadowAlpha = dropShadowAlpha;
+        this.styleID++;
+      }
+    }
+    get dropShadowAngle() {
+      return this._dropShadowAngle;
+    }
+    set dropShadowAngle(dropShadowAngle) {
+      if (this._dropShadowAngle !== dropShadowAngle) {
+        this._dropShadowAngle = dropShadowAngle;
+        this.styleID++;
+      }
+    }
+    get dropShadowBlur() {
+      return this._dropShadowBlur;
+    }
+    set dropShadowBlur(dropShadowBlur) {
+      if (this._dropShadowBlur !== dropShadowBlur) {
+        this._dropShadowBlur = dropShadowBlur;
+        this.styleID++;
+      }
+    }
+    get dropShadowColor() {
+      return this._dropShadowColor;
+    }
+    set dropShadowColor(dropShadowColor) {
+      const outputColor = getColor(dropShadowColor);
+      if (this._dropShadowColor !== outputColor) {
+        this._dropShadowColor = outputColor;
+        this.styleID++;
+      }
+    }
+    get dropShadowDistance() {
+      return this._dropShadowDistance;
+    }
+    set dropShadowDistance(dropShadowDistance) {
+      if (this._dropShadowDistance !== dropShadowDistance) {
+        this._dropShadowDistance = dropShadowDistance;
+        this.styleID++;
+      }
+    }
+    get fill() {
+      return this._fill;
+    }
+    set fill(fill) {
+      const outputColor = getColor(fill);
+      if (this._fill !== outputColor) {
+        this._fill = outputColor;
+        this.styleID++;
+      }
+    }
+    get fillGradientType() {
+      return this._fillGradientType;
+    }
+    set fillGradientType(fillGradientType) {
+      if (this._fillGradientType !== fillGradientType) {
+        this._fillGradientType = fillGradientType;
+        this.styleID++;
+      }
+    }
+    get fillGradientStops() {
+      return this._fillGradientStops;
+    }
+    set fillGradientStops(fillGradientStops) {
+      if (!areArraysEqual(this._fillGradientStops, fillGradientStops)) {
+        this._fillGradientStops = fillGradientStops;
+        this.styleID++;
+      }
+    }
+    get fontFamily() {
+      return this._fontFamily;
+    }
+    set fontFamily(fontFamily) {
+      if (this.fontFamily !== fontFamily) {
+        this._fontFamily = fontFamily;
+        this.styleID++;
+      }
+    }
+    get fontSize() {
+      return this._fontSize;
+    }
+    set fontSize(fontSize) {
+      if (this._fontSize !== fontSize) {
+        this._fontSize = fontSize;
+        this.styleID++;
+      }
+    }
+    get fontStyle() {
+      return this._fontStyle;
+    }
+    set fontStyle(fontStyle) {
+      if (this._fontStyle !== fontStyle) {
+        this._fontStyle = fontStyle;
+        this.styleID++;
+      }
+    }
+    get fontVariant() {
+      return this._fontVariant;
+    }
+    set fontVariant(fontVariant) {
+      if (this._fontVariant !== fontVariant) {
+        this._fontVariant = fontVariant;
+        this.styleID++;
+      }
+    }
+    get fontWeight() {
+      return this._fontWeight;
+    }
+    set fontWeight(fontWeight) {
+      if (this._fontWeight !== fontWeight) {
+        this._fontWeight = fontWeight;
+        this.styleID++;
+      }
+    }
+    get letterSpacing() {
+      return this._letterSpacing;
+    }
+    set letterSpacing(letterSpacing) {
+      if (this._letterSpacing !== letterSpacing) {
+        this._letterSpacing = letterSpacing;
+        this.styleID++;
+      }
+    }
+    get lineHeight() {
+      return this._lineHeight;
+    }
+    set lineHeight(lineHeight) {
+      if (this._lineHeight !== lineHeight) {
+        this._lineHeight = lineHeight;
+        this.styleID++;
+      }
+    }
+    get leading() {
+      return this._leading;
+    }
+    set leading(leading) {
+      if (this._leading !== leading) {
+        this._leading = leading;
+        this.styleID++;
+      }
+    }
+    get lineJoin() {
+      return this._lineJoin;
+    }
+    set lineJoin(lineJoin) {
+      if (this._lineJoin !== lineJoin) {
+        this._lineJoin = lineJoin;
+        this.styleID++;
+      }
+    }
+    get miterLimit() {
+      return this._miterLimit;
+    }
+    set miterLimit(miterLimit) {
+      if (this._miterLimit !== miterLimit) {
+        this._miterLimit = miterLimit;
+        this.styleID++;
+      }
+    }
+    get padding() {
+      return this._padding;
+    }
+    set padding(padding) {
+      if (this._padding !== padding) {
+        this._padding = padding;
+        this.styleID++;
+      }
+    }
+    get stroke() {
+      return this._stroke;
+    }
+    set stroke(stroke) {
+      const outputColor = getColor(stroke);
+      if (this._stroke !== outputColor) {
+        this._stroke = outputColor;
+        this.styleID++;
+      }
+    }
+    get strokeThickness() {
+      return this._strokeThickness;
+    }
+    set strokeThickness(strokeThickness) {
+      if (this._strokeThickness !== strokeThickness) {
+        this._strokeThickness = strokeThickness;
+        this.styleID++;
+      }
+    }
+    get textBaseline() {
+      return this._textBaseline;
+    }
+    set textBaseline(textBaseline) {
+      if (this._textBaseline !== textBaseline) {
+        this._textBaseline = textBaseline;
+        this.styleID++;
+      }
+    }
+    get trim() {
+      return this._trim;
+    }
+    set trim(trim) {
+      if (this._trim !== trim) {
+        this._trim = trim;
+        this.styleID++;
+      }
+    }
+    get whiteSpace() {
+      return this._whiteSpace;
+    }
+    set whiteSpace(whiteSpace) {
+      if (this._whiteSpace !== whiteSpace) {
+        this._whiteSpace = whiteSpace;
+        this.styleID++;
+      }
+    }
+    get wordWrap() {
+      return this._wordWrap;
+    }
+    set wordWrap(wordWrap) {
+      if (this._wordWrap !== wordWrap) {
+        this._wordWrap = wordWrap;
+        this.styleID++;
+      }
+    }
+    get wordWrapWidth() {
+      return this._wordWrapWidth;
+    }
+    set wordWrapWidth(wordWrapWidth) {
+      if (this._wordWrapWidth !== wordWrapWidth) {
+        this._wordWrapWidth = wordWrapWidth;
+        this.styleID++;
+      }
+    }
+    toFontString() {
+      const fontSizeString = typeof this.fontSize === "number" ? `${this.fontSize}px` : this.fontSize;
+      let fontFamilies = this.fontFamily;
+      if (!Array.isArray(this.fontFamily)) {
+        fontFamilies = this.fontFamily.split(",");
+      }
+      for (let i = fontFamilies.length - 1; i >= 0; i--) {
+        let fontFamily = fontFamilies[i].trim();
+        if (!/([\"\'])[^\'\"]+\1/.test(fontFamily) && !genericFontFamilies.includes(fontFamily)) {
+          fontFamily = `"${fontFamily}"`;
+        }
+        fontFamilies[i] = fontFamily;
+      }
+      return `${this.fontStyle} ${this.fontVariant} ${this.fontWeight} ${fontSizeString} ${fontFamilies.join(",")}`;
+    }
+  };
+  let TextStyle = _TextStyle;
+  TextStyle.defaultStyle = {
+    align: "left",
+    breakWords: false,
+    dropShadow: false,
+    dropShadowAlpha: 1,
+    dropShadowAngle: Math.PI / 6,
+    dropShadowBlur: 0,
+    dropShadowColor: "black",
+    dropShadowDistance: 5,
+    fill: "black",
+    fillGradientType: TEXT_GRADIENT.LINEAR_VERTICAL,
+    fillGradientStops: [],
+    fontFamily: "Arial",
+    fontSize: 26,
+    fontStyle: "normal",
+    fontVariant: "normal",
+    fontWeight: "normal",
+    leading: 0,
+    letterSpacing: 0,
+    lineHeight: 0,
+    lineJoin: "miter",
+    miterLimit: 10,
+    padding: 0,
+    stroke: "black",
+    strokeThickness: 0,
+    textBaseline: "alphabetic",
+    trim: false,
+    whiteSpace: "pre",
+    wordWrap: false,
+    wordWrapWidth: 100
+  };
+  function getColor(color) {
+    const temp = Color.shared;
+    if (!Array.isArray(color)) {
+      return temp.setValue(color).toHex();
+    } else {
+      return color.map((c) => temp.setValue(c).toHex());
+    }
+  }
+  function areArraysEqual(array1, array2) {
+    if (!Array.isArray(array1) || !Array.isArray(array2)) {
+      return false;
+    }
+    if (array1.length !== array2.length) {
+      return false;
+    }
+    for (let i = 0; i < array1.length; ++i) {
+      if (array1[i] !== array2[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function deepCopyProperties(target, source, propertyObj) {
+    for (const prop in propertyObj) {
+      if (Array.isArray(source[prop])) {
+        target[prop] = source[prop].slice();
+      } else {
+        target[prop] = source[prop];
+      }
+    }
+  }
+
+  const defaultDestroyOptions = {
+    texture: true,
+    children: false,
+    baseTexture: true
+  };
+  const _Text = class extends Sprite {
+    constructor(text, style, canvas) {
+      let ownCanvas = false;
+      if (!canvas) {
+        canvas = settings.ADAPTER.createCanvas();
+        ownCanvas = true;
+      }
+      canvas.width = 3;
+      canvas.height = 3;
+      const texture = Texture.from(canvas);
+      texture.orig = new Rectangle();
+      texture.trim = new Rectangle();
+      super(texture);
+      this._ownCanvas = ownCanvas;
+      this.canvas = canvas;
+      this.context = canvas.getContext("2d", {
+        willReadFrequently: true
+      });
+      this._resolution = _Text.defaultResolution ?? settings.RESOLUTION;
+      this._autoResolution = _Text.defaultAutoResolution;
+      this._text = null;
+      this._style = null;
+      this._styleListener = null;
+      this._font = "";
+      this.text = text;
+      this.style = style;
+      this.localStyleID = -1;
+    }
+    static get experimentalLetterSpacing() {
+      return TextMetrics.experimentalLetterSpacing;
+    }
+    static set experimentalLetterSpacing(value) {
+      deprecation$1("7.1.0", "Text.experimentalLetterSpacing is deprecated, use TextMetrics.experimentalLetterSpacing");
+      TextMetrics.experimentalLetterSpacing = value;
+    }
+    updateText(respectDirty) {
+      const style = this._style;
+      if (this.localStyleID !== style.styleID) {
+        this.dirty = true;
+        this.localStyleID = style.styleID;
+      }
+      if (!this.dirty && respectDirty) {
+        return;
+      }
+      this._font = this._style.toFontString();
+      const context = this.context;
+      const measured = TextMetrics.measureText(this._text || " ", this._style, this._style.wordWrap, this.canvas);
+      const width = measured.width;
+      const height = measured.height;
+      const lines = measured.lines;
+      const lineHeight = measured.lineHeight;
+      const lineWidths = measured.lineWidths;
+      const maxLineWidth = measured.maxLineWidth;
+      const fontProperties = measured.fontProperties;
+      this.canvas.width = Math.ceil(Math.ceil(Math.max(1, width) + style.padding * 2) * this._resolution);
+      this.canvas.height = Math.ceil(Math.ceil(Math.max(1, height) + style.padding * 2) * this._resolution);
+      context.scale(this._resolution, this._resolution);
+      context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+      context.font = this._font;
+      context.lineWidth = style.strokeThickness;
+      context.textBaseline = style.textBaseline;
+      context.lineJoin = style.lineJoin;
+      context.miterLimit = style.miterLimit;
+      let linePositionX;
+      let linePositionY;
+      const passesCount = style.dropShadow ? 2 : 1;
+      for (let i = 0; i < passesCount; ++i) {
+        const isShadowPass = style.dropShadow && i === 0;
+        const dsOffsetText = isShadowPass ? Math.ceil(Math.max(1, height) + style.padding * 2) : 0;
+        const dsOffsetShadow = dsOffsetText * this._resolution;
+        if (isShadowPass) {
+          context.fillStyle = "black";
+          context.strokeStyle = "black";
+          const dropShadowColor = style.dropShadowColor;
+          const dropShadowBlur = style.dropShadowBlur * this._resolution;
+          const dropShadowDistance = style.dropShadowDistance * this._resolution;
+          context.shadowColor = Color.shared.setValue(dropShadowColor).setAlpha(style.dropShadowAlpha).toRgbaString();
+          context.shadowBlur = dropShadowBlur;
+          context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;
+          context.shadowOffsetY = Math.sin(style.dropShadowAngle) * dropShadowDistance + dsOffsetShadow;
+        } else {
+          context.fillStyle = this._generateFillStyle(style, lines, measured);
+          context.strokeStyle = style.stroke;
+          context.shadowColor = "black";
+          context.shadowBlur = 0;
+          context.shadowOffsetX = 0;
+          context.shadowOffsetY = 0;
+        }
+        let linePositionYShift = (lineHeight - fontProperties.fontSize) / 2;
+        if (lineHeight - fontProperties.fontSize < 0) {
+          linePositionYShift = 0;
+        }
+        for (let i2 = 0; i2 < lines.length; i2++) {
+          linePositionX = style.strokeThickness / 2;
+          linePositionY = style.strokeThickness / 2 + i2 * lineHeight + fontProperties.ascent + linePositionYShift;
+          if (style.align === "right") {
+            linePositionX += maxLineWidth - lineWidths[i2];
+          } else if (style.align === "center") {
+            linePositionX += (maxLineWidth - lineWidths[i2]) / 2;
+          }
+          if (style.stroke && style.strokeThickness) {
+            this.drawLetterSpacing(lines[i2], linePositionX + style.padding, linePositionY + style.padding - dsOffsetText, true);
+          }
+          if (style.fill) {
+            this.drawLetterSpacing(lines[i2], linePositionX + style.padding, linePositionY + style.padding - dsOffsetText);
+          }
+        }
+      }
+      this.updateTexture();
+    }
+    drawLetterSpacing(text, x, y, isStroke = false) {
+      const style = this._style;
+      const letterSpacing = style.letterSpacing;
+      let useExperimentalLetterSpacing = false;
+      if (TextMetrics.experimentalLetterSpacingSupported) {
+        if (TextMetrics.experimentalLetterSpacing) {
+          this.context.letterSpacing = `${letterSpacing}px`;
+          this.context.textLetterSpacing = `${letterSpacing}px`;
+          useExperimentalLetterSpacing = true;
+        } else {
+          this.context.letterSpacing = "0px";
+          this.context.textLetterSpacing = "0px";
+        }
+      }
+      if (letterSpacing === 0 || useExperimentalLetterSpacing) {
+        if (isStroke) {
+          this.context.strokeText(text, x, y);
+        } else {
+          this.context.fillText(text, x, y);
+        }
+        return;
+      }
+      let currentPosition = x;
+      const stringArray = TextMetrics.graphemeSegmenter(text);
+      let previousWidth = this.context.measureText(text).width;
+      let currentWidth = 0;
+      for (let i = 0; i < stringArray.length; ++i) {
+        const currentChar = stringArray[i];
+        if (isStroke) {
+          this.context.strokeText(currentChar, currentPosition, y);
+        } else {
+          this.context.fillText(currentChar, currentPosition, y);
+        }
+        let textStr = "";
+        for (let j = i + 1; j < stringArray.length; ++j) {
+          textStr += stringArray[j];
+        }
+        currentWidth = this.context.measureText(textStr).width;
+        currentPosition += previousWidth - currentWidth + letterSpacing;
+        previousWidth = currentWidth;
+      }
+    }
+    updateTexture() {
+      const canvas = this.canvas;
+      if (this._style.trim) {
+        const trimmed = trimCanvas(canvas);
+        if (trimmed.data) {
+          canvas.width = trimmed.width;
+          canvas.height = trimmed.height;
+          this.context.putImageData(trimmed.data, 0, 0);
+        }
+      }
+      const texture = this._texture;
+      const style = this._style;
+      const padding = style.trim ? 0 : style.padding;
+      const baseTexture = texture.baseTexture;
+      texture.trim.width = texture._frame.width = canvas.width / this._resolution;
+      texture.trim.height = texture._frame.height = canvas.height / this._resolution;
+      texture.trim.x = -padding;
+      texture.trim.y = -padding;
+      texture.orig.width = texture._frame.width - padding * 2;
+      texture.orig.height = texture._frame.height - padding * 2;
+      this._onTextureUpdate();
+      baseTexture.setRealSize(canvas.width, canvas.height, this._resolution);
+      texture.updateUvs();
+      this.dirty = false;
+    }
+    _render(renderer) {
+      if (this._autoResolution && this._resolution !== renderer.resolution) {
+        this._resolution = renderer.resolution;
+        this.dirty = true;
+      }
+      this.updateText(true);
+      super._render(renderer);
+    }
+    updateTransform() {
+      this.updateText(true);
+      super.updateTransform();
+    }
+    getBounds(skipUpdate, rect) {
+      this.updateText(true);
+      if (this._textureID === -1) {
+        skipUpdate = false;
+      }
+      return super.getBounds(skipUpdate, rect);
+    }
+    getLocalBounds(rect) {
+      this.updateText(true);
+      return super.getLocalBounds.call(this, rect);
+    }
+    _calculateBounds() {
+      this.calculateVertices();
+      this._bounds.addQuad(this.vertexData);
+    }
+    _generateFillStyle(style, lines, metrics) {
+      const fillStyle = style.fill;
+      if (!Array.isArray(fillStyle)) {
+        return fillStyle;
+      } else if (fillStyle.length === 1) {
+        return fillStyle[0];
+      }
+      let gradient;
+      const dropShadowCorrection = style.dropShadow ? style.dropShadowDistance : 0;
+      const padding = style.padding || 0;
+      const width = this.canvas.width / this._resolution - dropShadowCorrection - padding * 2;
+      const height = this.canvas.height / this._resolution - dropShadowCorrection - padding * 2;
+      const fill = fillStyle.slice();
+      const fillGradientStops = style.fillGradientStops.slice();
+      if (!fillGradientStops.length) {
+        const lengthPlus1 = fill.length + 1;
+        for (let i = 1; i < lengthPlus1; ++i) {
+          fillGradientStops.push(i / lengthPlus1);
+        }
+      }
+      fill.unshift(fillStyle[0]);
+      fillGradientStops.unshift(0);
+      fill.push(fillStyle[fillStyle.length - 1]);
+      fillGradientStops.push(1);
+      if (style.fillGradientType === TEXT_GRADIENT.LINEAR_VERTICAL) {
+        gradient = this.context.createLinearGradient(width / 2, padding, width / 2, height + padding);
+        const textHeight = metrics.fontProperties.fontSize + style.strokeThickness;
+        for (let i = 0; i < lines.length; i++) {
+          const lastLineBottom = metrics.lineHeight * (i - 1) + textHeight;
+          const thisLineTop = metrics.lineHeight * i;
+          let thisLineGradientStart = thisLineTop;
+          if (i > 0 && lastLineBottom > thisLineTop) {
+            thisLineGradientStart = (thisLineTop + lastLineBottom) / 2;
+          }
+          const thisLineBottom = thisLineTop + textHeight;
+          const nextLineTop = metrics.lineHeight * (i + 1);
+          let thisLineGradientEnd = thisLineBottom;
+          if (i + 1 < lines.length && nextLineTop < thisLineBottom) {
+            thisLineGradientEnd = (thisLineBottom + nextLineTop) / 2;
+          }
+          const gradStopLineHeight = (thisLineGradientEnd - thisLineGradientStart) / height;
+          for (let j = 0; j < fill.length; j++) {
+            let lineStop = 0;
+            if (typeof fillGradientStops[j] === "number") {
+              lineStop = fillGradientStops[j];
+            } else {
+              lineStop = j / fill.length;
+            }
+            let globalStop = Math.min(1, Math.max(0, thisLineGradientStart / height + lineStop * gradStopLineHeight));
+            globalStop = Number(globalStop.toFixed(5));
+            gradient.addColorStop(globalStop, fill[j]);
+          }
+        }
+      } else {
+        gradient = this.context.createLinearGradient(padding, height / 2, width + padding, height / 2);
+        const totalIterations = fill.length + 1;
+        let currentIteration = 1;
+        for (let i = 0; i < fill.length; i++) {
+          let stop;
+          if (typeof fillGradientStops[i] === "number") {
+            stop = fillGradientStops[i];
+          } else {
+            stop = currentIteration / totalIterations;
+          }
+          gradient.addColorStop(stop, fill[i]);
+          currentIteration++;
+        }
+      }
+      return gradient;
+    }
+    destroy(options) {
+      if (typeof options === "boolean") {
+        options = { children: options };
+      }
+      options = Object.assign({}, defaultDestroyOptions, options);
+      super.destroy(options);
+      if (this._ownCanvas) {
+        this.canvas.height = this.canvas.width = 0;
+      }
+      this.context = null;
+      this.canvas = null;
+      this._style = null;
+    }
+    get width() {
+      this.updateText(true);
+      return Math.abs(this.scale.x) * this._texture.orig.width;
+    }
+    set width(value) {
+      this.updateText(true);
+      const s = sign(this.scale.x) || 1;
+      this.scale.x = s * value / this._texture.orig.width;
+      this._width = value;
+    }
+    get height() {
+      this.updateText(true);
+      return Math.abs(this.scale.y) * this._texture.orig.height;
+    }
+    set height(value) {
+      this.updateText(true);
+      const s = sign(this.scale.y) || 1;
+      this.scale.y = s * value / this._texture.orig.height;
+      this._height = value;
+    }
+    get style() {
+      return this._style;
+    }
+    set style(style) {
+      style = style || {};
+      if (style instanceof TextStyle) {
+        this._style = style;
+      } else {
+        this._style = new TextStyle(style);
+      }
+      this.localStyleID = -1;
+      this.dirty = true;
+    }
+    get text() {
+      return this._text;
+    }
+    set text(text) {
+      text = String(text === null || text === void 0 ? "" : text);
+      if (this._text === text) {
+        return;
+      }
+      this._text = text;
+      this.dirty = true;
+    }
+    get resolution() {
+      return this._resolution;
+    }
+    set resolution(value) {
+      this._autoResolution = false;
+      if (this._resolution === value) {
+        return;
+      }
+      this._resolution = value;
+      this.dirty = true;
+    }
+  };
+  let Text = _Text;
+  Text.defaultAutoResolution = true;
+
+  Text.prototype._renderCanvas = function _renderCanvas(renderer) {
+    if (this._autoResolution && this._resolution !== renderer.resolution) {
+      this._resolution = renderer.resolution;
+      this.dirty = true;
+    }
+    this.updateText(true);
+    Sprite.prototype._renderCanvas.call(this, renderer);
+  };
+
+  const _tempMatrix = new Matrix();
+  DisplayObject.prototype._cacheAsBitmap = false;
+  DisplayObject.prototype._cacheData = null;
+  DisplayObject.prototype._cacheAsBitmapResolution = null;
+  DisplayObject.prototype._cacheAsBitmapMultisample = null;
+  class CacheData {
+    constructor() {
+      this.textureCacheId = null;
+      this.originalRender = null;
+      this.originalRenderCanvas = null;
+      this.originalCalculateBounds = null;
+      this.originalGetLocalBounds = null;
+      this.originalUpdateTransform = null;
+      this.originalDestroy = null;
+      this.originalMask = null;
+      this.originalFilterArea = null;
+      this.originalContainsPoint = null;
+      this.sprite = null;
+    }
+  }
+  Object.defineProperties(DisplayObject.prototype, {
+    cacheAsBitmapResolution: {
+      get() {
+        return this._cacheAsBitmapResolution;
+      },
+      set(resolution) {
+        if (resolution === this._cacheAsBitmapResolution) {
+          return;
+        }
+        this._cacheAsBitmapResolution = resolution;
+        if (this.cacheAsBitmap) {
+          this.cacheAsBitmap = false;
+          this.cacheAsBitmap = true;
+        }
+      }
+    },
+    cacheAsBitmapMultisample: {
+      get() {
+        return this._cacheAsBitmapMultisample;
+      },
+      set(multisample) {
+        if (multisample === this._cacheAsBitmapMultisample) {
+          return;
+        }
+        this._cacheAsBitmapMultisample = multisample;
+        if (this.cacheAsBitmap) {
+          this.cacheAsBitmap = false;
+          this.cacheAsBitmap = true;
+        }
+      }
+    },
+    cacheAsBitmap: {
+      get() {
+        return this._cacheAsBitmap;
+      },
+      set(value) {
+        if (this._cacheAsBitmap === value) {
+          return;
+        }
+        this._cacheAsBitmap = value;
+        let data;
+        if (value) {
+          if (!this._cacheData) {
+            this._cacheData = new CacheData();
+          }
+          data = this._cacheData;
+          data.originalRender = this.render;
+          data.originalRenderCanvas = this.renderCanvas;
+          data.originalUpdateTransform = this.updateTransform;
+          data.originalCalculateBounds = this.calculateBounds;
+          data.originalGetLocalBounds = this.getLocalBounds;
+          data.originalDestroy = this.destroy;
+          data.originalContainsPoint = this.containsPoint;
+          data.originalMask = this._mask;
+          data.originalFilterArea = this.filterArea;
+          this.render = this._renderCached;
+          this.renderCanvas = this._renderCachedCanvas;
+          this.destroy = this._cacheAsBitmapDestroy;
+        } else {
+          data = this._cacheData;
+          if (data.sprite) {
+            this._destroyCachedDisplayObject();
+          }
+          this.render = data.originalRender;
+          this.renderCanvas = data.originalRenderCanvas;
+          this.calculateBounds = data.originalCalculateBounds;
+          this.getLocalBounds = data.originalGetLocalBounds;
+          this.destroy = data.originalDestroy;
+          this.updateTransform = data.originalUpdateTransform;
+          this.containsPoint = data.originalContainsPoint;
+          this._mask = data.originalMask;
+          this.filterArea = data.originalFilterArea;
+        }
+      }
+    }
+  });
+  DisplayObject.prototype._renderCached = function _renderCached(renderer) {
+    if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
+      return;
+    }
+    this._initCachedDisplayObject(renderer);
+    this._cacheData.sprite.transform._worldID = this.transform._worldID;
+    this._cacheData.sprite.worldAlpha = this.worldAlpha;
+    this._cacheData.sprite._render(renderer);
+  };
+  DisplayObject.prototype._initCachedDisplayObject = function _initCachedDisplayObject(renderer) {
+    if (this._cacheData?.sprite) {
+      return;
+    }
+    const cacheAlpha = this.alpha;
+    this.alpha = 1;
+    renderer.batch.flush();
+    const bounds = this.getLocalBounds(null, true).clone();
+    if (this.filters?.length) {
+      const padding = this.filters[0].padding;
+      bounds.pad(padding);
+    }
+    bounds.ceil(settings.RESOLUTION);
+    const cachedRenderTexture = renderer.renderTexture.current;
+    const cachedSourceFrame = renderer.renderTexture.sourceFrame.clone();
+    const cachedDestinationFrame = renderer.renderTexture.destinationFrame.clone();
+    const cachedProjectionTransform = renderer.projection.transform;
+    const renderTexture = RenderTexture.create({
+      width: bounds.width,
+      height: bounds.height,
+      resolution: this.cacheAsBitmapResolution || renderer.resolution,
+      multisample: this.cacheAsBitmapMultisample ?? renderer.multisample
+    });
+    const textureCacheId = `cacheAsBitmap_${uid()}`;
+    this._cacheData.textureCacheId = textureCacheId;
+    BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);
+    Texture.addToCache(renderTexture, textureCacheId);
+    const m = this.transform.localTransform.copyTo(_tempMatrix).invert().translate(-bounds.x, -bounds.y);
+    this.render = this._cacheData.originalRender;
+    renderer.render(this, { renderTexture, clear: true, transform: m, skipUpdateTransform: false });
+    renderer.framebuffer.blit();
+    renderer.projection.transform = cachedProjectionTransform;
+    renderer.renderTexture.bind(cachedRenderTexture, cachedSourceFrame, cachedDestinationFrame);
+    this.render = this._renderCached;
+    this.updateTransform = this.displayObjectUpdateTransform;
+    this.calculateBounds = this._calculateCachedBounds;
+    this.getLocalBounds = this._getCachedLocalBounds;
+    this._mask = null;
+    this.filterArea = null;
+    this.alpha = cacheAlpha;
+    const cachedSprite = new Sprite(renderTexture);
+    cachedSprite.transform.worldTransform = this.transform.worldTransform;
+    cachedSprite.anchor.x = -(bounds.x / bounds.width);
+    cachedSprite.anchor.y = -(bounds.y / bounds.height);
+    cachedSprite.alpha = cacheAlpha;
+    cachedSprite._bounds = this._bounds;
+    this._cacheData.sprite = cachedSprite;
+    this.transform._parentID = -1;
+    if (!this.parent) {
+      this.enableTempParent();
+      this.updateTransform();
+      this.disableTempParent(null);
+    } else {
+      this.updateTransform();
+    }
+    this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
+  };
+  DisplayObject.prototype._renderCachedCanvas = function _renderCachedCanvas(renderer) {
+    if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
+      return;
+    }
+    this._initCachedDisplayObjectCanvas(renderer);
+    this._cacheData.sprite.worldAlpha = this.worldAlpha;
+    this._cacheData.sprite._renderCanvas(renderer);
+  };
+  DisplayObject.prototype._initCachedDisplayObjectCanvas = function _initCachedDisplayObjectCanvas(renderer) {
+    if (this._cacheData?.sprite) {
+      return;
+    }
+    const bounds = this.getLocalBounds(null, true);
+    const cacheAlpha = this.alpha;
+    this.alpha = 1;
+    const cachedRenderTarget = renderer.canvasContext.activeContext;
+    const cachedProjectionTransform = renderer._projTransform;
+    bounds.ceil(settings.RESOLUTION);
+    const renderTexture = RenderTexture.create({ width: bounds.width, height: bounds.height });
+    const textureCacheId = `cacheAsBitmap_${uid()}`;
+    this._cacheData.textureCacheId = textureCacheId;
+    BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);
+    Texture.addToCache(renderTexture, textureCacheId);
+    const m = _tempMatrix;
+    this.transform.localTransform.copyTo(m);
+    m.invert();
+    m.tx -= bounds.x;
+    m.ty -= bounds.y;
+    this.renderCanvas = this._cacheData.originalRenderCanvas;
+    renderer.render(this, { renderTexture, clear: true, transform: m, skipUpdateTransform: false });
+    renderer.canvasContext.activeContext = cachedRenderTarget;
+    renderer._projTransform = cachedProjectionTransform;
+    this.renderCanvas = this._renderCachedCanvas;
+    this.updateTransform = this.displayObjectUpdateTransform;
+    this.calculateBounds = this._calculateCachedBounds;
+    this.getLocalBounds = this._getCachedLocalBounds;
+    this._mask = null;
+    this.filterArea = null;
+    this.alpha = cacheAlpha;
+    const cachedSprite = new Sprite(renderTexture);
+    cachedSprite.transform.worldTransform = this.transform.worldTransform;
+    cachedSprite.anchor.x = -(bounds.x / bounds.width);
+    cachedSprite.anchor.y = -(bounds.y / bounds.height);
+    cachedSprite.alpha = cacheAlpha;
+    cachedSprite._bounds = this._bounds;
+    this._cacheData.sprite = cachedSprite;
+    this.transform._parentID = -1;
+    if (!this.parent) {
+      this.parent = renderer._tempDisplayObjectParent;
+      this.updateTransform();
+      this.parent = null;
+    } else {
+      this.updateTransform();
+    }
+    this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
+  };
+  DisplayObject.prototype._calculateCachedBounds = function _calculateCachedBounds() {
+    this._bounds.clear();
+    this._cacheData.sprite.transform._worldID = this.transform._worldID;
+    this._cacheData.sprite._calculateBounds();
+    this._bounds.updateID = this._boundsID;
+  };
+  DisplayObject.prototype._getCachedLocalBounds = function _getCachedLocalBounds() {
+    return this._cacheData.sprite.getLocalBounds(null);
+  };
+  DisplayObject.prototype._destroyCachedDisplayObject = function _destroyCachedDisplayObject() {
+    this._cacheData.sprite._texture.destroy(true);
+    this._cacheData.sprite = null;
+    BaseTexture.removeFromCache(this._cacheData.textureCacheId);
+    Texture.removeFromCache(this._cacheData.textureCacheId);
+    this._cacheData.textureCacheId = null;
+  };
+  DisplayObject.prototype._cacheAsBitmapDestroy = function _cacheAsBitmapDestroy(options) {
+    this.cacheAsBitmap = false;
+    this.destroy(options);
+  };
+
+  DisplayObject.prototype.name = null;
+  Container.prototype.getChildByName = function getChildByName(name, deep) {
+    for (let i = 0, j = this.children.length; i < j; i++) {
+      if (this.children[i].name === name) {
+        return this.children[i];
+      }
+    }
+    if (deep) {
+      for (let i = 0, j = this.children.length; i < j; i++) {
+        const child = this.children[i];
+        if (!child.getChildByName) {
+          continue;
+        }
+        const target = child.getChildByName(name, true);
+        if (target) {
+          return target;
+        }
+      }
+    }
+    return null;
+  };
+
+  DisplayObject.prototype.getGlobalPosition = function getGlobalPosition(point = new Point(), skipUpdate = false) {
+    if (this.parent) {
+      this.parent.toGlobal(this.position, point, skipUpdate);
+    } else {
+      point.x = this.position.x;
+      point.y = this.position.y;
+    }
+    return point;
+  };
+
+  var fragment$5 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform float uAlpha;\n\nvoid main(void)\n{\n   gl_FragColor = texture2D(uSampler, vTextureCoord) * uAlpha;\n}\n";
+
+  class AlphaFilter extends Filter {
+    constructor(alpha = 1) {
+      super(defaultVertex, fragment$5, { uAlpha: 1 });
+      this.alpha = alpha;
+    }
+    get alpha() {
+      return this.uniforms.uAlpha;
+    }
+    set alpha(value) {
+      this.uniforms.uAlpha = value;
+    }
+  }
+
+  const GAUSSIAN_VALUES = {
+    5: [0.153388, 0.221461, 0.250301],
+    7: [0.071303, 0.131514, 0.189879, 0.214607],
+    9: [0.028532, 0.067234, 0.124009, 0.179044, 0.20236],
+    11: [93e-4, 0.028002, 0.065984, 0.121703, 0.175713, 0.198596],
+    13: [2406e-6, 9255e-6, 0.027867, 0.065666, 0.121117, 0.174868, 0.197641],
+    15: [489e-6, 2403e-6, 9246e-6, 0.02784, 0.065602, 0.120999, 0.174697, 0.197448]
+  };
+  const fragTemplate = [
+    "varying vec2 vBlurTexCoords[%size%];",
+    "uniform sampler2D uSampler;",
+    "void main(void)",
+    "{",
+    "    gl_FragColor = vec4(0.0);",
+    "    %blur%",
+    "}"
+  ].join("\n");
+  function generateBlurFragSource(kernelSize) {
+    const kernel = GAUSSIAN_VALUES[kernelSize];
+    const halfLength = kernel.length;
+    let fragSource = fragTemplate;
+    let blurLoop = "";
+    const template = "gl_FragColor += texture2D(uSampler, vBlurTexCoords[%index%]) * %value%;";
+    let value;
+    for (let i = 0; i < kernelSize; i++) {
+      let blur = template.replace("%index%", i.toString());
+      value = i;
+      if (i >= halfLength) {
+        value = kernelSize - i - 1;
+      }
+      blur = blur.replace("%value%", kernel[value].toString());
+      blurLoop += blur;
+      blurLoop += "\n";
+    }
+    fragSource = fragSource.replace("%blur%", blurLoop);
+    fragSource = fragSource.replace("%size%", kernelSize.toString());
+    return fragSource;
+  }
+
+  const vertTemplate = `
+    attribute vec2 aVertexPosition;
+
+    uniform mat3 projectionMatrix;
+
+    uniform float strength;
+
+    varying vec2 vBlurTexCoords[%size%];
+
+    uniform vec4 inputSize;
+    uniform vec4 outputFrame;
+
+    vec4 filterVertexPosition( void )
+    {
+        vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;
+
+        return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);
+    }
+
+    vec2 filterTextureCoord( void )
+    {
+        return aVertexPosition * (outputFrame.zw * inputSize.zw);
+    }
+
+    void main(void)
+    {
+        gl_Position = filterVertexPosition();
+
+        vec2 textureCoord = filterTextureCoord();
+        %blur%
+    }`;
+  function generateBlurVertSource(kernelSize, x) {
+    const halfLength = Math.ceil(kernelSize / 2);
+    let vertSource = vertTemplate;
+    let blurLoop = "";
+    let template;
+    if (x) {
+      template = "vBlurTexCoords[%index%] =  textureCoord + vec2(%sampleIndex% * strength, 0.0);";
+    } else {
+      template = "vBlurTexCoords[%index%] =  textureCoord + vec2(0.0, %sampleIndex% * strength);";
+    }
+    for (let i = 0; i < kernelSize; i++) {
+      let blur = template.replace("%index%", i.toString());
+      blur = blur.replace("%sampleIndex%", `${i - (halfLength - 1)}.0`);
+      blurLoop += blur;
+      blurLoop += "\n";
+    }
+    vertSource = vertSource.replace("%blur%", blurLoop);
+    vertSource = vertSource.replace("%size%", kernelSize.toString());
+    return vertSource;
+  }
+
+  class BlurFilterPass extends Filter {
+    constructor(horizontal, strength = 8, quality = 4, resolution = Filter.defaultResolution, kernelSize = 5) {
+      const vertSrc = generateBlurVertSource(kernelSize, horizontal);
+      const fragSrc = generateBlurFragSource(kernelSize);
+      super(vertSrc, fragSrc);
+      this.horizontal = horizontal;
+      this.resolution = resolution;
+      this._quality = 0;
+      this.quality = quality;
+      this.blur = strength;
+    }
+    apply(filterManager, input, output, clearMode) {
+      if (output) {
+        if (this.horizontal) {
+          this.uniforms.strength = 1 / output.width * (output.width / input.width);
+        } else {
+          this.uniforms.strength = 1 / output.height * (output.height / input.height);
+        }
+      } else {
+        if (this.horizontal) {
+          this.uniforms.strength = 1 / filterManager.renderer.width * (filterManager.renderer.width / input.width);
+        } else {
+          this.uniforms.strength = 1 / filterManager.renderer.height * (filterManager.renderer.height / input.height);
+        }
+      }
+      this.uniforms.strength *= this.strength;
+      this.uniforms.strength /= this.passes;
+      if (this.passes === 1) {
+        filterManager.applyFilter(this, input, output, clearMode);
+      } else {
+        const renderTarget = filterManager.getFilterTexture();
+        const renderer = filterManager.renderer;
+        let flip = input;
+        let flop = renderTarget;
+        this.state.blend = false;
+        filterManager.applyFilter(this, flip, flop, CLEAR_MODES.CLEAR);
+        for (let i = 1; i < this.passes - 1; i++) {
+          filterManager.bindAndClear(flip, CLEAR_MODES.BLIT);
+          this.uniforms.uSampler = flop;
+          const temp = flop;
+          flop = flip;
+          flip = temp;
+          renderer.shader.bind(this);
+          renderer.geometry.draw(5);
+        }
+        this.state.blend = true;
+        filterManager.applyFilter(this, flop, output, clearMode);
+        filterManager.returnFilterTexture(renderTarget);
+      }
+    }
+    get blur() {
+      return this.strength;
+    }
+    set blur(value) {
+      this.padding = 1 + Math.abs(value) * 2;
+      this.strength = value;
+    }
+    get quality() {
+      return this._quality;
+    }
+    set quality(value) {
+      this._quality = value;
+      this.passes = value;
+    }
+  }
+
+  class BlurFilter extends Filter {
+    constructor(strength = 8, quality = 4, resolution = Filter.defaultResolution, kernelSize = 5) {
+      super();
+      this._repeatEdgePixels = false;
+      this.blurXFilter = new BlurFilterPass(true, strength, quality, resolution, kernelSize);
+      this.blurYFilter = new BlurFilterPass(false, strength, quality, resolution, kernelSize);
+      this.resolution = resolution;
+      this.quality = quality;
+      this.blur = strength;
+      this.repeatEdgePixels = false;
+    }
+    apply(filterManager, input, output, clearMode) {
+      const xStrength = Math.abs(this.blurXFilter.strength);
+      const yStrength = Math.abs(this.blurYFilter.strength);
+      if (xStrength && yStrength) {
+        const renderTarget = filterManager.getFilterTexture();
+        this.blurXFilter.apply(filterManager, input, renderTarget, CLEAR_MODES.CLEAR);
+        this.blurYFilter.apply(filterManager, renderTarget, output, clearMode);
+        filterManager.returnFilterTexture(renderTarget);
+      } else if (yStrength) {
+        this.blurYFilter.apply(filterManager, input, output, clearMode);
+      } else {
+        this.blurXFilter.apply(filterManager, input, output, clearMode);
+      }
+    }
+    updatePadding() {
+      if (this._repeatEdgePixels) {
+        this.padding = 0;
+      } else {
+        this.padding = Math.max(Math.abs(this.blurXFilter.strength), Math.abs(this.blurYFilter.strength)) * 2;
+      }
+    }
+    get blur() {
+      return this.blurXFilter.blur;
+    }
+    set blur(value) {
+      this.blurXFilter.blur = this.blurYFilter.blur = value;
+      this.updatePadding();
+    }
+    get quality() {
+      return this.blurXFilter.quality;
+    }
+    set quality(value) {
+      this.blurXFilter.quality = this.blurYFilter.quality = value;
+    }
+    get blurX() {
+      return this.blurXFilter.blur;
+    }
+    set blurX(value) {
+      this.blurXFilter.blur = value;
+      this.updatePadding();
+    }
+    get blurY() {
+      return this.blurYFilter.blur;
+    }
+    set blurY(value) {
+      this.blurYFilter.blur = value;
+      this.updatePadding();
+    }
+    get blendMode() {
+      return this.blurYFilter.blendMode;
+    }
+    set blendMode(value) {
+      this.blurYFilter.blendMode = value;
+    }
+    get repeatEdgePixels() {
+      return this._repeatEdgePixels;
+    }
+    set repeatEdgePixels(value) {
+      this._repeatEdgePixels = value;
+      this.updatePadding();
+    }
+  }
+
+  var fragment$4 = "varying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float m[20];\nuniform float uAlpha;\n\nvoid main(void)\n{\n    vec4 c = texture2D(uSampler, vTextureCoord);\n\n    if (uAlpha == 0.0) {\n        gl_FragColor = c;\n        return;\n    }\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (c.a > 0.0) {\n      c.rgb /= c.a;\n    }\n\n    vec4 result;\n\n    result.r = (m[0] * c.r);\n        result.r += (m[1] * c.g);\n        result.r += (m[2] * c.b);\n        result.r += (m[3] * c.a);\n        result.r += m[4];\n\n    result.g = (m[5] * c.r);\n        result.g += (m[6] * c.g);\n        result.g += (m[7] * c.b);\n        result.g += (m[8] * c.a);\n        result.g += m[9];\n\n    result.b = (m[10] * c.r);\n       result.b += (m[11] * c.g);\n       result.b += (m[12] * c.b);\n       result.b += (m[13] * c.a);\n       result.b += m[14];\n\n    result.a = (m[15] * c.r);\n       result.a += (m[16] * c.g);\n       result.a += (m[17] * c.b);\n       result.a += (m[18] * c.a);\n       result.a += m[19];\n\n    vec3 rgb = mix(c.rgb, result.rgb, uAlpha);\n\n    // Premultiply alpha again.\n    rgb *= result.a;\n\n    gl_FragColor = vec4(rgb, result.a);\n}\n";
+
+  class ColorMatrixFilter extends Filter {
+    constructor() {
+      const uniforms = {
+        m: new Float32Array([
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0
+        ]),
+        uAlpha: 1
+      };
+      super(defaultFilterVertex, fragment$4, uniforms);
+      this.alpha = 1;
+    }
+    _loadMatrix(matrix, multiply = false) {
+      let newMatrix = matrix;
+      if (multiply) {
+        this._multiply(newMatrix, this.uniforms.m, matrix);
+        newMatrix = this._colorMatrix(newMatrix);
+      }
+      this.uniforms.m = newMatrix;
+    }
+    _multiply(out, a, b) {
+      out[0] = a[0] * b[0] + a[1] * b[5] + a[2] * b[10] + a[3] * b[15];
+      out[1] = a[0] * b[1] + a[1] * b[6] + a[2] * b[11] + a[3] * b[16];
+      out[2] = a[0] * b[2] + a[1] * b[7] + a[2] * b[12] + a[3] * b[17];
+      out[3] = a[0] * b[3] + a[1] * b[8] + a[2] * b[13] + a[3] * b[18];
+      out[4] = a[0] * b[4] + a[1] * b[9] + a[2] * b[14] + a[3] * b[19] + a[4];
+      out[5] = a[5] * b[0] + a[6] * b[5] + a[7] * b[10] + a[8] * b[15];
+      out[6] = a[5] * b[1] + a[6] * b[6] + a[7] * b[11] + a[8] * b[16];
+      out[7] = a[5] * b[2] + a[6] * b[7] + a[7] * b[12] + a[8] * b[17];
+      out[8] = a[5] * b[3] + a[6] * b[8] + a[7] * b[13] + a[8] * b[18];
+      out[9] = a[5] * b[4] + a[6] * b[9] + a[7] * b[14] + a[8] * b[19] + a[9];
+      out[10] = a[10] * b[0] + a[11] * b[5] + a[12] * b[10] + a[13] * b[15];
+      out[11] = a[10] * b[1] + a[11] * b[6] + a[12] * b[11] + a[13] * b[16];
+      out[12] = a[10] * b[2] + a[11] * b[7] + a[12] * b[12] + a[13] * b[17];
+      out[13] = a[10] * b[3] + a[11] * b[8] + a[12] * b[13] + a[13] * b[18];
+      out[14] = a[10] * b[4] + a[11] * b[9] + a[12] * b[14] + a[13] * b[19] + a[14];
+      out[15] = a[15] * b[0] + a[16] * b[5] + a[17] * b[10] + a[18] * b[15];
+      out[16] = a[15] * b[1] + a[16] * b[6] + a[17] * b[11] + a[18] * b[16];
+      out[17] = a[15] * b[2] + a[16] * b[7] + a[17] * b[12] + a[18] * b[17];
+      out[18] = a[15] * b[3] + a[16] * b[8] + a[17] * b[13] + a[18] * b[18];
+      out[19] = a[15] * b[4] + a[16] * b[9] + a[17] * b[14] + a[18] * b[19] + a[19];
+      return out;
+    }
+    _colorMatrix(matrix) {
+      const m = new Float32Array(matrix);
+      m[4] /= 255;
+      m[9] /= 255;
+      m[14] /= 255;
+      m[19] /= 255;
+      return m;
+    }
+    brightness(b, multiply) {
+      const matrix = [
+        b,
+        0,
+        0,
+        0,
+        0,
+        0,
+        b,
+        0,
+        0,
+        0,
+        0,
+        0,
+        b,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    tint(color, multiply) {
+      const [r, g, b] = Color.shared.setValue(color).toArray();
+      const matrix = [
+        r,
+        0,
+        0,
+        0,
+        0,
+        0,
+        g,
+        0,
+        0,
+        0,
+        0,
+        0,
+        b,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    greyscale(scale, multiply) {
+      const matrix = [
+        scale,
+        scale,
+        scale,
+        0,
+        0,
+        scale,
+        scale,
+        scale,
+        0,
+        0,
+        scale,
+        scale,
+        scale,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    blackAndWhite(multiply) {
+      const matrix = [
+        0.3,
+        0.6,
+        0.1,
+        0,
+        0,
+        0.3,
+        0.6,
+        0.1,
+        0,
+        0,
+        0.3,
+        0.6,
+        0.1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    hue(rotation, multiply) {
+      rotation = (rotation || 0) / 180 * Math.PI;
+      const cosR = Math.cos(rotation);
+      const sinR = Math.sin(rotation);
+      const sqrt = Math.sqrt;
+      const w = 1 / 3;
+      const sqrW = sqrt(w);
+      const a00 = cosR + (1 - cosR) * w;
+      const a01 = w * (1 - cosR) - sqrW * sinR;
+      const a02 = w * (1 - cosR) + sqrW * sinR;
+      const a10 = w * (1 - cosR) + sqrW * sinR;
+      const a11 = cosR + w * (1 - cosR);
+      const a12 = w * (1 - cosR) - sqrW * sinR;
+      const a20 = w * (1 - cosR) - sqrW * sinR;
+      const a21 = w * (1 - cosR) + sqrW * sinR;
+      const a22 = cosR + w * (1 - cosR);
+      const matrix = [
+        a00,
+        a01,
+        a02,
+        0,
+        0,
+        a10,
+        a11,
+        a12,
+        0,
+        0,
+        a20,
+        a21,
+        a22,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    contrast(amount, multiply) {
+      const v = (amount || 0) + 1;
+      const o = -0.5 * (v - 1);
+      const matrix = [
+        v,
+        0,
+        0,
+        0,
+        o,
+        0,
+        v,
+        0,
+        0,
+        o,
+        0,
+        0,
+        v,
+        0,
+        o,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    saturate(amount = 0, multiply) {
+      const x = amount * 2 / 3 + 1;
+      const y = (x - 1) * -0.5;
+      const matrix = [
+        x,
+        y,
+        y,
+        0,
+        0,
+        y,
+        x,
+        y,
+        0,
+        0,
+        y,
+        y,
+        x,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    desaturate() {
+      this.saturate(-1);
+    }
+    negative(multiply) {
+      const matrix = [
+        -1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        -1,
+        0,
+        1,
+        0,
+        0,
+        0,
+        -1,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    sepia(multiply) {
+      const matrix = [
+        0.393,
+        0.7689999,
+        0.18899999,
+        0,
+        0,
+        0.349,
+        0.6859999,
+        0.16799999,
+        0,
+        0,
+        0.272,
+        0.5339999,
+        0.13099999,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    technicolor(multiply) {
+      const matrix = [
+        1.9125277891456083,
+        -0.8545344976951645,
+        -0.09155508482755585,
+        0,
+        11.793603434377337,
+        -0.3087833385928097,
+        1.7658908555458428,
+        -0.10601743074722245,
+        0,
+        -70.35205161461398,
+        -0.231103377548616,
+        -0.7501899197440212,
+        1.847597816108189,
+        0,
+        30.950940869491138,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    polaroid(multiply) {
+      const matrix = [
+        1.438,
+        -0.062,
+        -0.062,
+        0,
+        0,
+        -0.122,
+        1.378,
+        -0.122,
+        0,
+        0,
+        -0.016,
+        -0.016,
+        1.483,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    toBGR(multiply) {
+      const matrix = [
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    kodachrome(multiply) {
+      const matrix = [
+        1.1285582396593525,
+        -0.3967382283601348,
+        -0.03992559172921793,
+        0,
+        63.72958762196502,
+        -0.16404339962244616,
+        1.0835251566291304,
+        -0.05498805115633132,
+        0,
+        24.732407896706203,
+        -0.16786010706155763,
+        -0.5603416277695248,
+        1.6014850761964943,
+        0,
+        35.62982807460946,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    browni(multiply) {
+      const matrix = [
+        0.5997023498159715,
+        0.34553243048391263,
+        -0.2708298674538042,
+        0,
+        47.43192855600873,
+        -0.037703249837783157,
+        0.8609577587992641,
+        0.15059552388459913,
+        0,
+        -36.96841498319127,
+        0.24113635128153335,
+        -0.07441037908422492,
+        0.44972182064877153,
+        0,
+        -7.562075277591283,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    vintage(multiply) {
+      const matrix = [
+        0.6279345635605994,
+        0.3202183420819367,
+        -0.03965408211312453,
+        0,
+        9.651285835294123,
+        0.02578397704808868,
+        0.6441188644374771,
+        0.03259127616149294,
+        0,
+        7.462829176470591,
+        0.0466055556782719,
+        -0.0851232987247891,
+        0.5241648018700465,
+        0,
+        5.159190588235296,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    colorTone(desaturation, toned, lightColor, darkColor, multiply) {
+      desaturation = desaturation || 0.2;
+      toned = toned || 0.15;
+      lightColor = lightColor || 16770432;
+      darkColor = darkColor || 3375104;
+      const temp = Color.shared;
+      const [lR, lG, lB] = temp.setValue(lightColor).toArray();
+      const [dR, dG, dB] = temp.setValue(darkColor).toArray();
+      const matrix = [
+        0.3,
+        0.59,
+        0.11,
+        0,
+        0,
+        lR,
+        lG,
+        lB,
+        desaturation,
+        0,
+        dR,
+        dG,
+        dB,
+        toned,
+        0,
+        lR - dR,
+        lG - dG,
+        lB - dB,
+        0,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    night(intensity, multiply) {
+      intensity = intensity || 0.1;
+      const matrix = [
+        intensity * -2,
+        -intensity,
+        0,
+        0,
+        0,
+        -intensity,
+        0,
+        intensity,
+        0,
+        0,
+        0,
+        intensity,
+        intensity * 2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    predator(amount, multiply) {
+      const matrix = [
+        11.224130630493164 * amount,
+        -4.794486999511719 * amount,
+        -2.8746118545532227 * amount,
+        0 * amount,
+        0.40342438220977783 * amount,
+        -3.6330697536468506 * amount,
+        9.193157196044922 * amount,
+        -2.951810836791992 * amount,
+        0 * amount,
+        -1.316135048866272 * amount,
+        -3.2184197902679443 * amount,
+        -4.2375030517578125 * amount,
+        7.476448059082031 * amount,
+        0 * amount,
+        0.8044459223747253 * amount,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    lsd(multiply) {
+      const matrix = [
+        2,
+        -0.4,
+        0.5,
+        0,
+        0,
+        -0.5,
+        2,
+        -0.4,
+        0,
+        0,
+        -0.4,
+        -0.5,
+        3,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, multiply);
+    }
+    reset() {
+      const matrix = [
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0
+      ];
+      this._loadMatrix(matrix, false);
+    }
+    get matrix() {
+      return this.uniforms.m;
+    }
+    set matrix(value) {
+      this.uniforms.m = value;
+    }
+    get alpha() {
+      return this.uniforms.uAlpha;
+    }
+    set alpha(value) {
+      this.uniforms.uAlpha = value;
+    }
+  }
+  ColorMatrixFilter.prototype.grayscale = ColorMatrixFilter.prototype.greyscale;
+
+  var fragment$3 = "varying vec2 vFilterCoord;\nvarying vec2 vTextureCoord;\n\nuniform vec2 scale;\nuniform mat2 rotation;\nuniform sampler2D uSampler;\nuniform sampler2D mapSampler;\n\nuniform highp vec4 inputSize;\nuniform vec4 inputClamp;\n\nvoid main(void)\n{\n  vec4 map =  texture2D(mapSampler, vFilterCoord);\n\n  map -= 0.5;\n  map.xy = scale * inputSize.zw * (rotation * map.xy);\n\n  gl_FragColor = texture2D(uSampler, clamp(vec2(vTextureCoord.x + map.x, vTextureCoord.y + map.y), inputClamp.xy, inputClamp.zw));\n}\n";
+
+  var vertex$2 = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\nuniform mat3 filterMatrix;\n\nvarying vec2 vTextureCoord;\nvarying vec2 vFilterCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n\tgl_Position = filterVertexPosition();\n\tvTextureCoord = filterTextureCoord();\n\tvFilterCoord = ( filterMatrix * vec3( vTextureCoord, 1.0)  ).xy;\n}\n";
+
+  class DisplacementFilter extends Filter {
+    constructor(sprite, scale) {
+      const maskMatrix = new Matrix();
+      sprite.renderable = false;
+      super(vertex$2, fragment$3, {
+        mapSampler: sprite._texture,
+        filterMatrix: maskMatrix,
+        scale: { x: 1, y: 1 },
+        rotation: new Float32Array([1, 0, 0, 1])
+      });
+      this.maskSprite = sprite;
+      this.maskMatrix = maskMatrix;
+      if (scale === null || scale === void 0) {
+        scale = 20;
+      }
+      this.scale = new Point(scale, scale);
+    }
+    apply(filterManager, input, output, clearMode) {
+      this.uniforms.filterMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, this.maskSprite);
+      this.uniforms.scale.x = this.scale.x;
+      this.uniforms.scale.y = this.scale.y;
+      const wt = this.maskSprite.worldTransform;
+      const lenX = Math.sqrt(wt.a * wt.a + wt.b * wt.b);
+      const lenY = Math.sqrt(wt.c * wt.c + wt.d * wt.d);
+      if (lenX !== 0 && lenY !== 0) {
+        this.uniforms.rotation[0] = wt.a / lenX;
+        this.uniforms.rotation[1] = wt.b / lenX;
+        this.uniforms.rotation[2] = wt.c / lenY;
+        this.uniforms.rotation[3] = wt.d / lenY;
+      }
+      filterManager.applyFilter(this, input, output, clearMode);
+    }
+    get map() {
+      return this.uniforms.mapSampler;
+    }
+    set map(value) {
+      this.uniforms.mapSampler = value;
+    }
+  }
+
+  var fragment$2 = "varying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nvarying vec2 vFragCoord;\nuniform sampler2D uSampler;\nuniform highp vec4 inputSize;\n\n\n/**\n Basic FXAA implementation based on the code on geeks3d.com with the\n modification that the texture2DLod stuff was removed since it's\n unsupported by WebGL.\n\n --\n\n From:\n https://github.com/mitsuhiko/webgl-meincraft\n\n Copyright (c) 2011 by Armin Ronacher.\n\n Some rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are\n met:\n\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n * Redistributions in binary form must reproduce the above\n copyright notice, this list of conditions and the following\n disclaimer in the documentation and/or other materials provided\n with the distribution.\n\n * The names of the contributors may not be used to endorse or\n promote products derived from this software without specific\n prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef FXAA_REDUCE_MIN\n#define FXAA_REDUCE_MIN   (1.0/ 128.0)\n#endif\n#ifndef FXAA_REDUCE_MUL\n#define FXAA_REDUCE_MUL   (1.0 / 8.0)\n#endif\n#ifndef FXAA_SPAN_MAX\n#define FXAA_SPAN_MAX     8.0\n#endif\n\n//optimized version for mobile, where dependent\n//texture reads can be a bottleneck\nvec4 fxaa(sampler2D tex, vec2 fragCoord, vec2 inverseVP,\n          vec2 v_rgbNW, vec2 v_rgbNE,\n          vec2 v_rgbSW, vec2 v_rgbSE,\n          vec2 v_rgbM) {\n    vec4 color;\n    vec3 rgbNW = texture2D(tex, v_rgbNW).xyz;\n    vec3 rgbNE = texture2D(tex, v_rgbNE).xyz;\n    vec3 rgbSW = texture2D(tex, v_rgbSW).xyz;\n    vec3 rgbSE = texture2D(tex, v_rgbSE).xyz;\n    vec4 texColor = texture2D(tex, v_rgbM);\n    vec3 rgbM  = texColor.xyz;\n    vec3 luma = vec3(0.299, 0.587, 0.114);\n    float lumaNW = dot(rgbNW, luma);\n    float lumaNE = dot(rgbNE, luma);\n    float lumaSW = dot(rgbSW, luma);\n    float lumaSE = dot(rgbSE, luma);\n    float lumaM  = dot(rgbM,  luma);\n    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));\n    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));\n\n    mediump vec2 dir;\n    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));\n    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));\n\n    float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) *\n                          (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);\n\n    float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);\n    dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX),\n              max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),\n                  dir * rcpDirMin)) * inverseVP;\n\n    vec3 rgbA = 0.5 * (\n                       texture2D(tex, fragCoord * inverseVP + dir * (1.0 / 3.0 - 0.5)).xyz +\n                       texture2D(tex, fragCoord * inverseVP + dir * (2.0 / 3.0 - 0.5)).xyz);\n    vec3 rgbB = rgbA * 0.5 + 0.25 * (\n                                     texture2D(tex, fragCoord * inverseVP + dir * -0.5).xyz +\n                                     texture2D(tex, fragCoord * inverseVP + dir * 0.5).xyz);\n\n    float lumaB = dot(rgbB, luma);\n    if ((lumaB < lumaMin) || (lumaB > lumaMax))\n        color = vec4(rgbA, texColor.a);\n    else\n        color = vec4(rgbB, texColor.a);\n    return color;\n}\n\nvoid main() {\n\n      vec4 color;\n\n      color = fxaa(uSampler, vFragCoord, inputSize.zw, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n\n      gl_FragColor = color;\n}\n";
+
+  var vertex$1 = "\nattribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nvarying vec2 vFragCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvoid texcoords(vec2 fragCoord, vec2 inverseVP,\n               out vec2 v_rgbNW, out vec2 v_rgbNE,\n               out vec2 v_rgbSW, out vec2 v_rgbSE,\n               out vec2 v_rgbM) {\n    v_rgbNW = (fragCoord + vec2(-1.0, -1.0)) * inverseVP;\n    v_rgbNE = (fragCoord + vec2(1.0, -1.0)) * inverseVP;\n    v_rgbSW = (fragCoord + vec2(-1.0, 1.0)) * inverseVP;\n    v_rgbSE = (fragCoord + vec2(1.0, 1.0)) * inverseVP;\n    v_rgbM = vec2(fragCoord * inverseVP);\n}\n\nvoid main(void) {\n\n   gl_Position = filterVertexPosition();\n\n   vFragCoord = aVertexPosition * outputFrame.zw;\n\n   texcoords(vFragCoord, inputSize.zw, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n}\n";
+
+  class FXAAFilter extends Filter {
+    constructor() {
+      super(vertex$1, fragment$2);
+    }
+  }
+
+  var fragment$1 = "precision highp float;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform float uNoise;\nuniform float uSeed;\nuniform sampler2D uSampler;\n\nfloat rand(vec2 co)\n{\n    return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvoid main()\n{\n    vec4 color = texture2D(uSampler, vTextureCoord);\n    float randomValue = rand(gl_FragCoord.xy * uSeed);\n    float diff = (randomValue - 0.5) * uNoise;\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (color.a > 0.0) {\n        color.rgb /= color.a;\n    }\n\n    color.r += diff;\n    color.g += diff;\n    color.b += diff;\n\n    // Premultiply alpha again.\n    color.rgb *= color.a;\n\n    gl_FragColor = color;\n}\n";
+
+  class NoiseFilter extends Filter {
+    constructor(noise = 0.5, seed = Math.random()) {
+      super(defaultFilterVertex, fragment$1, {
+        uNoise: 0,
+        uSeed: 0
+      });
+      this.noise = noise;
+      this.seed = seed;
+    }
+    get noise() {
+      return this.uniforms.uNoise;
+    }
+    set noise(value) {
+      this.uniforms.uNoise = value;
+    }
+    get seed() {
+      return this.uniforms.uSeed;
+    }
+    set seed(value) {
+      this.uniforms.uSeed = value;
+    }
+  }
+
+  const filters = {
+    AlphaFilter,
+    BlurFilter,
+    BlurFilterPass,
+    ColorMatrixFilter,
+    DisplacementFilter,
+    FXAAFilter,
+    NoiseFilter
+  };
+  Object.entries(filters).forEach(([key, FilterClass]) => {
+    Object.defineProperty(filters, key, {
+      get() {
+        deprecation$1("7.1.0", `filters.${key} has moved to ${key}`);
+        return FilterClass;
+      }
+    });
+  });
+
+  class EventsTickerClass {
+    constructor() {
+      this.interactionFrequency = 10;
+      this._deltaTime = 0;
+      this._didMove = false;
+      this.tickerAdded = false;
+      this._pauseUpdate = true;
+    }
+    init(events) {
+      this.removeTickerListener();
+      this.events = events;
+      this.interactionFrequency = 10;
+      this._deltaTime = 0;
+      this._didMove = false;
+      this.tickerAdded = false;
+      this._pauseUpdate = true;
+    }
+    get pauseUpdate() {
+      return this._pauseUpdate;
+    }
+    set pauseUpdate(paused) {
+      this._pauseUpdate = paused;
+    }
+    addTickerListener() {
+      if (this.tickerAdded || !this.domElement) {
+        return;
+      }
+      Ticker.system.add(this.tickerUpdate, this, UPDATE_PRIORITY.INTERACTION);
+      this.tickerAdded = true;
+    }
+    removeTickerListener() {
+      if (!this.tickerAdded) {
+        return;
+      }
+      Ticker.system.remove(this.tickerUpdate, this);
+      this.tickerAdded = false;
+    }
+    pointerMoved() {
+      this._didMove = true;
+    }
+    update() {
+      if (!this.domElement || this._pauseUpdate) {
+        return;
+      }
+      if (this._didMove) {
+        this._didMove = false;
+        return;
+      }
+      const rootPointerEvent = this.events["rootPointerEvent"];
+      if (this.events.supportsTouchEvents && rootPointerEvent.pointerType === "touch") {
+        return;
+      }
+      globalThis.document.dispatchEvent(new PointerEvent("pointermove", {
+        clientX: rootPointerEvent.clientX,
+        clientY: rootPointerEvent.clientY
+      }));
+    }
+    tickerUpdate(deltaTime) {
+      this._deltaTime += deltaTime;
+      if (this._deltaTime < this.interactionFrequency) {
+        return;
+      }
+      this._deltaTime = 0;
+      this.update();
+    }
+  }
+  const EventsTicker = new EventsTickerClass();
+
+  class FederatedEvent {
+    constructor(manager) {
+      this.bubbles = true;
+      this.cancelBubble = true;
+      this.cancelable = false;
+      this.composed = false;
+      this.defaultPrevented = false;
+      this.eventPhase = FederatedEvent.prototype.NONE;
+      this.propagationStopped = false;
+      this.propagationImmediatelyStopped = false;
+      this.layer = new Point();
+      this.page = new Point();
+      this.NONE = 0;
+      this.CAPTURING_PHASE = 1;
+      this.AT_TARGET = 2;
+      this.BUBBLING_PHASE = 3;
+      this.manager = manager;
+    }
+    get layerX() {
+      return this.layer.x;
+    }
+    get layerY() {
+      return this.layer.y;
+    }
+    get pageX() {
+      return this.page.x;
+    }
+    get pageY() {
+      return this.page.y;
+    }
+    get data() {
+      return this;
+    }
+    composedPath() {
+      if (this.manager && (!this.path || this.path[this.path.length - 1] !== this.target)) {
+        this.path = this.target ? this.manager.propagationPath(this.target) : [];
+      }
+      return this.path;
+    }
+    initEvent(_type, _bubbles, _cancelable) {
+      throw new Error("initEvent() is a legacy DOM API. It is not implemented in the Federated Events API.");
+    }
+    initUIEvent(_typeArg, _bubblesArg, _cancelableArg, _viewArg, _detailArg) {
+      throw new Error("initUIEvent() is a legacy DOM API. It is not implemented in the Federated Events API.");
+    }
+    preventDefault() {
+      if (this.nativeEvent instanceof Event && this.nativeEvent.cancelable) {
+        this.nativeEvent.preventDefault();
+      }
+      this.defaultPrevented = true;
+    }
+    stopImmediatePropagation() {
+      this.propagationImmediatelyStopped = true;
+    }
+    stopPropagation() {
+      this.propagationStopped = true;
+    }
+  }
+
+  class FederatedMouseEvent extends FederatedEvent {
+    constructor() {
+      super(...arguments);
+      this.client = new Point();
+      this.movement = new Point();
+      this.offset = new Point();
+      this.global = new Point();
+      this.screen = new Point();
+    }
+    get clientX() {
+      return this.client.x;
+    }
+    get clientY() {
+      return this.client.y;
+    }
+    get x() {
+      return this.clientX;
+    }
+    get y() {
+      return this.clientY;
+    }
+    get movementX() {
+      return this.movement.x;
+    }
+    get movementY() {
+      return this.movement.y;
+    }
+    get offsetX() {
+      return this.offset.x;
+    }
+    get offsetY() {
+      return this.offset.y;
+    }
+    get globalX() {
+      return this.global.x;
+    }
+    get globalY() {
+      return this.global.y;
+    }
+    get screenX() {
+      return this.screen.x;
+    }
+    get screenY() {
+      return this.screen.y;
+    }
+    getLocalPosition(displayObject, point, globalPos) {
+      return displayObject.worldTransform.applyInverse(globalPos || this.global, point);
+    }
+    getModifierState(key) {
+      return "getModifierState" in this.nativeEvent && this.nativeEvent.getModifierState(key);
+    }
+    initMouseEvent(_typeArg, _canBubbleArg, _cancelableArg, _viewArg, _detailArg, _screenXArg, _screenYArg, _clientXArg, _clientYArg, _ctrlKeyArg, _altKeyArg, _shiftKeyArg, _metaKeyArg, _buttonArg, _relatedTargetArg) {
+      throw new Error("Method not implemented.");
+    }
+  }
+
+  class FederatedPointerEvent extends FederatedMouseEvent {
+    constructor() {
+      super(...arguments);
+      this.width = 0;
+      this.height = 0;
+      this.isPrimary = false;
+    }
+    getCoalescedEvents() {
+      if (this.type === "pointermove" || this.type === "mousemove" || this.type === "touchmove") {
+        return [this];
+      }
+      return [];
+    }
+    getPredictedEvents() {
+      throw new Error("getPredictedEvents is not supported!");
+    }
+  }
+
+  class FederatedWheelEvent extends FederatedMouseEvent {
+    constructor() {
+      super(...arguments);
+      this.DOM_DELTA_PIXEL = 0;
+      this.DOM_DELTA_LINE = 1;
+      this.DOM_DELTA_PAGE = 2;
+    }
+  }
+  FederatedWheelEvent.DOM_DELTA_PIXEL = 0;
+  FederatedWheelEvent.DOM_DELTA_LINE = 1;
+  FederatedWheelEvent.DOM_DELTA_PAGE = 2;
+
+  const PROPAGATION_LIMIT = 2048;
+  const tempHitLocation = new Point();
+  const tempLocalMapping = new Point();
+  class EventBoundary {
+    constructor(rootTarget) {
+      this.dispatch = new eventemitter3();
+      this.moveOnAll = false;
+      this.enableGlobalMoveEvents = true;
+      this.mappingState = {
+        trackingData: {}
+      };
+      this.eventPool = /* @__PURE__ */ new Map();
+      this._allInteractiveElements = [];
+      this._hitElements = [];
+      this._isPointerMoveEvent = false;
+      this.rootTarget = rootTarget;
+      this.hitPruneFn = this.hitPruneFn.bind(this);
+      this.hitTestFn = this.hitTestFn.bind(this);
+      this.mapPointerDown = this.mapPointerDown.bind(this);
+      this.mapPointerMove = this.mapPointerMove.bind(this);
+      this.mapPointerOut = this.mapPointerOut.bind(this);
+      this.mapPointerOver = this.mapPointerOver.bind(this);
+      this.mapPointerUp = this.mapPointerUp.bind(this);
+      this.mapPointerUpOutside = this.mapPointerUpOutside.bind(this);
+      this.mapWheel = this.mapWheel.bind(this);
+      this.mappingTable = {};
+      this.addEventMapping("pointerdown", this.mapPointerDown);
+      this.addEventMapping("pointermove", this.mapPointerMove);
+      this.addEventMapping("pointerout", this.mapPointerOut);
+      this.addEventMapping("pointerleave", this.mapPointerOut);
+      this.addEventMapping("pointerover", this.mapPointerOver);
+      this.addEventMapping("pointerup", this.mapPointerUp);
+      this.addEventMapping("pointerupoutside", this.mapPointerUpOutside);
+      this.addEventMapping("wheel", this.mapWheel);
+    }
+    addEventMapping(type, fn) {
+      if (!this.mappingTable[type]) {
+        this.mappingTable[type] = [];
+      }
+      this.mappingTable[type].push({
+        fn,
+        priority: 0
+      });
+      this.mappingTable[type].sort((a, b) => a.priority - b.priority);
+    }
+    dispatchEvent(e, type) {
+      e.propagationStopped = false;
+      e.propagationImmediatelyStopped = false;
+      this.propagate(e, type);
+      this.dispatch.emit(type || e.type, e);
+    }
+    mapEvent(e) {
+      if (!this.rootTarget) {
+        return;
+      }
+      const mappers = this.mappingTable[e.type];
+      if (mappers) {
+        for (let i = 0, j = mappers.length; i < j; i++) {
+          mappers[i].fn(e);
+        }
+      } else {
+        console.warn(`[EventBoundary]: Event mapping not defined for ${e.type}`);
+      }
+    }
+    hitTest(x, y) {
+      EventsTicker.pauseUpdate = true;
+      const useMove = this._isPointerMoveEvent && this.enableGlobalMoveEvents;
+      const fn = useMove ? "hitTestMoveRecursive" : "hitTestRecursive";
+      const invertedPath = this[fn](this.rootTarget, this.rootTarget.eventMode, tempHitLocation.set(x, y), this.hitTestFn, this.hitPruneFn);
+      return invertedPath && invertedPath[0];
+    }
+    propagate(e, type) {
+      if (!e.target) {
+        return;
+      }
+      const composedPath = e.composedPath();
+      e.eventPhase = e.CAPTURING_PHASE;
+      for (let i = 0, j = composedPath.length - 1; i < j; i++) {
+        e.currentTarget = composedPath[i];
+        this.notifyTarget(e, type);
+        if (e.propagationStopped || e.propagationImmediatelyStopped)
+          return;
+      }
+      e.eventPhase = e.AT_TARGET;
+      e.currentTarget = e.target;
+      this.notifyTarget(e, type);
+      if (e.propagationStopped || e.propagationImmediatelyStopped)
+        return;
+      e.eventPhase = e.BUBBLING_PHASE;
+      for (let i = composedPath.length - 2; i >= 0; i--) {
+        e.currentTarget = composedPath[i];
+        this.notifyTarget(e, type);
+        if (e.propagationStopped || e.propagationImmediatelyStopped)
+          return;
+      }
+    }
+    all(e, type, targets = this._allInteractiveElements) {
+      if (targets.length === 0)
+        return;
+      e.eventPhase = e.BUBBLING_PHASE;
+      const events = Array.isArray(type) ? type : [type];
+      for (let i = targets.length - 1; i >= 0; i--) {
+        events.forEach((event) => {
+          e.currentTarget = targets[i];
+          this.notifyTarget(e, event);
+        });
+      }
+    }
+    propagationPath(target) {
+      const propagationPath = [target];
+      for (let i = 0; i < PROPAGATION_LIMIT && target !== this.rootTarget; i++) {
+        if (!target.parent) {
+          throw new Error("Cannot find propagation path to disconnected target");
+        }
+        propagationPath.push(target.parent);
+        target = target.parent;
+      }
+      propagationPath.reverse();
+      return propagationPath;
+    }
+    hitTestMoveRecursive(currentTarget, eventMode, location, testFn, pruneFn, ignore = false) {
+      let shouldReturn = false;
+      if (this._interactivePrune(currentTarget))
+        return null;
+      if (currentTarget.eventMode === "dynamic" || eventMode === "dynamic") {
+        EventsTicker.pauseUpdate = false;
+      }
+      if (currentTarget.interactiveChildren && currentTarget.children) {
+        const children = currentTarget.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+          const child = children[i];
+          const nestedHit = this.hitTestMoveRecursive(child, this._isInteractive(eventMode) ? eventMode : child.eventMode, location, testFn, pruneFn, ignore || pruneFn(currentTarget, location));
+          if (nestedHit) {
+            if (nestedHit.length > 0 && !nestedHit[nestedHit.length - 1].parent) {
+              continue;
+            }
+            const isInteractive = currentTarget.isInteractive();
+            if (nestedHit.length > 0 || isInteractive) {
+              if (isInteractive)
+                this._allInteractiveElements.push(currentTarget);
+              nestedHit.push(currentTarget);
+            }
+            if (this._hitElements.length === 0)
+              this._hitElements = nestedHit;
+            shouldReturn = true;
+          }
+        }
+      }
+      const isInteractiveMode = this._isInteractive(eventMode);
+      const isInteractiveTarget = currentTarget.isInteractive();
+      if (isInteractiveTarget && isInteractiveTarget)
+        this._allInteractiveElements.push(currentTarget);
+      if (ignore || this._hitElements.length > 0)
+        return null;
+      if (shouldReturn)
+        return this._hitElements;
+      if (isInteractiveMode && (!pruneFn(currentTarget, location) && testFn(currentTarget, location))) {
+        return isInteractiveTarget ? [currentTarget] : [];
+      }
+      return null;
+    }
+    hitTestRecursive(currentTarget, eventMode, location, testFn, pruneFn) {
+      if (this._interactivePrune(currentTarget) || pruneFn(currentTarget, location)) {
+        return null;
+      }
+      if (currentTarget.eventMode === "dynamic" || eventMode === "dynamic") {
+        EventsTicker.pauseUpdate = false;
+      }
+      if (currentTarget.interactiveChildren && currentTarget.children) {
+        const children = currentTarget.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+          const child = children[i];
+          const nestedHit = this.hitTestRecursive(child, this._isInteractive(eventMode) ? eventMode : child.eventMode, location, testFn, pruneFn);
+          if (nestedHit) {
+            if (nestedHit.length > 0 && !nestedHit[nestedHit.length - 1].parent) {
+              continue;
+            }
+            const isInteractive = currentTarget.isInteractive();
+            if (nestedHit.length > 0 || isInteractive)
+              nestedHit.push(currentTarget);
+            return nestedHit;
+          }
+        }
+      }
+      const isInteractiveMode = this._isInteractive(eventMode);
+      const isInteractiveTarget = currentTarget.isInteractive();
+      if (isInteractiveMode && testFn(currentTarget, location)) {
+        return isInteractiveTarget ? [currentTarget] : [];
+      }
+      return null;
+    }
+    _isInteractive(int) {
+      return int === "static" || int === "dynamic";
+    }
+    _interactivePrune(displayObject) {
+      if (!displayObject || displayObject.isMask || !displayObject.visible || !displayObject.renderable) {
+        return true;
+      }
+      if (displayObject.eventMode === "none") {
+        return true;
+      }
+      if (displayObject.eventMode === "passive" && !displayObject.interactiveChildren) {
+        return true;
+      }
+      if (displayObject.isMask) {
+        return true;
+      }
+      return false;
+    }
+    hitPruneFn(displayObject, location) {
+      if (displayObject.hitArea) {
+        displayObject.worldTransform.applyInverse(location, tempLocalMapping);
+        if (!displayObject.hitArea.contains(tempLocalMapping.x, tempLocalMapping.y)) {
+          return true;
+        }
+      }
+      if (displayObject._mask) {
+        const maskObject = displayObject._mask.isMaskData ? displayObject._mask.maskObject : displayObject._mask;
+        if (maskObject && !maskObject.containsPoint?.(location)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    hitTestFn(displayObject, location) {
+      if (displayObject.eventMode === "passive") {
+        return false;
+      }
+      if (displayObject.hitArea) {
+        return true;
+      }
+      if (displayObject.containsPoint) {
+        return displayObject.containsPoint(location);
+      }
+      return false;
+    }
+    notifyTarget(e, type) {
+      type = type ?? e.type;
+      const handlerKey = `on${type}`;
+      e.currentTarget[handlerKey]?.(e);
+      const key = e.eventPhase === e.CAPTURING_PHASE || e.eventPhase === e.AT_TARGET ? `${type}capture` : type;
+      this.notifyListeners(e, key);
+      if (e.eventPhase === e.AT_TARGET) {
+        this.notifyListeners(e, type);
+      }
+    }
+    mapPointerDown(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        console.warn("EventBoundary cannot map a non-pointer event as a pointer event");
+        return;
+      }
+      const e = this.createPointerEvent(from);
+      this.dispatchEvent(e, "pointerdown");
+      if (e.pointerType === "touch") {
+        this.dispatchEvent(e, "touchstart");
+      } else if (e.pointerType === "mouse" || e.pointerType === "pen") {
+        const isRightButton = e.button === 2;
+        this.dispatchEvent(e, isRightButton ? "rightdown" : "mousedown");
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      trackingData.pressTargetsByButton[from.button] = e.composedPath();
+      this.freeEvent(e);
+    }
+    mapPointerMove(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        console.warn("EventBoundary cannot map a non-pointer event as a pointer event");
+        return;
+      }
+      this._allInteractiveElements.length = 0;
+      this._hitElements.length = 0;
+      this._isPointerMoveEvent = true;
+      const e = this.createPointerEvent(from);
+      this._isPointerMoveEvent = false;
+      const isMouse = e.pointerType === "mouse" || e.pointerType === "pen";
+      const trackingData = this.trackingData(from.pointerId);
+      const outTarget = this.findMountedTarget(trackingData.overTargets);
+      if (trackingData.overTargets?.length > 0 && outTarget !== e.target) {
+        const outType = from.type === "mousemove" ? "mouseout" : "pointerout";
+        const outEvent = this.createPointerEvent(from, outType, outTarget);
+        this.dispatchEvent(outEvent, "pointerout");
+        if (isMouse)
+          this.dispatchEvent(outEvent, "mouseout");
+        if (!e.composedPath().includes(outTarget)) {
+          const leaveEvent = this.createPointerEvent(from, "pointerleave", outTarget);
+          leaveEvent.eventPhase = leaveEvent.AT_TARGET;
+          while (leaveEvent.target && !e.composedPath().includes(leaveEvent.target)) {
+            leaveEvent.currentTarget = leaveEvent.target;
+            this.notifyTarget(leaveEvent);
+            if (isMouse)
+              this.notifyTarget(leaveEvent, "mouseleave");
+            leaveEvent.target = leaveEvent.target.parent;
+          }
+          this.freeEvent(leaveEvent);
+        }
+        this.freeEvent(outEvent);
+      }
+      if (outTarget !== e.target) {
+        const overType = from.type === "mousemove" ? "mouseover" : "pointerover";
+        const overEvent = this.clonePointerEvent(e, overType);
+        this.dispatchEvent(overEvent, "pointerover");
+        if (isMouse)
+          this.dispatchEvent(overEvent, "mouseover");
+        let overTargetAncestor = outTarget?.parent;
+        while (overTargetAncestor && overTargetAncestor !== this.rootTarget.parent) {
+          if (overTargetAncestor === e.target)
+            break;
+          overTargetAncestor = overTargetAncestor.parent;
+        }
+        const didPointerEnter = !overTargetAncestor || overTargetAncestor === this.rootTarget.parent;
+        if (didPointerEnter) {
+          const enterEvent = this.clonePointerEvent(e, "pointerenter");
+          enterEvent.eventPhase = enterEvent.AT_TARGET;
+          while (enterEvent.target && enterEvent.target !== outTarget && enterEvent.target !== this.rootTarget.parent) {
+            enterEvent.currentTarget = enterEvent.target;
+            this.notifyTarget(enterEvent);
+            if (isMouse)
+              this.notifyTarget(enterEvent, "mouseenter");
+            enterEvent.target = enterEvent.target.parent;
+          }
+          this.freeEvent(enterEvent);
+        }
+        this.freeEvent(overEvent);
+      }
+      const allMethods = [];
+      const allowGlobalPointerEvents = this.enableGlobalMoveEvents ?? true;
+      this.moveOnAll ? allMethods.push("pointermove") : this.dispatchEvent(e, "pointermove");
+      allowGlobalPointerEvents && allMethods.push("globalpointermove");
+      if (e.pointerType === "touch") {
+        this.moveOnAll ? allMethods.splice(1, 0, "touchmove") : this.dispatchEvent(e, "touchmove");
+        allowGlobalPointerEvents && allMethods.push("globaltouchmove");
+      }
+      if (isMouse) {
+        this.moveOnAll ? allMethods.splice(1, 0, "mousemove") : this.dispatchEvent(e, "mousemove");
+        allowGlobalPointerEvents && allMethods.push("globalmousemove");
+        this.cursor = e.target?.cursor;
+      }
+      if (allMethods.length > 0) {
+        this.all(e, allMethods);
+      }
+      this._allInteractiveElements.length = 0;
+      this._hitElements.length = 0;
+      trackingData.overTargets = e.composedPath();
+      this.freeEvent(e);
+    }
+    mapPointerOver(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        console.warn("EventBoundary cannot map a non-pointer event as a pointer event");
+        return;
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      const e = this.createPointerEvent(from);
+      const isMouse = e.pointerType === "mouse" || e.pointerType === "pen";
+      this.dispatchEvent(e, "pointerover");
+      if (isMouse)
+        this.dispatchEvent(e, "mouseover");
+      if (e.pointerType === "mouse")
+        this.cursor = e.target?.cursor;
+      const enterEvent = this.clonePointerEvent(e, "pointerenter");
+      enterEvent.eventPhase = enterEvent.AT_TARGET;
+      while (enterEvent.target && enterEvent.target !== this.rootTarget.parent) {
+        enterEvent.currentTarget = enterEvent.target;
+        this.notifyTarget(enterEvent);
+        if (isMouse)
+          this.notifyTarget(enterEvent, "mouseenter");
+        enterEvent.target = enterEvent.target.parent;
+      }
+      trackingData.overTargets = e.composedPath();
+      this.freeEvent(e);
+      this.freeEvent(enterEvent);
+    }
+    mapPointerOut(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        console.warn("EventBoundary cannot map a non-pointer event as a pointer event");
+        return;
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      if (trackingData.overTargets) {
+        const isMouse = from.pointerType === "mouse" || from.pointerType === "pen";
+        const outTarget = this.findMountedTarget(trackingData.overTargets);
+        const outEvent = this.createPointerEvent(from, "pointerout", outTarget);
+        this.dispatchEvent(outEvent);
+        if (isMouse)
+          this.dispatchEvent(outEvent, "mouseout");
+        const leaveEvent = this.createPointerEvent(from, "pointerleave", outTarget);
+        leaveEvent.eventPhase = leaveEvent.AT_TARGET;
+        while (leaveEvent.target && leaveEvent.target !== this.rootTarget.parent) {
+          leaveEvent.currentTarget = leaveEvent.target;
+          this.notifyTarget(leaveEvent);
+          if (isMouse)
+            this.notifyTarget(leaveEvent, "mouseleave");
+          leaveEvent.target = leaveEvent.target.parent;
+        }
+        trackingData.overTargets = null;
+        this.freeEvent(outEvent);
+        this.freeEvent(leaveEvent);
+      }
+      this.cursor = null;
+    }
+    mapPointerUp(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        console.warn("EventBoundary cannot map a non-pointer event as a pointer event");
+        return;
+      }
+      const now = performance.now();
+      const e = this.createPointerEvent(from);
+      this.dispatchEvent(e, "pointerup");
+      if (e.pointerType === "touch") {
+        this.dispatchEvent(e, "touchend");
+      } else if (e.pointerType === "mouse" || e.pointerType === "pen") {
+        const isRightButton = e.button === 2;
+        this.dispatchEvent(e, isRightButton ? "rightup" : "mouseup");
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]);
+      let clickTarget = pressTarget;
+      if (pressTarget && !e.composedPath().includes(pressTarget)) {
+        let currentTarget = pressTarget;
+        while (currentTarget && !e.composedPath().includes(currentTarget)) {
+          e.currentTarget = currentTarget;
+          this.notifyTarget(e, "pointerupoutside");
+          if (e.pointerType === "touch") {
+            this.notifyTarget(e, "touchendoutside");
+          } else if (e.pointerType === "mouse" || e.pointerType === "pen") {
+            const isRightButton = e.button === 2;
+            this.notifyTarget(e, isRightButton ? "rightupoutside" : "mouseupoutside");
+          }
+          currentTarget = currentTarget.parent;
+        }
+        delete trackingData.pressTargetsByButton[from.button];
+        clickTarget = currentTarget;
+      }
+      if (clickTarget) {
+        const clickEvent = this.clonePointerEvent(e, "click");
+        clickEvent.target = clickTarget;
+        clickEvent.path = null;
+        if (!trackingData.clicksByButton[from.button]) {
+          trackingData.clicksByButton[from.button] = {
+            clickCount: 0,
+            target: clickEvent.target,
+            timeStamp: now
+          };
+        }
+        const clickHistory = trackingData.clicksByButton[from.button];
+        if (clickHistory.target === clickEvent.target && now - clickHistory.timeStamp < 200) {
+          ++clickHistory.clickCount;
+        } else {
+          clickHistory.clickCount = 1;
+        }
+        clickHistory.target = clickEvent.target;
+        clickHistory.timeStamp = now;
+        clickEvent.detail = clickHistory.clickCount;
+        if (clickEvent.pointerType === "mouse") {
+          const isRightButton = clickEvent.button === 2;
+          this.dispatchEvent(clickEvent, isRightButton ? "rightclick" : "click");
+        } else if (clickEvent.pointerType === "touch") {
+          this.dispatchEvent(clickEvent, "tap");
+        }
+        this.dispatchEvent(clickEvent, "pointertap");
+        this.freeEvent(clickEvent);
+      }
+      this.freeEvent(e);
+    }
+    mapPointerUpOutside(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        console.warn("EventBoundary cannot map a non-pointer event as a pointer event");
+        return;
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]);
+      const e = this.createPointerEvent(from);
+      if (pressTarget) {
+        let currentTarget = pressTarget;
+        while (currentTarget) {
+          e.currentTarget = currentTarget;
+          this.notifyTarget(e, "pointerupoutside");
+          if (e.pointerType === "touch") {
+            this.notifyTarget(e, "touchendoutside");
+          } else if (e.pointerType === "mouse" || e.pointerType === "pen") {
+            this.notifyTarget(e, e.button === 2 ? "rightupoutside" : "mouseupoutside");
+          }
+          currentTarget = currentTarget.parent;
+        }
+        delete trackingData.pressTargetsByButton[from.button];
+      }
+      this.freeEvent(e);
+    }
+    mapWheel(from) {
+      if (!(from instanceof FederatedWheelEvent)) {
+        console.warn("EventBoundary cannot map a non-wheel event as a wheel event");
+        return;
+      }
+      const wheelEvent = this.createWheelEvent(from);
+      this.dispatchEvent(wheelEvent);
+      this.freeEvent(wheelEvent);
+    }
+    findMountedTarget(propagationPath) {
+      if (!propagationPath) {
+        return null;
+      }
+      let currentTarget = propagationPath[0];
+      for (let i = 1; i < propagationPath.length; i++) {
+        if (propagationPath[i].parent === currentTarget) {
+          currentTarget = propagationPath[i];
+        } else {
+          break;
+        }
+      }
+      return currentTarget;
+    }
+    createPointerEvent(from, type, target) {
+      const event = this.allocateEvent(FederatedPointerEvent);
+      this.copyPointerData(from, event);
+      this.copyMouseData(from, event);
+      this.copyData(from, event);
+      event.nativeEvent = from.nativeEvent;
+      event.originalEvent = from;
+      event.target = target ?? this.hitTest(event.global.x, event.global.y) ?? this._hitElements[0];
+      if (typeof type === "string") {
+        event.type = type;
+      }
+      return event;
+    }
+    createWheelEvent(from) {
+      const event = this.allocateEvent(FederatedWheelEvent);
+      this.copyWheelData(from, event);
+      this.copyMouseData(from, event);
+      this.copyData(from, event);
+      event.nativeEvent = from.nativeEvent;
+      event.originalEvent = from;
+      event.target = this.hitTest(event.global.x, event.global.y);
+      return event;
+    }
+    clonePointerEvent(from, type) {
+      const event = this.allocateEvent(FederatedPointerEvent);
+      event.nativeEvent = from.nativeEvent;
+      event.originalEvent = from.originalEvent;
+      this.copyPointerData(from, event);
+      this.copyMouseData(from, event);
+      this.copyData(from, event);
+      event.target = from.target;
+      event.path = from.composedPath().slice();
+      event.type = type ?? event.type;
+      return event;
+    }
+    copyWheelData(from, to) {
+      to.deltaMode = from.deltaMode;
+      to.deltaX = from.deltaX;
+      to.deltaY = from.deltaY;
+      to.deltaZ = from.deltaZ;
+    }
+    copyPointerData(from, to) {
+      if (!(from instanceof FederatedPointerEvent && to instanceof FederatedPointerEvent))
+        return;
+      to.pointerId = from.pointerId;
+      to.width = from.width;
+      to.height = from.height;
+      to.isPrimary = from.isPrimary;
+      to.pointerType = from.pointerType;
+      to.pressure = from.pressure;
+      to.tangentialPressure = from.tangentialPressure;
+      to.tiltX = from.tiltX;
+      to.tiltY = from.tiltY;
+      to.twist = from.twist;
+    }
+    copyMouseData(from, to) {
+      if (!(from instanceof FederatedMouseEvent && to instanceof FederatedMouseEvent))
+        return;
+      to.altKey = from.altKey;
+      to.button = from.button;
+      to.buttons = from.buttons;
+      to.client.copyFrom(from.client);
+      to.ctrlKey = from.ctrlKey;
+      to.metaKey = from.metaKey;
+      to.movement.copyFrom(from.movement);
+      to.screen.copyFrom(from.screen);
+      to.shiftKey = from.shiftKey;
+      to.global.copyFrom(from.global);
+    }
+    copyData(from, to) {
+      to.isTrusted = from.isTrusted;
+      to.srcElement = from.srcElement;
+      to.timeStamp = performance.now();
+      to.type = from.type;
+      to.detail = from.detail;
+      to.view = from.view;
+      to.which = from.which;
+      to.layer.copyFrom(from.layer);
+      to.page.copyFrom(from.page);
+    }
+    trackingData(id) {
+      if (!this.mappingState.trackingData[id]) {
+        this.mappingState.trackingData[id] = {
+          pressTargetsByButton: {},
+          clicksByButton: {},
+          overTarget: null
+        };
+      }
+      return this.mappingState.trackingData[id];
+    }
+    allocateEvent(constructor) {
+      if (!this.eventPool.has(constructor)) {
+        this.eventPool.set(constructor, []);
+      }
+      const event = this.eventPool.get(constructor).pop() || new constructor(this);
+      event.eventPhase = event.NONE;
+      event.currentTarget = null;
+      event.path = null;
+      event.target = null;
+      return event;
+    }
+    freeEvent(event) {
+      if (event.manager !== this)
+        throw new Error("It is illegal to free an event not managed by this EventBoundary!");
+      const constructor = event.constructor;
+      if (!this.eventPool.has(constructor)) {
+        this.eventPool.set(constructor, []);
+      }
+      this.eventPool.get(constructor).push(event);
+    }
+    notifyListeners(e, type) {
+      const listeners = e.currentTarget._events[type];
+      if (!listeners)
+        return;
+      if (!e.currentTarget.isInteractive())
+        return;
+      if ("fn" in listeners) {
+        if (listeners.once)
+          e.currentTarget.removeListener(type, listeners.fn, void 0, true);
+        listeners.fn.call(listeners.context, e);
+      } else {
+        for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) {
+          if (listeners[i].once)
+            e.currentTarget.removeListener(type, listeners[i].fn, void 0, true);
+          listeners[i].fn.call(listeners[i].context, e);
+        }
+      }
+    }
+  }
+
+  const MOUSE_POINTER_ID = 1;
+  const TOUCH_TO_POINTER = {
+    touchstart: "pointerdown",
+    touchend: "pointerup",
+    touchendoutside: "pointerupoutside",
+    touchmove: "pointermove",
+    touchcancel: "pointercancel"
+  };
+  const _EventSystem = class {
+    constructor(renderer) {
+      this.supportsTouchEvents = "ontouchstart" in globalThis;
+      this.supportsPointerEvents = !!globalThis.PointerEvent;
+      this.domElement = null;
+      this.resolution = 1;
+      this.renderer = renderer;
+      this.rootBoundary = new EventBoundary(null);
+      EventsTicker.init(this);
+      this.autoPreventDefault = true;
+      this.eventsAdded = false;
+      this.rootPointerEvent = new FederatedPointerEvent(null);
+      this.rootWheelEvent = new FederatedWheelEvent(null);
+      this.cursorStyles = {
+        default: "inherit",
+        pointer: "pointer"
+      };
+      this.features = new Proxy({ ..._EventSystem.defaultEventFeatures }, {
+        set: (target, key, value) => {
+          if (key === "globalMove") {
+            this.rootBoundary.enableGlobalMoveEvents = value;
+          }
+          target[key] = value;
+          return true;
+        }
+      });
+      this.onPointerDown = this.onPointerDown.bind(this);
+      this.onPointerMove = this.onPointerMove.bind(this);
+      this.onPointerUp = this.onPointerUp.bind(this);
+      this.onPointerOverOut = this.onPointerOverOut.bind(this);
+      this.onWheel = this.onWheel.bind(this);
+    }
+    static get defaultEventMode() {
+      return this._defaultEventMode;
+    }
+    init(options) {
+      const { view, resolution } = this.renderer;
+      this.setTargetElement(view);
+      this.resolution = resolution;
+      _EventSystem._defaultEventMode = options.eventMode ?? "auto";
+      Object.assign(this.features, options.eventFeatures ?? {});
+      this.rootBoundary.enableGlobalMoveEvents = this.features.globalMove;
+    }
+    resolutionChange(resolution) {
+      this.resolution = resolution;
+    }
+    destroy() {
+      this.setTargetElement(null);
+      this.renderer = null;
+    }
+    setCursor(mode) {
+      mode = mode || "default";
+      let applyStyles = true;
+      if (globalThis.OffscreenCanvas && this.domElement instanceof OffscreenCanvas) {
+        applyStyles = false;
+      }
+      if (this.currentCursor === mode) {
+        return;
+      }
+      this.currentCursor = mode;
+      const style = this.cursorStyles[mode];
+      if (style) {
+        switch (typeof style) {
+          case "string":
+            if (applyStyles) {
+              this.domElement.style.cursor = style;
+            }
+            break;
+          case "function":
+            style(mode);
+            break;
+          case "object":
+            if (applyStyles) {
+              Object.assign(this.domElement.style, style);
+            }
+            break;
+        }
+      } else if (applyStyles && typeof mode === "string" && !Object.prototype.hasOwnProperty.call(this.cursorStyles, mode)) {
+        this.domElement.style.cursor = mode;
+      }
+    }
+    get pointer() {
+      return this.rootPointerEvent;
+    }
+    onPointerDown(nativeEvent) {
+      if (!this.features.click)
+        return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      if (this.supportsTouchEvents && nativeEvent.pointerType === "touch")
+        return;
+      const events = this.normalizeToPointerData(nativeEvent);
+      if (this.autoPreventDefault && events[0].isNormalized) {
+        const cancelable = nativeEvent.cancelable || !("cancelable" in nativeEvent);
+        if (cancelable) {
+          nativeEvent.preventDefault();
+        }
+      }
+      for (let i = 0, j = events.length; i < j; i++) {
+        const nativeEvent2 = events[i];
+        const federatedEvent = this.bootstrapEvent(this.rootPointerEvent, nativeEvent2);
+        this.rootBoundary.mapEvent(federatedEvent);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    onPointerMove(nativeEvent) {
+      if (!this.features.move)
+        return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      if (this.supportsTouchEvents && nativeEvent.pointerType === "touch")
+        return;
+      EventsTicker.pointerMoved();
+      const normalizedEvents = this.normalizeToPointerData(nativeEvent);
+      for (let i = 0, j = normalizedEvents.length; i < j; i++) {
+        const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]);
+        this.rootBoundary.mapEvent(event);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    onPointerUp(nativeEvent) {
+      if (!this.features.click)
+        return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      if (this.supportsTouchEvents && nativeEvent.pointerType === "touch")
+        return;
+      let target = nativeEvent.target;
+      if (nativeEvent.composedPath && nativeEvent.composedPath().length > 0) {
+        target = nativeEvent.composedPath()[0];
+      }
+      const outside = target !== this.domElement ? "outside" : "";
+      const normalizedEvents = this.normalizeToPointerData(nativeEvent);
+      for (let i = 0, j = normalizedEvents.length; i < j; i++) {
+        const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]);
+        event.type += outside;
+        this.rootBoundary.mapEvent(event);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    onPointerOverOut(nativeEvent) {
+      if (!this.features.click)
+        return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      if (this.supportsTouchEvents && nativeEvent.pointerType === "touch")
+        return;
+      const normalizedEvents = this.normalizeToPointerData(nativeEvent);
+      for (let i = 0, j = normalizedEvents.length; i < j; i++) {
+        const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]);
+        this.rootBoundary.mapEvent(event);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    onWheel(nativeEvent) {
+      if (!this.features.wheel)
+        return;
+      const wheelEvent = this.normalizeWheelEvent(nativeEvent);
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      this.rootBoundary.mapEvent(wheelEvent);
+    }
+    setTargetElement(element) {
+      this.removeEvents();
+      this.domElement = element;
+      EventsTicker.domElement = element;
+      this.addEvents();
+    }
+    addEvents() {
+      if (this.eventsAdded || !this.domElement) {
+        return;
+      }
+      EventsTicker.addTickerListener();
+      const style = this.domElement.style;
+      if (style) {
+        if (globalThis.navigator.msPointerEnabled) {
+          style.msContentZooming = "none";
+          style.msTouchAction = "none";
+        } else if (this.supportsPointerEvents) {
+          style.touchAction = "none";
+        }
+      }
+      if (this.supportsPointerEvents) {
+        globalThis.document.addEventListener("pointermove", this.onPointerMove, true);
+        this.domElement.addEventListener("pointerdown", this.onPointerDown, true);
+        this.domElement.addEventListener("pointerleave", this.onPointerOverOut, true);
+        this.domElement.addEventListener("pointerover", this.onPointerOverOut, true);
+        globalThis.addEventListener("pointerup", this.onPointerUp, true);
+      } else {
+        globalThis.document.addEventListener("mousemove", this.onPointerMove, true);
+        this.domElement.addEventListener("mousedown", this.onPointerDown, true);
+        this.domElement.addEventListener("mouseout", this.onPointerOverOut, true);
+        this.domElement.addEventListener("mouseover", this.onPointerOverOut, true);
+        globalThis.addEventListener("mouseup", this.onPointerUp, true);
+      }
+      if (this.supportsTouchEvents) {
+        this.domElement.addEventListener("touchstart", this.onPointerDown, true);
+        this.domElement.addEventListener("touchend", this.onPointerUp, true);
+        this.domElement.addEventListener("touchmove", this.onPointerMove, true);
+      }
+      this.domElement.addEventListener("wheel", this.onWheel, {
+        passive: true,
+        capture: true
+      });
+      this.eventsAdded = true;
+    }
+    removeEvents() {
+      if (!this.eventsAdded || !this.domElement) {
+        return;
+      }
+      EventsTicker.removeTickerListener();
+      const style = this.domElement.style;
+      if (globalThis.navigator.msPointerEnabled) {
+        style.msContentZooming = "";
+        style.msTouchAction = "";
+      } else if (this.supportsPointerEvents) {
+        style.touchAction = "";
+      }
+      if (this.supportsPointerEvents) {
+        globalThis.document.removeEventListener("pointermove", this.onPointerMove, true);
+        this.domElement.removeEventListener("pointerdown", this.onPointerDown, true);
+        this.domElement.removeEventListener("pointerleave", this.onPointerOverOut, true);
+        this.domElement.removeEventListener("pointerover", this.onPointerOverOut, true);
+        globalThis.removeEventListener("pointerup", this.onPointerUp, true);
+      } else {
+        globalThis.document.removeEventListener("mousemove", this.onPointerMove, true);
+        this.domElement.removeEventListener("mousedown", this.onPointerDown, true);
+        this.domElement.removeEventListener("mouseout", this.onPointerOverOut, true);
+        this.domElement.removeEventListener("mouseover", this.onPointerOverOut, true);
+        globalThis.removeEventListener("mouseup", this.onPointerUp, true);
+      }
+      if (this.supportsTouchEvents) {
+        this.domElement.removeEventListener("touchstart", this.onPointerDown, true);
+        this.domElement.removeEventListener("touchend", this.onPointerUp, true);
+        this.domElement.removeEventListener("touchmove", this.onPointerMove, true);
+      }
+      this.domElement.removeEventListener("wheel", this.onWheel, true);
+      this.domElement = null;
+      this.eventsAdded = false;
+    }
+    mapPositionToPoint(point, x, y) {
+      let rect;
+      if (!this.domElement.parentElement) {
+        rect = {
+          x: 0,
+          y: 0,
+          width: this.domElement.width,
+          height: this.domElement.height,
+          left: 0,
+          top: 0
+        };
+      } else {
+        rect = this.domElement.getBoundingClientRect();
+      }
+      const resolutionMultiplier = 1 / this.resolution;
+      point.x = (x - rect.left) * (this.domElement.width / rect.width) * resolutionMultiplier;
+      point.y = (y - rect.top) * (this.domElement.height / rect.height) * resolutionMultiplier;
+    }
+    normalizeToPointerData(event) {
+      const normalizedEvents = [];
+      if (this.supportsTouchEvents && event instanceof TouchEvent) {
+        for (let i = 0, li = event.changedTouches.length; i < li; i++) {
+          const touch = event.changedTouches[i];
+          if (typeof touch.button === "undefined")
+            touch.button = 0;
+          if (typeof touch.buttons === "undefined")
+            touch.buttons = 1;
+          if (typeof touch.isPrimary === "undefined") {
+            touch.isPrimary = event.touches.length === 1 && event.type === "touchstart";
+          }
+          if (typeof touch.width === "undefined")
+            touch.width = touch.radiusX || 1;
+          if (typeof touch.height === "undefined")
+            touch.height = touch.radiusY || 1;
+          if (typeof touch.tiltX === "undefined")
+            touch.tiltX = 0;
+          if (typeof touch.tiltY === "undefined")
+            touch.tiltY = 0;
+          if (typeof touch.pointerType === "undefined")
+            touch.pointerType = "touch";
+          if (typeof touch.pointerId === "undefined")
+            touch.pointerId = touch.identifier || 0;
+          if (typeof touch.pressure === "undefined")
+            touch.pressure = touch.force || 0.5;
+          if (typeof touch.twist === "undefined")
+            touch.twist = 0;
+          if (typeof touch.tangentialPressure === "undefined")
+            touch.tangentialPressure = 0;
+          if (typeof touch.layerX === "undefined")
+            touch.layerX = touch.offsetX = touch.clientX;
+          if (typeof touch.layerY === "undefined")
+            touch.layerY = touch.offsetY = touch.clientY;
+          touch.isNormalized = true;
+          touch.type = event.type;
+          normalizedEvents.push(touch);
+        }
+      } else if (!globalThis.MouseEvent || event instanceof MouseEvent && (!this.supportsPointerEvents || !(event instanceof globalThis.PointerEvent))) {
+        const tempEvent = event;
+        if (typeof tempEvent.isPrimary === "undefined")
+          tempEvent.isPrimary = true;
+        if (typeof tempEvent.width === "undefined")
+          tempEvent.width = 1;
+        if (typeof tempEvent.height === "undefined")
+          tempEvent.height = 1;
+        if (typeof tempEvent.tiltX === "undefined")
+          tempEvent.tiltX = 0;
+        if (typeof tempEvent.tiltY === "undefined")
+          tempEvent.tiltY = 0;
+        if (typeof tempEvent.pointerType === "undefined")
+          tempEvent.pointerType = "mouse";
+        if (typeof tempEvent.pointerId === "undefined")
+          tempEvent.pointerId = MOUSE_POINTER_ID;
+        if (typeof tempEvent.pressure === "undefined")
+          tempEvent.pressure = 0.5;
+        if (typeof tempEvent.twist === "undefined")
+          tempEvent.twist = 0;
+        if (typeof tempEvent.tangentialPressure === "undefined")
+          tempEvent.tangentialPressure = 0;
+        tempEvent.isNormalized = true;
+        normalizedEvents.push(tempEvent);
+      } else {
+        normalizedEvents.push(event);
+      }
+      return normalizedEvents;
+    }
+    normalizeWheelEvent(nativeEvent) {
+      const event = this.rootWheelEvent;
+      this.transferMouseData(event, nativeEvent);
+      event.deltaX = nativeEvent.deltaX;
+      event.deltaY = nativeEvent.deltaY;
+      event.deltaZ = nativeEvent.deltaZ;
+      event.deltaMode = nativeEvent.deltaMode;
+      this.mapPositionToPoint(event.screen, nativeEvent.clientX, nativeEvent.clientY);
+      event.global.copyFrom(event.screen);
+      event.offset.copyFrom(event.screen);
+      event.nativeEvent = nativeEvent;
+      event.type = nativeEvent.type;
+      return event;
+    }
+    bootstrapEvent(event, nativeEvent) {
+      event.originalEvent = null;
+      event.nativeEvent = nativeEvent;
+      event.pointerId = nativeEvent.pointerId;
+      event.width = nativeEvent.width;
+      event.height = nativeEvent.height;
+      event.isPrimary = nativeEvent.isPrimary;
+      event.pointerType = nativeEvent.pointerType;
+      event.pressure = nativeEvent.pressure;
+      event.tangentialPressure = nativeEvent.tangentialPressure;
+      event.tiltX = nativeEvent.tiltX;
+      event.tiltY = nativeEvent.tiltY;
+      event.twist = nativeEvent.twist;
+      this.transferMouseData(event, nativeEvent);
+      this.mapPositionToPoint(event.screen, nativeEvent.clientX, nativeEvent.clientY);
+      event.global.copyFrom(event.screen);
+      event.offset.copyFrom(event.screen);
+      event.isTrusted = nativeEvent.isTrusted;
+      if (event.type === "pointerleave") {
+        event.type = "pointerout";
+      }
+      if (event.type.startsWith("mouse")) {
+        event.type = event.type.replace("mouse", "pointer");
+      }
+      if (event.type.startsWith("touch")) {
+        event.type = TOUCH_TO_POINTER[event.type] || event.type;
+      }
+      return event;
+    }
+    transferMouseData(event, nativeEvent) {
+      event.isTrusted = nativeEvent.isTrusted;
+      event.srcElement = nativeEvent.srcElement;
+      event.timeStamp = performance.now();
+      event.type = nativeEvent.type;
+      event.altKey = nativeEvent.altKey;
+      event.button = nativeEvent.button;
+      event.buttons = nativeEvent.buttons;
+      event.client.x = nativeEvent.clientX;
+      event.client.y = nativeEvent.clientY;
+      event.ctrlKey = nativeEvent.ctrlKey;
+      event.metaKey = nativeEvent.metaKey;
+      event.movement.x = nativeEvent.movementX;
+      event.movement.y = nativeEvent.movementY;
+      event.page.x = nativeEvent.pageX;
+      event.page.y = nativeEvent.pageY;
+      event.relatedTarget = null;
+      event.shiftKey = nativeEvent.shiftKey;
+    }
+  };
+  let EventSystem = _EventSystem;
+  EventSystem.extension = {
+    name: "events",
+    type: [
+      ExtensionType.RendererSystem,
+      ExtensionType.CanvasRendererSystem
+    ]
+  };
+  EventSystem.defaultEventFeatures = {
+    move: true,
+    globalMove: true,
+    click: true,
+    wheel: true
+  };
+  extensions$1.add(EventSystem);
+
+  function convertEventModeToInteractiveMode(mode) {
+    return mode === "dynamic" || mode === "static";
+  }
+  const FederatedDisplayObject = {
+    onclick: null,
+    onmousedown: null,
+    onmouseenter: null,
+    onmouseleave: null,
+    onmousemove: null,
+    onglobalmousemove: null,
+    onmouseout: null,
+    onmouseover: null,
+    onmouseup: null,
+    onmouseupoutside: null,
+    onpointercancel: null,
+    onpointerdown: null,
+    onpointerenter: null,
+    onpointerleave: null,
+    onpointermove: null,
+    onglobalpointermove: null,
+    onpointerout: null,
+    onpointerover: null,
+    onpointertap: null,
+    onpointerup: null,
+    onpointerupoutside: null,
+    onrightclick: null,
+    onrightdown: null,
+    onrightup: null,
+    onrightupoutside: null,
+    ontap: null,
+    ontouchcancel: null,
+    ontouchend: null,
+    ontouchendoutside: null,
+    ontouchmove: null,
+    onglobaltouchmove: null,
+    ontouchstart: null,
+    onwheel: null,
+    _internalInteractive: void 0,
+    get interactive() {
+      return this._internalInteractive ?? convertEventModeToInteractiveMode(EventSystem.defaultEventMode);
+    },
+    set interactive(value) {
+      deprecation$1("7.2.0", `Setting interactive is deprecated, use eventMode = 'none'/'passive'/'auto'/'static'/'dynamic' instead.`);
+      this._internalInteractive = value;
+      this.eventMode = value ? "static" : "auto";
+    },
+    _internalEventMode: void 0,
+    get eventMode() {
+      return this._internalEventMode ?? EventSystem.defaultEventMode;
+    },
+    set eventMode(value) {
+      this._internalInteractive = convertEventModeToInteractiveMode(value);
+      this._internalEventMode = value;
+    },
+    isInteractive() {
+      return this.eventMode === "static" || this.eventMode === "dynamic";
+    },
+    interactiveChildren: true,
+    hitArea: null,
+    addEventListener(type, listener, options) {
+      const capture = typeof options === "boolean" && options || typeof options === "object" && options.capture;
+      const context = typeof listener === "function" ? void 0 : listener;
+      type = capture ? `${type}capture` : type;
+      listener = typeof listener === "function" ? listener : listener.handleEvent;
+      this.on(type, listener, context);
+    },
+    removeEventListener(type, listener, options) {
+      const capture = typeof options === "boolean" && options || typeof options === "object" && options.capture;
+      const context = typeof listener === "function" ? void 0 : listener;
+      type = capture ? `${type}capture` : type;
+      listener = typeof listener === "function" ? listener : listener.handleEvent;
+      this.off(type, listener, context);
+    },
+    dispatchEvent(e) {
+      if (!(e instanceof FederatedEvent)) {
+        throw new Error("DisplayObject cannot propagate events outside of the Federated Events API");
+      }
+      e.defaultPrevented = false;
+      e.path = null;
+      e.target = this;
+      e.manager.dispatchEvent(e);
+      return !e.defaultPrevented;
+    }
+  };
+  DisplayObject.mixin(FederatedDisplayObject);
+
+  const accessibleTarget = {
+    accessible: false,
+    accessibleTitle: null,
+    accessibleHint: null,
+    tabIndex: 0,
+    _accessibleActive: false,
+    _accessibleDiv: null,
+    accessibleType: "button",
+    accessiblePointerEvents: "auto",
+    accessibleChildren: true,
+    renderId: -1
+  };
+
+  DisplayObject.mixin(accessibleTarget);
+  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 AccessibilityManager {
+    constructor(renderer) {
+      this.debug = false;
+      this._isActive = false;
+      this._isMobileAccessibility = false;
+      this.pool = [];
+      this.renderId = 0;
+      this.children = [];
+      this.androidUpdateCount = 0;
+      this.androidUpdateFrequency = 500;
+      this._hookDiv = null;
+      if (isMobile.tablet || isMobile.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);
+    }
+    get isActive() {
+      return this._isActive;
+    }
+    get isMobileAccessibility() {
+      return this._isMobileAccessibility;
+    }
+    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;
+    }
+    destroyTouchHook() {
+      if (!this._hookDiv) {
+        return;
+      }
+      document.body.removeChild(this._hookDiv);
+      this._hookDiv = null;
+    }
+    activate() {
+      if (this._isActive) {
+        return;
+      }
+      this._isActive = true;
+      globalThis.document.addEventListener("mousemove", this._onMouseMove, true);
+      globalThis.removeEventListener("keydown", this._onKeyDown, false);
+      this.renderer.on("postrender", this.update, this);
+      this.renderer.view.parentNode?.appendChild(this.div);
+    }
+    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.off("postrender", this.update);
+      this.div.parentNode?.removeChild(this.div);
+    }
+    updateAccessibleObjects(displayObject) {
+      if (!displayObject.visible || !displayObject.accessibleChildren) {
+        return;
+      }
+      if (displayObject.accessible && displayObject.isInteractive()) {
+        if (!displayObject._accessibleActive) {
+          this.addChild(displayObject);
+        }
+        displayObject.renderId = this.renderId;
+      }
+      const children = displayObject.children;
+      if (children) {
+        for (let i = 0; i < children.length; i++) {
+          this.updateAccessibleObjects(children[i]);
+        }
+      }
+    }
+    update() {
+      const now = performance.now();
+      if (isMobile.android.device && now < this.androidUpdateCount) {
+        return;
+      }
+      this.androidUpdateCount = now + this.androidUpdateFrequency;
+      if (!this.renderer.renderingToScreen) {
+        return;
+      }
+      if (this.renderer.lastObjectRendered) {
+        this.updateAccessibleObjects(this.renderer.lastObjectRendered);
+      }
+      const { x, y, width, height } = this.renderer.view.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();
+            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++;
+    }
+    updateDebugHTML(div) {
+      div.innerHTML = `type: ${div.type}</br> title : ${div.title}</br> tabIndex: ${div.tabIndex}`;
+    }
+    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;
+      }
+    }
+    addChild(displayObject) {
+      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 = displayObject.accessiblePointerEvents;
+      div.type = displayObject.accessibleType;
+      if (displayObject.accessibleTitle && displayObject.accessibleTitle !== null) {
+        div.title = displayObject.accessibleTitle;
+      } else if (!displayObject.accessibleHint || displayObject.accessibleHint === null) {
+        div.title = `displayObject ${displayObject.tabIndex}`;
+      }
+      if (displayObject.accessibleHint && displayObject.accessibleHint !== null) {
+        div.setAttribute("aria-label", displayObject.accessibleHint);
+      }
+      if (this.debug)
+        this.updateDebugHTML(div);
+      displayObject._accessibleActive = true;
+      displayObject._accessibleDiv = div;
+      div.displayObject = displayObject;
+      this.children.push(displayObject);
+      this.div.appendChild(displayObject._accessibleDiv);
+      displayObject._accessibleDiv.tabIndex = displayObject.tabIndex;
+    }
+    _dispatchEvent(e, type) {
+      const { displayObject: target } = e.target;
+      const boundry = this.renderer.events.rootBoundary;
+      const event = Object.assign(new FederatedEvent(boundry), { target });
+      boundry.rootTarget = this.renderer.lastObjectRendered;
+      type.forEach((type2) => boundry.dispatchEvent(event, type2));
+    }
+    _onClick(e) {
+      this._dispatchEvent(e, ["click", "pointertap", "tap"]);
+    }
+    _onFocus(e) {
+      if (!e.target.getAttribute("aria-live")) {
+        e.target.setAttribute("aria-live", "assertive");
+      }
+      this._dispatchEvent(e, ["mouseover"]);
+    }
+    _onFocusOut(e) {
+      if (!e.target.getAttribute("aria-live")) {
+        e.target.setAttribute("aria-live", "polite");
+      }
+      this._dispatchEvent(e, ["mouseout"]);
+    }
+    _onKeyDown(e) {
+      if (e.keyCode !== KEY_CODE_TAB) {
+        return;
+      }
+      this.activate();
+    }
+    _onMouseMove(e) {
+      if (e.movementX === 0 && e.movementY === 0) {
+        return;
+      }
+      this.deactivate();
+    }
+    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;
+    }
+  }
+  AccessibilityManager.extension = {
+    name: "accessibility",
+    type: [
+      ExtensionType.RendererPlugin,
+      ExtensionType.CanvasRendererPlugin
+    ]
+  };
+  extensions$1.add(AccessibilityManager);
+
+  const _Application = class {
+    constructor(options) {
+      this.stage = new Container();
+      options = Object.assign({
+        forceCanvas: false
+      }, options);
+      this.renderer = autoDetectRenderer(options);
+      _Application._plugins.forEach((plugin) => {
+        plugin.init.call(this, options);
+      });
+    }
+    render() {
+      this.renderer.render(this.stage);
+    }
+    get view() {
+      return this.renderer.view;
+    }
+    get screen() {
+      return this.renderer.screen;
+    }
+    destroy(removeView, stageOptions) {
+      const plugins = _Application._plugins.slice(0);
+      plugins.reverse();
+      plugins.forEach((plugin) => {
+        plugin.destroy.call(this);
+      });
+      this.stage.destroy(stageOptions);
+      this.stage = null;
+      this.renderer.destroy(removeView);
+      this.renderer = null;
+    }
+  };
+  let Application = _Application;
+  Application._plugins = [];
+  extensions$1.handleByList(ExtensionType.Application, Application._plugins);
+
+  class ResizePlugin {
+    static init(options) {
+      Object.defineProperty(this, "resizeTo", {
+        set(dom) {
+          globalThis.removeEventListener("resize", this.queueResize);
+          this._resizeTo = dom;
+          if (dom) {
+            globalThis.addEventListener("resize", this.queueResize);
+            this.resize();
+          }
+        },
+        get() {
+          return this._resizeTo;
+        }
+      });
+      this.queueResize = () => {
+        if (!this._resizeTo) {
+          return;
+        }
+        this.cancelResize();
+        this._resizeId = requestAnimationFrame(() => this.resize());
+      };
+      this.cancelResize = () => {
+        if (this._resizeId) {
+          cancelAnimationFrame(this._resizeId);
+          this._resizeId = null;
+        }
+      };
+      this.resize = () => {
+        if (!this._resizeTo) {
+          return;
+        }
+        this.cancelResize();
+        let width;
+        let height;
+        if (this._resizeTo === globalThis.window) {
+          width = globalThis.innerWidth;
+          height = globalThis.innerHeight;
+        } else {
+          const { clientWidth, clientHeight } = this._resizeTo;
+          width = clientWidth;
+          height = clientHeight;
+        }
+        this.renderer.resize(width, height);
+        this.render();
+      };
+      this._resizeId = null;
+      this._resizeTo = null;
+      this.resizeTo = options.resizeTo || null;
+    }
+    static destroy() {
+      globalThis.removeEventListener("resize", this.queueResize);
+      this.cancelResize();
+      this.cancelResize = null;
+      this.queueResize = null;
+      this.resizeTo = null;
+      this.resize = null;
+    }
+  }
+  ResizePlugin.extension = ExtensionType.Application;
+  extensions$1.add(ResizePlugin);
+
+  const assetKeyMap = {
+    loader: ExtensionType.LoadParser,
+    resolver: ExtensionType.ResolveParser,
+    cache: ExtensionType.CacheParser,
+    detection: ExtensionType.DetectionParser
+  };
+  extensions$1.handle(ExtensionType.Asset, (extension) => {
+    const ref = extension.ref;
+    Object.entries(assetKeyMap).filter(([key]) => !!ref[key]).forEach(([key, type]) => extensions$1.add(Object.assign(ref[key], { extension: ref[key].extension ?? type })));
+  }, (extension) => {
+    const ref = extension.ref;
+    Object.keys(assetKeyMap).filter((key) => !!ref[key]).forEach((key) => extensions$1.remove(ref[key]));
+  });
+
+  class BackgroundLoader {
+    constructor(loader, verbose = false) {
+      this._loader = loader;
+      this._assetList = [];
+      this._isLoading = false;
+      this._maxConcurrent = 1;
+      this.verbose = verbose;
+    }
+    add(assetUrls) {
+      assetUrls.forEach((a) => {
+        this._assetList.push(a);
+      });
+      if (this.verbose)
+        console.log("[BackgroundLoader] assets: ", this._assetList);
+      if (this._isActive && !this._isLoading) {
+        this._next();
+      }
+    }
+    async _next() {
+      if (this._assetList.length && this._isActive) {
+        this._isLoading = true;
+        const toLoad = [];
+        const toLoadAmount = Math.min(this._assetList.length, this._maxConcurrent);
+        for (let i = 0; i < toLoadAmount; i++) {
+          toLoad.push(this._assetList.pop());
+        }
+        await this._loader.load(toLoad);
+        this._isLoading = false;
+        this._next();
+      }
+    }
+    get active() {
+      return this._isActive;
+    }
+    set active(value) {
+      if (this._isActive === value)
+        return;
+      this._isActive = value;
+      if (value && !this._isLoading) {
+        this._next();
+      }
+    }
+  }
+
+  function checkDataUrl(url, mimes) {
+    if (Array.isArray(mimes)) {
+      for (const mime of mimes) {
+        if (url.startsWith(`data:${mime}`))
+          return true;
+      }
+      return false;
+    }
+    return url.startsWith(`data:${mimes}`);
+  }
+
+  function checkExtension(url, extension) {
+    const tempURL = url.split("?")[0];
+    const ext = path.extname(tempURL).toLowerCase();
+    if (Array.isArray(extension)) {
+      return extension.includes(ext);
+    }
+    return ext === extension;
+  }
+
+  const convertToList = (input, transform) => {
+    if (!Array.isArray(input)) {
+      input = [input];
+    }
+    if (!transform) {
+      return input;
+    }
+    return input.map((item) => {
+      if (typeof item === "string") {
+        return transform(item);
+      }
+      return item;
+    });
+  };
+
+  const copySearchParams = (targetUrl, sourceUrl) => {
+    const searchParams = sourceUrl.split("?")[1];
+    if (searchParams) {
+      targetUrl += `?${searchParams}`;
+    }
+    return targetUrl;
+  };
+
+  function processX(base, ids, depth, result, tags) {
+    const id = ids[depth];
+    for (let i = 0; i < id.length; i++) {
+      const value = id[i];
+      if (depth < ids.length - 1) {
+        processX(base.replace(result[depth], value), ids, depth + 1, result, tags);
+      } else {
+        tags.push(base.replace(result[depth], value));
+      }
+    }
+  }
+  function createStringVariations(string) {
+    const regex = /\{(.*?)\}/g;
+    const result = string.match(regex);
+    const tags = [];
+    if (result) {
+      const ids = [];
+      result.forEach((vars) => {
+        const split = vars.substring(1, vars.length - 1).split(",");
+        ids.push(split);
+      });
+      processX(string, ids, 0, result, tags);
+    } else {
+      tags.push(string);
+    }
+    return tags;
+  }
+
+  const isSingleItem = (item) => !Array.isArray(item);
+
+  class CacheClass {
+    constructor() {
+      this._parsers = [];
+      this._cache = /* @__PURE__ */ new Map();
+      this._cacheMap = /* @__PURE__ */ new Map();
+    }
+    reset() {
+      this._cacheMap.clear();
+      this._cache.clear();
+    }
+    has(key) {
+      return this._cache.has(key);
+    }
+    get(key) {
+      const result = this._cache.get(key);
+      if (!result) {
+        console.warn(`[Assets] Asset id ${key} was not found in the Cache`);
+      }
+      return result;
+    }
+    set(key, value) {
+      const keys = convertToList(key);
+      let cacheableAssets;
+      for (let i = 0; i < this.parsers.length; i++) {
+        const parser = this.parsers[i];
+        if (parser.test(value)) {
+          cacheableAssets = parser.getCacheableAssets(keys, value);
+          break;
+        }
+      }
+      if (!cacheableAssets) {
+        cacheableAssets = {};
+        keys.forEach((key2) => {
+          cacheableAssets[key2] = value;
+        });
+      }
+      const cacheKeys = Object.keys(cacheableAssets);
+      const cachedAssets = {
+        cacheKeys,
+        keys
+      };
+      keys.forEach((key2) => {
+        this._cacheMap.set(key2, cachedAssets);
+      });
+      cacheKeys.forEach((key2) => {
+        if (this._cache.has(key2) && this._cache.get(key2) !== value) {
+          console.warn("[Cache] already has key:", key2);
+        }
+        this._cache.set(key2, cacheableAssets[key2]);
+      });
+      if (value instanceof Texture) {
+        const texture = value;
+        keys.forEach((key2) => {
+          if (texture.baseTexture !== Texture.EMPTY.baseTexture) {
+            BaseTexture.addToCache(texture.baseTexture, key2);
+          }
+          Texture.addToCache(texture, key2);
+        });
+      }
+    }
+    remove(key) {
+      this._cacheMap.get(key);
+      if (!this._cacheMap.has(key)) {
+        console.warn(`[Assets] Asset id ${key} was not found in the Cache`);
+        return;
+      }
+      const cacheMap = this._cacheMap.get(key);
+      const cacheKeys = cacheMap.cacheKeys;
+      cacheKeys.forEach((key2) => {
+        this._cache.delete(key2);
+      });
+      cacheMap.keys.forEach((key2) => {
+        this._cacheMap.delete(key2);
+      });
+    }
+    get parsers() {
+      return this._parsers;
+    }
+  }
+  const Cache = new CacheClass();
+
+  class Loader {
+    constructor() {
+      this._parsers = [];
+      this._parsersValidated = false;
+      this.parsers = new Proxy(this._parsers, {
+        set: (target, key, value) => {
+          this._parsersValidated = false;
+          target[key] = value;
+          return true;
+        }
+      });
+      this.promiseCache = {};
+    }
+    reset() {
+      this._parsersValidated = false;
+      this.promiseCache = {};
+    }
+    _getLoadPromiseAndParser(url, data) {
+      const result = {
+        promise: null,
+        parser: null
+      };
+      result.promise = (async () => {
+        let asset = null;
+        let parser = null;
+        if (data.loadParser) {
+          parser = this._parserHash[data.loadParser];
+          if (!parser) {
+            console.warn(`[Assets] specified load parser "${data.loadParser}" not found while loading ${url}`);
+          }
+        }
+        if (!parser) {
+          for (let i = 0; i < this.parsers.length; i++) {
+            const parserX = this.parsers[i];
+            if (parserX.load && parserX.test?.(url, data, this)) {
+              parser = parserX;
+              break;
+            }
+          }
+          if (!parser) {
+            console.warn(`[Assets] ${url} could not be loaded as we don't know how to parse it, ensure the correct parser has been added`);
+            return null;
+          }
+        }
+        asset = await parser.load(url, data, this);
+        result.parser = parser;
+        for (let i = 0; i < this.parsers.length; i++) {
+          const parser2 = this.parsers[i];
+          if (parser2.parse) {
+            if (parser2.parse && await parser2.testParse?.(asset, data, this)) {
+              asset = await parser2.parse(asset, data, this) || asset;
+              result.parser = parser2;
+            }
+          }
+        }
+        return asset;
+      })();
+      return result;
+    }
+    async load(assetsToLoadIn, onProgress) {
+      if (!this._parsersValidated) {
+        this._validateParsers();
+      }
+      let count = 0;
+      const assets = {};
+      const singleAsset = isSingleItem(assetsToLoadIn);
+      const assetsToLoad = convertToList(assetsToLoadIn, (item) => ({
+        src: item
+      }));
+      const total = assetsToLoad.length;
+      const promises = assetsToLoad.map(async (asset) => {
+        const url = path.toAbsolute(asset.src);
+        if (!assets[asset.src]) {
+          try {
+            if (!this.promiseCache[url]) {
+              this.promiseCache[url] = this._getLoadPromiseAndParser(url, asset);
+            }
+            assets[asset.src] = await this.promiseCache[url].promise;
+            if (onProgress)
+              onProgress(++count / total);
+          } catch (e) {
+            delete this.promiseCache[url];
+            delete assets[asset.src];
+            throw new Error(`[Loader.load] Failed to load ${url}.
+${e}`);
+          }
+        }
+      });
+      await Promise.all(promises);
+      return singleAsset ? assets[assetsToLoad[0].src] : assets;
+    }
+    async unload(assetsToUnloadIn) {
+      const assetsToUnload = convertToList(assetsToUnloadIn, (item) => ({
+        src: item
+      }));
+      const promises = assetsToUnload.map(async (asset) => {
+        const url = path.toAbsolute(asset.src);
+        const loadPromise = this.promiseCache[url];
+        if (loadPromise) {
+          const loadedAsset = await loadPromise.promise;
+          loadPromise.parser?.unload?.(loadedAsset, asset, this);
+          delete this.promiseCache[url];
+        }
+      });
+      await Promise.all(promises);
+    }
+    _validateParsers() {
+      this._parsersValidated = true;
+      this._parserHash = this._parsers.filter((parser) => parser.name).reduce((hash, parser) => {
+        if (hash[parser.name]) {
+          console.warn(`[Assets] loadParser name conflict "${parser.name}"`);
+        }
+        return { ...hash, [parser.name]: parser };
+      }, {});
+    }
+  }
+
+  var LoaderParserPriority = /* @__PURE__ */ ((LoaderParserPriority2) => {
+    LoaderParserPriority2[LoaderParserPriority2["Low"] = 0] = "Low";
+    LoaderParserPriority2[LoaderParserPriority2["Normal"] = 1] = "Normal";
+    LoaderParserPriority2[LoaderParserPriority2["High"] = 2] = "High";
+    return LoaderParserPriority2;
+  })(LoaderParserPriority || {});
+
+  const validJSONExtension = ".json";
+  const validJSONMIME = "application/json";
+  const loadJson = {
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.Low
+    },
+    name: "loadJson",
+    test(url) {
+      return checkDataUrl(url, validJSONMIME) || checkExtension(url, validJSONExtension);
+    },
+    async load(url) {
+      const response = await settings.ADAPTER.fetch(url);
+      const json = await response.json();
+      return json;
+    }
+  };
+  extensions$1.add(loadJson);
+
+  const validTXTExtension = ".txt";
+  const validTXTMIME = "text/plain";
+  const loadTxt = {
+    name: "loadTxt",
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.Low
+    },
+    test(url) {
+      return checkDataUrl(url, validTXTMIME) || checkExtension(url, validTXTExtension);
+    },
+    async load(url) {
+      const response = await settings.ADAPTER.fetch(url);
+      const txt = await response.text();
+      return txt;
+    }
+  };
+  extensions$1.add(loadTxt);
+
+  const validWeights = [
+    "normal",
+    "bold",
+    "100",
+    "200",
+    "300",
+    "400",
+    "500",
+    "600",
+    "700",
+    "800",
+    "900"
+  ];
+  const validFontExtensions = [".ttf", ".otf", ".woff", ".woff2"];
+  const validFontMIMEs = [
+    "font/ttf",
+    "font/otf",
+    "font/woff",
+    "font/woff2"
+  ];
+  const CSS_IDENT_TOKEN_REGEX = /^(--|-?[A-Z_])[0-9A-Z_-]*$/i;
+  function getFontFamilyName(url) {
+    const ext = path.extname(url);
+    const name = path.basename(url, ext);
+    const nameWithSpaces = name.replace(/(-|_)/g, " ");
+    const nameTokens = nameWithSpaces.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1));
+    let valid = nameTokens.length > 0;
+    for (const token of nameTokens) {
+      if (!token.match(CSS_IDENT_TOKEN_REGEX)) {
+        valid = false;
+        break;
+      }
+    }
+    let fontFamilyName = nameTokens.join(" ");
+    if (!valid) {
+      fontFamilyName = `"${fontFamilyName.replace(/[\\"]/g, "\\$&")}"`;
+    }
+    return fontFamilyName;
+  }
+  const loadWebFont = {
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.Low
+    },
+    name: "loadWebFont",
+    test(url) {
+      return checkDataUrl(url, validFontMIMEs) || checkExtension(url, validFontExtensions);
+    },
+    async load(url, options) {
+      const fonts = settings.ADAPTER.getFontFaceSet();
+      if (fonts) {
+        const fontFaces = [];
+        const name = options.data?.family ?? getFontFamilyName(url);
+        const weights = options.data?.weights?.filter((weight) => validWeights.includes(weight)) ?? ["normal"];
+        const data = options.data ?? {};
+        for (let i = 0; i < weights.length; i++) {
+          const weight = weights[i];
+          const font = new FontFace(name, `url(${encodeURI(url)})`, {
+            ...data,
+            weight
+          });
+          await font.load();
+          fonts.add(font);
+          fontFaces.push(font);
+        }
+        return fontFaces.length === 1 ? fontFaces[0] : fontFaces;
+      }
+      console.warn("[loadWebFont] FontFace API is not supported. Skipping loading font");
+      return null;
+    },
+    unload(font) {
+      (Array.isArray(font) ? font : [font]).forEach((t) => settings.ADAPTER.getFontFaceSet().delete(t));
+    }
+  };
+  extensions$1.add(loadWebFont);
+
+  let UUID = 0;
+  let MAX_WORKERS;
+  const WHITE_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=";
+  const checkImageBitmapCode = {
+    id: "checkImageBitmap",
+    code: `
+    async function checkImageBitmap()
+    {
+        try
+        {
+            if (typeof createImageBitmap !== 'function') return false;
+
+            const response = await fetch('${WHITE_PNG}');
+            const imageBlob =  await response.blob();
+            const imageBitmap = await createImageBitmap(imageBlob);
+
+            return imageBitmap.width === 1 && imageBitmap.height === 1;
+        }
+        catch (e)
+        {
+            return false;
+        }
+    }
+    checkImageBitmap().then((result) => { self.postMessage(result); });
+    `
+  };
+  const workerCode = {
+    id: "loadImageBitmap",
+    code: `
+    async function loadImageBitmap(url)
+    {
+        const response = await fetch(url);
+
+        if (!response.ok)
+        {
+            throw new Error(\`[WorkerManager.loadImageBitmap] Failed to fetch \${url}: \`
+                + \`\${response.status} \${response.statusText}\`);
+        }
+
+        const imageBlob =  await response.blob();
+        const imageBitmap = await createImageBitmap(imageBlob);
+
+        return imageBitmap;
+    }
+    self.onmessage = async (event) =>
+    {
+        try
+        {
+            const imageBitmap = await loadImageBitmap(event.data.data[0]);
+
+            self.postMessage({
+                data: imageBitmap,
+                uuid: event.data.uuid,
+                id: event.data.id,
+            }, [imageBitmap]);
+        }
+        catch(e)
+        {
+            self.postMessage({
+                error: e,
+                uuid: event.data.uuid,
+                id: event.data.id,
+            });
+        }
+    };`
+  };
+  let workerURL;
+  class WorkerManagerClass {
+    constructor() {
+      this._initialized = false;
+      this._createdWorkers = 0;
+      this.workerPool = [];
+      this.queue = [];
+      this.resolveHash = {};
+    }
+    isImageBitmapSupported() {
+      if (this._isImageBitmapSupported !== void 0)
+        return this._isImageBitmapSupported;
+      this._isImageBitmapSupported = new Promise((resolve) => {
+        const workerURL2 = URL.createObjectURL(new Blob([checkImageBitmapCode.code], { type: "application/javascript" }));
+        const worker = new Worker(workerURL2);
+        worker.addEventListener("message", (event) => {
+          worker.terminate();
+          URL.revokeObjectURL(workerURL2);
+          resolve(event.data);
+        });
+      });
+      return this._isImageBitmapSupported;
+    }
+    loadImageBitmap(src) {
+      return this._run("loadImageBitmap", [src]);
+    }
+    async _initWorkers() {
+      if (this._initialized)
+        return;
+      this._initialized = true;
+    }
+    getWorker() {
+      if (MAX_WORKERS === void 0) {
+        MAX_WORKERS = navigator.hardwareConcurrency || 4;
+      }
+      let worker = this.workerPool.pop();
+      if (!worker && this._createdWorkers < MAX_WORKERS) {
+        if (!workerURL) {
+          workerURL = URL.createObjectURL(new Blob([workerCode.code], { type: "application/javascript" }));
+        }
+        this._createdWorkers++;
+        worker = new Worker(workerURL);
+        worker.addEventListener("message", (event) => {
+          this.complete(event.data);
+          this.returnWorker(event.target);
+          this.next();
+        });
+      }
+      return worker;
+    }
+    returnWorker(worker) {
+      this.workerPool.push(worker);
+    }
+    complete(data) {
+      if (data.error !== void 0) {
+        this.resolveHash[data.uuid].reject(data.error);
+      } else {
+        this.resolveHash[data.uuid].resolve(data.data);
+      }
+      this.resolveHash[data.uuid] = null;
+    }
+    async _run(id, args) {
+      await this._initWorkers();
+      const promise = new Promise((resolve, reject) => {
+        this.queue.push({ id, arguments: args, resolve, reject });
+      });
+      this.next();
+      return promise;
+    }
+    next() {
+      if (!this.queue.length)
+        return;
+      const worker = this.getWorker();
+      if (!worker) {
+        return;
+      }
+      const toDo = this.queue.pop();
+      const id = toDo.id;
+      this.resolveHash[UUID] = { resolve: toDo.resolve, reject: toDo.reject };
+      worker.postMessage({
+        data: toDo.arguments,
+        uuid: UUID++,
+        id
+      });
+    }
+  }
+  const WorkerManager = new WorkerManagerClass();
+
+  function createTexture(base, loader, url) {
+    const texture = new Texture(base);
+    texture.baseTexture.on("dispose", () => {
+      delete loader.promiseCache[url];
+    });
+    return texture;
+  }
+
+  const validImageExtensions = [".jpeg", ".jpg", ".png", ".webp", ".avif"];
+  const validImageMIMEs = [
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+    "image/avif"
+  ];
+  async function loadImageBitmap(url) {
+    const response = await settings.ADAPTER.fetch(url);
+    if (!response.ok) {
+      throw new Error(`[loadImageBitmap] Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    const imageBlob = await response.blob();
+    const imageBitmap = await createImageBitmap(imageBlob);
+    return imageBitmap;
+  }
+  const loadTextures = {
+    name: "loadTextures",
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.High
+    },
+    config: {
+      preferWorkers: true,
+      preferCreateImageBitmap: true,
+      crossOrigin: "anonymous"
+    },
+    test(url) {
+      return checkDataUrl(url, validImageMIMEs) || checkExtension(url, validImageExtensions);
+    },
+    async load(url, asset, loader) {
+      let src = null;
+      if (globalThis.createImageBitmap && this.config.preferCreateImageBitmap) {
+        if (this.config.preferWorkers && await WorkerManager.isImageBitmapSupported()) {
+          src = await WorkerManager.loadImageBitmap(url);
+        } else {
+          src = await loadImageBitmap(url);
+        }
+      } else {
+        src = await new Promise((resolve) => {
+          src = new Image();
+          src.crossOrigin = this.config.crossOrigin;
+          src.src = url;
+          if (src.complete) {
+            resolve(src);
+          } else {
+            src.onload = () => {
+              resolve(src);
+            };
+          }
+        });
+      }
+      const base = new BaseTexture(src, {
+        resolution: getResolutionOfUrl(url),
+        ...asset.data
+      });
+      base.resource.src = url;
+      return createTexture(base, loader, url);
+    },
+    unload(texture) {
+      texture.destroy(true);
+    }
+  };
+  extensions$1.add(loadTextures);
+
+  const validSVGExtension = ".svg";
+  const validSVGMIME = "image/svg+xml";
+  const loadSVG = {
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.High
+    },
+    name: "loadSVG",
+    test(url) {
+      return checkDataUrl(url, validSVGMIME) || checkExtension(url, validSVGExtension);
+    },
+    async testParse(data) {
+      return SVGResource.test(data);
+    },
+    async parse(asset, data, loader) {
+      const src = new SVGResource(asset, data?.data?.resourceOptions);
+      await src.load();
+      const base = new BaseTexture(src, {
+        resolution: getResolutionOfUrl(asset),
+        ...data?.data
+      });
+      base.resource.src = asset;
+      const texture = createTexture(base, loader, asset);
+      return texture;
+    },
+    async load(url, _options) {
+      const response = await settings.ADAPTER.fetch(url);
+      return response.text();
+    },
+    unload: loadTextures.unload
+  };
+  extensions$1.add(loadSVG);
+
+  class Resolver {
+    constructor() {
+      this._defaultBundleIdentifierOptions = {
+        connector: "-",
+        createBundleAssetId: (bundleId, assetId) => `${bundleId}${this._bundleIdConnector}${assetId}`,
+        extractAssetIdFromBundle: (bundleId, assetBundleId) => assetBundleId.replace(`${bundleId}${this._bundleIdConnector}`, "")
+      };
+      this._bundleIdConnector = this._defaultBundleIdentifierOptions.connector;
+      this._createBundleAssetId = this._defaultBundleIdentifierOptions.createBundleAssetId;
+      this._extractAssetIdFromBundle = this._defaultBundleIdentifierOptions.extractAssetIdFromBundle;
+      this._assetMap = {};
+      this._preferredOrder = [];
+      this._parsers = [];
+      this._resolverHash = {};
+      this._bundles = {};
+    }
+    setBundleIdentifier(bundleIdentifier) {
+      this._bundleIdConnector = bundleIdentifier.connector ?? this._bundleIdConnector;
+      this._createBundleAssetId = bundleIdentifier.createBundleAssetId ?? this._createBundleAssetId;
+      this._extractAssetIdFromBundle = bundleIdentifier.extractAssetIdFromBundle ?? this._extractAssetIdFromBundle;
+      if (this._extractAssetIdFromBundle("foo", this._createBundleAssetId("foo", "bar")) !== "bar") {
+        throw new Error("[Resolver] GenerateBundleAssetId are not working correctly");
+      }
+    }
+    prefer(...preferOrders) {
+      preferOrders.forEach((prefer) => {
+        this._preferredOrder.push(prefer);
+        if (!prefer.priority) {
+          prefer.priority = Object.keys(prefer.params);
+        }
+      });
+      this._resolverHash = {};
+    }
+    set basePath(basePath) {
+      this._basePath = basePath;
+    }
+    get basePath() {
+      return this._basePath;
+    }
+    set rootPath(rootPath) {
+      this._rootPath = rootPath;
+    }
+    get rootPath() {
+      return this._rootPath;
+    }
+    get parsers() {
+      return this._parsers;
+    }
+    reset() {
+      this.setBundleIdentifier(this._defaultBundleIdentifierOptions);
+      this._assetMap = {};
+      this._preferredOrder = [];
+      this._resolverHash = {};
+      this._rootPath = null;
+      this._basePath = null;
+      this._manifest = null;
+      this._bundles = {};
+      this._defaultSearchParams = null;
+    }
+    setDefaultSearchParams(searchParams) {
+      if (typeof searchParams === "string") {
+        this._defaultSearchParams = searchParams;
+      } else {
+        const queryValues = searchParams;
+        this._defaultSearchParams = Object.keys(queryValues).map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(queryValues[key])}`).join("&");
+      }
+    }
+    addManifest(manifest) {
+      if (this._manifest) {
+        console.warn("[Resolver] Manifest already exists, this will be overwritten");
+      }
+      this._manifest = manifest;
+      manifest.bundles.forEach((bundle) => {
+        this.addBundle(bundle.name, bundle.assets);
+      });
+    }
+    addBundle(bundleId, assets) {
+      const assetNames = [];
+      if (Array.isArray(assets)) {
+        assets.forEach((asset) => {
+          if (typeof asset.name === "string") {
+            const bundleAssetId = this._createBundleAssetId(bundleId, asset.name);
+            assetNames.push(bundleAssetId);
+            this.add([asset.name, bundleAssetId], asset.srcs, asset.data);
+          } else {
+            const bundleIds = asset.name.map((name) => this._createBundleAssetId(bundleId, name));
+            bundleIds.forEach((bundleId2) => {
+              assetNames.push(bundleId2);
+            });
+            this.add([...asset.name, ...bundleIds], asset.srcs);
+          }
+        });
+      } else {
+        Object.keys(assets).forEach((key) => {
+          assetNames.push(this._createBundleAssetId(bundleId, key));
+          this.add([key, this._createBundleAssetId(bundleId, key)], assets[key]);
+        });
+      }
+      this._bundles[bundleId] = assetNames;
+    }
+    add(keysIn, assetsIn, data) {
+      const keys = convertToList(keysIn);
+      keys.forEach((key) => {
+        if (this.hasKey(key)) {
+          console.warn(`[Resolver] already has key: ${key} overwriting`);
+        }
+      });
+      if (!Array.isArray(assetsIn)) {
+        if (typeof assetsIn === "string") {
+          assetsIn = createStringVariations(assetsIn);
+        } else {
+          assetsIn = [assetsIn];
+        }
+      }
+      const assetMap = assetsIn.map((asset) => {
+        let formattedAsset = asset;
+        if (typeof asset === "string") {
+          let parsed = false;
+          for (let i = 0; i < this._parsers.length; i++) {
+            const parser = this._parsers[i];
+            if (parser.test(asset)) {
+              formattedAsset = parser.parse(asset);
+              parsed = true;
+              break;
+            }
+          }
+          if (!parsed) {
+            formattedAsset = {
+              src: asset
+            };
+          }
+        }
+        if (!formattedAsset.format) {
+          formattedAsset.format = formattedAsset.src.split(".").pop();
+        }
+        if (!formattedAsset.alias) {
+          formattedAsset.alias = keys;
+        }
+        if (this._basePath || this._rootPath) {
+          formattedAsset.src = path.toAbsolute(formattedAsset.src, this._basePath, this._rootPath);
+        }
+        formattedAsset.src = this._appendDefaultSearchParams(formattedAsset.src);
+        formattedAsset.data = formattedAsset.data ?? data;
+        return formattedAsset;
+      });
+      keys.forEach((key) => {
+        this._assetMap[key] = assetMap;
+      });
+    }
+    resolveBundle(bundleIds) {
+      const singleAsset = isSingleItem(bundleIds);
+      bundleIds = convertToList(bundleIds);
+      const out = {};
+      bundleIds.forEach((bundleId) => {
+        const assetNames = this._bundles[bundleId];
+        if (assetNames) {
+          const results = this.resolve(assetNames);
+          const assets = {};
+          for (const key in results) {
+            const asset = results[key];
+            assets[this._extractAssetIdFromBundle(bundleId, key)] = asset;
+          }
+          out[bundleId] = assets;
+        }
+      });
+      return singleAsset ? out[bundleIds[0]] : out;
+    }
+    resolveUrl(key) {
+      const result = this.resolve(key);
+      if (typeof key !== "string") {
+        const out = {};
+        for (const i in result) {
+          out[i] = result[i].src;
+        }
+        return out;
+      }
+      return result.src;
+    }
+    resolve(keys) {
+      const singleAsset = isSingleItem(keys);
+      keys = convertToList(keys);
+      const result = {};
+      keys.forEach((key) => {
+        if (!this._resolverHash[key]) {
+          if (this._assetMap[key]) {
+            let assets = this._assetMap[key];
+            const preferredOrder = this._getPreferredOrder(assets);
+            const bestAsset = assets[0];
+            preferredOrder?.priority.forEach((priorityKey) => {
+              preferredOrder.params[priorityKey].forEach((value) => {
+                const filteredAssets = assets.filter((asset) => {
+                  if (asset[priorityKey]) {
+                    return asset[priorityKey] === value;
+                  }
+                  return false;
+                });
+                if (filteredAssets.length) {
+                  assets = filteredAssets;
+                }
+              });
+            });
+            this._resolverHash[key] = assets[0] ?? bestAsset;
+          } else {
+            let src = key;
+            if (this._basePath || this._rootPath) {
+              src = path.toAbsolute(src, this._basePath, this._rootPath);
+            }
+            src = this._appendDefaultSearchParams(src);
+            this._resolverHash[key] = {
+              src
+            };
+          }
+        }
+        result[key] = this._resolverHash[key];
+      });
+      return singleAsset ? result[keys[0]] : result;
+    }
+    hasKey(key) {
+      return !!this._assetMap[key];
+    }
+    hasBundle(key) {
+      return !!this._bundles[key];
+    }
+    _getPreferredOrder(assets) {
+      for (let i = 0; i < assets.length; i++) {
+        const asset = assets[0];
+        const preferred = this._preferredOrder.find((preference) => preference.params.format.includes(asset.format));
+        if (preferred) {
+          return preferred;
+        }
+      }
+      return this._preferredOrder[0];
+    }
+    _appendDefaultSearchParams(url) {
+      if (!this._defaultSearchParams)
+        return url;
+      const paramConnector = /\?/.test(url) ? "&" : "?";
+      return `${url}${paramConnector}${this._defaultSearchParams}`;
+    }
+  }
+
+  class AssetsClass {
+    constructor() {
+      this._detections = [];
+      this._initialized = false;
+      this.resolver = new Resolver();
+      this.loader = new Loader();
+      this.cache = Cache;
+      this._backgroundLoader = new BackgroundLoader(this.loader);
+      this._backgroundLoader.active = true;
+      this.reset();
+    }
+    async init(options = {}) {
+      if (this._initialized) {
+        console.warn("[Assets]AssetManager already initialized, did you load before calling this Asset.init()?");
+        return;
+      }
+      this._initialized = true;
+      if (options.defaultSearchParams) {
+        this.resolver.setDefaultSearchParams(options.defaultSearchParams);
+      }
+      if (options.basePath) {
+        this.resolver.basePath = options.basePath;
+      }
+      if (options.bundleIdentifier) {
+        this.resolver.setBundleIdentifier(options.bundleIdentifier);
+      }
+      if (options.manifest) {
+        let manifest = options.manifest;
+        if (typeof manifest === "string") {
+          manifest = await this.load(manifest);
+        }
+        this.resolver.addManifest(manifest);
+      }
+      const resolutionPref = options.texturePreference?.resolution ?? 1;
+      const resolution = typeof resolutionPref === "number" ? [resolutionPref] : resolutionPref;
+      let formats = [];
+      if (options.texturePreference?.format) {
+        const formatPref = options.texturePreference?.format;
+        formats = typeof formatPref === "string" ? [formatPref] : formatPref;
+        for (const detection of this._detections) {
+          if (!await detection.test()) {
+            formats = await detection.remove(formats);
+          }
+        }
+      } else {
+        for (const detection of this._detections) {
+          if (await detection.test()) {
+            formats = await detection.add(formats);
+          }
+        }
+      }
+      this.resolver.prefer({
+        params: {
+          format: formats,
+          resolution
+        }
+      });
+      if (options.preferences) {
+        this.setPreferences(options.preferences);
+      }
+    }
+    add(keysIn, assetsIn, data) {
+      this.resolver.add(keysIn, assetsIn, data);
+    }
+    async load(urls, onProgress) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      const singleAsset = isSingleItem(urls);
+      const urlArray = convertToList(urls).map((url) => {
+        if (typeof url !== "string") {
+          this.resolver.add(url.src, url);
+          return url.src;
+        }
+        if (!this.resolver.hasKey(url)) {
+          this.resolver.add(url, url);
+        }
+        return url;
+      });
+      const resolveResults = this.resolver.resolve(urlArray);
+      const out = await this._mapLoadToResolve(resolveResults, onProgress);
+      return singleAsset ? out[urlArray[0]] : out;
+    }
+    addBundle(bundleId, assets) {
+      this.resolver.addBundle(bundleId, assets);
+    }
+    async loadBundle(bundleIds, onProgress) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      let singleAsset = false;
+      if (typeof bundleIds === "string") {
+        singleAsset = true;
+        bundleIds = [bundleIds];
+      }
+      const resolveResults = this.resolver.resolveBundle(bundleIds);
+      const out = {};
+      const keys = Object.keys(resolveResults);
+      let count = 0;
+      let total = 0;
+      const _onProgress = () => {
+        onProgress?.(++count / total);
+      };
+      const promises = keys.map((bundleId) => {
+        const resolveResult = resolveResults[bundleId];
+        total += Object.keys(resolveResult).length;
+        return this._mapLoadToResolve(resolveResult, _onProgress).then((resolveResult2) => {
+          out[bundleId] = resolveResult2;
+        });
+      });
+      await Promise.all(promises);
+      return singleAsset ? out[bundleIds[0]] : out;
+    }
+    async backgroundLoad(urls) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      if (typeof urls === "string") {
+        urls = [urls];
+      }
+      const resolveResults = this.resolver.resolve(urls);
+      this._backgroundLoader.add(Object.values(resolveResults));
+    }
+    async backgroundLoadBundle(bundleIds) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      if (typeof bundleIds === "string") {
+        bundleIds = [bundleIds];
+      }
+      const resolveResults = this.resolver.resolveBundle(bundleIds);
+      Object.values(resolveResults).forEach((resolveResult) => {
+        this._backgroundLoader.add(Object.values(resolveResult));
+      });
+    }
+    reset() {
+      this.resolver.reset();
+      this.loader.reset();
+      this.cache.reset();
+      this._initialized = false;
+    }
+    get(keys) {
+      if (typeof keys === "string") {
+        return Cache.get(keys);
+      }
+      const assets = {};
+      for (let i = 0; i < keys.length; i++) {
+        assets[i] = Cache.get(keys[i]);
+      }
+      return assets;
+    }
+    async _mapLoadToResolve(resolveResults, onProgress) {
+      const resolveArray = Object.values(resolveResults);
+      const resolveKeys = Object.keys(resolveResults);
+      this._backgroundLoader.active = false;
+      const loadedAssets = await this.loader.load(resolveArray, onProgress);
+      this._backgroundLoader.active = true;
+      const out = {};
+      resolveArray.forEach((resolveResult, i) => {
+        const asset = loadedAssets[resolveResult.src];
+        const keys = [resolveResult.src];
+        if (resolveResult.alias) {
+          keys.push(...resolveResult.alias);
+        }
+        out[resolveKeys[i]] = asset;
+        Cache.set(keys, asset);
+      });
+      return out;
+    }
+    async unload(urls) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      const urlArray = convertToList(urls).map((url) => typeof url !== "string" ? url.src : url);
+      const resolveResults = this.resolver.resolve(urlArray);
+      await this._unloadFromResolved(resolveResults);
+    }
+    async unloadBundle(bundleIds) {
+      if (!this._initialized) {
+        await this.init();
+      }
+      bundleIds = convertToList(bundleIds);
+      const resolveResults = this.resolver.resolveBundle(bundleIds);
+      const promises = Object.keys(resolveResults).map((bundleId) => this._unloadFromResolved(resolveResults[bundleId]));
+      await Promise.all(promises);
+    }
+    async _unloadFromResolved(resolveResult) {
+      const resolveArray = Object.values(resolveResult);
+      resolveArray.forEach((resolveResult2) => {
+        Cache.remove(resolveResult2.src);
+      });
+      await this.loader.unload(resolveArray);
+    }
+    get detections() {
+      return this._detections;
+    }
+    get preferWorkers() {
+      return loadTextures.config.preferWorkers;
+    }
+    set preferWorkers(value) {
+      deprecation$1("7.2.0", "Assets.prefersWorkers is deprecated, use Assets.setPreferences({ preferWorkers: true }) instead.");
+      this.setPreferences({ preferWorkers: value });
+    }
+    setPreferences(preferences) {
+      this.loader.parsers.forEach((parser) => {
+        if (!parser.config)
+          return;
+        Object.keys(parser.config).filter((key) => key in preferences).forEach((key) => {
+          parser.config[key] = preferences[key];
+        });
+      });
+    }
+  }
+  const Assets = new AssetsClass();
+  extensions$1.handleByList(ExtensionType.LoadParser, Assets.loader.parsers).handleByList(ExtensionType.ResolveParser, Assets.resolver.parsers).handleByList(ExtensionType.CacheParser, Assets.cache.parsers).handleByList(ExtensionType.DetectionParser, Assets.detections);
+
+  const cacheTextureArray = {
+    extension: ExtensionType.CacheParser,
+    test: (asset) => Array.isArray(asset) && asset.every((t) => t instanceof Texture),
+    getCacheableAssets: (keys, asset) => {
+      const out = {};
+      keys.forEach((key) => {
+        asset.forEach((item, i) => {
+          out[key + (i === 0 ? "" : i + 1)] = item;
+        });
+      });
+      return out;
+    }
+  };
+  extensions$1.add(cacheTextureArray);
+
+  const detectAvif = {
+    extension: {
+      type: ExtensionType.DetectionParser,
+      priority: 1
+    },
+    test: async () => {
+      if (!globalThis.createImageBitmap)
+        return false;
+      const avifData = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=";
+      const blob = await settings.ADAPTER.fetch(avifData).then((r) => r.blob());
+      return createImageBitmap(blob).then(() => true, () => false);
+    },
+    add: async (formats) => [...formats, "avif"],
+    remove: async (formats) => formats.filter((f) => f !== "avif")
+  };
+  extensions$1.add(detectAvif);
+
+  const detectWebp = {
+    extension: {
+      type: ExtensionType.DetectionParser,
+      priority: 0
+    },
+    test: async () => {
+      if (!globalThis.createImageBitmap)
+        return false;
+      const webpData = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA=";
+      const blob = await settings.ADAPTER.fetch(webpData).then((r) => r.blob());
+      return createImageBitmap(blob).then(() => true, () => false);
+    },
+    add: async (formats) => [...formats, "webp"],
+    remove: async (formats) => formats.filter((f) => f !== "webp")
+  };
+  extensions$1.add(detectWebp);
+
+  const imageFormats = ["png", "jpg", "jpeg"];
+  const detectDefaults = {
+    extension: {
+      type: ExtensionType.DetectionParser,
+      priority: -1
+    },
+    test: () => Promise.resolve(true),
+    add: async (formats) => [...formats, ...imageFormats],
+    remove: async (formats) => formats.filter((f) => !imageFormats.includes(f))
+  };
+  extensions$1.add(detectDefaults);
+
+  const resolveTextureUrl = {
+    extension: ExtensionType.ResolveParser,
+    test: loadTextures.test,
+    parse: (value) => ({
+      resolution: parseFloat(settings.RETINA_PREFIX.exec(value)?.[1] ?? "1"),
+      format: value.split(".").pop(),
+      src: value
+    })
+  };
+  extensions$1.add(resolveTextureUrl);
+
+  var INTERNAL_FORMATS = /* @__PURE__ */ ((INTERNAL_FORMATS2) => {
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA8_ETC2_EAC"] = 37496] = "COMPRESSED_RGBA8_ETC2_EAC";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SRGB8_ETC2"] = 37493] = "COMPRESSED_SRGB8_ETC2";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37497] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37494] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37495] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL";
+    INTERNAL_FORMATS2[INTERNAL_FORMATS2["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR";
+    return INTERNAL_FORMATS2;
+  })(INTERNAL_FORMATS || {});
+  const INTERNAL_FORMAT_TO_BYTES_PER_PIXEL = {
+    [33776 /* COMPRESSED_RGB_S3TC_DXT1_EXT */]: 0.5,
+    [33777 /* COMPRESSED_RGBA_S3TC_DXT1_EXT */]: 0.5,
+    [33778 /* COMPRESSED_RGBA_S3TC_DXT3_EXT */]: 1,
+    [33779 /* COMPRESSED_RGBA_S3TC_DXT5_EXT */]: 1,
+    [35916 /* COMPRESSED_SRGB_S3TC_DXT1_EXT */]: 0.5,
+    [35917 /* COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT */]: 0.5,
+    [35918 /* COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT */]: 1,
+    [35919 /* COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT */]: 1,
+    [37488 /* COMPRESSED_R11_EAC */]: 0.5,
+    [37489 /* COMPRESSED_SIGNED_R11_EAC */]: 0.5,
+    [37490 /* COMPRESSED_RG11_EAC */]: 1,
+    [37491 /* COMPRESSED_SIGNED_RG11_EAC */]: 1,
+    [37492 /* COMPRESSED_RGB8_ETC2 */]: 0.5,
+    [37496 /* COMPRESSED_RGBA8_ETC2_EAC */]: 1,
+    [37493 /* COMPRESSED_SRGB8_ETC2 */]: 0.5,
+    [37497 /* COMPRESSED_SRGB8_ALPHA8_ETC2_EAC */]: 1,
+    [37494 /* COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 */]: 0.5,
+    [37495 /* COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 */]: 0.5,
+    [35840 /* COMPRESSED_RGB_PVRTC_4BPPV1_IMG */]: 0.5,
+    [35842 /* COMPRESSED_RGBA_PVRTC_4BPPV1_IMG */]: 0.5,
+    [35841 /* COMPRESSED_RGB_PVRTC_2BPPV1_IMG */]: 0.25,
+    [35843 /* COMPRESSED_RGBA_PVRTC_2BPPV1_IMG */]: 0.25,
+    [36196 /* COMPRESSED_RGB_ETC1_WEBGL */]: 0.5,
+    [35986 /* COMPRESSED_RGB_ATC_WEBGL */]: 0.5,
+    [35986 /* COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL */]: 1,
+    [34798 /* COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL */]: 1,
+    [37808 /* COMPRESSED_RGBA_ASTC_4x4_KHR */]: 1
+  };
+
+  let storedGl;
+  let extensions;
+  function getCompressedTextureExtensions() {
+    extensions = {
+      s3tc: storedGl.getExtension("WEBGL_compressed_texture_s3tc"),
+      s3tc_sRGB: storedGl.getExtension("WEBGL_compressed_texture_s3tc_srgb"),
+      etc: storedGl.getExtension("WEBGL_compressed_texture_etc"),
+      etc1: storedGl.getExtension("WEBGL_compressed_texture_etc1"),
+      pvrtc: storedGl.getExtension("WEBGL_compressed_texture_pvrtc") || storedGl.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc"),
+      atc: storedGl.getExtension("WEBGL_compressed_texture_atc"),
+      astc: storedGl.getExtension("WEBGL_compressed_texture_astc")
+    };
+  }
+  const detectCompressedTextures = {
+    extension: {
+      type: ExtensionType.DetectionParser,
+      priority: 2
+    },
+    test: async () => {
+      const canvas = settings.ADAPTER.createCanvas();
+      const gl = canvas.getContext("webgl");
+      if (!gl) {
+        console.warn("WebGL not available for compressed textures.");
+        return false;
+      }
+      storedGl = gl;
+      return true;
+    },
+    add: async (formats) => {
+      if (!extensions)
+        getCompressedTextureExtensions();
+      const textureFormats = [];
+      for (const extensionName in extensions) {
+        const extension = extensions[extensionName];
+        if (!extension) {
+          continue;
+        }
+        textureFormats.push(extensionName);
+      }
+      return [...textureFormats, ...formats];
+    },
+    remove: async (formats) => {
+      if (!extensions)
+        getCompressedTextureExtensions();
+      return formats.filter((f) => !(f in extensions));
+    }
+  };
+  extensions$1.add(detectCompressedTextures);
+
+  class BlobResource extends BufferResource {
+    constructor(source, options = { width: 1, height: 1, autoLoad: true }) {
+      let origin;
+      let data;
+      if (typeof source === "string") {
+        origin = source;
+        data = new Uint8Array();
+      } else {
+        origin = null;
+        data = source;
+      }
+      super(data, options);
+      this.origin = origin;
+      this.buffer = data ? new ViewableBuffer(data) : null;
+      this._load = null;
+      this.loaded = false;
+      if (this.origin !== null && options.autoLoad !== false) {
+        this.load();
+      }
+      if (this.origin === null && this.buffer) {
+        this._load = Promise.resolve(this);
+        this.loaded = true;
+        this.onBlobLoaded(this.buffer.rawBinaryData);
+      }
+    }
+    onBlobLoaded(_data) {
+    }
+    load() {
+      if (this._load) {
+        return this._load;
+      }
+      this._load = fetch(this.origin).then((response) => response.blob()).then((blob) => blob.arrayBuffer()).then((arrayBuffer) => {
+        this.data = new Uint32Array(arrayBuffer);
+        this.buffer = new ViewableBuffer(arrayBuffer);
+        this.loaded = true;
+        this.onBlobLoaded(arrayBuffer);
+        this.update();
+        return this;
+      });
+      return this._load;
+    }
+  }
+
+  class CompressedTextureResource extends BlobResource {
+    constructor(source, options) {
+      super(source, options);
+      this.format = options.format;
+      this.levels = options.levels || 1;
+      this._width = options.width;
+      this._height = options.height;
+      this._extension = CompressedTextureResource._formatToExtension(this.format);
+      if (options.levelBuffers || this.buffer) {
+        this._levelBuffers = options.levelBuffers || CompressedTextureResource._createLevelBuffers(source instanceof Uint8Array ? source : this.buffer.uint8View, this.format, this.levels, 4, 4, this.width, this.height);
+      }
+    }
+    upload(renderer, _texture, _glTexture) {
+      const gl = renderer.gl;
+      const extension = renderer.context.extensions[this._extension];
+      if (!extension) {
+        throw new Error(`${this._extension} textures are not supported on the current machine`);
+      }
+      if (!this._levelBuffers) {
+        return false;
+      }
+      for (let i = 0, j = this.levels; i < j; i++) {
+        const { levelID, levelWidth, levelHeight, levelBuffer } = this._levelBuffers[i];
+        gl.compressedTexImage2D(gl.TEXTURE_2D, levelID, this.format, levelWidth, levelHeight, 0, levelBuffer);
+      }
+      return true;
+    }
+    onBlobLoaded() {
+      this._levelBuffers = CompressedTextureResource._createLevelBuffers(this.buffer.uint8View, this.format, this.levels, 4, 4, this.width, this.height);
+    }
+    static _formatToExtension(format) {
+      if (format >= 33776 && format <= 33779) {
+        return "s3tc";
+      } else if (format >= 37488 && format <= 37497) {
+        return "etc";
+      } else if (format >= 35840 && format <= 35843) {
+        return "pvrtc";
+      } else if (format >= 36196) {
+        return "etc1";
+      } else if (format >= 35986 && format <= 34798) {
+        return "atc";
+      }
+      throw new Error("Invalid (compressed) texture format given!");
+    }
+    static _createLevelBuffers(buffer, format, levels, blockWidth, blockHeight, imageWidth, imageHeight) {
+      const buffers = new Array(levels);
+      let offset = buffer.byteOffset;
+      let levelWidth = imageWidth;
+      let levelHeight = imageHeight;
+      let alignedLevelWidth = levelWidth + blockWidth - 1 & ~(blockWidth - 1);
+      let alignedLevelHeight = levelHeight + blockHeight - 1 & ~(blockHeight - 1);
+      let levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];
+      for (let i = 0; i < levels; i++) {
+        buffers[i] = {
+          levelID: i,
+          levelWidth: levels > 1 ? levelWidth : alignedLevelWidth,
+          levelHeight: levels > 1 ? levelHeight : alignedLevelHeight,
+          levelBuffer: new Uint8Array(buffer.buffer, offset, levelSize)
+        };
+        offset += levelSize;
+        levelWidth = levelWidth >> 1 || 1;
+        levelHeight = levelHeight >> 1 || 1;
+        alignedLevelWidth = levelWidth + blockWidth - 1 & ~(blockWidth - 1);
+        alignedLevelHeight = levelHeight + blockHeight - 1 & ~(blockHeight - 1);
+        levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];
+      }
+      return buffers;
+    }
+  }
+
+  const DDS_MAGIC_SIZE = 4;
+  const DDS_HEADER_SIZE = 124;
+  const DDS_HEADER_PF_SIZE = 32;
+  const DDS_HEADER_DX10_SIZE = 20;
+  const DDS_MAGIC = 542327876;
+  const DDS_FIELDS = {
+    SIZE: 1,
+    FLAGS: 2,
+    HEIGHT: 3,
+    WIDTH: 4,
+    MIPMAP_COUNT: 7,
+    PIXEL_FORMAT: 19
+  };
+  const DDS_PF_FIELDS = {
+    SIZE: 0,
+    FLAGS: 1,
+    FOURCC: 2,
+    RGB_BITCOUNT: 3,
+    R_BIT_MASK: 4,
+    G_BIT_MASK: 5,
+    B_BIT_MASK: 6,
+    A_BIT_MASK: 7
+  };
+  const DDS_DX10_FIELDS = {
+    DXGI_FORMAT: 0,
+    RESOURCE_DIMENSION: 1,
+    MISC_FLAG: 2,
+    ARRAY_SIZE: 3,
+    MISC_FLAGS2: 4
+  };
+  var DXGI_FORMAT = /* @__PURE__ */ ((DXGI_FORMAT2) => {
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_UNKNOWN"] = 0] = "DXGI_FORMAT_UNKNOWN";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32A32_TYPELESS"] = 1] = "DXGI_FORMAT_R32G32B32A32_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32A32_FLOAT"] = 2] = "DXGI_FORMAT_R32G32B32A32_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32A32_UINT"] = 3] = "DXGI_FORMAT_R32G32B32A32_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32A32_SINT"] = 4] = "DXGI_FORMAT_R32G32B32A32_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32_TYPELESS"] = 5] = "DXGI_FORMAT_R32G32B32_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32_FLOAT"] = 6] = "DXGI_FORMAT_R32G32B32_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32_UINT"] = 7] = "DXGI_FORMAT_R32G32B32_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32B32_SINT"] = 8] = "DXGI_FORMAT_R32G32B32_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16B16A16_TYPELESS"] = 9] = "DXGI_FORMAT_R16G16B16A16_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16B16A16_FLOAT"] = 10] = "DXGI_FORMAT_R16G16B16A16_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16B16A16_UNORM"] = 11] = "DXGI_FORMAT_R16G16B16A16_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16B16A16_UINT"] = 12] = "DXGI_FORMAT_R16G16B16A16_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16B16A16_SNORM"] = 13] = "DXGI_FORMAT_R16G16B16A16_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16B16A16_SINT"] = 14] = "DXGI_FORMAT_R16G16B16A16_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32_TYPELESS"] = 15] = "DXGI_FORMAT_R32G32_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32_FLOAT"] = 16] = "DXGI_FORMAT_R32G32_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32_UINT"] = 17] = "DXGI_FORMAT_R32G32_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G32_SINT"] = 18] = "DXGI_FORMAT_R32G32_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32G8X24_TYPELESS"] = 19] = "DXGI_FORMAT_R32G8X24_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_D32_FLOAT_S8X24_UINT"] = 20] = "DXGI_FORMAT_D32_FLOAT_S8X24_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS"] = 21] = "DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_X32_TYPELESS_G8X24_UINT"] = 22] = "DXGI_FORMAT_X32_TYPELESS_G8X24_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R10G10B10A2_TYPELESS"] = 23] = "DXGI_FORMAT_R10G10B10A2_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R10G10B10A2_UNORM"] = 24] = "DXGI_FORMAT_R10G10B10A2_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R10G10B10A2_UINT"] = 25] = "DXGI_FORMAT_R10G10B10A2_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R11G11B10_FLOAT"] = 26] = "DXGI_FORMAT_R11G11B10_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8B8A8_TYPELESS"] = 27] = "DXGI_FORMAT_R8G8B8A8_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8B8A8_UNORM"] = 28] = "DXGI_FORMAT_R8G8B8A8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8B8A8_UNORM_SRGB"] = 29] = "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8B8A8_UINT"] = 30] = "DXGI_FORMAT_R8G8B8A8_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8B8A8_SNORM"] = 31] = "DXGI_FORMAT_R8G8B8A8_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8B8A8_SINT"] = 32] = "DXGI_FORMAT_R8G8B8A8_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16_TYPELESS"] = 33] = "DXGI_FORMAT_R16G16_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16_FLOAT"] = 34] = "DXGI_FORMAT_R16G16_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16_UNORM"] = 35] = "DXGI_FORMAT_R16G16_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16_UINT"] = 36] = "DXGI_FORMAT_R16G16_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16_SNORM"] = 37] = "DXGI_FORMAT_R16G16_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16G16_SINT"] = 38] = "DXGI_FORMAT_R16G16_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32_TYPELESS"] = 39] = "DXGI_FORMAT_R32_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_D32_FLOAT"] = 40] = "DXGI_FORMAT_D32_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32_FLOAT"] = 41] = "DXGI_FORMAT_R32_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32_UINT"] = 42] = "DXGI_FORMAT_R32_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R32_SINT"] = 43] = "DXGI_FORMAT_R32_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R24G8_TYPELESS"] = 44] = "DXGI_FORMAT_R24G8_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_D24_UNORM_S8_UINT"] = 45] = "DXGI_FORMAT_D24_UNORM_S8_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R24_UNORM_X8_TYPELESS"] = 46] = "DXGI_FORMAT_R24_UNORM_X8_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_X24_TYPELESS_G8_UINT"] = 47] = "DXGI_FORMAT_X24_TYPELESS_G8_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8_TYPELESS"] = 48] = "DXGI_FORMAT_R8G8_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8_UNORM"] = 49] = "DXGI_FORMAT_R8G8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8_UINT"] = 50] = "DXGI_FORMAT_R8G8_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8_SNORM"] = 51] = "DXGI_FORMAT_R8G8_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8_SINT"] = 52] = "DXGI_FORMAT_R8G8_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16_TYPELESS"] = 53] = "DXGI_FORMAT_R16_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16_FLOAT"] = 54] = "DXGI_FORMAT_R16_FLOAT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_D16_UNORM"] = 55] = "DXGI_FORMAT_D16_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16_UNORM"] = 56] = "DXGI_FORMAT_R16_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16_UINT"] = 57] = "DXGI_FORMAT_R16_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16_SNORM"] = 58] = "DXGI_FORMAT_R16_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R16_SINT"] = 59] = "DXGI_FORMAT_R16_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8_TYPELESS"] = 60] = "DXGI_FORMAT_R8_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8_UNORM"] = 61] = "DXGI_FORMAT_R8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8_UINT"] = 62] = "DXGI_FORMAT_R8_UINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8_SNORM"] = 63] = "DXGI_FORMAT_R8_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8_SINT"] = 64] = "DXGI_FORMAT_R8_SINT";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_A8_UNORM"] = 65] = "DXGI_FORMAT_A8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R1_UNORM"] = 66] = "DXGI_FORMAT_R1_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R9G9B9E5_SHAREDEXP"] = 67] = "DXGI_FORMAT_R9G9B9E5_SHAREDEXP";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R8G8_B8G8_UNORM"] = 68] = "DXGI_FORMAT_R8G8_B8G8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_G8R8_G8B8_UNORM"] = 69] = "DXGI_FORMAT_G8R8_G8B8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC1_TYPELESS"] = 70] = "DXGI_FORMAT_BC1_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC1_UNORM"] = 71] = "DXGI_FORMAT_BC1_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC1_UNORM_SRGB"] = 72] = "DXGI_FORMAT_BC1_UNORM_SRGB";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC2_TYPELESS"] = 73] = "DXGI_FORMAT_BC2_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC2_UNORM"] = 74] = "DXGI_FORMAT_BC2_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC2_UNORM_SRGB"] = 75] = "DXGI_FORMAT_BC2_UNORM_SRGB";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC3_TYPELESS"] = 76] = "DXGI_FORMAT_BC3_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC3_UNORM"] = 77] = "DXGI_FORMAT_BC3_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC3_UNORM_SRGB"] = 78] = "DXGI_FORMAT_BC3_UNORM_SRGB";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC4_TYPELESS"] = 79] = "DXGI_FORMAT_BC4_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC4_UNORM"] = 80] = "DXGI_FORMAT_BC4_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC4_SNORM"] = 81] = "DXGI_FORMAT_BC4_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC5_TYPELESS"] = 82] = "DXGI_FORMAT_BC5_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC5_UNORM"] = 83] = "DXGI_FORMAT_BC5_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC5_SNORM"] = 84] = "DXGI_FORMAT_BC5_SNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B5G6R5_UNORM"] = 85] = "DXGI_FORMAT_B5G6R5_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B5G5R5A1_UNORM"] = 86] = "DXGI_FORMAT_B5G5R5A1_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B8G8R8A8_UNORM"] = 87] = "DXGI_FORMAT_B8G8R8A8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B8G8R8X8_UNORM"] = 88] = "DXGI_FORMAT_B8G8R8X8_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM"] = 89] = "DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B8G8R8A8_TYPELESS"] = 90] = "DXGI_FORMAT_B8G8R8A8_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B8G8R8A8_UNORM_SRGB"] = 91] = "DXGI_FORMAT_B8G8R8A8_UNORM_SRGB";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B8G8R8X8_TYPELESS"] = 92] = "DXGI_FORMAT_B8G8R8X8_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B8G8R8X8_UNORM_SRGB"] = 93] = "DXGI_FORMAT_B8G8R8X8_UNORM_SRGB";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC6H_TYPELESS"] = 94] = "DXGI_FORMAT_BC6H_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC6H_UF16"] = 95] = "DXGI_FORMAT_BC6H_UF16";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC6H_SF16"] = 96] = "DXGI_FORMAT_BC6H_SF16";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC7_TYPELESS"] = 97] = "DXGI_FORMAT_BC7_TYPELESS";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC7_UNORM"] = 98] = "DXGI_FORMAT_BC7_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_BC7_UNORM_SRGB"] = 99] = "DXGI_FORMAT_BC7_UNORM_SRGB";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_AYUV"] = 100] = "DXGI_FORMAT_AYUV";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_Y410"] = 101] = "DXGI_FORMAT_Y410";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_Y416"] = 102] = "DXGI_FORMAT_Y416";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_NV12"] = 103] = "DXGI_FORMAT_NV12";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_P010"] = 104] = "DXGI_FORMAT_P010";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_P016"] = 105] = "DXGI_FORMAT_P016";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_420_OPAQUE"] = 106] = "DXGI_FORMAT_420_OPAQUE";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_YUY2"] = 107] = "DXGI_FORMAT_YUY2";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_Y210"] = 108] = "DXGI_FORMAT_Y210";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_Y216"] = 109] = "DXGI_FORMAT_Y216";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_NV11"] = 110] = "DXGI_FORMAT_NV11";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_AI44"] = 111] = "DXGI_FORMAT_AI44";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_IA44"] = 112] = "DXGI_FORMAT_IA44";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_P8"] = 113] = "DXGI_FORMAT_P8";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_A8P8"] = 114] = "DXGI_FORMAT_A8P8";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_B4G4R4A4_UNORM"] = 115] = "DXGI_FORMAT_B4G4R4A4_UNORM";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_P208"] = 116] = "DXGI_FORMAT_P208";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_V208"] = 117] = "DXGI_FORMAT_V208";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_V408"] = 118] = "DXGI_FORMAT_V408";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE"] = 119] = "DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE"] = 120] = "DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE";
+    DXGI_FORMAT2[DXGI_FORMAT2["DXGI_FORMAT_FORCE_UINT"] = 121] = "DXGI_FORMAT_FORCE_UINT";
+    return DXGI_FORMAT2;
+  })(DXGI_FORMAT || {});
+  var D3D10_RESOURCE_DIMENSION = /* @__PURE__ */ ((D3D10_RESOURCE_DIMENSION2) => {
+    D3D10_RESOURCE_DIMENSION2[D3D10_RESOURCE_DIMENSION2["DDS_DIMENSION_TEXTURE1D"] = 2] = "DDS_DIMENSION_TEXTURE1D";
+    D3D10_RESOURCE_DIMENSION2[D3D10_RESOURCE_DIMENSION2["DDS_DIMENSION_TEXTURE2D"] = 3] = "DDS_DIMENSION_TEXTURE2D";
+    D3D10_RESOURCE_DIMENSION2[D3D10_RESOURCE_DIMENSION2["DDS_DIMENSION_TEXTURE3D"] = 6] = "DDS_DIMENSION_TEXTURE3D";
+    return D3D10_RESOURCE_DIMENSION2;
+  })(D3D10_RESOURCE_DIMENSION || {});
+  const PF_FLAGS = 1;
+  const DDPF_ALPHA = 2;
+  const DDPF_FOURCC = 4;
+  const DDPF_RGB = 64;
+  const DDPF_YUV = 512;
+  const DDPF_LUMINANCE = 131072;
+  const FOURCC_DXT1 = 827611204;
+  const FOURCC_DXT3 = 861165636;
+  const FOURCC_DXT5 = 894720068;
+  const FOURCC_DX10 = 808540228;
+  const DDS_RESOURCE_MISC_TEXTURECUBE = 4;
+  const FOURCC_TO_FORMAT = {
+    [FOURCC_DXT1]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+    [FOURCC_DXT3]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    [FOURCC_DXT5]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+  };
+  const DXGI_TO_FORMAT = {
+    [70 /* DXGI_FORMAT_BC1_TYPELESS */]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+    [71 /* DXGI_FORMAT_BC1_UNORM */]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+    [73 /* DXGI_FORMAT_BC2_TYPELESS */]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    [74 /* DXGI_FORMAT_BC2_UNORM */]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    [76 /* DXGI_FORMAT_BC3_TYPELESS */]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    [77 /* DXGI_FORMAT_BC3_UNORM */]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    [72 /* DXGI_FORMAT_BC1_UNORM_SRGB */]: INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+    [75 /* DXGI_FORMAT_BC2_UNORM_SRGB */]: INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+    [78 /* DXGI_FORMAT_BC3_UNORM_SRGB */]: INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
+  };
+  function parseDDS(arrayBuffer) {
+    const data = new Uint32Array(arrayBuffer);
+    const magicWord = data[0];
+    if (magicWord !== DDS_MAGIC) {
+      throw new Error("Invalid DDS file magic word");
+    }
+    const header = new Uint32Array(arrayBuffer, 0, DDS_HEADER_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+    const height = header[DDS_FIELDS.HEIGHT];
+    const width = header[DDS_FIELDS.WIDTH];
+    const mipmapCount = header[DDS_FIELDS.MIPMAP_COUNT];
+    const pixelFormat = new Uint32Array(arrayBuffer, DDS_FIELDS.PIXEL_FORMAT * Uint32Array.BYTES_PER_ELEMENT, DDS_HEADER_PF_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+    const formatFlags = pixelFormat[PF_FLAGS];
+    if (formatFlags & DDPF_FOURCC) {
+      const fourCC = pixelFormat[DDS_PF_FIELDS.FOURCC];
+      if (fourCC !== FOURCC_DX10) {
+        const internalFormat2 = FOURCC_TO_FORMAT[fourCC];
+        const dataOffset2 = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;
+        const texData = new Uint8Array(arrayBuffer, dataOffset2);
+        const resource = new CompressedTextureResource(texData, {
+          format: internalFormat2,
+          width,
+          height,
+          levels: mipmapCount
+        });
+        return [resource];
+      }
+      const dx10Offset = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;
+      const dx10Header = new Uint32Array(data.buffer, dx10Offset, DDS_HEADER_DX10_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+      const dxgiFormat = dx10Header[DDS_DX10_FIELDS.DXGI_FORMAT];
+      const resourceDimension = dx10Header[DDS_DX10_FIELDS.RESOURCE_DIMENSION];
+      const miscFlag = dx10Header[DDS_DX10_FIELDS.MISC_FLAG];
+      const arraySize = dx10Header[DDS_DX10_FIELDS.ARRAY_SIZE];
+      const internalFormat = DXGI_TO_FORMAT[dxgiFormat];
+      if (internalFormat === void 0) {
+        throw new Error(`DDSParser cannot parse texture data with DXGI format ${dxgiFormat}`);
+      }
+      if (miscFlag === DDS_RESOURCE_MISC_TEXTURECUBE) {
+        throw new Error("DDSParser does not support cubemap textures");
+      }
+      if (resourceDimension === 6 /* DDS_DIMENSION_TEXTURE3D */) {
+        throw new Error("DDSParser does not supported 3D texture data");
+      }
+      const imageBuffers = new Array();
+      const dataOffset = DDS_MAGIC_SIZE + DDS_HEADER_SIZE + DDS_HEADER_DX10_SIZE;
+      if (arraySize === 1) {
+        imageBuffers.push(new Uint8Array(arrayBuffer, dataOffset));
+      } else {
+        const pixelSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[internalFormat];
+        let imageSize = 0;
+        let levelWidth = width;
+        let levelHeight = height;
+        for (let i = 0; i < mipmapCount; i++) {
+          const alignedLevelWidth = Math.max(1, levelWidth + 3 & ~3);
+          const alignedLevelHeight = Math.max(1, levelHeight + 3 & ~3);
+          const levelSize = alignedLevelWidth * alignedLevelHeight * pixelSize;
+          imageSize += levelSize;
+          levelWidth = levelWidth >>> 1;
+          levelHeight = levelHeight >>> 1;
+        }
+        let imageOffset = dataOffset;
+        for (let i = 0; i < arraySize; i++) {
+          imageBuffers.push(new Uint8Array(arrayBuffer, imageOffset, imageSize));
+          imageOffset += imageSize;
+        }
+      }
+      return imageBuffers.map((buffer) => new CompressedTextureResource(buffer, {
+        format: internalFormat,
+        width,
+        height,
+        levels: mipmapCount
+      }));
+    }
+    if (formatFlags & DDPF_RGB) {
+      throw new Error("DDSParser does not support uncompressed texture data.");
+    }
+    if (formatFlags & DDPF_YUV) {
+      throw new Error("DDSParser does not supported YUV uncompressed texture data.");
+    }
+    if (formatFlags & DDPF_LUMINANCE) {
+      throw new Error("DDSParser does not support single-channel (lumninance) texture data!");
+    }
+    if (formatFlags & DDPF_ALPHA) {
+      throw new Error("DDSParser does not support single-channel (alpha) texture data!");
+    }
+    throw new Error("DDSParser failed to load a texture file due to an unknown reason!");
+  }
+
+  const FILE_IDENTIFIER = [171, 75, 84, 88, 32, 49, 49, 187, 13, 10, 26, 10];
+  const ENDIANNESS = 67305985;
+  const KTX_FIELDS = {
+    FILE_IDENTIFIER: 0,
+    ENDIANNESS: 12,
+    GL_TYPE: 16,
+    GL_TYPE_SIZE: 20,
+    GL_FORMAT: 24,
+    GL_INTERNAL_FORMAT: 28,
+    GL_BASE_INTERNAL_FORMAT: 32,
+    PIXEL_WIDTH: 36,
+    PIXEL_HEIGHT: 40,
+    PIXEL_DEPTH: 44,
+    NUMBER_OF_ARRAY_ELEMENTS: 48,
+    NUMBER_OF_FACES: 52,
+    NUMBER_OF_MIPMAP_LEVELS: 56,
+    BYTES_OF_KEY_VALUE_DATA: 60
+  };
+  const FILE_HEADER_SIZE = 64;
+  const TYPES_TO_BYTES_PER_COMPONENT = {
+    [TYPES.UNSIGNED_BYTE]: 1,
+    [TYPES.UNSIGNED_SHORT]: 2,
+    [TYPES.INT]: 4,
+    [TYPES.UNSIGNED_INT]: 4,
+    [TYPES.FLOAT]: 4,
+    [TYPES.HALF_FLOAT]: 8
+  };
+  const FORMATS_TO_COMPONENTS = {
+    [FORMATS.RGBA]: 4,
+    [FORMATS.RGB]: 3,
+    [FORMATS.RG]: 2,
+    [FORMATS.RED]: 1,
+    [FORMATS.LUMINANCE]: 1,
+    [FORMATS.LUMINANCE_ALPHA]: 2,
+    [FORMATS.ALPHA]: 1
+  };
+  const TYPES_TO_BYTES_PER_PIXEL = {
+    [TYPES.UNSIGNED_SHORT_4_4_4_4]: 2,
+    [TYPES.UNSIGNED_SHORT_5_5_5_1]: 2,
+    [TYPES.UNSIGNED_SHORT_5_6_5]: 2
+  };
+  function parseKTX(url, arrayBuffer, loadKeyValueData = false) {
+    const dataView = new DataView(arrayBuffer);
+    if (!validate(url, dataView)) {
+      return null;
+    }
+    const littleEndian = dataView.getUint32(KTX_FIELDS.ENDIANNESS, true) === ENDIANNESS;
+    const glType = dataView.getUint32(KTX_FIELDS.GL_TYPE, littleEndian);
+    const glFormat = dataView.getUint32(KTX_FIELDS.GL_FORMAT, littleEndian);
+    const glInternalFormat = dataView.getUint32(KTX_FIELDS.GL_INTERNAL_FORMAT, littleEndian);
+    const pixelWidth = dataView.getUint32(KTX_FIELDS.PIXEL_WIDTH, littleEndian);
+    const pixelHeight = dataView.getUint32(KTX_FIELDS.PIXEL_HEIGHT, littleEndian) || 1;
+    const pixelDepth = dataView.getUint32(KTX_FIELDS.PIXEL_DEPTH, littleEndian) || 1;
+    const numberOfArrayElements = dataView.getUint32(KTX_FIELDS.NUMBER_OF_ARRAY_ELEMENTS, littleEndian) || 1;
+    const numberOfFaces = dataView.getUint32(KTX_FIELDS.NUMBER_OF_FACES, littleEndian);
+    const numberOfMipmapLevels = dataView.getUint32(KTX_FIELDS.NUMBER_OF_MIPMAP_LEVELS, littleEndian);
+    const bytesOfKeyValueData = dataView.getUint32(KTX_FIELDS.BYTES_OF_KEY_VALUE_DATA, littleEndian);
+    if (pixelHeight === 0 || pixelDepth !== 1) {
+      throw new Error("Only 2D textures are supported");
+    }
+    if (numberOfFaces !== 1) {
+      throw new Error("CubeTextures are not supported by KTXLoader yet!");
+    }
+    if (numberOfArrayElements !== 1) {
+      throw new Error("WebGL does not support array textures");
+    }
+    const blockWidth = 4;
+    const blockHeight = 4;
+    const alignedWidth = pixelWidth + 3 & ~3;
+    const alignedHeight = pixelHeight + 3 & ~3;
+    const imageBuffers = new Array(numberOfArrayElements);
+    let imagePixels = pixelWidth * pixelHeight;
+    if (glType === 0) {
+      imagePixels = alignedWidth * alignedHeight;
+    }
+    let imagePixelByteSize;
+    if (glType !== 0) {
+      if (TYPES_TO_BYTES_PER_COMPONENT[glType]) {
+        imagePixelByteSize = TYPES_TO_BYTES_PER_COMPONENT[glType] * FORMATS_TO_COMPONENTS[glFormat];
+      } else {
+        imagePixelByteSize = TYPES_TO_BYTES_PER_PIXEL[glType];
+      }
+    } else {
+      imagePixelByteSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[glInternalFormat];
+    }
+    if (imagePixelByteSize === void 0) {
+      throw new Error("Unable to resolve the pixel format stored in the *.ktx file!");
+    }
+    const kvData = loadKeyValueData ? parseKvData(dataView, bytesOfKeyValueData, littleEndian) : null;
+    const imageByteSize = imagePixels * imagePixelByteSize;
+    let mipByteSize = imageByteSize;
+    let mipWidth = pixelWidth;
+    let mipHeight = pixelHeight;
+    let alignedMipWidth = alignedWidth;
+    let alignedMipHeight = alignedHeight;
+    let imageOffset = FILE_HEADER_SIZE + bytesOfKeyValueData;
+    for (let mipmapLevel = 0; mipmapLevel < numberOfMipmapLevels; mipmapLevel++) {
+      const imageSize = dataView.getUint32(imageOffset, littleEndian);
+      let elementOffset = imageOffset + 4;
+      for (let arrayElement = 0; arrayElement < numberOfArrayElements; arrayElement++) {
+        let mips = imageBuffers[arrayElement];
+        if (!mips) {
+          mips = imageBuffers[arrayElement] = new Array(numberOfMipmapLevels);
+        }
+        mips[mipmapLevel] = {
+          levelID: mipmapLevel,
+          levelWidth: numberOfMipmapLevels > 1 || glType !== 0 ? mipWidth : alignedMipWidth,
+          levelHeight: numberOfMipmapLevels > 1 || glType !== 0 ? mipHeight : alignedMipHeight,
+          levelBuffer: new Uint8Array(arrayBuffer, elementOffset, mipByteSize)
+        };
+        elementOffset += mipByteSize;
+      }
+      imageOffset += imageSize + 4;
+      imageOffset = imageOffset % 4 !== 0 ? imageOffset + 4 - imageOffset % 4 : imageOffset;
+      mipWidth = mipWidth >> 1 || 1;
+      mipHeight = mipHeight >> 1 || 1;
+      alignedMipWidth = mipWidth + blockWidth - 1 & ~(blockWidth - 1);
+      alignedMipHeight = mipHeight + blockHeight - 1 & ~(blockHeight - 1);
+      mipByteSize = alignedMipWidth * alignedMipHeight * imagePixelByteSize;
+    }
+    if (glType !== 0) {
+      return {
+        uncompressed: imageBuffers.map((levelBuffers) => {
+          let buffer = levelBuffers[0].levelBuffer;
+          let convertToInt = false;
+          if (glType === TYPES.FLOAT) {
+            buffer = new Float32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
+          } else if (glType === TYPES.UNSIGNED_INT) {
+            convertToInt = true;
+            buffer = new Uint32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
+          } else if (glType === TYPES.INT) {
+            convertToInt = true;
+            buffer = new Int32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
+          }
+          return {
+            resource: new BufferResource(buffer, {
+              width: levelBuffers[0].levelWidth,
+              height: levelBuffers[0].levelHeight
+            }),
+            type: glType,
+            format: convertToInt ? convertFormatToInteger(glFormat) : glFormat
+          };
+        }),
+        kvData
+      };
+    }
+    return {
+      compressed: imageBuffers.map((levelBuffers) => new CompressedTextureResource(null, {
+        format: glInternalFormat,
+        width: pixelWidth,
+        height: pixelHeight,
+        levels: numberOfMipmapLevels,
+        levelBuffers
+      })),
+      kvData
+    };
+  }
+  function validate(url, dataView) {
+    for (let i = 0; i < FILE_IDENTIFIER.length; i++) {
+      if (dataView.getUint8(i) !== FILE_IDENTIFIER[i]) {
+        console.error(`${url} is not a valid *.ktx file!`);
+        return false;
+      }
+    }
+    return true;
+  }
+  function convertFormatToInteger(format) {
+    switch (format) {
+      case FORMATS.RGBA:
+        return FORMATS.RGBA_INTEGER;
+      case FORMATS.RGB:
+        return FORMATS.RGB_INTEGER;
+      case FORMATS.RG:
+        return FORMATS.RG_INTEGER;
+      case FORMATS.RED:
+        return FORMATS.RED_INTEGER;
+      default:
+        return format;
+    }
+  }
+  function parseKvData(dataView, bytesOfKeyValueData, littleEndian) {
+    const kvData = /* @__PURE__ */ new Map();
+    let bytesIntoKeyValueData = 0;
+    while (bytesIntoKeyValueData < bytesOfKeyValueData) {
+      const keyAndValueByteSize = dataView.getUint32(FILE_HEADER_SIZE + bytesIntoKeyValueData, littleEndian);
+      const keyAndValueByteOffset = FILE_HEADER_SIZE + bytesIntoKeyValueData + 4;
+      const valuePadding = 3 - (keyAndValueByteSize + 3) % 4;
+      if (keyAndValueByteSize === 0 || keyAndValueByteSize > bytesOfKeyValueData - bytesIntoKeyValueData) {
+        console.error("KTXLoader: keyAndValueByteSize out of bounds");
+        break;
+      }
+      let keyNulByte = 0;
+      for (; keyNulByte < keyAndValueByteSize; keyNulByte++) {
+        if (dataView.getUint8(keyAndValueByteOffset + keyNulByte) === 0) {
+          break;
+        }
+      }
+      if (keyNulByte === -1) {
+        console.error("KTXLoader: Failed to find null byte terminating kvData key");
+        break;
+      }
+      const key = new TextDecoder().decode(new Uint8Array(dataView.buffer, keyAndValueByteOffset, keyNulByte));
+      const value = new DataView(dataView.buffer, keyAndValueByteOffset + keyNulByte + 1, keyAndValueByteSize - keyNulByte - 1);
+      kvData.set(key, value);
+      bytesIntoKeyValueData += 4 + keyAndValueByteSize + valuePadding;
+    }
+    return kvData;
+  }
+
+  const loadDDS = {
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.High
+    },
+    name: "loadDDS",
+    test(url) {
+      return checkExtension(url, ".dds");
+    },
+    async load(url, asset, loader) {
+      const response = await settings.ADAPTER.fetch(url);
+      const arrayBuffer = await response.arrayBuffer();
+      const resources = parseDDS(arrayBuffer);
+      const textures = resources.map((resource) => {
+        const base = new BaseTexture(resource, {
+          mipmap: MIPMAP_MODES.OFF,
+          alphaMode: ALPHA_MODES.NO_PREMULTIPLIED_ALPHA,
+          resolution: getResolutionOfUrl(url),
+          ...asset.data
+        });
+        return createTexture(base, loader, url);
+      });
+      return textures.length === 1 ? textures[0] : textures;
+    },
+    unload(texture) {
+      if (Array.isArray(texture)) {
+        texture.forEach((t) => t.destroy(true));
+      } else {
+        texture.destroy(true);
+      }
+    }
+  };
+  extensions$1.add(loadDDS);
+
+  const loadKTX = {
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.High
+    },
+    name: "loadKTX",
+    test(url) {
+      return checkExtension(url, ".ktx");
+    },
+    async load(url, asset, loader) {
+      const response = await settings.ADAPTER.fetch(url);
+      const arrayBuffer = await response.arrayBuffer();
+      const { compressed, uncompressed, kvData } = parseKTX(url, arrayBuffer);
+      const resources = compressed ?? uncompressed;
+      const options = {
+        mipmap: MIPMAP_MODES.OFF,
+        alphaMode: ALPHA_MODES.NO_PREMULTIPLIED_ALPHA,
+        resolution: getResolutionOfUrl(url),
+        ...asset.data
+      };
+      const textures = resources.map((resource) => {
+        if (resources === uncompressed) {
+          Object.assign(options, {
+            type: resource.type,
+            format: resource.format
+          });
+        }
+        const base = new BaseTexture(resource, options);
+        base.ktxKeyValueData = kvData;
+        return createTexture(base, loader, url);
+      });
+      return textures.length === 1 ? textures[0] : textures;
+    },
+    unload(texture) {
+      if (Array.isArray(texture)) {
+        texture.forEach((t) => t.destroy(true));
+      } else {
+        texture.destroy(true);
+      }
+    }
+  };
+  extensions$1.add(loadKTX);
+
+  const resolveCompressedTextureUrl = {
+    extension: ExtensionType.ResolveParser,
+    test: (value) => {
+      const temp = value.split("?")[0];
+      const extension = temp.split(".").pop();
+      return ["basis", "ktx", "dds"].includes(extension);
+    },
+    parse: (value) => {
+      const temp = value.split("?")[0];
+      const extension = temp.split(".").pop();
+      if (extension === "ktx") {
+        const extensions2 = [
+          ".s3tc.ktx",
+          ".s3tc_sRGB.ktx",
+          ".etc.ktx",
+          ".etc1.ktx",
+          ".pvrt.ktx",
+          ".atc.ktx",
+          ".astc.ktx"
+        ];
+        if (extensions2.some((ext) => value.endsWith(ext))) {
+          return {
+            resolution: parseFloat(settings.RETINA_PREFIX.exec(value)?.[1] ?? "1"),
+            format: extensions2.find((ext) => value.endsWith(ext)),
+            src: value
+          };
+        }
+      }
+      return {
+        resolution: parseFloat(settings.RETINA_PREFIX.exec(value)?.[1] ?? "1"),
+        format: value.split(".").pop(),
+        src: value
+      };
+    }
+  };
+  extensions$1.add(resolveCompressedTextureUrl);
+
+  const TEMP_RECT$1 = new Rectangle();
+  const BYTES_PER_PIXEL = 4;
+  const _Extract = class {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    async image(target, format, quality) {
+      const image = new Image();
+      image.src = await this.base64(target, format, quality);
+      return image;
+    }
+    async base64(target, format, quality) {
+      const canvas = this.canvas(target);
+      if (canvas.toBlob !== void 0) {
+        return new Promise((resolve, reject) => {
+          canvas.toBlob((blob) => {
+            if (!blob) {
+              reject(new Error("ICanvas.toBlob failed!"));
+              return;
+            }
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+          }, format, quality);
+        });
+      }
+      if (canvas.toDataURL !== void 0) {
+        return canvas.toDataURL(format, quality);
+      }
+      if (canvas.convertToBlob !== void 0) {
+        const blob = await canvas.convertToBlob({ type: format, quality });
+        return new Promise((resolve, reject) => {
+          const reader = new FileReader();
+          reader.onload = () => resolve(reader.result);
+          reader.onerror = reject;
+          reader.readAsDataURL(blob);
+        });
+      }
+      throw new Error("Extract.base64() requires ICanvas.toDataURL, ICanvas.toBlob, or ICanvas.convertToBlob to be implemented");
+    }
+    canvas(target, frame) {
+      const { pixels, width, height, flipY } = this._rawPixels(target, frame);
+      if (flipY) {
+        _Extract._flipY(pixels, width, height);
+      }
+      _Extract._unpremultiplyAlpha(pixels);
+      const canvasBuffer = new CanvasRenderTarget(width, height, 1);
+      const imageData = new ImageData(new Uint8ClampedArray(pixels.buffer), width, height);
+      canvasBuffer.context.putImageData(imageData, 0, 0);
+      return canvasBuffer.canvas;
+    }
+    pixels(target, frame) {
+      const { pixels, width, height, flipY } = this._rawPixels(target, frame);
+      if (flipY) {
+        _Extract._flipY(pixels, width, height);
+      }
+      _Extract._unpremultiplyAlpha(pixels);
+      return pixels;
+    }
+    _rawPixels(target, frame) {
+      const renderer = this.renderer;
+      if (!renderer) {
+        throw new Error("The Extract has already been destroyed");
+      }
+      let resolution;
+      let flipY = false;
+      let renderTexture;
+      let generated = false;
+      if (target) {
+        if (target instanceof RenderTexture) {
+          renderTexture = target;
+        } else {
+          renderTexture = renderer.generateTexture(target, {
+            resolution: renderer.resolution,
+            multisample: renderer.multisample
+          });
+          generated = true;
+        }
+      }
+      if (renderTexture) {
+        resolution = renderTexture.baseTexture.resolution;
+        frame = frame ?? renderTexture.frame;
+        flipY = false;
+        if (!generated) {
+          renderer.renderTexture.bind(renderTexture);
+          const fbo = renderTexture.framebuffer.glFramebuffers[renderer.CONTEXT_UID];
+          if (fbo.blitFramebuffer) {
+            renderer.framebuffer.bind(fbo.blitFramebuffer);
+          }
+        }
+      } else {
+        resolution = renderer.resolution;
+        if (!frame) {
+          frame = TEMP_RECT$1;
+          frame.width = renderer.width / resolution;
+          frame.height = renderer.height / resolution;
+        }
+        flipY = true;
+        renderer.renderTexture.bind();
+      }
+      const width = Math.round(frame.width * resolution);
+      const height = Math.round(frame.height * resolution);
+      const pixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
+      const gl = renderer.gl;
+      gl.readPixels(Math.round(frame.x * resolution), Math.round(frame.y * resolution), width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+      if (generated) {
+        renderTexture?.destroy(true);
+      }
+      return { pixels, width, height, flipY };
+    }
+    destroy() {
+      this.renderer = null;
+    }
+    static _flipY(pixels, width, height) {
+      const w = width << 2;
+      const h = height >> 1;
+      const temp = new Uint8Array(w);
+      for (let y = 0; y < h; y++) {
+        const t = y * w;
+        const b = (height - y - 1) * w;
+        temp.set(pixels.subarray(t, t + w));
+        pixels.copyWithin(t, b, b + w);
+        pixels.set(temp, b);
+      }
+    }
+    static _unpremultiplyAlpha(pixels) {
+      if (pixels instanceof Uint8ClampedArray) {
+        pixels = new Uint8Array(pixels.buffer);
+      }
+      const n = pixels.length;
+      for (let i = 0; i < n; i += 4) {
+        const alpha = pixels[i + 3];
+        if (alpha !== 0) {
+          const a = 255.001 / alpha;
+          pixels[i] = pixels[i] * a + 0.5;
+          pixels[i + 1] = pixels[i + 1] * a + 0.5;
+          pixels[i + 2] = pixels[i + 2] * a + 0.5;
+        }
+      }
+    }
+  };
+  let Extract = _Extract;
+  Extract.extension = {
+    name: "extract",
+    type: ExtensionType.RendererSystem
+  };
+  extensions$1.add(Extract);
+
+  const buildCircle = {
+    build(graphicsData) {
+      const points = graphicsData.points;
+      let x;
+      let y;
+      let dx;
+      let dy;
+      let rx;
+      let ry;
+      if (graphicsData.type === SHAPES.CIRC) {
+        const circle = graphicsData.shape;
+        x = circle.x;
+        y = circle.y;
+        rx = ry = circle.radius;
+        dx = dy = 0;
+      } else if (graphicsData.type === SHAPES.ELIP) {
+        const ellipse = graphicsData.shape;
+        x = ellipse.x;
+        y = ellipse.y;
+        rx = ellipse.width;
+        ry = ellipse.height;
+        dx = dy = 0;
+      } else {
+        const roundedRect = graphicsData.shape;
+        const halfWidth = roundedRect.width / 2;
+        const halfHeight = roundedRect.height / 2;
+        x = roundedRect.x + halfWidth;
+        y = roundedRect.y + halfHeight;
+        rx = ry = Math.max(0, Math.min(roundedRect.radius, Math.min(halfWidth, halfHeight)));
+        dx = halfWidth - rx;
+        dy = halfHeight - ry;
+      }
+      if (!(rx >= 0 && ry >= 0 && dx >= 0 && dy >= 0)) {
+        points.length = 0;
+        return;
+      }
+      const n = Math.ceil(2.3 * Math.sqrt(rx + ry));
+      const m = n * 8 + (dx ? 4 : 0) + (dy ? 4 : 0);
+      points.length = m;
+      if (m === 0) {
+        return;
+      }
+      if (n === 0) {
+        points.length = 8;
+        points[0] = points[6] = x + dx;
+        points[1] = points[3] = y + dy;
+        points[2] = points[4] = x - dx;
+        points[5] = points[7] = y - dy;
+        return;
+      }
+      let j1 = 0;
+      let j2 = n * 4 + (dx ? 2 : 0) + 2;
+      let j3 = j2;
+      let j4 = m;
+      {
+        const x0 = dx + rx;
+        const y0 = dy;
+        const x1 = x + x0;
+        const x2 = x - x0;
+        const y1 = y + y0;
+        points[j1++] = x1;
+        points[j1++] = y1;
+        points[--j2] = y1;
+        points[--j2] = x2;
+        if (dy) {
+          const y2 = y - y0;
+          points[j3++] = x2;
+          points[j3++] = y2;
+          points[--j4] = y2;
+          points[--j4] = x1;
+        }
+      }
+      for (let i = 1; i < n; i++) {
+        const a = Math.PI / 2 * (i / n);
+        const x0 = dx + Math.cos(a) * rx;
+        const y0 = dy + Math.sin(a) * ry;
+        const x1 = x + x0;
+        const x2 = x - x0;
+        const y1 = y + y0;
+        const y2 = y - y0;
+        points[j1++] = x1;
+        points[j1++] = y1;
+        points[--j2] = y1;
+        points[--j2] = x2;
+        points[j3++] = x2;
+        points[j3++] = y2;
+        points[--j4] = y2;
+        points[--j4] = x1;
+      }
+      {
+        const x0 = dx;
+        const y0 = dy + ry;
+        const x1 = x + x0;
+        const x2 = x - x0;
+        const y1 = y + y0;
+        const y2 = y - y0;
+        points[j1++] = x1;
+        points[j1++] = y1;
+        points[--j4] = y2;
+        points[--j4] = x1;
+        if (dx) {
+          points[j1++] = x2;
+          points[j1++] = y1;
+          points[--j4] = y2;
+          points[--j4] = x2;
+        }
+      }
+    },
+    triangulate(graphicsData, graphicsGeometry) {
+      const points = graphicsData.points;
+      const verts = graphicsGeometry.points;
+      const indices = graphicsGeometry.indices;
+      if (points.length === 0) {
+        return;
+      }
+      let vertPos = verts.length / 2;
+      const center = vertPos;
+      let x;
+      let y;
+      if (graphicsData.type !== SHAPES.RREC) {
+        const circle = graphicsData.shape;
+        x = circle.x;
+        y = circle.y;
+      } else {
+        const roundedRect = graphicsData.shape;
+        x = roundedRect.x + roundedRect.width / 2;
+        y = roundedRect.y + roundedRect.height / 2;
+      }
+      const matrix = graphicsData.matrix;
+      verts.push(graphicsData.matrix ? matrix.a * x + matrix.c * y + matrix.tx : x, graphicsData.matrix ? matrix.b * x + matrix.d * y + matrix.ty : y);
+      vertPos++;
+      verts.push(points[0], points[1]);
+      for (let i = 2; i < points.length; i += 2) {
+        verts.push(points[i], points[i + 1]);
+        indices.push(vertPos++, center, vertPos);
+      }
+      indices.push(center + 1, center, vertPos);
+    }
+  };
+
+  function fixOrientation(points, hole = false) {
+    const m = points.length;
+    if (m < 6) {
+      return;
+    }
+    let area = 0;
+    for (let i = 0, x1 = points[m - 2], y1 = points[m - 1]; i < m; i += 2) {
+      const x2 = points[i];
+      const y2 = points[i + 1];
+      area += (x2 - x1) * (y2 + y1);
+      x1 = x2;
+      y1 = y2;
+    }
+    if (!hole && area > 0 || hole && area <= 0) {
+      const n = m / 2;
+      for (let i = n + n % 2; i < m; i += 2) {
+        const i1 = m - i - 2;
+        const i2 = m - i - 1;
+        const i3 = i;
+        const i4 = i + 1;
+        [points[i1], points[i3]] = [points[i3], points[i1]];
+        [points[i2], points[i4]] = [points[i4], points[i2]];
+      }
+    }
+  }
+  const buildPoly = {
+    build(graphicsData) {
+      graphicsData.points = graphicsData.shape.points.slice();
+    },
+    triangulate(graphicsData, graphicsGeometry) {
+      let points = graphicsData.points;
+      const holes = graphicsData.holes;
+      const verts = graphicsGeometry.points;
+      const indices = graphicsGeometry.indices;
+      if (points.length >= 6) {
+        fixOrientation(points, false);
+        const holeArray = [];
+        for (let i = 0; i < holes.length; i++) {
+          const hole = holes[i];
+          fixOrientation(hole.points, true);
+          holeArray.push(points.length / 2);
+          points = points.concat(hole.points);
+        }
+        const triangles = earcut_1(points, holeArray, 2);
+        if (!triangles) {
+          return;
+        }
+        const vertPos = verts.length / 2;
+        for (let i = 0; i < triangles.length; i += 3) {
+          indices.push(triangles[i] + vertPos);
+          indices.push(triangles[i + 1] + vertPos);
+          indices.push(triangles[i + 2] + vertPos);
+        }
+        for (let i = 0; i < points.length; i++) {
+          verts.push(points[i]);
+        }
+      }
+    }
+  };
+
+  const buildRectangle = {
+    build(graphicsData) {
+      const rectData = graphicsData.shape;
+      const x = rectData.x;
+      const y = rectData.y;
+      const width = rectData.width;
+      const height = rectData.height;
+      const points = graphicsData.points;
+      points.length = 0;
+      if (!(width >= 0 && height >= 0)) {
+        return;
+      }
+      points.push(x, y, x + width, y, x + width, y + height, x, y + height);
+    },
+    triangulate(graphicsData, graphicsGeometry) {
+      const points = graphicsData.points;
+      const verts = graphicsGeometry.points;
+      if (points.length === 0) {
+        return;
+      }
+      const vertPos = verts.length / 2;
+      verts.push(points[0], points[1], points[2], points[3], points[6], points[7], points[4], points[5]);
+      graphicsGeometry.indices.push(vertPos, vertPos + 1, vertPos + 2, vertPos + 1, vertPos + 2, vertPos + 3);
+    }
+  };
+
+  const buildRoundedRectangle = {
+    build(graphicsData) {
+      buildCircle.build(graphicsData);
+    },
+    triangulate(graphicsData, graphicsGeometry) {
+      buildCircle.triangulate(graphicsData, graphicsGeometry);
+    }
+  };
+
+  var LINE_JOIN = /* @__PURE__ */ ((LINE_JOIN2) => {
+    LINE_JOIN2["MITER"] = "miter";
+    LINE_JOIN2["BEVEL"] = "bevel";
+    LINE_JOIN2["ROUND"] = "round";
+    return LINE_JOIN2;
+  })(LINE_JOIN || {});
+  var LINE_CAP = /* @__PURE__ */ ((LINE_CAP2) => {
+    LINE_CAP2["BUTT"] = "butt";
+    LINE_CAP2["ROUND"] = "round";
+    LINE_CAP2["SQUARE"] = "square";
+    return LINE_CAP2;
+  })(LINE_CAP || {});
+  const curves = {
+    adaptive: true,
+    maxLength: 10,
+    minSegments: 8,
+    maxSegments: 2048,
+    epsilon: 1e-4,
+    _segmentsCount(length, defaultSegments = 20) {
+      if (!this.adaptive || !length || isNaN(length)) {
+        return defaultSegments;
+      }
+      let result = Math.ceil(length / this.maxLength);
+      if (result < this.minSegments) {
+        result = this.minSegments;
+      } else if (result > this.maxSegments) {
+        result = this.maxSegments;
+      }
+      return result;
+    }
+  };
+  const GRAPHICS_CURVES = curves;
+
+  class ArcUtils {
+    static curveTo(x1, y1, x2, y2, radius, points) {
+      const fromX = points[points.length - 2];
+      const fromY = points[points.length - 1];
+      const a1 = fromY - y1;
+      const b1 = fromX - x1;
+      const a2 = y2 - y1;
+      const b2 = x2 - x1;
+      const mm = Math.abs(a1 * b2 - b1 * a2);
+      if (mm < 1e-8 || radius === 0) {
+        if (points[points.length - 2] !== x1 || points[points.length - 1] !== y1) {
+          points.push(x1, y1);
+        }
+        return null;
+      }
+      const dd = a1 * a1 + b1 * b1;
+      const cc = a2 * a2 + b2 * b2;
+      const tt = a1 * a2 + b1 * b2;
+      const k1 = radius * Math.sqrt(dd) / mm;
+      const k2 = radius * Math.sqrt(cc) / mm;
+      const j1 = k1 * tt / dd;
+      const j2 = k2 * tt / cc;
+      const cx = k1 * b2 + k2 * b1;
+      const cy = k1 * a2 + k2 * a1;
+      const px = b1 * (k2 + j1);
+      const py = a1 * (k2 + j1);
+      const qx = b2 * (k1 + j2);
+      const qy = a2 * (k1 + j2);
+      const startAngle = Math.atan2(py - cy, px - cx);
+      const endAngle = Math.atan2(qy - cy, qx - cx);
+      return {
+        cx: cx + x1,
+        cy: cy + y1,
+        radius,
+        startAngle,
+        endAngle,
+        anticlockwise: b1 * a2 > b2 * a1
+      };
+    }
+    static arc(_startX, _startY, cx, cy, radius, startAngle, endAngle, _anticlockwise, points) {
+      const sweep = endAngle - startAngle;
+      const n = curves._segmentsCount(Math.abs(sweep) * radius, Math.ceil(Math.abs(sweep) / PI_2) * 40);
+      const theta = sweep / (n * 2);
+      const theta2 = theta * 2;
+      const cTheta = Math.cos(theta);
+      const sTheta = Math.sin(theta);
+      const segMinus = n - 1;
+      const remainder = segMinus % 1 / segMinus;
+      for (let i = 0; i <= segMinus; ++i) {
+        const real = i + remainder * i;
+        const angle = theta + startAngle + theta2 * real;
+        const c = Math.cos(angle);
+        const s = -Math.sin(angle);
+        points.push((cTheta * c + sTheta * s) * radius + cx, (cTheta * -s + sTheta * c) * radius + cy);
+      }
+    }
+  }
+
+  class BatchPart {
+    constructor() {
+      this.reset();
+    }
+    begin(style, startIndex, attribStart) {
+      this.reset();
+      this.style = style;
+      this.start = startIndex;
+      this.attribStart = attribStart;
+    }
+    end(endIndex, endAttrib) {
+      this.attribSize = endAttrib - this.attribStart;
+      this.size = endIndex - this.start;
+    }
+    reset() {
+      this.style = null;
+      this.size = 0;
+      this.start = 0;
+      this.attribStart = 0;
+      this.attribSize = 0;
+    }
+  }
+
+  class BezierUtils {
+    static curveLength(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
+      const n = 10;
+      let result = 0;
+      let t = 0;
+      let t2 = 0;
+      let t3 = 0;
+      let nt = 0;
+      let nt2 = 0;
+      let nt3 = 0;
+      let x = 0;
+      let y = 0;
+      let dx = 0;
+      let dy = 0;
+      let prevX = fromX;
+      let prevY = fromY;
+      for (let i = 1; i <= n; ++i) {
+        t = i / n;
+        t2 = t * t;
+        t3 = t2 * t;
+        nt = 1 - t;
+        nt2 = nt * nt;
+        nt3 = nt2 * nt;
+        x = nt3 * fromX + 3 * nt2 * t * cpX + 3 * nt * t2 * cpX2 + t3 * toX;
+        y = nt3 * fromY + 3 * nt2 * t * cpY + 3 * nt * t2 * cpY2 + t3 * toY;
+        dx = prevX - x;
+        dy = prevY - y;
+        prevX = x;
+        prevY = y;
+        result += Math.sqrt(dx * dx + dy * dy);
+      }
+      return result;
+    }
+    static curveTo(cpX, cpY, cpX2, cpY2, toX, toY, points) {
+      const fromX = points[points.length - 2];
+      const fromY = points[points.length - 1];
+      points.length -= 2;
+      const n = curves._segmentsCount(BezierUtils.curveLength(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY));
+      let dt = 0;
+      let dt2 = 0;
+      let dt3 = 0;
+      let t2 = 0;
+      let t3 = 0;
+      points.push(fromX, fromY);
+      for (let i = 1, j = 0; i <= n; ++i) {
+        j = i / n;
+        dt = 1 - j;
+        dt2 = dt * dt;
+        dt3 = dt2 * dt;
+        t2 = j * j;
+        t3 = t2 * j;
+        points.push(dt3 * fromX + 3 * dt2 * j * cpX + 3 * dt * t2 * cpX2 + t3 * toX, dt3 * fromY + 3 * dt2 * j * cpY + 3 * dt * t2 * cpY2 + t3 * toY);
+      }
+    }
+  }
+
+  function square(x, y, nx, ny, innerWeight, outerWeight, clockwise, verts) {
+    const ix = x - nx * innerWeight;
+    const iy = y - ny * innerWeight;
+    const ox = x + nx * outerWeight;
+    const oy = y + ny * outerWeight;
+    let exx;
+    let eyy;
+    if (clockwise) {
+      exx = ny;
+      eyy = -nx;
+    } else {
+      exx = -ny;
+      eyy = nx;
+    }
+    const eix = ix + exx;
+    const eiy = iy + eyy;
+    const eox = ox + exx;
+    const eoy = oy + eyy;
+    verts.push(eix, eiy, eox, eoy);
+    return 2;
+  }
+  function round(cx, cy, sx, sy, ex, ey, verts, clockwise) {
+    const cx2p0x = sx - cx;
+    const cy2p0y = sy - cy;
+    let angle0 = Math.atan2(cx2p0x, cy2p0y);
+    let angle1 = Math.atan2(ex - cx, ey - cy);
+    if (clockwise && angle0 < angle1) {
+      angle0 += Math.PI * 2;
+    } else if (!clockwise && angle0 > angle1) {
+      angle1 += Math.PI * 2;
+    }
+    let startAngle = angle0;
+    const angleDiff = angle1 - angle0;
+    const absAngleDiff = Math.abs(angleDiff);
+    const radius = Math.sqrt(cx2p0x * cx2p0x + cy2p0y * cy2p0y);
+    const segCount = (15 * absAngleDiff * Math.sqrt(radius) / Math.PI >> 0) + 1;
+    const angleInc = angleDiff / segCount;
+    startAngle += angleInc;
+    if (clockwise) {
+      verts.push(cx, cy, sx, sy);
+      for (let i = 1, angle = startAngle; i < segCount; i++, angle += angleInc) {
+        verts.push(cx, cy, cx + Math.sin(angle) * radius, cy + Math.cos(angle) * radius);
+      }
+      verts.push(cx, cy, ex, ey);
+    } else {
+      verts.push(sx, sy, cx, cy);
+      for (let i = 1, angle = startAngle; i < segCount; i++, angle += angleInc) {
+        verts.push(cx + Math.sin(angle) * radius, cy + Math.cos(angle) * radius, cx, cy);
+      }
+      verts.push(ex, ey, cx, cy);
+    }
+    return segCount * 2;
+  }
+  function buildNonNativeLine(graphicsData, graphicsGeometry) {
+    const shape = graphicsData.shape;
+    let points = graphicsData.points || shape.points.slice();
+    const eps = graphicsGeometry.closePointEps;
+    if (points.length === 0) {
+      return;
+    }
+    const style = graphicsData.lineStyle;
+    const firstPoint = new Point(points[0], points[1]);
+    const lastPoint = new Point(points[points.length - 2], points[points.length - 1]);
+    const closedShape = shape.type !== SHAPES.POLY || shape.closeStroke;
+    const closedPath = Math.abs(firstPoint.x - lastPoint.x) < eps && Math.abs(firstPoint.y - lastPoint.y) < eps;
+    if (closedShape) {
+      points = points.slice();
+      if (closedPath) {
+        points.pop();
+        points.pop();
+        lastPoint.set(points[points.length - 2], points[points.length - 1]);
+      }
+      const midPointX = (firstPoint.x + lastPoint.x) * 0.5;
+      const midPointY = (lastPoint.y + firstPoint.y) * 0.5;
+      points.unshift(midPointX, midPointY);
+      points.push(midPointX, midPointY);
+    }
+    const verts = graphicsGeometry.points;
+    const length = points.length / 2;
+    let indexCount = points.length;
+    const indexStart = verts.length / 2;
+    const width = style.width / 2;
+    const widthSquared = width * width;
+    const miterLimitSquared = style.miterLimit * style.miterLimit;
+    let x0 = points[0];
+    let y0 = points[1];
+    let x1 = points[2];
+    let y1 = points[3];
+    let x2 = 0;
+    let y2 = 0;
+    let perpx = -(y0 - y1);
+    let perpy = x0 - x1;
+    let perp1x = 0;
+    let perp1y = 0;
+    let dist = Math.sqrt(perpx * perpx + perpy * perpy);
+    perpx /= dist;
+    perpy /= dist;
+    perpx *= width;
+    perpy *= width;
+    const ratio = style.alignment;
+    const innerWeight = (1 - ratio) * 2;
+    const outerWeight = ratio * 2;
+    if (!closedShape) {
+      if (style.cap === LINE_CAP.ROUND) {
+        indexCount += round(x0 - perpx * (innerWeight - outerWeight) * 0.5, y0 - perpy * (innerWeight - outerWeight) * 0.5, x0 - perpx * innerWeight, y0 - perpy * innerWeight, x0 + perpx * outerWeight, y0 + perpy * outerWeight, verts, true) + 2;
+      } else if (style.cap === LINE_CAP.SQUARE) {
+        indexCount += square(x0, y0, perpx, perpy, innerWeight, outerWeight, true, verts);
+      }
+    }
+    verts.push(x0 - perpx * innerWeight, y0 - perpy * innerWeight, x0 + perpx * outerWeight, y0 + perpy * outerWeight);
+    for (let i = 1; i < length - 1; ++i) {
+      x0 = points[(i - 1) * 2];
+      y0 = points[(i - 1) * 2 + 1];
+      x1 = points[i * 2];
+      y1 = points[i * 2 + 1];
+      x2 = points[(i + 1) * 2];
+      y2 = points[(i + 1) * 2 + 1];
+      perpx = -(y0 - y1);
+      perpy = x0 - x1;
+      dist = Math.sqrt(perpx * perpx + perpy * perpy);
+      perpx /= dist;
+      perpy /= dist;
+      perpx *= width;
+      perpy *= width;
+      perp1x = -(y1 - y2);
+      perp1y = x1 - x2;
+      dist = Math.sqrt(perp1x * perp1x + perp1y * perp1y);
+      perp1x /= dist;
+      perp1y /= dist;
+      perp1x *= width;
+      perp1y *= width;
+      const dx0 = x1 - x0;
+      const dy0 = y0 - y1;
+      const dx1 = x1 - x2;
+      const dy1 = y2 - y1;
+      const dot = dx0 * dx1 + dy0 * dy1;
+      const cross = dy0 * dx1 - dy1 * dx0;
+      const clockwise = cross < 0;
+      if (Math.abs(cross) < 1e-3 * Math.abs(dot)) {
+        verts.push(x1 - perpx * innerWeight, y1 - perpy * innerWeight, x1 + perpx * outerWeight, y1 + perpy * outerWeight);
+        if (dot >= 0) {
+          if (style.join === LINE_JOIN.ROUND) {
+            indexCount += round(x1, y1, x1 - perpx * innerWeight, y1 - perpy * innerWeight, x1 - perp1x * innerWeight, y1 - perp1y * innerWeight, verts, false) + 4;
+          } else {
+            indexCount += 2;
+          }
+          verts.push(x1 - perp1x * outerWeight, y1 - perp1y * outerWeight, x1 + perp1x * innerWeight, y1 + perp1y * innerWeight);
+        }
+        continue;
+      }
+      const c1 = (-perpx + x0) * (-perpy + y1) - (-perpx + x1) * (-perpy + y0);
+      const c2 = (-perp1x + x2) * (-perp1y + y1) - (-perp1x + x1) * (-perp1y + y2);
+      const px = (dx0 * c2 - dx1 * c1) / cross;
+      const py = (dy1 * c1 - dy0 * c2) / cross;
+      const pdist = (px - x1) * (px - x1) + (py - y1) * (py - y1);
+      const imx = x1 + (px - x1) * innerWeight;
+      const imy = y1 + (py - y1) * innerWeight;
+      const omx = x1 - (px - x1) * outerWeight;
+      const omy = y1 - (py - y1) * outerWeight;
+      const smallerInsideSegmentSq = Math.min(dx0 * dx0 + dy0 * dy0, dx1 * dx1 + dy1 * dy1);
+      const insideWeight = clockwise ? innerWeight : outerWeight;
+      const smallerInsideDiagonalSq = smallerInsideSegmentSq + insideWeight * insideWeight * widthSquared;
+      const insideMiterOk = pdist <= smallerInsideDiagonalSq;
+      let join = style.join;
+      if (join === LINE_JOIN.MITER && pdist / widthSquared > miterLimitSquared) {
+        join = LINE_JOIN.BEVEL;
+      }
+      if (insideMiterOk) {
+        switch (join) {
+          case LINE_JOIN.MITER: {
+            verts.push(imx, imy, omx, omy);
+            break;
+          }
+          case LINE_JOIN.BEVEL: {
+            if (clockwise) {
+              verts.push(imx, imy, x1 + perpx * outerWeight, y1 + perpy * outerWeight, imx, imy, x1 + perp1x * outerWeight, y1 + perp1y * outerWeight);
+            } else {
+              verts.push(x1 - perpx * innerWeight, y1 - perpy * innerWeight, omx, omy, x1 - perp1x * innerWeight, y1 - perp1y * innerWeight, omx, omy);
+            }
+            indexCount += 2;
+            break;
+          }
+          case LINE_JOIN.ROUND: {
+            if (clockwise) {
+              verts.push(imx, imy, x1 + perpx * outerWeight, y1 + perpy * outerWeight);
+              indexCount += round(x1, y1, x1 + perpx * outerWeight, y1 + perpy * outerWeight, x1 + perp1x * outerWeight, y1 + perp1y * outerWeight, verts, true) + 4;
+              verts.push(imx, imy, x1 + perp1x * outerWeight, y1 + perp1y * outerWeight);
+            } else {
+              verts.push(x1 - perpx * innerWeight, y1 - perpy * innerWeight, omx, omy);
+              indexCount += round(x1, y1, x1 - perpx * innerWeight, y1 - perpy * innerWeight, x1 - perp1x * innerWeight, y1 - perp1y * innerWeight, verts, false) + 4;
+              verts.push(x1 - perp1x * innerWeight, y1 - perp1y * innerWeight, omx, omy);
+            }
+            break;
+          }
+        }
+      } else {
+        verts.push(x1 - perpx * innerWeight, y1 - perpy * innerWeight, x1 + perpx * outerWeight, y1 + perpy * outerWeight);
+        switch (join) {
+          case LINE_JOIN.MITER: {
+            if (clockwise) {
+              verts.push(omx, omy, omx, omy);
+            } else {
+              verts.push(imx, imy, imx, imy);
+            }
+            indexCount += 2;
+            break;
+          }
+          case LINE_JOIN.ROUND: {
+            if (clockwise) {
+              indexCount += round(x1, y1, x1 + perpx * outerWeight, y1 + perpy * outerWeight, x1 + perp1x * outerWeight, y1 + perp1y * outerWeight, verts, true) + 2;
+            } else {
+              indexCount += round(x1, y1, x1 - perpx * innerWeight, y1 - perpy * innerWeight, x1 - perp1x * innerWeight, y1 - perp1y * innerWeight, verts, false) + 2;
+            }
+            break;
+          }
+        }
+        verts.push(x1 - perp1x * innerWeight, y1 - perp1y * innerWeight, x1 + perp1x * outerWeight, y1 + perp1y * outerWeight);
+        indexCount += 2;
+      }
+    }
+    x0 = points[(length - 2) * 2];
+    y0 = points[(length - 2) * 2 + 1];
+    x1 = points[(length - 1) * 2];
+    y1 = points[(length - 1) * 2 + 1];
+    perpx = -(y0 - y1);
+    perpy = x0 - x1;
+    dist = Math.sqrt(perpx * perpx + perpy * perpy);
+    perpx /= dist;
+    perpy /= dist;
+    perpx *= width;
+    perpy *= width;
+    verts.push(x1 - perpx * innerWeight, y1 - perpy * innerWeight, x1 + perpx * outerWeight, y1 + perpy * outerWeight);
+    if (!closedShape) {
+      if (style.cap === LINE_CAP.ROUND) {
+        indexCount += round(x1 - perpx * (innerWeight - outerWeight) * 0.5, y1 - perpy * (innerWeight - outerWeight) * 0.5, x1 - perpx * innerWeight, y1 - perpy * innerWeight, x1 + perpx * outerWeight, y1 + perpy * outerWeight, verts, false) + 2;
+      } else if (style.cap === LINE_CAP.SQUARE) {
+        indexCount += square(x1, y1, perpx, perpy, innerWeight, outerWeight, false, verts);
+      }
+    }
+    const indices = graphicsGeometry.indices;
+    const eps2 = curves.epsilon * curves.epsilon;
+    for (let i = indexStart; i < indexCount + indexStart - 2; ++i) {
+      x0 = verts[i * 2];
+      y0 = verts[i * 2 + 1];
+      x1 = verts[(i + 1) * 2];
+      y1 = verts[(i + 1) * 2 + 1];
+      x2 = verts[(i + 2) * 2];
+      y2 = verts[(i + 2) * 2 + 1];
+      if (Math.abs(x0 * (y1 - y2) + x1 * (y2 - y0) + x2 * (y0 - y1)) < eps2) {
+        continue;
+      }
+      indices.push(i, i + 1, i + 2);
+    }
+  }
+  function buildNativeLine(graphicsData, graphicsGeometry) {
+    let i = 0;
+    const shape = graphicsData.shape;
+    const points = graphicsData.points || shape.points;
+    const closedShape = shape.type !== SHAPES.POLY || shape.closeStroke;
+    if (points.length === 0)
+      return;
+    const verts = graphicsGeometry.points;
+    const indices = graphicsGeometry.indices;
+    const length = points.length / 2;
+    const startIndex = verts.length / 2;
+    let currentIndex = startIndex;
+    verts.push(points[0], points[1]);
+    for (i = 1; i < length; i++) {
+      verts.push(points[i * 2], points[i * 2 + 1]);
+      indices.push(currentIndex, currentIndex + 1);
+      currentIndex++;
+    }
+    if (closedShape) {
+      indices.push(currentIndex, startIndex);
+    }
+  }
+  function buildLine(graphicsData, graphicsGeometry) {
+    if (graphicsData.lineStyle.native) {
+      buildNativeLine(graphicsData, graphicsGeometry);
+    } else {
+      buildNonNativeLine(graphicsData, graphicsGeometry);
+    }
+  }
+
+  class QuadraticUtils {
+    static curveLength(fromX, fromY, cpX, cpY, toX, toY) {
+      const ax = fromX - 2 * cpX + toX;
+      const ay = fromY - 2 * cpY + toY;
+      const bx = 2 * cpX - 2 * fromX;
+      const by = 2 * cpY - 2 * fromY;
+      const a = 4 * (ax * ax + ay * ay);
+      const b = 4 * (ax * bx + ay * by);
+      const c = bx * bx + by * by;
+      const s = 2 * Math.sqrt(a + b + c);
+      const a2 = Math.sqrt(a);
+      const a32 = 2 * a * a2;
+      const c2 = 2 * Math.sqrt(c);
+      const ba = b / a2;
+      return (a32 * s + a2 * b * (s - c2) + (4 * c * a - b * b) * Math.log((2 * a2 + ba + s) / (ba + c2))) / (4 * a32);
+    }
+    static curveTo(cpX, cpY, toX, toY, points) {
+      const fromX = points[points.length - 2];
+      const fromY = points[points.length - 1];
+      const n = curves._segmentsCount(QuadraticUtils.curveLength(fromX, fromY, cpX, cpY, toX, toY));
+      let xa = 0;
+      let ya = 0;
+      for (let i = 1; i <= n; ++i) {
+        const j = i / n;
+        xa = fromX + (cpX - fromX) * j;
+        ya = fromY + (cpY - fromY) * j;
+        points.push(xa + (cpX + (toX - cpX) * j - xa) * j, ya + (cpY + (toY - cpY) * j - ya) * j);
+      }
+    }
+  }
+
+  const FILL_COMMANDS = {
+    [SHAPES.POLY]: buildPoly,
+    [SHAPES.CIRC]: buildCircle,
+    [SHAPES.ELIP]: buildCircle,
+    [SHAPES.RECT]: buildRectangle,
+    [SHAPES.RREC]: buildRoundedRectangle
+  };
+  const BATCH_POOL = [];
+  const DRAW_CALL_POOL = [];
+
+  class GraphicsData {
+    constructor(shape, fillStyle = null, lineStyle = null, matrix = null) {
+      this.points = [];
+      this.holes = [];
+      this.shape = shape;
+      this.lineStyle = lineStyle;
+      this.fillStyle = fillStyle;
+      this.matrix = matrix;
+      this.type = shape.type;
+    }
+    clone() {
+      return new GraphicsData(this.shape, this.fillStyle, this.lineStyle, this.matrix);
+    }
+    destroy() {
+      this.shape = null;
+      this.holes.length = 0;
+      this.holes = null;
+      this.points.length = 0;
+      this.points = null;
+      this.lineStyle = null;
+      this.fillStyle = null;
+    }
+  }
+
+  const tmpPoint = new Point();
+  const _GraphicsGeometry = class extends BatchGeometry {
+    constructor() {
+      super();
+      this.closePointEps = 1e-4;
+      this.boundsPadding = 0;
+      this.uvsFloat32 = null;
+      this.indicesUint16 = null;
+      this.batchable = false;
+      this.points = [];
+      this.colors = [];
+      this.uvs = [];
+      this.indices = [];
+      this.textureIds = [];
+      this.graphicsData = [];
+      this.drawCalls = [];
+      this.batchDirty = -1;
+      this.batches = [];
+      this.dirty = 0;
+      this.cacheDirty = -1;
+      this.clearDirty = 0;
+      this.shapeIndex = 0;
+      this._bounds = new Bounds();
+      this.boundsDirty = -1;
+    }
+    get bounds() {
+      this.updateBatches();
+      if (this.boundsDirty !== this.dirty) {
+        this.boundsDirty = this.dirty;
+        this.calculateBounds();
+      }
+      return this._bounds;
+    }
+    invalidate() {
+      this.boundsDirty = -1;
+      this.dirty++;
+      this.batchDirty++;
+      this.shapeIndex = 0;
+      this.points.length = 0;
+      this.colors.length = 0;
+      this.uvs.length = 0;
+      this.indices.length = 0;
+      this.textureIds.length = 0;
+      for (let i = 0; i < this.drawCalls.length; i++) {
+        this.drawCalls[i].texArray.clear();
+        DRAW_CALL_POOL.push(this.drawCalls[i]);
+      }
+      this.drawCalls.length = 0;
+      for (let i = 0; i < this.batches.length; i++) {
+        const batchPart = this.batches[i];
+        batchPart.reset();
+        BATCH_POOL.push(batchPart);
+      }
+      this.batches.length = 0;
+    }
+    clear() {
+      if (this.graphicsData.length > 0) {
+        this.invalidate();
+        this.clearDirty++;
+        this.graphicsData.length = 0;
+      }
+      return this;
+    }
+    drawShape(shape, fillStyle = null, lineStyle = null, matrix = null) {
+      const data = new GraphicsData(shape, fillStyle, lineStyle, matrix);
+      this.graphicsData.push(data);
+      this.dirty++;
+      return this;
+    }
+    drawHole(shape, matrix = null) {
+      if (!this.graphicsData.length) {
+        return null;
+      }
+      const data = new GraphicsData(shape, null, null, matrix);
+      const lastShape = this.graphicsData[this.graphicsData.length - 1];
+      data.lineStyle = lastShape.lineStyle;
+      lastShape.holes.push(data);
+      this.dirty++;
+      return this;
+    }
+    destroy() {
+      super.destroy();
+      for (let i = 0; i < this.graphicsData.length; ++i) {
+        this.graphicsData[i].destroy();
+      }
+      this.points.length = 0;
+      this.points = null;
+      this.colors.length = 0;
+      this.colors = null;
+      this.uvs.length = 0;
+      this.uvs = null;
+      this.indices.length = 0;
+      this.indices = null;
+      this.indexBuffer.destroy();
+      this.indexBuffer = null;
+      this.graphicsData.length = 0;
+      this.graphicsData = null;
+      this.drawCalls.length = 0;
+      this.drawCalls = null;
+      this.batches.length = 0;
+      this.batches = null;
+      this._bounds = null;
+    }
+    containsPoint(point) {
+      const graphicsData = this.graphicsData;
+      for (let i = 0; i < graphicsData.length; ++i) {
+        const data = graphicsData[i];
+        if (!data.fillStyle.visible) {
+          continue;
+        }
+        if (data.shape) {
+          if (data.matrix) {
+            data.matrix.applyInverse(point, tmpPoint);
+          } else {
+            tmpPoint.copyFrom(point);
+          }
+          if (data.shape.contains(tmpPoint.x, tmpPoint.y)) {
+            let hitHole = false;
+            if (data.holes) {
+              for (let i2 = 0; i2 < data.holes.length; i2++) {
+                const hole = data.holes[i2];
+                if (hole.shape.contains(tmpPoint.x, tmpPoint.y)) {
+                  hitHole = true;
+                  break;
+                }
+              }
+            }
+            if (!hitHole) {
+              return true;
+            }
+          }
+        }
+      }
+      return false;
+    }
+    updateBatches() {
+      if (!this.graphicsData.length) {
+        this.batchable = true;
+        return;
+      }
+      if (!this.validateBatching()) {
+        return;
+      }
+      this.cacheDirty = this.dirty;
+      const uvs = this.uvs;
+      const graphicsData = this.graphicsData;
+      let batchPart = null;
+      let currentStyle = null;
+      if (this.batches.length > 0) {
+        batchPart = this.batches[this.batches.length - 1];
+        currentStyle = batchPart.style;
+      }
+      for (let i = this.shapeIndex; i < graphicsData.length; i++) {
+        this.shapeIndex++;
+        const data = graphicsData[i];
+        const fillStyle = data.fillStyle;
+        const lineStyle = data.lineStyle;
+        const command = FILL_COMMANDS[data.type];
+        command.build(data);
+        if (data.matrix) {
+          this.transformPoints(data.points, data.matrix);
+        }
+        if (fillStyle.visible || lineStyle.visible) {
+          this.processHoles(data.holes);
+        }
+        for (let j = 0; j < 2; j++) {
+          const style = j === 0 ? fillStyle : lineStyle;
+          if (!style.visible)
+            continue;
+          const nextTexture = style.texture.baseTexture;
+          const index2 = this.indices.length;
+          const attribIndex = this.points.length / 2;
+          nextTexture.wrapMode = WRAP_MODES.REPEAT;
+          if (j === 0) {
+            this.processFill(data);
+          } else {
+            this.processLine(data);
+          }
+          const size = this.points.length / 2 - attribIndex;
+          if (size === 0)
+            continue;
+          if (batchPart && !this._compareStyles(currentStyle, style)) {
+            batchPart.end(index2, attribIndex);
+            batchPart = null;
+          }
+          if (!batchPart) {
+            batchPart = BATCH_POOL.pop() || new BatchPart();
+            batchPart.begin(style, index2, attribIndex);
+            this.batches.push(batchPart);
+            currentStyle = style;
+          }
+          this.addUvs(this.points, uvs, style.texture, attribIndex, size, style.matrix);
+        }
+      }
+      const index = this.indices.length;
+      const attrib = this.points.length / 2;
+      if (batchPart) {
+        batchPart.end(index, attrib);
+      }
+      if (this.batches.length === 0) {
+        this.batchable = true;
+        return;
+      }
+      const need32 = attrib > 65535;
+      if (this.indicesUint16 && this.indices.length === this.indicesUint16.length && need32 === this.indicesUint16.BYTES_PER_ELEMENT > 2) {
+        this.indicesUint16.set(this.indices);
+      } else {
+        this.indicesUint16 = need32 ? new Uint32Array(this.indices) : new Uint16Array(this.indices);
+      }
+      this.batchable = this.isBatchable();
+      if (this.batchable) {
+        this.packBatches();
+      } else {
+        this.buildDrawCalls();
+      }
+    }
+    _compareStyles(styleA, styleB) {
+      if (!styleA || !styleB) {
+        return false;
+      }
+      if (styleA.texture.baseTexture !== styleB.texture.baseTexture) {
+        return false;
+      }
+      if (styleA.color + styleA.alpha !== styleB.color + styleB.alpha) {
+        return false;
+      }
+      if (!!styleA.native !== !!styleB.native) {
+        return false;
+      }
+      return true;
+    }
+    validateBatching() {
+      if (this.dirty === this.cacheDirty || !this.graphicsData.length) {
+        return false;
+      }
+      for (let i = 0, l = this.graphicsData.length; i < l; i++) {
+        const data = this.graphicsData[i];
+        const fill = data.fillStyle;
+        const line = data.lineStyle;
+        if (fill && !fill.texture.baseTexture.valid)
+          return false;
+        if (line && !line.texture.baseTexture.valid)
+          return false;
+      }
+      return true;
+    }
+    packBatches() {
+      this.batchDirty++;
+      this.uvsFloat32 = new Float32Array(this.uvs);
+      const batches = this.batches;
+      for (let i = 0, l = batches.length; i < l; i++) {
+        const batch = batches[i];
+        for (let j = 0; j < batch.size; j++) {
+          const index = batch.start + j;
+          this.indicesUint16[index] = this.indicesUint16[index] - batch.attribStart;
+        }
+      }
+    }
+    isBatchable() {
+      if (this.points.length > 65535 * 2) {
+        return false;
+      }
+      const batches = this.batches;
+      for (let i = 0; i < batches.length; i++) {
+        if (batches[i].style.native) {
+          return false;
+        }
+      }
+      return this.points.length < _GraphicsGeometry.BATCHABLE_SIZE * 2;
+    }
+    buildDrawCalls() {
+      let TICK = ++BaseTexture._globalBatch;
+      for (let i = 0; i < this.drawCalls.length; i++) {
+        this.drawCalls[i].texArray.clear();
+        DRAW_CALL_POOL.push(this.drawCalls[i]);
+      }
+      this.drawCalls.length = 0;
+      const colors = this.colors;
+      const textureIds = this.textureIds;
+      let currentGroup = DRAW_CALL_POOL.pop();
+      if (!currentGroup) {
+        currentGroup = new BatchDrawCall();
+        currentGroup.texArray = new BatchTextureArray();
+      }
+      currentGroup.texArray.count = 0;
+      currentGroup.start = 0;
+      currentGroup.size = 0;
+      currentGroup.type = DRAW_MODES.TRIANGLES;
+      let textureCount = 0;
+      let currentTexture = null;
+      let textureId = 0;
+      let native = false;
+      let drawMode = DRAW_MODES.TRIANGLES;
+      let index = 0;
+      this.drawCalls.push(currentGroup);
+      for (let i = 0; i < this.batches.length; i++) {
+        const data = this.batches[i];
+        const maxTextures = 8;
+        const style = data.style;
+        const nextTexture = style.texture.baseTexture;
+        if (native !== !!style.native) {
+          native = !!style.native;
+          drawMode = native ? DRAW_MODES.LINES : DRAW_MODES.TRIANGLES;
+          currentTexture = null;
+          textureCount = maxTextures;
+          TICK++;
+        }
+        if (currentTexture !== nextTexture) {
+          currentTexture = nextTexture;
+          if (nextTexture._batchEnabled !== TICK) {
+            if (textureCount === maxTextures) {
+              TICK++;
+              textureCount = 0;
+              if (currentGroup.size > 0) {
+                currentGroup = DRAW_CALL_POOL.pop();
+                if (!currentGroup) {
+                  currentGroup = new BatchDrawCall();
+                  currentGroup.texArray = new BatchTextureArray();
+                }
+                this.drawCalls.push(currentGroup);
+              }
+              currentGroup.start = index;
+              currentGroup.size = 0;
+              currentGroup.texArray.count = 0;
+              currentGroup.type = drawMode;
+            }
+            nextTexture.touched = 1;
+            nextTexture._batchEnabled = TICK;
+            nextTexture._batchLocation = textureCount;
+            nextTexture.wrapMode = WRAP_MODES.REPEAT;
+            currentGroup.texArray.elements[currentGroup.texArray.count++] = nextTexture;
+            textureCount++;
+          }
+        }
+        currentGroup.size += data.size;
+        index += data.size;
+        textureId = nextTexture._batchLocation;
+        this.addColors(colors, style.color, style.alpha, data.attribSize, data.attribStart);
+        this.addTextureIds(textureIds, textureId, data.attribSize, data.attribStart);
+      }
+      BaseTexture._globalBatch = TICK;
+      this.packAttributes();
+    }
+    packAttributes() {
+      const verts = this.points;
+      const uvs = this.uvs;
+      const colors = this.colors;
+      const textureIds = this.textureIds;
+      const glPoints = new ArrayBuffer(verts.length * 3 * 4);
+      const f32 = new Float32Array(glPoints);
+      const u32 = new Uint32Array(glPoints);
+      let p = 0;
+      for (let i = 0; i < verts.length / 2; i++) {
+        f32[p++] = verts[i * 2];
+        f32[p++] = verts[i * 2 + 1];
+        f32[p++] = uvs[i * 2];
+        f32[p++] = uvs[i * 2 + 1];
+        u32[p++] = colors[i];
+        f32[p++] = textureIds[i];
+      }
+      this._buffer.update(glPoints);
+      this._indexBuffer.update(this.indicesUint16);
+    }
+    processFill(data) {
+      if (data.holes.length) {
+        buildPoly.triangulate(data, this);
+      } else {
+        const command = FILL_COMMANDS[data.type];
+        command.triangulate(data, this);
+      }
+    }
+    processLine(data) {
+      buildLine(data, this);
+      for (let i = 0; i < data.holes.length; i++) {
+        buildLine(data.holes[i], this);
+      }
+    }
+    processHoles(holes) {
+      for (let i = 0; i < holes.length; i++) {
+        const hole = holes[i];
+        const command = FILL_COMMANDS[hole.type];
+        command.build(hole);
+        if (hole.matrix) {
+          this.transformPoints(hole.points, hole.matrix);
+        }
+      }
+    }
+    calculateBounds() {
+      const bounds = this._bounds;
+      bounds.clear();
+      bounds.addVertexData(this.points, 0, this.points.length);
+      bounds.pad(this.boundsPadding, this.boundsPadding);
+    }
+    transformPoints(points, matrix) {
+      for (let i = 0; i < points.length / 2; i++) {
+        const x = points[i * 2];
+        const y = points[i * 2 + 1];
+        points[i * 2] = matrix.a * x + matrix.c * y + matrix.tx;
+        points[i * 2 + 1] = matrix.b * x + matrix.d * y + matrix.ty;
+      }
+    }
+    addColors(colors, color, alpha, size, offset = 0) {
+      const bgr = Color.shared.setValue(color).toLittleEndianNumber();
+      const result = Color.shared.setValue(bgr).toPremultiplied(alpha);
+      colors.length = Math.max(colors.length, offset + size);
+      for (let i = 0; i < size; i++) {
+        colors[offset + i] = result;
+      }
+    }
+    addTextureIds(textureIds, id, size, offset = 0) {
+      textureIds.length = Math.max(textureIds.length, offset + size);
+      for (let i = 0; i < size; i++) {
+        textureIds[offset + i] = id;
+      }
+    }
+    addUvs(verts, uvs, texture, start, size, matrix = null) {
+      let index = 0;
+      const uvsStart = uvs.length;
+      const frame = texture.frame;
+      while (index < size) {
+        let x = verts[(start + index) * 2];
+        let y = verts[(start + index) * 2 + 1];
+        if (matrix) {
+          const nx = matrix.a * x + matrix.c * y + matrix.tx;
+          y = matrix.b * x + matrix.d * y + matrix.ty;
+          x = nx;
+        }
+        index++;
+        uvs.push(x / frame.width, y / frame.height);
+      }
+      const baseTexture = texture.baseTexture;
+      if (frame.width < baseTexture.width || frame.height < baseTexture.height) {
+        this.adjustUvs(uvs, texture, uvsStart, size);
+      }
+    }
+    adjustUvs(uvs, texture, start, size) {
+      const baseTexture = texture.baseTexture;
+      const eps = 1e-6;
+      const finish = start + size * 2;
+      const frame = texture.frame;
+      const scaleX = frame.width / baseTexture.width;
+      const scaleY = frame.height / baseTexture.height;
+      let offsetX = frame.x / frame.width;
+      let offsetY = frame.y / frame.height;
+      let minX = Math.floor(uvs[start] + eps);
+      let minY = Math.floor(uvs[start + 1] + eps);
+      for (let i = start + 2; i < finish; i += 2) {
+        minX = Math.min(minX, Math.floor(uvs[i] + eps));
+        minY = Math.min(minY, Math.floor(uvs[i + 1] + eps));
+      }
+      offsetX -= minX;
+      offsetY -= minY;
+      for (let i = start; i < finish; i += 2) {
+        uvs[i] = (uvs[i] + offsetX) * scaleX;
+        uvs[i + 1] = (uvs[i + 1] + offsetY) * scaleY;
+      }
+    }
+  };
+  let GraphicsGeometry = _GraphicsGeometry;
+  GraphicsGeometry.BATCHABLE_SIZE = 100;
+
+  class FillStyle {
+    constructor() {
+      this.color = 16777215;
+      this.alpha = 1;
+      this.texture = Texture.WHITE;
+      this.matrix = null;
+      this.visible = false;
+      this.reset();
+    }
+    clone() {
+      const obj = new FillStyle();
+      obj.color = this.color;
+      obj.alpha = this.alpha;
+      obj.texture = this.texture;
+      obj.matrix = this.matrix;
+      obj.visible = this.visible;
+      return obj;
+    }
+    reset() {
+      this.color = 16777215;
+      this.alpha = 1;
+      this.texture = Texture.WHITE;
+      this.matrix = null;
+      this.visible = false;
+    }
+    destroy() {
+      this.texture = null;
+      this.matrix = null;
+    }
+  }
+
+  class LineStyle extends FillStyle {
+    constructor() {
+      super(...arguments);
+      this.width = 0;
+      this.alignment = 0.5;
+      this.native = false;
+      this.cap = LINE_CAP.BUTT;
+      this.join = LINE_JOIN.MITER;
+      this.miterLimit = 10;
+    }
+    clone() {
+      const obj = new LineStyle();
+      obj.color = this.color;
+      obj.alpha = this.alpha;
+      obj.texture = this.texture;
+      obj.matrix = this.matrix;
+      obj.visible = this.visible;
+      obj.width = this.width;
+      obj.alignment = this.alignment;
+      obj.native = this.native;
+      obj.cap = this.cap;
+      obj.join = this.join;
+      obj.miterLimit = this.miterLimit;
+      return obj;
+    }
+    reset() {
+      super.reset();
+      this.color = 0;
+      this.alignment = 0.5;
+      this.width = 0;
+      this.native = false;
+    }
+  }
+
+  const DEFAULT_SHADERS = {};
+  const _Graphics = class extends Container {
+    constructor(geometry = null) {
+      super();
+      this.shader = null;
+      this.pluginName = "batch";
+      this.currentPath = null;
+      this.batches = [];
+      this.batchTint = -1;
+      this.batchDirty = -1;
+      this.vertexData = null;
+      this._fillStyle = new FillStyle();
+      this._lineStyle = new LineStyle();
+      this._matrix = null;
+      this._holeMode = false;
+      this.state = State.for2d();
+      this._geometry = geometry || new GraphicsGeometry();
+      this._geometry.refCount++;
+      this._transformID = -1;
+      this._tintColor = new Color(16777215);
+      this.blendMode = BLEND_MODES.NORMAL;
+    }
+    get geometry() {
+      return this._geometry;
+    }
+    clone() {
+      this.finishPoly();
+      return new _Graphics(this._geometry);
+    }
+    set blendMode(value) {
+      this.state.blendMode = value;
+    }
+    get blendMode() {
+      return this.state.blendMode;
+    }
+    get tint() {
+      return this._tintColor.value;
+    }
+    set tint(value) {
+      this._tintColor.setValue(value);
+    }
+    get fill() {
+      return this._fillStyle;
+    }
+    get line() {
+      return this._lineStyle;
+    }
+    lineStyle(options = null, color = 0, alpha, alignment = 0.5, native = false) {
+      if (typeof options === "number") {
+        options = { width: options, color, alpha, alignment, native };
+      }
+      return this.lineTextureStyle(options);
+    }
+    lineTextureStyle(options) {
+      const defaultLineStyleOptions = {
+        width: 0,
+        texture: Texture.WHITE,
+        color: options?.texture ? 16777215 : 0,
+        matrix: null,
+        alignment: 0.5,
+        native: false,
+        cap: LINE_CAP.BUTT,
+        join: LINE_JOIN.MITER,
+        miterLimit: 10
+      };
+      options = Object.assign(defaultLineStyleOptions, options);
+      this.normalizeColor(options);
+      if (this.currentPath) {
+        this.startPoly();
+      }
+      const visible = options.width > 0 && options.alpha > 0;
+      if (!visible) {
+        this._lineStyle.reset();
+      } else {
+        if (options.matrix) {
+          options.matrix = options.matrix.clone();
+          options.matrix.invert();
+        }
+        Object.assign(this._lineStyle, { visible }, options);
+      }
+      return this;
+    }
+    startPoly() {
+      if (this.currentPath) {
+        const points = this.currentPath.points;
+        const len = this.currentPath.points.length;
+        if (len > 2) {
+          this.drawShape(this.currentPath);
+          this.currentPath = new Polygon();
+          this.currentPath.closeStroke = false;
+          this.currentPath.points.push(points[len - 2], points[len - 1]);
+        }
+      } else {
+        this.currentPath = new Polygon();
+        this.currentPath.closeStroke = false;
+      }
+    }
+    finishPoly() {
+      if (this.currentPath) {
+        if (this.currentPath.points.length > 2) {
+          this.drawShape(this.currentPath);
+          this.currentPath = null;
+        } else {
+          this.currentPath.points.length = 0;
+        }
+      }
+    }
+    moveTo(x, y) {
+      this.startPoly();
+      this.currentPath.points[0] = x;
+      this.currentPath.points[1] = y;
+      return this;
+    }
+    lineTo(x, y) {
+      if (!this.currentPath) {
+        this.moveTo(0, 0);
+      }
+      const points = this.currentPath.points;
+      const fromX = points[points.length - 2];
+      const fromY = points[points.length - 1];
+      if (fromX !== x || fromY !== y) {
+        points.push(x, y);
+      }
+      return this;
+    }
+    _initCurve(x = 0, y = 0) {
+      if (this.currentPath) {
+        if (this.currentPath.points.length === 0) {
+          this.currentPath.points = [x, y];
+        }
+      } else {
+        this.moveTo(x, y);
+      }
+    }
+    quadraticCurveTo(cpX, cpY, toX, toY) {
+      this._initCurve();
+      const points = this.currentPath.points;
+      if (points.length === 0) {
+        this.moveTo(0, 0);
+      }
+      QuadraticUtils.curveTo(cpX, cpY, toX, toY, points);
+      return this;
+    }
+    bezierCurveTo(cpX, cpY, cpX2, cpY2, toX, toY) {
+      this._initCurve();
+      BezierUtils.curveTo(cpX, cpY, cpX2, cpY2, toX, toY, this.currentPath.points);
+      return this;
+    }
+    arcTo(x1, y1, x2, y2, radius) {
+      this._initCurve(x1, y1);
+      const points = this.currentPath.points;
+      const result = ArcUtils.curveTo(x1, y1, x2, y2, radius, points);
+      if (result) {
+        const { cx, cy, radius: radius2, startAngle, endAngle, anticlockwise } = result;
+        this.arc(cx, cy, radius2, startAngle, endAngle, anticlockwise);
+      }
+      return this;
+    }
+    arc(cx, cy, radius, startAngle, endAngle, anticlockwise = false) {
+      if (startAngle === endAngle) {
+        return this;
+      }
+      if (!anticlockwise && endAngle <= startAngle) {
+        endAngle += PI_2;
+      } else if (anticlockwise && startAngle <= endAngle) {
+        startAngle += PI_2;
+      }
+      const sweep = endAngle - startAngle;
+      if (sweep === 0) {
+        return this;
+      }
+      const startX = cx + Math.cos(startAngle) * radius;
+      const startY = cy + Math.sin(startAngle) * radius;
+      const eps = this._geometry.closePointEps;
+      let points = this.currentPath ? this.currentPath.points : null;
+      if (points) {
+        const xDiff = Math.abs(points[points.length - 2] - startX);
+        const yDiff = Math.abs(points[points.length - 1] - startY);
+        if (xDiff < eps && yDiff < eps) {
+        } else {
+          points.push(startX, startY);
+        }
+      } else {
+        this.moveTo(startX, startY);
+        points = this.currentPath.points;
+      }
+      ArcUtils.arc(startX, startY, cx, cy, radius, startAngle, endAngle, anticlockwise, points);
+      return this;
+    }
+    beginFill(color = 0, alpha) {
+      return this.beginTextureFill({ texture: Texture.WHITE, color, alpha });
+    }
+    normalizeColor(options) {
+      const temp = Color.shared.setValue(options.color ?? 0);
+      options.color = temp.toNumber();
+      options.alpha ?? (options.alpha = temp.alpha);
+    }
+    beginTextureFill(options) {
+      const defaultOptions = {
+        texture: Texture.WHITE,
+        color: 16777215,
+        matrix: null
+      };
+      options = Object.assign(defaultOptions, options);
+      this.normalizeColor(options);
+      if (this.currentPath) {
+        this.startPoly();
+      }
+      const visible = options.alpha > 0;
+      if (!visible) {
+        this._fillStyle.reset();
+      } else {
+        if (options.matrix) {
+          options.matrix = options.matrix.clone();
+          options.matrix.invert();
+        }
+        Object.assign(this._fillStyle, { visible }, options);
+      }
+      return this;
+    }
+    endFill() {
+      this.finishPoly();
+      this._fillStyle.reset();
+      return this;
+    }
+    drawRect(x, y, width, height) {
+      return this.drawShape(new Rectangle(x, y, width, height));
+    }
+    drawRoundedRect(x, y, width, height, radius) {
+      return this.drawShape(new RoundedRectangle(x, y, width, height, radius));
+    }
+    drawCircle(x, y, radius) {
+      return this.drawShape(new Circle(x, y, radius));
+    }
+    drawEllipse(x, y, width, height) {
+      return this.drawShape(new Ellipse(x, y, width, height));
+    }
+    drawPolygon(...path) {
+      let points;
+      let closeStroke = true;
+      const poly = path[0];
+      if (poly.points) {
+        closeStroke = poly.closeStroke;
+        points = poly.points;
+      } else if (Array.isArray(path[0])) {
+        points = path[0];
+      } else {
+        points = path;
+      }
+      const shape = new Polygon(points);
+      shape.closeStroke = closeStroke;
+      this.drawShape(shape);
+      return this;
+    }
+    drawShape(shape) {
+      if (!this._holeMode) {
+        this._geometry.drawShape(shape, this._fillStyle.clone(), this._lineStyle.clone(), this._matrix);
+      } else {
+        this._geometry.drawHole(shape, this._matrix);
+      }
+      return this;
+    }
+    clear() {
+      this._geometry.clear();
+      this._lineStyle.reset();
+      this._fillStyle.reset();
+      this._boundsID++;
+      this._matrix = null;
+      this._holeMode = false;
+      this.currentPath = null;
+      return this;
+    }
+    isFastRect() {
+      const data = this._geometry.graphicsData;
+      return data.length === 1 && data[0].shape.type === SHAPES.RECT && !data[0].matrix && !data[0].holes.length && !(data[0].lineStyle.visible && data[0].lineStyle.width);
+    }
+    _render(renderer) {
+      this.finishPoly();
+      const geometry = this._geometry;
+      geometry.updateBatches();
+      if (geometry.batchable) {
+        if (this.batchDirty !== geometry.batchDirty) {
+          this._populateBatches();
+        }
+        this._renderBatched(renderer);
+      } else {
+        renderer.batch.flush();
+        this._renderDirect(renderer);
+      }
+    }
+    _populateBatches() {
+      const geometry = this._geometry;
+      const blendMode = this.blendMode;
+      const len = geometry.batches.length;
+      this.batchTint = -1;
+      this._transformID = -1;
+      this.batchDirty = geometry.batchDirty;
+      this.batches.length = len;
+      this.vertexData = new Float32Array(geometry.points);
+      for (let i = 0; i < len; i++) {
+        const gI = geometry.batches[i];
+        const color = gI.style.color;
+        const vertexData = new Float32Array(this.vertexData.buffer, gI.attribStart * 4 * 2, gI.attribSize * 2);
+        const uvs = new Float32Array(geometry.uvsFloat32.buffer, gI.attribStart * 4 * 2, gI.attribSize * 2);
+        const indices = new Uint16Array(geometry.indicesUint16.buffer, gI.start * 2, gI.size);
+        const batch = {
+          vertexData,
+          blendMode,
+          indices,
+          uvs,
+          _batchRGB: Color.shared.setValue(color).toRgbArray(),
+          _tintRGB: color,
+          _texture: gI.style.texture,
+          alpha: gI.style.alpha,
+          worldAlpha: 1
+        };
+        this.batches[i] = batch;
+      }
+    }
+    _renderBatched(renderer) {
+      if (!this.batches.length) {
+        return;
+      }
+      renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
+      this.calculateVertices();
+      this.calculateTints();
+      for (let i = 0, l = this.batches.length; i < l; i++) {
+        const batch = this.batches[i];
+        batch.worldAlpha = this.worldAlpha * batch.alpha;
+        renderer.plugins[this.pluginName].render(batch);
+      }
+    }
+    _renderDirect(renderer) {
+      const shader = this._resolveDirectShader(renderer);
+      const geometry = this._geometry;
+      const worldAlpha = this.worldAlpha;
+      const uniforms = shader.uniforms;
+      const drawCalls = geometry.drawCalls;
+      uniforms.translationMatrix = this.transform.worldTransform;
+      Color.shared.setValue(this._tintColor).premultiply(worldAlpha).toArray(uniforms.tint);
+      renderer.shader.bind(shader);
+      renderer.geometry.bind(geometry, shader);
+      renderer.state.set(this.state);
+      for (let i = 0, l = drawCalls.length; i < l; i++) {
+        this._renderDrawCallDirect(renderer, geometry.drawCalls[i]);
+      }
+    }
+    _renderDrawCallDirect(renderer, drawCall) {
+      const { texArray, type, size, start } = drawCall;
+      const groupTextureCount = texArray.count;
+      for (let j = 0; j < groupTextureCount; j++) {
+        renderer.texture.bind(texArray.elements[j], j);
+      }
+      renderer.geometry.draw(type, size, start);
+    }
+    _resolveDirectShader(renderer) {
+      let shader = this.shader;
+      const pluginName = this.pluginName;
+      if (!shader) {
+        if (!DEFAULT_SHADERS[pluginName]) {
+          const { maxTextures } = renderer.plugins[pluginName];
+          const sampleValues = new Int32Array(maxTextures);
+          for (let i = 0; i < maxTextures; i++) {
+            sampleValues[i] = i;
+          }
+          const uniforms = {
+            tint: new Float32Array([1, 1, 1, 1]),
+            translationMatrix: new Matrix(),
+            default: UniformGroup.from({ uSamplers: sampleValues }, true)
+          };
+          const program = renderer.plugins[pluginName]._shader.program;
+          DEFAULT_SHADERS[pluginName] = new Shader(program, uniforms);
+        }
+        shader = DEFAULT_SHADERS[pluginName];
+      }
+      return shader;
+    }
+    _calculateBounds() {
+      this.finishPoly();
+      const geometry = this._geometry;
+      if (!geometry.graphicsData.length) {
+        return;
+      }
+      const { minX, minY, maxX, maxY } = geometry.bounds;
+      this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);
+    }
+    containsPoint(point) {
+      this.worldTransform.applyInverse(point, _Graphics._TEMP_POINT);
+      return this._geometry.containsPoint(_Graphics._TEMP_POINT);
+    }
+    calculateTints() {
+      if (this.batchTint !== this.tint) {
+        this.batchTint = this._tintColor.toNumber();
+        for (let i = 0; i < this.batches.length; i++) {
+          const batch = this.batches[i];
+          batch._tintRGB = Color.shared.setValue(this._tintColor).multiply(batch._batchRGB).toLittleEndianNumber();
+        }
+      }
+    }
+    calculateVertices() {
+      const wtID = this.transform._worldID;
+      if (this._transformID === wtID) {
+        return;
+      }
+      this._transformID = wtID;
+      const wt = this.transform.worldTransform;
+      const a = wt.a;
+      const b = wt.b;
+      const c = wt.c;
+      const d = wt.d;
+      const tx = wt.tx;
+      const ty = wt.ty;
+      const data = this._geometry.points;
+      const vertexData = this.vertexData;
+      let count = 0;
+      for (let i = 0; i < data.length; i += 2) {
+        const x = data[i];
+        const y = data[i + 1];
+        vertexData[count++] = a * x + c * y + tx;
+        vertexData[count++] = d * y + b * x + ty;
+      }
+    }
+    closePath() {
+      const currentPath = this.currentPath;
+      if (currentPath) {
+        currentPath.closeStroke = true;
+        this.finishPoly();
+      }
+      return this;
+    }
+    setMatrix(matrix) {
+      this._matrix = matrix;
+      return this;
+    }
+    beginHole() {
+      this.finishPoly();
+      this._holeMode = true;
+      return this;
+    }
+    endHole() {
+      this.finishPoly();
+      this._holeMode = false;
+      return this;
+    }
+    destroy(options) {
+      this._geometry.refCount--;
+      if (this._geometry.refCount === 0) {
+        this._geometry.dispose();
+      }
+      this._matrix = null;
+      this.currentPath = null;
+      this._lineStyle.destroy();
+      this._lineStyle = null;
+      this._fillStyle.destroy();
+      this._fillStyle = null;
+      this._geometry = null;
+      this.shader = null;
+      this.vertexData = null;
+      this.batches.length = 0;
+      this.batches = null;
+      super.destroy(options);
+    }
+  };
+  let Graphics = _Graphics;
+  Graphics.curves = curves;
+  Graphics._TEMP_POINT = new Point();
+
+  const graphicsUtils = {
+    buildPoly,
+    buildCircle,
+    buildRectangle,
+    buildRoundedRectangle,
+    buildLine,
+    ArcUtils,
+    BezierUtils,
+    QuadraticUtils,
+    BatchPart,
+    FILL_COMMANDS,
+    BATCH_POOL,
+    DRAW_CALL_POOL
+  };
+
+  class MeshBatchUvs {
+    constructor(uvBuffer, uvMatrix) {
+      this.uvBuffer = uvBuffer;
+      this.uvMatrix = uvMatrix;
+      this.data = null;
+      this._bufferUpdateId = -1;
+      this._textureUpdateId = -1;
+      this._updateID = 0;
+    }
+    update(forceUpdate) {
+      if (!forceUpdate && this._bufferUpdateId === this.uvBuffer._updateID && this._textureUpdateId === this.uvMatrix._updateID) {
+        return;
+      }
+      this._bufferUpdateId = this.uvBuffer._updateID;
+      this._textureUpdateId = this.uvMatrix._updateID;
+      const data = this.uvBuffer.data;
+      if (!this.data || this.data.length !== data.length) {
+        this.data = new Float32Array(data.length);
+      }
+      this.uvMatrix.multiplyUvs(data, this.data);
+      this._updateID++;
+    }
+  }
+
+  const tempPoint = new Point();
+  const tempPolygon = new Polygon();
+  const _Mesh = class extends Container {
+    constructor(geometry, shader, state, drawMode = DRAW_MODES.TRIANGLES) {
+      super();
+      this.geometry = geometry;
+      this.shader = shader;
+      this.state = state || State.for2d();
+      this.drawMode = drawMode;
+      this.start = 0;
+      this.size = 0;
+      this.uvs = null;
+      this.indices = null;
+      this.vertexData = new Float32Array(1);
+      this.vertexDirty = -1;
+      this._transformID = -1;
+      this._roundPixels = settings.ROUND_PIXELS;
+      this.batchUvs = null;
+    }
+    get geometry() {
+      return this._geometry;
+    }
+    set geometry(value) {
+      if (this._geometry === value) {
+        return;
+      }
+      if (this._geometry) {
+        this._geometry.refCount--;
+        if (this._geometry.refCount === 0) {
+          this._geometry.dispose();
+        }
+      }
+      this._geometry = value;
+      if (this._geometry) {
+        this._geometry.refCount++;
+      }
+      this.vertexDirty = -1;
+    }
+    get uvBuffer() {
+      return this.geometry.buffers[1];
+    }
+    get verticesBuffer() {
+      return this.geometry.buffers[0];
+    }
+    set material(value) {
+      this.shader = value;
+    }
+    get material() {
+      return this.shader;
+    }
+    set blendMode(value) {
+      this.state.blendMode = value;
+    }
+    get blendMode() {
+      return this.state.blendMode;
+    }
+    set roundPixels(value) {
+      if (this._roundPixels !== value) {
+        this._transformID = -1;
+      }
+      this._roundPixels = value;
+    }
+    get roundPixels() {
+      return this._roundPixels;
+    }
+    get tint() {
+      return "tint" in this.shader ? this.shader.tint : null;
+    }
+    set tint(value) {
+      this.shader.tint = value;
+    }
+    get tintValue() {
+      return this.shader.tintValue;
+    }
+    get texture() {
+      return "texture" in this.shader ? this.shader.texture : null;
+    }
+    set texture(value) {
+      this.shader.texture = value;
+    }
+    _render(renderer) {
+      const vertices = this.geometry.buffers[0].data;
+      const shader = this.shader;
+      if (shader.batchable && this.drawMode === DRAW_MODES.TRIANGLES && vertices.length < _Mesh.BATCHABLE_SIZE * 2) {
+        this._renderToBatch(renderer);
+      } else {
+        this._renderDefault(renderer);
+      }
+    }
+    _renderDefault(renderer) {
+      const shader = this.shader;
+      shader.alpha = this.worldAlpha;
+      if (shader.update) {
+        shader.update();
+      }
+      renderer.batch.flush();
+      shader.uniforms.translationMatrix = this.transform.worldTransform.toArray(true);
+      renderer.shader.bind(shader);
+      renderer.state.set(this.state);
+      renderer.geometry.bind(this.geometry, shader);
+      renderer.geometry.draw(this.drawMode, this.size, this.start, this.geometry.instanceCount);
+    }
+    _renderToBatch(renderer) {
+      const geometry = this.geometry;
+      const shader = this.shader;
+      if (shader.uvMatrix) {
+        shader.uvMatrix.update();
+        this.calculateUvs();
+      }
+      this.calculateVertices();
+      this.indices = geometry.indexBuffer.data;
+      this._tintRGB = shader._tintRGB;
+      this._texture = shader.texture;
+      const pluginName = this.material.pluginName;
+      renderer.batch.setObjectRenderer(renderer.plugins[pluginName]);
+      renderer.plugins[pluginName].render(this);
+    }
+    calculateVertices() {
+      const geometry = this.geometry;
+      const verticesBuffer = geometry.buffers[0];
+      const vertices = verticesBuffer.data;
+      const vertexDirtyId = verticesBuffer._updateID;
+      if (vertexDirtyId === this.vertexDirty && this._transformID === this.transform._worldID) {
+        return;
+      }
+      this._transformID = this.transform._worldID;
+      if (this.vertexData.length !== vertices.length) {
+        this.vertexData = new Float32Array(vertices.length);
+      }
+      const wt = this.transform.worldTransform;
+      const a = wt.a;
+      const b = wt.b;
+      const c = wt.c;
+      const d = wt.d;
+      const tx = wt.tx;
+      const ty = wt.ty;
+      const vertexData = this.vertexData;
+      for (let i = 0; i < vertexData.length / 2; i++) {
+        const x = vertices[i * 2];
+        const y = vertices[i * 2 + 1];
+        vertexData[i * 2] = a * x + c * y + tx;
+        vertexData[i * 2 + 1] = b * x + d * y + ty;
+      }
+      if (this._roundPixels) {
+        const resolution = settings.RESOLUTION;
+        for (let i = 0; i < vertexData.length; ++i) {
+          vertexData[i] = Math.round(vertexData[i] * resolution) / resolution;
+        }
+      }
+      this.vertexDirty = vertexDirtyId;
+    }
+    calculateUvs() {
+      const geomUvs = this.geometry.buffers[1];
+      const shader = this.shader;
+      if (!shader.uvMatrix.isSimple) {
+        if (!this.batchUvs) {
+          this.batchUvs = new MeshBatchUvs(geomUvs, shader.uvMatrix);
+        }
+        this.batchUvs.update();
+        this.uvs = this.batchUvs.data;
+      } else {
+        this.uvs = geomUvs.data;
+      }
+    }
+    _calculateBounds() {
+      this.calculateVertices();
+      this._bounds.addVertexData(this.vertexData, 0, this.vertexData.length);
+    }
+    containsPoint(point) {
+      if (!this.getBounds().contains(point.x, point.y)) {
+        return false;
+      }
+      this.worldTransform.applyInverse(point, tempPoint);
+      const vertices = this.geometry.getBuffer("aVertexPosition").data;
+      const points = tempPolygon.points;
+      const indices = this.geometry.getIndex().data;
+      const len = indices.length;
+      const step = this.drawMode === 4 ? 3 : 1;
+      for (let i = 0; i + 2 < len; i += step) {
+        const ind0 = indices[i] * 2;
+        const ind1 = indices[i + 1] * 2;
+        const ind2 = indices[i + 2] * 2;
+        points[0] = vertices[ind0];
+        points[1] = vertices[ind0 + 1];
+        points[2] = vertices[ind1];
+        points[3] = vertices[ind1 + 1];
+        points[4] = vertices[ind2];
+        points[5] = vertices[ind2 + 1];
+        if (tempPolygon.contains(tempPoint.x, tempPoint.y)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    destroy(options) {
+      super.destroy(options);
+      if (this._cachedTexture) {
+        this._cachedTexture.destroy();
+        this._cachedTexture = null;
+      }
+      this.geometry = null;
+      this.shader = null;
+      this.state = null;
+      this.uvs = null;
+      this.indices = null;
+      this.vertexData = null;
+    }
+  };
+  let Mesh = _Mesh;
+  Mesh.BATCHABLE_SIZE = 100;
+
+  class MeshGeometry extends Geometry {
+    constructor(vertices, uvs, index) {
+      super();
+      const verticesBuffer = new Buffer(vertices);
+      const uvsBuffer = new Buffer(uvs, true);
+      const indexBuffer = new Buffer(index, true, true);
+      this.addAttribute("aVertexPosition", verticesBuffer, 2, false, TYPES.FLOAT).addAttribute("aTextureCoord", uvsBuffer, 2, false, TYPES.FLOAT).addIndex(indexBuffer);
+      this._updateId = -1;
+    }
+    get vertexDirtyId() {
+      return this.buffers[0]._updateID;
+    }
+  }
+
+  var fragment = "varying vec2 vTextureCoord;\nuniform vec4 uColor;\n\nuniform sampler2D uSampler;\n\nvoid main(void)\n{\n    gl_FragColor = texture2D(uSampler, vTextureCoord) * uColor;\n}\n";
+
+  var vertex = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTextureMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTextureMatrix * vec3(aTextureCoord, 1.0)).xy;\n}\n";
+
+  class MeshMaterial extends Shader {
+    constructor(uSampler, options) {
+      const uniforms = {
+        uSampler,
+        alpha: 1,
+        uTextureMatrix: Matrix.IDENTITY,
+        uColor: new Float32Array([1, 1, 1, 1])
+      };
+      options = Object.assign({
+        tint: 16777215,
+        alpha: 1,
+        pluginName: "batch"
+      }, options);
+      if (options.uniforms) {
+        Object.assign(uniforms, options.uniforms);
+      }
+      super(options.program || Program.from(vertex, fragment), uniforms);
+      this._colorDirty = false;
+      this.uvMatrix = new TextureMatrix(uSampler);
+      this.batchable = options.program === void 0;
+      this.pluginName = options.pluginName;
+      this._tintColor = new Color(options.tint);
+      this._tintRGB = this._tintColor.toLittleEndianNumber();
+      this._colorDirty = true;
+      this.alpha = options.alpha;
+    }
+    get texture() {
+      return this.uniforms.uSampler;
+    }
+    set texture(value) {
+      if (this.uniforms.uSampler !== value) {
+        if (!this.uniforms.uSampler.baseTexture.alphaMode !== !value.baseTexture.alphaMode) {
+          this._colorDirty = true;
+        }
+        this.uniforms.uSampler = value;
+        this.uvMatrix.texture = value;
+      }
+    }
+    set alpha(value) {
+      if (value === this._alpha)
+        return;
+      this._alpha = value;
+      this._colorDirty = true;
+    }
+    get alpha() {
+      return this._alpha;
+    }
+    set tint(value) {
+      if (value === this.tint)
+        return;
+      this._tintColor.setValue(value);
+      this._tintRGB = this._tintColor.toLittleEndianNumber();
+      this._colorDirty = true;
+    }
+    get tint() {
+      return this._tintColor.value;
+    }
+    get tintValue() {
+      return this._tintColor.toNumber();
+    }
+    update() {
+      if (this._colorDirty) {
+        this._colorDirty = false;
+        const baseTexture = this.texture.baseTexture;
+        const applyToChannels = baseTexture.alphaMode;
+        Color.shared.setValue(this._tintColor).premultiply(this._alpha, applyToChannels).toArray(this.uniforms.uColor);
+      }
+      if (this.uvMatrix.update()) {
+        this.uniforms.uTextureMatrix = this.uvMatrix.mapCoord;
+      }
+    }
+  }
+
+  class PlaneGeometry extends MeshGeometry {
+    constructor(width = 100, height = 100, segWidth = 10, segHeight = 10) {
+      super();
+      this.segWidth = segWidth;
+      this.segHeight = segHeight;
+      this.width = width;
+      this.height = height;
+      this.build();
+    }
+    build() {
+      const total = this.segWidth * this.segHeight;
+      const verts = [];
+      const uvs = [];
+      const indices = [];
+      const segmentsX = this.segWidth - 1;
+      const segmentsY = this.segHeight - 1;
+      const sizeX = this.width / segmentsX;
+      const sizeY = this.height / segmentsY;
+      for (let i = 0; i < total; i++) {
+        const x = i % this.segWidth;
+        const y = i / this.segWidth | 0;
+        verts.push(x * sizeX, y * sizeY);
+        uvs.push(x / segmentsX, y / segmentsY);
+      }
+      const totalSub = segmentsX * segmentsY;
+      for (let i = 0; i < totalSub; i++) {
+        const xpos = i % segmentsX;
+        const ypos = i / segmentsX | 0;
+        const value = ypos * this.segWidth + xpos;
+        const value2 = ypos * this.segWidth + xpos + 1;
+        const value3 = (ypos + 1) * this.segWidth + xpos;
+        const value4 = (ypos + 1) * this.segWidth + xpos + 1;
+        indices.push(value, value2, value3, value2, value4, value3);
+      }
+      this.buffers[0].data = new Float32Array(verts);
+      this.buffers[1].data = new Float32Array(uvs);
+      this.indexBuffer.data = new Uint16Array(indices);
+      this.buffers[0].update();
+      this.buffers[1].update();
+      this.indexBuffer.update();
+    }
+  }
+
+  class RopeGeometry extends MeshGeometry {
+    constructor(width = 200, points, textureScale = 0) {
+      super(new Float32Array(points.length * 4), new Float32Array(points.length * 4), new Uint16Array((points.length - 1) * 6));
+      this.points = points;
+      this._width = width;
+      this.textureScale = textureScale;
+      this.build();
+    }
+    get width() {
+      return this._width;
+    }
+    build() {
+      const points = this.points;
+      if (!points)
+        return;
+      const vertexBuffer = this.getBuffer("aVertexPosition");
+      const uvBuffer = this.getBuffer("aTextureCoord");
+      const indexBuffer = this.getIndex();
+      if (points.length < 1) {
+        return;
+      }
+      if (vertexBuffer.data.length / 4 !== points.length) {
+        vertexBuffer.data = new Float32Array(points.length * 4);
+        uvBuffer.data = new Float32Array(points.length * 4);
+        indexBuffer.data = new Uint16Array((points.length - 1) * 6);
+      }
+      const uvs = uvBuffer.data;
+      const indices = indexBuffer.data;
+      uvs[0] = 0;
+      uvs[1] = 0;
+      uvs[2] = 0;
+      uvs[3] = 1;
+      let amount = 0;
+      let prev = points[0];
+      const textureWidth = this._width * this.textureScale;
+      const total = points.length;
+      for (let i = 0; i < total; i++) {
+        const index = i * 4;
+        if (this.textureScale > 0) {
+          const dx = prev.x - points[i].x;
+          const dy = prev.y - points[i].y;
+          const distance = Math.sqrt(dx * dx + dy * dy);
+          prev = points[i];
+          amount += distance / textureWidth;
+        } else {
+          amount = i / (total - 1);
+        }
+        uvs[index] = amount;
+        uvs[index + 1] = 0;
+        uvs[index + 2] = amount;
+        uvs[index + 3] = 1;
+      }
+      let indexCount = 0;
+      for (let i = 0; i < total - 1; i++) {
+        const index = i * 2;
+        indices[indexCount++] = index;
+        indices[indexCount++] = index + 1;
+        indices[indexCount++] = index + 2;
+        indices[indexCount++] = index + 2;
+        indices[indexCount++] = index + 1;
+        indices[indexCount++] = index + 3;
+      }
+      uvBuffer.update();
+      indexBuffer.update();
+      this.updateVertices();
+    }
+    updateVertices() {
+      const points = this.points;
+      if (points.length < 1) {
+        return;
+      }
+      let lastPoint = points[0];
+      let nextPoint;
+      let perpX = 0;
+      let perpY = 0;
+      const vertices = this.buffers[0].data;
+      const total = points.length;
+      const halfWidth = this.textureScale > 0 ? this.textureScale * this._width / 2 : this._width / 2;
+      for (let i = 0; i < total; i++) {
+        const point = points[i];
+        const index = i * 4;
+        if (i < points.length - 1) {
+          nextPoint = points[i + 1];
+        } else {
+          nextPoint = point;
+        }
+        perpY = -(nextPoint.x - lastPoint.x);
+        perpX = nextPoint.y - lastPoint.y;
+        let ratio = (1 - i / (total - 1)) * 10;
+        if (ratio > 1) {
+          ratio = 1;
+        }
+        const perpLength = Math.sqrt(perpX * perpX + perpY * perpY);
+        if (perpLength < 1e-6) {
+          perpX = 0;
+          perpY = 0;
+        } else {
+          perpX /= perpLength;
+          perpY /= perpLength;
+          perpX *= halfWidth;
+          perpY *= halfWidth;
+        }
+        vertices[index] = point.x + perpX;
+        vertices[index + 1] = point.y + perpY;
+        vertices[index + 2] = point.x - perpX;
+        vertices[index + 3] = point.y - perpY;
+        lastPoint = point;
+      }
+      this.buffers[0].update();
+    }
+    update() {
+      if (this.textureScale > 0) {
+        this.build();
+      } else {
+        this.updateVertices();
+      }
+    }
+  }
+
+  class SimplePlane extends Mesh {
+    constructor(texture, verticesX, verticesY) {
+      const planeGeometry = new PlaneGeometry(texture.width, texture.height, verticesX, verticesY);
+      const meshMaterial = new MeshMaterial(Texture.WHITE);
+      super(planeGeometry, meshMaterial);
+      this.texture = texture;
+      this.autoResize = true;
+    }
+    textureUpdated() {
+      this._textureID = this.shader.texture._updateID;
+      const geometry = this.geometry;
+      const { width, height } = this.shader.texture;
+      if (this.autoResize && (geometry.width !== width || geometry.height !== height)) {
+        geometry.width = this.shader.texture.width;
+        geometry.height = this.shader.texture.height;
+        geometry.build();
+      }
+    }
+    set texture(value) {
+      if (this.shader.texture === value) {
+        return;
+      }
+      this.shader.texture = value;
+      this._textureID = -1;
+      if (value.baseTexture.valid) {
+        this.textureUpdated();
+      } else {
+        value.once("update", this.textureUpdated, this);
+      }
+    }
+    get texture() {
+      return this.shader.texture;
+    }
+    _render(renderer) {
+      if (this._textureID !== this.shader.texture._updateID) {
+        this.textureUpdated();
+      }
+      super._render(renderer);
+    }
+    destroy(options) {
+      this.shader.texture.off("update", this.textureUpdated, this);
+      super.destroy(options);
+    }
+  }
+
+  const DEFAULT_BORDER_SIZE = 10;
+  class NineSlicePlane extends SimplePlane {
+    constructor(texture, leftWidth, topHeight, rightWidth, bottomHeight) {
+      super(Texture.WHITE, 4, 4);
+      this._origWidth = texture.orig.width;
+      this._origHeight = texture.orig.height;
+      this._width = this._origWidth;
+      this._height = this._origHeight;
+      this._leftWidth = leftWidth ?? texture.defaultBorders?.left ?? DEFAULT_BORDER_SIZE;
+      this._rightWidth = rightWidth ?? texture.defaultBorders?.right ?? DEFAULT_BORDER_SIZE;
+      this._topHeight = topHeight ?? texture.defaultBorders?.top ?? DEFAULT_BORDER_SIZE;
+      this._bottomHeight = bottomHeight ?? texture.defaultBorders?.bottom ?? DEFAULT_BORDER_SIZE;
+      this.texture = texture;
+    }
+    textureUpdated() {
+      this._textureID = this.shader.texture._updateID;
+      this._refresh();
+    }
+    get vertices() {
+      return this.geometry.getBuffer("aVertexPosition").data;
+    }
+    set vertices(value) {
+      this.geometry.getBuffer("aVertexPosition").data = value;
+    }
+    updateHorizontalVertices() {
+      const vertices = this.vertices;
+      const scale = this._getMinScale();
+      vertices[9] = vertices[11] = vertices[13] = vertices[15] = this._topHeight * scale;
+      vertices[17] = vertices[19] = vertices[21] = vertices[23] = this._height - this._bottomHeight * scale;
+      vertices[25] = vertices[27] = vertices[29] = vertices[31] = this._height;
+    }
+    updateVerticalVertices() {
+      const vertices = this.vertices;
+      const scale = this._getMinScale();
+      vertices[2] = vertices[10] = vertices[18] = vertices[26] = this._leftWidth * scale;
+      vertices[4] = vertices[12] = vertices[20] = vertices[28] = this._width - this._rightWidth * scale;
+      vertices[6] = vertices[14] = vertices[22] = vertices[30] = this._width;
+    }
+    _getMinScale() {
+      const w = this._leftWidth + this._rightWidth;
+      const scaleW = this._width > w ? 1 : this._width / w;
+      const h = this._topHeight + this._bottomHeight;
+      const scaleH = this._height > h ? 1 : this._height / h;
+      const scale = Math.min(scaleW, scaleH);
+      return scale;
+    }
+    get width() {
+      return this._width;
+    }
+    set width(value) {
+      this._width = value;
+      this._refresh();
+    }
+    get height() {
+      return this._height;
+    }
+    set height(value) {
+      this._height = value;
+      this._refresh();
+    }
+    get leftWidth() {
+      return this._leftWidth;
+    }
+    set leftWidth(value) {
+      this._leftWidth = value;
+      this._refresh();
+    }
+    get rightWidth() {
+      return this._rightWidth;
+    }
+    set rightWidth(value) {
+      this._rightWidth = value;
+      this._refresh();
+    }
+    get topHeight() {
+      return this._topHeight;
+    }
+    set topHeight(value) {
+      this._topHeight = value;
+      this._refresh();
+    }
+    get bottomHeight() {
+      return this._bottomHeight;
+    }
+    set bottomHeight(value) {
+      this._bottomHeight = value;
+      this._refresh();
+    }
+    _refresh() {
+      const texture = this.texture;
+      const uvs = this.geometry.buffers[1].data;
+      this._origWidth = texture.orig.width;
+      this._origHeight = texture.orig.height;
+      const _uvw = 1 / this._origWidth;
+      const _uvh = 1 / this._origHeight;
+      uvs[0] = uvs[8] = uvs[16] = uvs[24] = 0;
+      uvs[1] = uvs[3] = uvs[5] = uvs[7] = 0;
+      uvs[6] = uvs[14] = uvs[22] = uvs[30] = 1;
+      uvs[25] = uvs[27] = uvs[29] = uvs[31] = 1;
+      uvs[2] = uvs[10] = uvs[18] = uvs[26] = _uvw * this._leftWidth;
+      uvs[4] = uvs[12] = uvs[20] = uvs[28] = 1 - _uvw * this._rightWidth;
+      uvs[9] = uvs[11] = uvs[13] = uvs[15] = _uvh * this._topHeight;
+      uvs[17] = uvs[19] = uvs[21] = uvs[23] = 1 - _uvh * this._bottomHeight;
+      this.updateHorizontalVertices();
+      this.updateVerticalVertices();
+      this.geometry.buffers[0].update();
+      this.geometry.buffers[1].update();
+    }
+  }
+
+  class SimpleMesh extends Mesh {
+    constructor(texture = Texture.EMPTY, vertices, uvs, indices, drawMode) {
+      const geometry = new MeshGeometry(vertices, uvs, indices);
+      geometry.getBuffer("aVertexPosition").static = false;
+      const meshMaterial = new MeshMaterial(texture);
+      super(geometry, meshMaterial, null, drawMode);
+      this.autoUpdate = true;
+    }
+    get vertices() {
+      return this.geometry.getBuffer("aVertexPosition").data;
+    }
+    set vertices(value) {
+      this.geometry.getBuffer("aVertexPosition").data = value;
+    }
+    _render(renderer) {
+      if (this.autoUpdate) {
+        this.geometry.getBuffer("aVertexPosition").update();
+      }
+      super._render(renderer);
+    }
+  }
+
+  class SimpleRope extends Mesh {
+    constructor(texture, points, textureScale = 0) {
+      const ropeGeometry = new RopeGeometry(texture.height, points, textureScale);
+      const meshMaterial = new MeshMaterial(texture);
+      if (textureScale > 0) {
+        texture.baseTexture.wrapMode = WRAP_MODES.REPEAT;
+      }
+      super(ropeGeometry, meshMaterial);
+      this.autoUpdate = true;
+    }
+    _render(renderer) {
+      const geometry = this.geometry;
+      if (this.autoUpdate || geometry._width !== this.shader.texture.height) {
+        geometry._width = this.shader.texture.height;
+        geometry.update();
+      }
+      super._render(renderer);
+    }
+  }
+
+  class CountLimiter {
+    constructor(maxItemsPerFrame) {
+      this.maxItemsPerFrame = maxItemsPerFrame;
+      this.itemsLeft = 0;
+    }
+    beginFrame() {
+      this.itemsLeft = this.maxItemsPerFrame;
+    }
+    allowedToUpload() {
+      return this.itemsLeft-- > 0;
+    }
+  }
+
+  function findMultipleBaseTextures(item, queue) {
+    let result = false;
+    if (item?._textures?.length) {
+      for (let i = 0; i < item._textures.length; i++) {
+        if (item._textures[i] instanceof Texture) {
+          const baseTexture = item._textures[i].baseTexture;
+          if (!queue.includes(baseTexture)) {
+            queue.push(baseTexture);
+            result = true;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  function findBaseTexture(item, queue) {
+    if (item.baseTexture instanceof BaseTexture) {
+      const texture = item.baseTexture;
+      if (!queue.includes(texture)) {
+        queue.push(texture);
+      }
+      return true;
+    }
+    return false;
+  }
+  function findTexture(item, queue) {
+    if (item._texture && item._texture instanceof Texture) {
+      const texture = item._texture.baseTexture;
+      if (!queue.includes(texture)) {
+        queue.push(texture);
+      }
+      return true;
+    }
+    return false;
+  }
+  function drawText(_helper, item) {
+    if (item instanceof Text) {
+      item.updateText(true);
+      return true;
+    }
+    return false;
+  }
+  function calculateTextStyle(_helper, item) {
+    if (item instanceof TextStyle) {
+      const font = item.toFontString();
+      TextMetrics.measureFont(font);
+      return true;
+    }
+    return false;
+  }
+  function findText(item, queue) {
+    if (item instanceof Text) {
+      if (!queue.includes(item.style)) {
+        queue.push(item.style);
+      }
+      if (!queue.includes(item)) {
+        queue.push(item);
+      }
+      const texture = item._texture.baseTexture;
+      if (!queue.includes(texture)) {
+        queue.push(texture);
+      }
+      return true;
+    }
+    return false;
+  }
+  function findTextStyle(item, queue) {
+    if (item instanceof TextStyle) {
+      if (!queue.includes(item)) {
+        queue.push(item);
+      }
+      return true;
+    }
+    return false;
+  }
+  const _BasePrepare = class {
+    constructor(renderer) {
+      this.limiter = new CountLimiter(_BasePrepare.uploadsPerFrame);
+      this.renderer = renderer;
+      this.uploadHookHelper = null;
+      this.queue = [];
+      this.addHooks = [];
+      this.uploadHooks = [];
+      this.completes = [];
+      this.ticking = false;
+      this.delayedTick = () => {
+        if (!this.queue) {
+          return;
+        }
+        this.prepareItems();
+      };
+      this.registerFindHook(findText);
+      this.registerFindHook(findTextStyle);
+      this.registerFindHook(findMultipleBaseTextures);
+      this.registerFindHook(findBaseTexture);
+      this.registerFindHook(findTexture);
+      this.registerUploadHook(drawText);
+      this.registerUploadHook(calculateTextStyle);
+    }
+    upload(item) {
+      return new Promise((resolve) => {
+        if (item) {
+          this.add(item);
+        }
+        if (this.queue.length) {
+          this.completes.push(resolve);
+          if (!this.ticking) {
+            this.ticking = true;
+            Ticker.system.addOnce(this.tick, this, UPDATE_PRIORITY.UTILITY);
+          }
+        } else {
+          resolve();
+        }
+      });
+    }
+    tick() {
+      setTimeout(this.delayedTick, 0);
+    }
+    prepareItems() {
+      this.limiter.beginFrame();
+      while (this.queue.length && this.limiter.allowedToUpload()) {
+        const item = this.queue[0];
+        let uploaded = false;
+        if (item && !item._destroyed) {
+          for (let i = 0, len = this.uploadHooks.length; i < len; i++) {
+            if (this.uploadHooks[i](this.uploadHookHelper, item)) {
+              this.queue.shift();
+              uploaded = true;
+              break;
+            }
+          }
+        }
+        if (!uploaded) {
+          this.queue.shift();
+        }
+      }
+      if (!this.queue.length) {
+        this.ticking = false;
+        const completes = this.completes.slice(0);
+        this.completes.length = 0;
+        for (let i = 0, len = completes.length; i < len; i++) {
+          completes[i]();
+        }
+      } else {
+        Ticker.system.addOnce(this.tick, this, UPDATE_PRIORITY.UTILITY);
+      }
+    }
+    registerFindHook(addHook) {
+      if (addHook) {
+        this.addHooks.push(addHook);
+      }
+      return this;
+    }
+    registerUploadHook(uploadHook) {
+      if (uploadHook) {
+        this.uploadHooks.push(uploadHook);
+      }
+      return this;
+    }
+    add(item) {
+      for (let i = 0, len = this.addHooks.length; i < len; i++) {
+        if (this.addHooks[i](item, this.queue)) {
+          break;
+        }
+      }
+      if (item instanceof Container) {
+        for (let i = item.children.length - 1; i >= 0; i--) {
+          this.add(item.children[i]);
+        }
+      }
+      return this;
+    }
+    destroy() {
+      if (this.ticking) {
+        Ticker.system.remove(this.tick, this);
+      }
+      this.ticking = false;
+      this.addHooks = null;
+      this.uploadHooks = null;
+      this.renderer = null;
+      this.completes = null;
+      this.queue = null;
+      this.limiter = null;
+      this.uploadHookHelper = null;
+    }
+  };
+  let BasePrepare = _BasePrepare;
+  BasePrepare.uploadsPerFrame = 4;
+
+  Object.defineProperties(settings, {
+    UPLOADS_PER_FRAME: {
+      get() {
+        return BasePrepare.uploadsPerFrame;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.UPLOADS_PER_FRAME is deprecated, use prepare.BasePrepare.uploadsPerFrame");
+        BasePrepare.uploadsPerFrame = value;
+      }
+    }
+  });
+
+  function uploadBaseTextures$1(renderer, item) {
+    if (item instanceof BaseTexture) {
+      if (!item._glTextures[renderer.CONTEXT_UID]) {
+        renderer.texture.bind(item);
+      }
+      return true;
+    }
+    return false;
+  }
+  function uploadGraphics(renderer, item) {
+    if (!(item instanceof Graphics)) {
+      return false;
+    }
+    const { geometry } = item;
+    item.finishPoly();
+    geometry.updateBatches();
+    const { batches } = geometry;
+    for (let i = 0; i < batches.length; i++) {
+      const { texture } = batches[i].style;
+      if (texture) {
+        uploadBaseTextures$1(renderer, texture.baseTexture);
+      }
+    }
+    if (!geometry.batchable) {
+      renderer.geometry.bind(geometry, item._resolveDirectShader(renderer));
+    }
+    return true;
+  }
+  function findGraphics(item, queue) {
+    if (item instanceof Graphics) {
+      queue.push(item);
+      return true;
+    }
+    return false;
+  }
+  class Prepare extends BasePrepare {
+    constructor(renderer) {
+      super(renderer);
+      this.uploadHookHelper = this.renderer;
+      this.registerFindHook(findGraphics);
+      this.registerUploadHook(uploadBaseTextures$1);
+      this.registerUploadHook(uploadGraphics);
+    }
+  }
+  Prepare.extension = {
+    name: "prepare",
+    type: ExtensionType.RendererSystem
+  };
+  extensions$1.add(Prepare);
+
+  class TimeLimiter {
+    constructor(maxMilliseconds) {
+      this.maxMilliseconds = maxMilliseconds;
+      this.frameStart = 0;
+    }
+    beginFrame() {
+      this.frameStart = Date.now();
+    }
+    allowedToUpload() {
+      return Date.now() - this.frameStart < this.maxMilliseconds;
+    }
+  }
+
+  class AnimatedSprite extends Sprite {
+    constructor(textures, autoUpdate = true) {
+      super(textures[0] instanceof Texture ? textures[0] : textures[0].texture);
+      this._textures = null;
+      this._durations = null;
+      this._autoUpdate = autoUpdate;
+      this._isConnectedToTicker = false;
+      this.animationSpeed = 1;
+      this.loop = true;
+      this.updateAnchor = false;
+      this.onComplete = null;
+      this.onFrameChange = null;
+      this.onLoop = null;
+      this._currentTime = 0;
+      this._playing = false;
+      this._previousFrame = null;
+      this.textures = textures;
+    }
+    stop() {
+      if (!this._playing) {
+        return;
+      }
+      this._playing = false;
+      if (this._autoUpdate && this._isConnectedToTicker) {
+        Ticker.shared.remove(this.update, this);
+        this._isConnectedToTicker = false;
+      }
+    }
+    play() {
+      if (this._playing) {
+        return;
+      }
+      this._playing = true;
+      if (this._autoUpdate && !this._isConnectedToTicker) {
+        Ticker.shared.add(this.update, this, UPDATE_PRIORITY.HIGH);
+        this._isConnectedToTicker = true;
+      }
+    }
+    gotoAndStop(frameNumber) {
+      this.stop();
+      this.currentFrame = frameNumber;
+    }
+    gotoAndPlay(frameNumber) {
+      this.currentFrame = frameNumber;
+      this.play();
+    }
+    update(deltaTime) {
+      if (!this._playing) {
+        return;
+      }
+      const elapsed = this.animationSpeed * deltaTime;
+      const previousFrame = this.currentFrame;
+      if (this._durations !== null) {
+        let lag = this._currentTime % 1 * this._durations[this.currentFrame];
+        lag += elapsed / 60 * 1e3;
+        while (lag < 0) {
+          this._currentTime--;
+          lag += this._durations[this.currentFrame];
+        }
+        const sign = Math.sign(this.animationSpeed * deltaTime);
+        this._currentTime = Math.floor(this._currentTime);
+        while (lag >= this._durations[this.currentFrame]) {
+          lag -= this._durations[this.currentFrame] * sign;
+          this._currentTime += sign;
+        }
+        this._currentTime += lag / this._durations[this.currentFrame];
+      } else {
+        this._currentTime += elapsed;
+      }
+      if (this._currentTime < 0 && !this.loop) {
+        this.gotoAndStop(0);
+        if (this.onComplete) {
+          this.onComplete();
+        }
+      } else if (this._currentTime >= this._textures.length && !this.loop) {
+        this.gotoAndStop(this._textures.length - 1);
+        if (this.onComplete) {
+          this.onComplete();
+        }
+      } else if (previousFrame !== this.currentFrame) {
+        if (this.loop && this.onLoop) {
+          if (this.animationSpeed > 0 && this.currentFrame < previousFrame || this.animationSpeed < 0 && this.currentFrame > previousFrame) {
+            this.onLoop();
+          }
+        }
+        this.updateTexture();
+      }
+    }
+    updateTexture() {
+      const currentFrame = this.currentFrame;
+      if (this._previousFrame === currentFrame) {
+        return;
+      }
+      this._previousFrame = currentFrame;
+      this._texture = this._textures[currentFrame];
+      this._textureID = -1;
+      this._textureTrimmedID = -1;
+      this._cachedTint = 16777215;
+      this.uvs = this._texture._uvs.uvsFloat32;
+      if (this.updateAnchor) {
+        this._anchor.copyFrom(this._texture.defaultAnchor);
+      }
+      if (this.onFrameChange) {
+        this.onFrameChange(this.currentFrame);
+      }
+    }
+    destroy(options) {
+      this.stop();
+      super.destroy(options);
+      this.onComplete = null;
+      this.onFrameChange = null;
+      this.onLoop = null;
+    }
+    static fromFrames(frames) {
+      const textures = [];
+      for (let i = 0; i < frames.length; ++i) {
+        textures.push(Texture.from(frames[i]));
+      }
+      return new AnimatedSprite(textures);
+    }
+    static fromImages(images) {
+      const textures = [];
+      for (let i = 0; i < images.length; ++i) {
+        textures.push(Texture.from(images[i]));
+      }
+      return new AnimatedSprite(textures);
+    }
+    get totalFrames() {
+      return this._textures.length;
+    }
+    get textures() {
+      return this._textures;
+    }
+    set textures(value) {
+      if (value[0] instanceof Texture) {
+        this._textures = value;
+        this._durations = null;
+      } else {
+        this._textures = [];
+        this._durations = [];
+        for (let i = 0; i < value.length; i++) {
+          this._textures.push(value[i].texture);
+          this._durations.push(value[i].time);
+        }
+      }
+      this._previousFrame = null;
+      this.gotoAndStop(0);
+      this.updateTexture();
+    }
+    get currentFrame() {
+      let currentFrame = Math.floor(this._currentTime) % this._textures.length;
+      if (currentFrame < 0) {
+        currentFrame += this._textures.length;
+      }
+      return currentFrame;
+    }
+    set currentFrame(value) {
+      if (value < 0 || value > this.totalFrames - 1) {
+        throw new Error(`[AnimatedSprite]: Invalid frame index value ${value}, expected to be between 0 and totalFrames ${this.totalFrames}.`);
+      }
+      const previousFrame = this.currentFrame;
+      this._currentTime = value;
+      if (previousFrame !== this.currentFrame) {
+        this.updateTexture();
+      }
+    }
+    get playing() {
+      return this._playing;
+    }
+    get autoUpdate() {
+      return this._autoUpdate;
+    }
+    set autoUpdate(value) {
+      if (value !== this._autoUpdate) {
+        this._autoUpdate = value;
+        if (!this._autoUpdate && this._isConnectedToTicker) {
+          Ticker.shared.remove(this.update, this);
+          this._isConnectedToTicker = false;
+        } else if (this._autoUpdate && !this._isConnectedToTicker && this._playing) {
+          Ticker.shared.add(this.update, this);
+          this._isConnectedToTicker = true;
+        }
+      }
+    }
+  }
+
+  const _Spritesheet = class {
+    constructor(texture, data, resolutionFilename = null) {
+      this.linkedSheets = [];
+      this._texture = texture instanceof Texture ? texture : null;
+      this.baseTexture = texture instanceof BaseTexture ? texture : this._texture.baseTexture;
+      this.textures = {};
+      this.animations = {};
+      this.data = data;
+      const resource = this.baseTexture.resource;
+      this.resolution = this._updateResolution(resolutionFilename || (resource ? resource.url : null));
+      this._frames = this.data.frames;
+      this._frameKeys = Object.keys(this._frames);
+      this._batchIndex = 0;
+      this._callback = null;
+    }
+    _updateResolution(resolutionFilename = null) {
+      const { scale } = this.data.meta;
+      let resolution = getResolutionOfUrl(resolutionFilename, null);
+      if (resolution === null) {
+        resolution = parseFloat(scale ?? "1");
+      }
+      if (resolution !== 1) {
+        this.baseTexture.setResolution(resolution);
+      }
+      return resolution;
+    }
+    parse() {
+      return new Promise((resolve) => {
+        this._callback = resolve;
+        this._batchIndex = 0;
+        if (this._frameKeys.length <= _Spritesheet.BATCH_SIZE) {
+          this._processFrames(0);
+          this._processAnimations();
+          this._parseComplete();
+        } else {
+          this._nextBatch();
+        }
+      });
+    }
+    _processFrames(initialFrameIndex) {
+      let frameIndex = initialFrameIndex;
+      const maxFrames = _Spritesheet.BATCH_SIZE;
+      while (frameIndex - initialFrameIndex < maxFrames && frameIndex < this._frameKeys.length) {
+        const i = this._frameKeys[frameIndex];
+        const data = this._frames[i];
+        const rect = data.frame;
+        if (rect) {
+          let frame = null;
+          let trim = null;
+          const sourceSize = data.trimmed !== false && data.sourceSize ? data.sourceSize : data.frame;
+          const orig = new Rectangle(0, 0, Math.floor(sourceSize.w) / this.resolution, Math.floor(sourceSize.h) / this.resolution);
+          if (data.rotated) {
+            frame = new Rectangle(Math.floor(rect.x) / this.resolution, Math.floor(rect.y) / this.resolution, Math.floor(rect.h) / this.resolution, Math.floor(rect.w) / this.resolution);
+          } else {
+            frame = new Rectangle(Math.floor(rect.x) / this.resolution, Math.floor(rect.y) / this.resolution, Math.floor(rect.w) / this.resolution, Math.floor(rect.h) / this.resolution);
+          }
+          if (data.trimmed !== false && data.spriteSourceSize) {
+            trim = new Rectangle(Math.floor(data.spriteSourceSize.x) / this.resolution, Math.floor(data.spriteSourceSize.y) / this.resolution, Math.floor(rect.w) / this.resolution, Math.floor(rect.h) / this.resolution);
+          }
+          this.textures[i] = new Texture(this.baseTexture, frame, orig, trim, data.rotated ? 2 : 0, data.anchor, data.borders);
+          Texture.addToCache(this.textures[i], i);
+        }
+        frameIndex++;
+      }
+    }
+    _processAnimations() {
+      const animations = this.data.animations || {};
+      for (const animName in animations) {
+        this.animations[animName] = [];
+        for (let i = 0; i < animations[animName].length; i++) {
+          const frameName = animations[animName][i];
+          this.animations[animName].push(this.textures[frameName]);
+        }
+      }
+    }
+    _parseComplete() {
+      const callback = this._callback;
+      this._callback = null;
+      this._batchIndex = 0;
+      callback.call(this, this.textures);
+    }
+    _nextBatch() {
+      this._processFrames(this._batchIndex * _Spritesheet.BATCH_SIZE);
+      this._batchIndex++;
+      setTimeout(() => {
+        if (this._batchIndex * _Spritesheet.BATCH_SIZE < this._frameKeys.length) {
+          this._nextBatch();
+        } else {
+          this._processAnimations();
+          this._parseComplete();
+        }
+      }, 0);
+    }
+    destroy(destroyBase = false) {
+      for (const i in this.textures) {
+        this.textures[i].destroy();
+      }
+      this._frames = null;
+      this._frameKeys = null;
+      this.data = null;
+      this.textures = null;
+      if (destroyBase) {
+        this._texture?.destroy();
+        this.baseTexture.destroy();
+      }
+      this._texture = null;
+      this.baseTexture = null;
+      this.linkedSheets = [];
+    }
+  };
+  let Spritesheet = _Spritesheet;
+  Spritesheet.BATCH_SIZE = 1e3;
+
+  const validImages = ["jpg", "png", "jpeg", "avif", "webp"];
+  function getCacheableAssets(keys, asset, ignoreMultiPack) {
+    const out = {};
+    keys.forEach((key) => {
+      out[key] = asset;
+    });
+    Object.keys(asset.textures).forEach((key) => {
+      out[key] = asset.textures[key];
+    });
+    if (!ignoreMultiPack) {
+      const basePath = path.dirname(keys[0]);
+      asset.linkedSheets.forEach((item, i) => {
+        const out2 = getCacheableAssets([`${basePath}/${asset.data.meta.related_multi_packs[i]}`], item, true);
+        Object.assign(out, out2);
+      });
+    }
+    return out;
+  }
+  const spritesheetAsset = {
+    extension: ExtensionType.Asset,
+    cache: {
+      test: (asset) => asset instanceof Spritesheet,
+      getCacheableAssets: (keys, asset) => getCacheableAssets(keys, asset, false)
+    },
+    resolver: {
+      test: (value) => {
+        const tempURL = value.split("?")[0];
+        const split = tempURL.split(".");
+        const extension = split.pop();
+        const format = split.pop();
+        return extension === "json" && validImages.includes(format);
+      },
+      parse: (value) => {
+        const split = value.split(".");
+        return {
+          resolution: parseFloat(settings.RETINA_PREFIX.exec(value)?.[1] ?? "1"),
+          format: split[split.length - 2],
+          src: value
+        };
+      }
+    },
+    loader: {
+      name: "spritesheetLoader",
+      extension: {
+        type: ExtensionType.LoadParser,
+        priority: LoaderParserPriority.Normal
+      },
+      async testParse(asset, options) {
+        return path.extname(options.src).toLowerCase() === ".json" && !!asset.frames;
+      },
+      async parse(asset, options, loader) {
+        let basePath = path.dirname(options.src);
+        if (basePath && basePath.lastIndexOf("/") !== basePath.length - 1) {
+          basePath += "/";
+        }
+        let imagePath = basePath + asset.meta.image;
+        imagePath = copySearchParams(imagePath, options.src);
+        const assets = await loader.load([imagePath]);
+        const texture = assets[imagePath];
+        const spritesheet = new Spritesheet(texture.baseTexture, asset, options.src);
+        await spritesheet.parse();
+        const multiPacks = asset?.meta?.related_multi_packs;
+        if (Array.isArray(multiPacks)) {
+          const promises = [];
+          for (const item of multiPacks) {
+            if (typeof item !== "string") {
+              continue;
+            }
+            let itemUrl = basePath + item;
+            if (options.data?.ignoreMultiPack) {
+              continue;
+            }
+            itemUrl = copySearchParams(itemUrl, options.src);
+            promises.push(loader.load({
+              src: itemUrl,
+              data: {
+                ignoreMultiPack: true
+              }
+            }));
+          }
+          const res = await Promise.all(promises);
+          spritesheet.linkedSheets = res;
+          res.forEach((item) => {
+            item.linkedSheets = [spritesheet].concat(spritesheet.linkedSheets.filter((sp) => sp !== item));
+          });
+        }
+        return spritesheet;
+      },
+      unload(spritesheet) {
+        spritesheet.destroy(true);
+      }
+    }
+  };
+  extensions$1.add(spritesheetAsset);
+
+  class BitmapFontData {
+    constructor() {
+      this.info = [];
+      this.common = [];
+      this.page = [];
+      this.char = [];
+      this.kerning = [];
+      this.distanceField = [];
+    }
+  }
+
+  class TextFormat {
+    static test(data) {
+      return typeof data === "string" && data.startsWith("info face=");
+    }
+    static parse(txt) {
+      const items = txt.match(/^[a-z]+\s+.+$/gm);
+      const rawData = {
+        info: [],
+        common: [],
+        page: [],
+        char: [],
+        chars: [],
+        kerning: [],
+        kernings: [],
+        distanceField: []
+      };
+      for (const i in items) {
+        const name = items[i].match(/^[a-z]+/gm)[0];
+        const attributeList = items[i].match(/[a-zA-Z]+=([^\s"']+|"([^"]*)")/gm);
+        const itemData = {};
+        for (const i2 in attributeList) {
+          const split = attributeList[i2].split("=");
+          const key = split[0];
+          const strValue = split[1].replace(/"/gm, "");
+          const floatValue = parseFloat(strValue);
+          const value = isNaN(floatValue) ? strValue : floatValue;
+          itemData[key] = value;
+        }
+        rawData[name].push(itemData);
+      }
+      const font = new BitmapFontData();
+      rawData.info.forEach((info) => font.info.push({
+        face: info.face,
+        size: parseInt(info.size, 10)
+      }));
+      rawData.common.forEach((common) => font.common.push({
+        lineHeight: parseInt(common.lineHeight, 10)
+      }));
+      rawData.page.forEach((page) => font.page.push({
+        id: parseInt(page.id, 10),
+        file: page.file
+      }));
+      rawData.char.forEach((char) => font.char.push({
+        id: parseInt(char.id, 10),
+        page: parseInt(char.page, 10),
+        x: parseInt(char.x, 10),
+        y: parseInt(char.y, 10),
+        width: parseInt(char.width, 10),
+        height: parseInt(char.height, 10),
+        xoffset: parseInt(char.xoffset, 10),
+        yoffset: parseInt(char.yoffset, 10),
+        xadvance: parseInt(char.xadvance, 10)
+      }));
+      rawData.kerning.forEach((kerning) => font.kerning.push({
+        first: parseInt(kerning.first, 10),
+        second: parseInt(kerning.second, 10),
+        amount: parseInt(kerning.amount, 10)
+      }));
+      rawData.distanceField.forEach((df) => font.distanceField.push({
+        distanceRange: parseInt(df.distanceRange, 10),
+        fieldType: df.fieldType
+      }));
+      return font;
+    }
+  }
+
+  class XMLFormat {
+    static test(data) {
+      const xml = data;
+      return "getElementsByTagName" in xml && xml.getElementsByTagName("page").length && xml.getElementsByTagName("info")[0].getAttribute("face") !== null;
+    }
+    static parse(xml) {
+      const data = new BitmapFontData();
+      const info = xml.getElementsByTagName("info");
+      const common = xml.getElementsByTagName("common");
+      const page = xml.getElementsByTagName("page");
+      const char = xml.getElementsByTagName("char");
+      const kerning = xml.getElementsByTagName("kerning");
+      const distanceField = xml.getElementsByTagName("distanceField");
+      for (let i = 0; i < info.length; i++) {
+        data.info.push({
+          face: info[i].getAttribute("face"),
+          size: parseInt(info[i].getAttribute("size"), 10)
+        });
+      }
+      for (let i = 0; i < common.length; i++) {
+        data.common.push({
+          lineHeight: parseInt(common[i].getAttribute("lineHeight"), 10)
+        });
+      }
+      for (let i = 0; i < page.length; i++) {
+        data.page.push({
+          id: parseInt(page[i].getAttribute("id"), 10) || 0,
+          file: page[i].getAttribute("file")
+        });
+      }
+      for (let i = 0; i < char.length; i++) {
+        const letter = char[i];
+        data.char.push({
+          id: parseInt(letter.getAttribute("id"), 10),
+          page: parseInt(letter.getAttribute("page"), 10) || 0,
+          x: parseInt(letter.getAttribute("x"), 10),
+          y: parseInt(letter.getAttribute("y"), 10),
+          width: parseInt(letter.getAttribute("width"), 10),
+          height: parseInt(letter.getAttribute("height"), 10),
+          xoffset: parseInt(letter.getAttribute("xoffset"), 10),
+          yoffset: parseInt(letter.getAttribute("yoffset"), 10),
+          xadvance: parseInt(letter.getAttribute("xadvance"), 10)
+        });
+      }
+      for (let i = 0; i < kerning.length; i++) {
+        data.kerning.push({
+          first: parseInt(kerning[i].getAttribute("first"), 10),
+          second: parseInt(kerning[i].getAttribute("second"), 10),
+          amount: parseInt(kerning[i].getAttribute("amount"), 10)
+        });
+      }
+      for (let i = 0; i < distanceField.length; i++) {
+        data.distanceField.push({
+          fieldType: distanceField[i].getAttribute("fieldType"),
+          distanceRange: parseInt(distanceField[i].getAttribute("distanceRange"), 10)
+        });
+      }
+      return data;
+    }
+  }
+
+  class XMLStringFormat {
+    static test(data) {
+      if (typeof data === "string" && data.includes("<font>")) {
+        return XMLFormat.test(settings.ADAPTER.parseXML(data));
+      }
+      return false;
+    }
+    static parse(xmlTxt) {
+      return XMLFormat.parse(settings.ADAPTER.parseXML(xmlTxt));
+    }
+  }
+
+  const formats = [
+    TextFormat,
+    XMLFormat,
+    XMLStringFormat
+  ];
+  function autoDetectFormat(data) {
+    for (let i = 0; i < formats.length; i++) {
+      if (formats[i].test(data)) {
+        return formats[i];
+      }
+    }
+    return null;
+  }
+
+  function generateFillStyle(canvas, context, style, resolution, lines, metrics) {
+    const fillStyle = style.fill;
+    if (!Array.isArray(fillStyle)) {
+      return fillStyle;
+    } else if (fillStyle.length === 1) {
+      return fillStyle[0];
+    }
+    let gradient;
+    const dropShadowCorrection = style.dropShadow ? style.dropShadowDistance : 0;
+    const padding = style.padding || 0;
+    const width = canvas.width / resolution - dropShadowCorrection - padding * 2;
+    const height = canvas.height / resolution - dropShadowCorrection - padding * 2;
+    const fill = fillStyle.slice();
+    const fillGradientStops = style.fillGradientStops.slice();
+    if (!fillGradientStops.length) {
+      const lengthPlus1 = fill.length + 1;
+      for (let i = 1; i < lengthPlus1; ++i) {
+        fillGradientStops.push(i / lengthPlus1);
+      }
+    }
+    fill.unshift(fillStyle[0]);
+    fillGradientStops.unshift(0);
+    fill.push(fillStyle[fillStyle.length - 1]);
+    fillGradientStops.push(1);
+    if (style.fillGradientType === TEXT_GRADIENT.LINEAR_VERTICAL) {
+      gradient = context.createLinearGradient(width / 2, padding, width / 2, height + padding);
+      let lastIterationStop = 0;
+      const textHeight = metrics.fontProperties.fontSize + style.strokeThickness;
+      const gradStopLineHeight = textHeight / height;
+      for (let i = 0; i < lines.length; i++) {
+        const thisLineTop = metrics.lineHeight * i;
+        for (let j = 0; j < fill.length; j++) {
+          let lineStop = 0;
+          if (typeof fillGradientStops[j] === "number") {
+            lineStop = fillGradientStops[j];
+          } else {
+            lineStop = j / fill.length;
+          }
+          const globalStop = thisLineTop / height + lineStop * gradStopLineHeight;
+          let clampedStop = Math.max(lastIterationStop, globalStop);
+          clampedStop = Math.min(clampedStop, 1);
+          gradient.addColorStop(clampedStop, fill[j]);
+          lastIterationStop = clampedStop;
+        }
+      }
+    } else {
+      gradient = context.createLinearGradient(padding, height / 2, width + padding, height / 2);
+      const totalIterations = fill.length + 1;
+      let currentIteration = 1;
+      for (let i = 0; i < fill.length; i++) {
+        let stop;
+        if (typeof fillGradientStops[i] === "number") {
+          stop = fillGradientStops[i];
+        } else {
+          stop = currentIteration / totalIterations;
+        }
+        gradient.addColorStop(stop, fill[i]);
+        currentIteration++;
+      }
+    }
+    return gradient;
+  }
+
+  function drawGlyph(canvas, context, metrics, x, y, resolution, style) {
+    const char = metrics.text;
+    const fontProperties = metrics.fontProperties;
+    context.translate(x, y);
+    context.scale(resolution, resolution);
+    const tx = style.strokeThickness / 2;
+    const ty = -(style.strokeThickness / 2);
+    context.font = style.toFontString();
+    context.lineWidth = style.strokeThickness;
+    context.textBaseline = style.textBaseline;
+    context.lineJoin = style.lineJoin;
+    context.miterLimit = style.miterLimit;
+    context.fillStyle = generateFillStyle(canvas, context, style, resolution, [char], metrics);
+    context.strokeStyle = style.stroke;
+    if (style.dropShadow) {
+      const dropShadowColor = style.dropShadowColor;
+      const dropShadowBlur = style.dropShadowBlur * resolution;
+      const dropShadowDistance = style.dropShadowDistance * resolution;
+      context.shadowColor = Color.shared.setValue(dropShadowColor).setAlpha(style.dropShadowAlpha).toRgbaString();
+      context.shadowBlur = dropShadowBlur;
+      context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;
+      context.shadowOffsetY = Math.sin(style.dropShadowAngle) * dropShadowDistance;
+    } else {
+      context.shadowColor = "black";
+      context.shadowBlur = 0;
+      context.shadowOffsetX = 0;
+      context.shadowOffsetY = 0;
+    }
+    if (style.stroke && style.strokeThickness) {
+      context.strokeText(char, tx, ty + metrics.lineHeight - fontProperties.descent);
+    }
+    if (style.fill) {
+      context.fillText(char, tx, ty + metrics.lineHeight - fontProperties.descent);
+    }
+    context.setTransform(1, 0, 0, 1, 0, 0);
+    context.fillStyle = "rgba(0, 0, 0, 0)";
+  }
+
+  function extractCharCode(str) {
+    return str.codePointAt ? str.codePointAt(0) : str.charCodeAt(0);
+  }
+
+  function splitTextToCharacters(text) {
+    return Array.from ? Array.from(text) : text.split("");
+  }
+
+  function resolveCharacters(chars) {
+    if (typeof chars === "string") {
+      chars = [chars];
+    }
+    const result = [];
+    for (let i = 0, j = chars.length; i < j; i++) {
+      const item = chars[i];
+      if (Array.isArray(item)) {
+        if (item.length !== 2) {
+          throw new Error(`[BitmapFont]: Invalid character range length, expecting 2 got ${item.length}.`);
+        }
+        const startCode = item[0].charCodeAt(0);
+        const endCode = item[1].charCodeAt(0);
+        if (endCode < startCode) {
+          throw new Error("[BitmapFont]: Invalid character range.");
+        }
+        for (let i2 = startCode, j2 = endCode; i2 <= j2; i2++) {
+          result.push(String.fromCharCode(i2));
+        }
+      } else {
+        result.push(...splitTextToCharacters(item));
+      }
+    }
+    if (result.length === 0) {
+      throw new Error("[BitmapFont]: Empty set when resolving characters.");
+    }
+    return result;
+  }
+
+  const _BitmapFont = class {
+    constructor(data, textures, ownsTextures) {
+      const [info] = data.info;
+      const [common] = data.common;
+      const [page] = data.page;
+      const [distanceField] = data.distanceField;
+      const res = getResolutionOfUrl(page.file);
+      const pageTextures = {};
+      this._ownsTextures = ownsTextures;
+      this.font = info.face;
+      this.size = info.size;
+      this.lineHeight = common.lineHeight / res;
+      this.chars = {};
+      this.pageTextures = pageTextures;
+      for (let i = 0; i < data.page.length; i++) {
+        const { id, file } = data.page[i];
+        pageTextures[id] = textures instanceof Array ? textures[i] : textures[file];
+        if (distanceField?.fieldType && distanceField.fieldType !== "none") {
+          pageTextures[id].baseTexture.alphaMode = ALPHA_MODES.NO_PREMULTIPLIED_ALPHA;
+          pageTextures[id].baseTexture.mipmap = MIPMAP_MODES.OFF;
+        }
+      }
+      for (let i = 0; i < data.char.length; i++) {
+        const { id, page: page2 } = data.char[i];
+        let { x, y, width, height, xoffset, yoffset, xadvance } = data.char[i];
+        x /= res;
+        y /= res;
+        width /= res;
+        height /= res;
+        xoffset /= res;
+        yoffset /= res;
+        xadvance /= res;
+        const rect = new Rectangle(x + pageTextures[page2].frame.x / res, y + pageTextures[page2].frame.y / res, width, height);
+        this.chars[id] = {
+          xOffset: xoffset,
+          yOffset: yoffset,
+          xAdvance: xadvance,
+          kerning: {},
+          texture: new Texture(pageTextures[page2].baseTexture, rect),
+          page: page2
+        };
+      }
+      for (let i = 0; i < data.kerning.length; i++) {
+        let { first, second, amount } = data.kerning[i];
+        first /= res;
+        second /= res;
+        amount /= res;
+        if (this.chars[second]) {
+          this.chars[second].kerning[first] = amount;
+        }
+      }
+      this.distanceFieldRange = distanceField?.distanceRange;
+      this.distanceFieldType = distanceField?.fieldType?.toLowerCase() ?? "none";
+    }
+    destroy() {
+      for (const id in this.chars) {
+        this.chars[id].texture.destroy();
+        this.chars[id].texture = null;
+      }
+      for (const id in this.pageTextures) {
+        if (this._ownsTextures) {
+          this.pageTextures[id].destroy(true);
+        }
+        this.pageTextures[id] = null;
+      }
+      this.chars = null;
+      this.pageTextures = null;
+    }
+    static install(data, textures, ownsTextures) {
+      let fontData;
+      if (data instanceof BitmapFontData) {
+        fontData = data;
+      } else {
+        const format = autoDetectFormat(data);
+        if (!format) {
+          throw new Error("Unrecognized data format for font.");
+        }
+        fontData = format.parse(data);
+      }
+      if (textures instanceof Texture) {
+        textures = [textures];
+      }
+      const font = new _BitmapFont(fontData, textures, ownsTextures);
+      _BitmapFont.available[font.font] = font;
+      return font;
+    }
+    static uninstall(name) {
+      const font = _BitmapFont.available[name];
+      if (!font) {
+        throw new Error(`No font found named '${name}'`);
+      }
+      font.destroy();
+      delete _BitmapFont.available[name];
+    }
+    static from(name, textStyle, options) {
+      if (!name) {
+        throw new Error("[BitmapFont] Property `name` is required.");
+      }
+      const {
+        chars,
+        padding,
+        resolution,
+        textureWidth,
+        textureHeight,
+        ...baseOptions
+      } = Object.assign({}, _BitmapFont.defaultOptions, options);
+      const charsList = resolveCharacters(chars);
+      const style = textStyle instanceof TextStyle ? textStyle : new TextStyle(textStyle);
+      const lineWidth = textureWidth;
+      const fontData = new BitmapFontData();
+      fontData.info[0] = {
+        face: style.fontFamily,
+        size: style.fontSize
+      };
+      fontData.common[0] = {
+        lineHeight: style.fontSize
+      };
+      let positionX = 0;
+      let positionY = 0;
+      let canvas;
+      let context;
+      let baseTexture;
+      let maxCharHeight = 0;
+      const baseTextures = [];
+      const textures = [];
+      for (let i = 0; i < charsList.length; i++) {
+        if (!canvas) {
+          canvas = settings.ADAPTER.createCanvas();
+          canvas.width = textureWidth;
+          canvas.height = textureHeight;
+          context = canvas.getContext("2d");
+          baseTexture = new BaseTexture(canvas, { resolution, ...baseOptions });
+          baseTextures.push(baseTexture);
+          textures.push(new Texture(baseTexture));
+          fontData.page.push({
+            id: textures.length - 1,
+            file: ""
+          });
+        }
+        const character = charsList[i];
+        const metrics = TextMetrics.measureText(character, style, false, canvas);
+        const width = metrics.width;
+        const height = Math.ceil(metrics.height);
+        const textureGlyphWidth = Math.ceil((style.fontStyle === "italic" ? 2 : 1) * width);
+        if (positionY >= textureHeight - height * resolution) {
+          if (positionY === 0) {
+            throw new Error(`[BitmapFont] textureHeight ${textureHeight}px is too small (fontFamily: '${style.fontFamily}', fontSize: ${style.fontSize}px, char: '${character}')`);
+          }
+          --i;
+          canvas = null;
+          context = null;
+          baseTexture = null;
+          positionY = 0;
+          positionX = 0;
+          maxCharHeight = 0;
+          continue;
+        }
+        maxCharHeight = Math.max(height + metrics.fontProperties.descent, maxCharHeight);
+        if (textureGlyphWidth * resolution + positionX >= lineWidth) {
+          if (positionX === 0) {
+            throw new Error(`[BitmapFont] textureWidth ${textureWidth}px is too small (fontFamily: '${style.fontFamily}', fontSize: ${style.fontSize}px, char: '${character}')`);
+          }
+          --i;
+          positionY += maxCharHeight * resolution;
+          positionY = Math.ceil(positionY);
+          positionX = 0;
+          maxCharHeight = 0;
+          continue;
+        }
+        drawGlyph(canvas, context, metrics, positionX, positionY, resolution, style);
+        const id = extractCharCode(metrics.text);
+        fontData.char.push({
+          id,
+          page: textures.length - 1,
+          x: positionX / resolution,
+          y: positionY / resolution,
+          width: textureGlyphWidth,
+          height,
+          xoffset: 0,
+          yoffset: 0,
+          xadvance: width - (style.dropShadow ? style.dropShadowDistance : 0) - (style.stroke ? style.strokeThickness : 0)
+        });
+        positionX += (textureGlyphWidth + 2 * padding) * resolution;
+        positionX = Math.ceil(positionX);
+      }
+      for (let i = 0, len = charsList.length; i < len; i++) {
+        const first = charsList[i];
+        for (let j = 0; j < len; j++) {
+          const second = charsList[j];
+          const c1 = context.measureText(first).width;
+          const c2 = context.measureText(second).width;
+          const total = context.measureText(first + second).width;
+          const amount = total - (c1 + c2);
+          if (amount) {
+            fontData.kerning.push({
+              first: extractCharCode(first),
+              second: extractCharCode(second),
+              amount
+            });
+          }
+        }
+      }
+      const font = new _BitmapFont(fontData, textures, true);
+      if (_BitmapFont.available[name] !== void 0) {
+        _BitmapFont.uninstall(name);
+      }
+      _BitmapFont.available[name] = font;
+      return font;
+    }
+  };
+  let BitmapFont = _BitmapFont;
+  BitmapFont.ALPHA = [["a", "z"], ["A", "Z"], " "];
+  BitmapFont.NUMERIC = [["0", "9"]];
+  BitmapFont.ALPHANUMERIC = [["a", "z"], ["A", "Z"], ["0", "9"], " "];
+  BitmapFont.ASCII = [[" ", "~"]];
+  BitmapFont.defaultOptions = {
+    resolution: 1,
+    textureWidth: 512,
+    textureHeight: 512,
+    padding: 4,
+    chars: _BitmapFont.ALPHANUMERIC
+  };
+  BitmapFont.available = {};
+
+  var msdfFrag = "// Pixi texture info\r\nvarying vec2 vTextureCoord;\r\nuniform sampler2D uSampler;\r\n\r\n// Tint\r\nuniform vec4 uColor;\r\n\r\n// on 2D applications fwidth is screenScale / glyphAtlasScale * distanceFieldRange\r\nuniform float uFWidth;\r\n\r\nvoid main(void) {\r\n\r\n  // To stack MSDF and SDF we need a non-pre-multiplied-alpha texture.\r\n  vec4 texColor = texture2D(uSampler, vTextureCoord);\r\n\r\n  // MSDF\r\n  float median = texColor.r + texColor.g + texColor.b -\r\n                  min(texColor.r, min(texColor.g, texColor.b)) -\r\n                  max(texColor.r, max(texColor.g, texColor.b));\r\n  // SDF\r\n  median = min(median, texColor.a);\r\n\r\n  float screenPxDistance = uFWidth * (median - 0.5);\r\n  float alpha = clamp(screenPxDistance + 0.5, 0.0, 1.0);\r\n  if (median < 0.01) {\r\n    alpha = 0.0;\r\n  } else if (median > 0.99) {\r\n    alpha = 1.0;\r\n  }\r\n\r\n  // Gamma correction for coverage-like alpha\r\n  float luma = dot(uColor.rgb, vec3(0.299, 0.587, 0.114));\r\n  float gamma = mix(1.0, 1.0 / 2.2, luma);\r\n  float coverage = pow(uColor.a * alpha, gamma);  \r\n\r\n  // NPM Textures, NPM outputs\r\n  gl_FragColor = vec4(uColor.rgb, coverage);\r\n}\r\n";
+
+  var msdfVert = "// Mesh material default fragment\r\nattribute vec2 aVertexPosition;\r\nattribute vec2 aTextureCoord;\r\n\r\nuniform mat3 projectionMatrix;\r\nuniform mat3 translationMatrix;\r\nuniform mat3 uTextureMatrix;\r\n\r\nvarying vec2 vTextureCoord;\r\n\r\nvoid main(void)\r\n{\r\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\r\n\r\n    vTextureCoord = (uTextureMatrix * vec3(aTextureCoord, 1.0)).xy;\r\n}\r\n";
+
+  const pageMeshDataDefaultPageMeshData = [];
+  const pageMeshDataMSDFPageMeshData = [];
+  const charRenderDataPool = [];
+  const _BitmapText = class extends Container {
+    constructor(text, style = {}) {
+      super();
+      const { align, tint, maxWidth, letterSpacing, fontName, fontSize } = Object.assign({}, _BitmapText.styleDefaults, style);
+      if (!BitmapFont.available[fontName]) {
+        throw new Error(`Missing BitmapFont "${fontName}"`);
+      }
+      this._activePagesMeshData = [];
+      this._textWidth = 0;
+      this._textHeight = 0;
+      this._align = align;
+      this._tintColor = new Color(tint);
+      this._font = void 0;
+      this._fontName = fontName;
+      this._fontSize = fontSize;
+      this.text = text;
+      this._maxWidth = maxWidth;
+      this._maxLineHeight = 0;
+      this._letterSpacing = letterSpacing;
+      this._anchor = new ObservablePoint(() => {
+        this.dirty = true;
+      }, this, 0, 0);
+      this._roundPixels = settings.ROUND_PIXELS;
+      this.dirty = true;
+      this._resolution = settings.RESOLUTION;
+      this._autoResolution = true;
+      this._textureCache = {};
+    }
+    updateText() {
+      const data = BitmapFont.available[this._fontName];
+      const fontSize = this.fontSize;
+      const scale = fontSize / data.size;
+      const pos = new Point();
+      const chars = [];
+      const lineWidths = [];
+      const lineSpaces = [];
+      const text = this._text.replace(/(?:\r\n|\r)/g, "\n") || " ";
+      const charsInput = splitTextToCharacters(text);
+      const maxWidth = this._maxWidth * data.size / fontSize;
+      const pageMeshDataPool = data.distanceFieldType === "none" ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;
+      let prevCharCode = null;
+      let lastLineWidth = 0;
+      let maxLineWidth = 0;
+      let line = 0;
+      let lastBreakPos = -1;
+      let lastBreakWidth = 0;
+      let spacesRemoved = 0;
+      let maxLineHeight = 0;
+      let spaceCount = 0;
+      for (let i = 0; i < charsInput.length; i++) {
+        const char = charsInput[i];
+        const charCode = extractCharCode(char);
+        if (/(?:\s)/.test(char)) {
+          lastBreakPos = i;
+          lastBreakWidth = lastLineWidth;
+          spaceCount++;
+        }
+        if (char === "\r" || char === "\n") {
+          lineWidths.push(lastLineWidth);
+          lineSpaces.push(-1);
+          maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
+          ++line;
+          ++spacesRemoved;
+          pos.x = 0;
+          pos.y += data.lineHeight;
+          prevCharCode = null;
+          spaceCount = 0;
+          continue;
+        }
+        const charData = data.chars[charCode];
+        if (!charData) {
+          continue;
+        }
+        if (prevCharCode && charData.kerning[prevCharCode]) {
+          pos.x += charData.kerning[prevCharCode];
+        }
+        const charRenderData = charRenderDataPool.pop() || {
+          texture: Texture.EMPTY,
+          line: 0,
+          charCode: 0,
+          prevSpaces: 0,
+          position: new Point()
+        };
+        charRenderData.texture = charData.texture;
+        charRenderData.line = line;
+        charRenderData.charCode = charCode;
+        charRenderData.position.x = Math.round(pos.x + charData.xOffset + this._letterSpacing / 2);
+        charRenderData.position.y = Math.round(pos.y + charData.yOffset);
+        charRenderData.prevSpaces = spaceCount;
+        chars.push(charRenderData);
+        lastLineWidth = charRenderData.position.x + Math.max(charData.xAdvance - charData.xOffset, charData.texture.orig.width);
+        pos.x += charData.xAdvance + this._letterSpacing;
+        maxLineHeight = Math.max(maxLineHeight, charData.yOffset + charData.texture.height);
+        prevCharCode = charCode;
+        if (lastBreakPos !== -1 && maxWidth > 0 && pos.x > maxWidth) {
+          ++spacesRemoved;
+          removeItems(chars, 1 + lastBreakPos - spacesRemoved, 1 + i - lastBreakPos);
+          i = lastBreakPos;
+          lastBreakPos = -1;
+          lineWidths.push(lastBreakWidth);
+          lineSpaces.push(chars.length > 0 ? chars[chars.length - 1].prevSpaces : 0);
+          maxLineWidth = Math.max(maxLineWidth, lastBreakWidth);
+          line++;
+          pos.x = 0;
+          pos.y += data.lineHeight;
+          prevCharCode = null;
+          spaceCount = 0;
+        }
+      }
+      const lastChar = charsInput[charsInput.length - 1];
+      if (lastChar !== "\r" && lastChar !== "\n") {
+        if (/(?:\s)/.test(lastChar)) {
+          lastLineWidth = lastBreakWidth;
+        }
+        lineWidths.push(lastLineWidth);
+        maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
+        lineSpaces.push(-1);
+      }
+      const lineAlignOffsets = [];
+      for (let i = 0; i <= line; i++) {
+        let alignOffset = 0;
+        if (this._align === "right") {
+          alignOffset = maxLineWidth - lineWidths[i];
+        } else if (this._align === "center") {
+          alignOffset = (maxLineWidth - lineWidths[i]) / 2;
+        } else if (this._align === "justify") {
+          alignOffset = lineSpaces[i] < 0 ? 0 : (maxLineWidth - lineWidths[i]) / lineSpaces[i];
+        }
+        lineAlignOffsets.push(alignOffset);
+      }
+      const lenChars = chars.length;
+      const pagesMeshData = {};
+      const newPagesMeshData = [];
+      const activePagesMeshData = this._activePagesMeshData;
+      pageMeshDataPool.push(...activePagesMeshData);
+      for (let i = 0; i < lenChars; i++) {
+        const texture = chars[i].texture;
+        const baseTextureUid = texture.baseTexture.uid;
+        if (!pagesMeshData[baseTextureUid]) {
+          let pageMeshData = pageMeshDataPool.pop();
+          if (!pageMeshData) {
+            const geometry = new MeshGeometry();
+            let material;
+            let meshBlendMode;
+            if (data.distanceFieldType === "none") {
+              material = new MeshMaterial(Texture.EMPTY);
+              meshBlendMode = BLEND_MODES.NORMAL;
+            } else {
+              material = new MeshMaterial(Texture.EMPTY, { program: Program.from(msdfVert, msdfFrag), uniforms: { uFWidth: 0 } });
+              meshBlendMode = BLEND_MODES.NORMAL_NPM;
+            }
+            const mesh = new Mesh(geometry, material);
+            mesh.blendMode = meshBlendMode;
+            pageMeshData = {
+              index: 0,
+              indexCount: 0,
+              vertexCount: 0,
+              uvsCount: 0,
+              total: 0,
+              mesh,
+              vertices: null,
+              uvs: null,
+              indices: null
+            };
+          }
+          pageMeshData.index = 0;
+          pageMeshData.indexCount = 0;
+          pageMeshData.vertexCount = 0;
+          pageMeshData.uvsCount = 0;
+          pageMeshData.total = 0;
+          const { _textureCache } = this;
+          _textureCache[baseTextureUid] = _textureCache[baseTextureUid] || new Texture(texture.baseTexture);
+          pageMeshData.mesh.texture = _textureCache[baseTextureUid];
+          pageMeshData.mesh.tint = this._tintColor.value;
+          newPagesMeshData.push(pageMeshData);
+          pagesMeshData[baseTextureUid] = pageMeshData;
+        }
+        pagesMeshData[baseTextureUid].total++;
+      }
+      for (let i = 0; i < activePagesMeshData.length; i++) {
+        if (!newPagesMeshData.includes(activePagesMeshData[i])) {
+          this.removeChild(activePagesMeshData[i].mesh);
+        }
+      }
+      for (let i = 0; i < newPagesMeshData.length; i++) {
+        if (newPagesMeshData[i].mesh.parent !== this) {
+          this.addChild(newPagesMeshData[i].mesh);
+        }
+      }
+      this._activePagesMeshData = newPagesMeshData;
+      for (const i in pagesMeshData) {
+        const pageMeshData = pagesMeshData[i];
+        const total = pageMeshData.total;
+        if (!(pageMeshData.indices?.length > 6 * total) || pageMeshData.vertices.length < Mesh.BATCHABLE_SIZE * 2) {
+          pageMeshData.vertices = new Float32Array(4 * 2 * total);
+          pageMeshData.uvs = new Float32Array(4 * 2 * total);
+          pageMeshData.indices = new Uint16Array(6 * total);
+        } else {
+          const total2 = pageMeshData.total;
+          const vertices = pageMeshData.vertices;
+          for (let i2 = total2 * 4 * 2; i2 < vertices.length; i2++) {
+            vertices[i2] = 0;
+          }
+        }
+        pageMeshData.mesh.size = 6 * total;
+      }
+      for (let i = 0; i < lenChars; i++) {
+        const char = chars[i];
+        let offset = char.position.x + lineAlignOffsets[char.line] * (this._align === "justify" ? char.prevSpaces : 1);
+        if (this._roundPixels) {
+          offset = Math.round(offset);
+        }
+        const xPos = offset * scale;
+        const yPos = char.position.y * scale;
+        const texture = char.texture;
+        const pageMesh = pagesMeshData[texture.baseTexture.uid];
+        const textureFrame = texture.frame;
+        const textureUvs = texture._uvs;
+        const index = pageMesh.index++;
+        pageMesh.indices[index * 6 + 0] = 0 + index * 4;
+        pageMesh.indices[index * 6 + 1] = 1 + index * 4;
+        pageMesh.indices[index * 6 + 2] = 2 + index * 4;
+        pageMesh.indices[index * 6 + 3] = 0 + index * 4;
+        pageMesh.indices[index * 6 + 4] = 2 + index * 4;
+        pageMesh.indices[index * 6 + 5] = 3 + index * 4;
+        pageMesh.vertices[index * 8 + 0] = xPos;
+        pageMesh.vertices[index * 8 + 1] = yPos;
+        pageMesh.vertices[index * 8 + 2] = xPos + textureFrame.width * scale;
+        pageMesh.vertices[index * 8 + 3] = yPos;
+        pageMesh.vertices[index * 8 + 4] = xPos + textureFrame.width * scale;
+        pageMesh.vertices[index * 8 + 5] = yPos + textureFrame.height * scale;
+        pageMesh.vertices[index * 8 + 6] = xPos;
+        pageMesh.vertices[index * 8 + 7] = yPos + textureFrame.height * scale;
+        pageMesh.uvs[index * 8 + 0] = textureUvs.x0;
+        pageMesh.uvs[index * 8 + 1] = textureUvs.y0;
+        pageMesh.uvs[index * 8 + 2] = textureUvs.x1;
+        pageMesh.uvs[index * 8 + 3] = textureUvs.y1;
+        pageMesh.uvs[index * 8 + 4] = textureUvs.x2;
+        pageMesh.uvs[index * 8 + 5] = textureUvs.y2;
+        pageMesh.uvs[index * 8 + 6] = textureUvs.x3;
+        pageMesh.uvs[index * 8 + 7] = textureUvs.y3;
+      }
+      this._textWidth = maxLineWidth * scale;
+      this._textHeight = (pos.y + data.lineHeight) * scale;
+      for (const i in pagesMeshData) {
+        const pageMeshData = pagesMeshData[i];
+        if (this.anchor.x !== 0 || this.anchor.y !== 0) {
+          let vertexCount = 0;
+          const anchorOffsetX = this._textWidth * this.anchor.x;
+          const anchorOffsetY = this._textHeight * this.anchor.y;
+          for (let i2 = 0; i2 < pageMeshData.total; i2++) {
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
+            pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
+          }
+        }
+        this._maxLineHeight = maxLineHeight * scale;
+        const vertexBuffer = pageMeshData.mesh.geometry.getBuffer("aVertexPosition");
+        const textureBuffer = pageMeshData.mesh.geometry.getBuffer("aTextureCoord");
+        const indexBuffer = pageMeshData.mesh.geometry.getIndex();
+        vertexBuffer.data = pageMeshData.vertices;
+        textureBuffer.data = pageMeshData.uvs;
+        indexBuffer.data = pageMeshData.indices;
+        vertexBuffer.update();
+        textureBuffer.update();
+        indexBuffer.update();
+      }
+      for (let i = 0; i < chars.length; i++) {
+        charRenderDataPool.push(chars[i]);
+      }
+      this._font = data;
+      this.dirty = false;
+    }
+    updateTransform() {
+      this.validate();
+      this.containerUpdateTransform();
+    }
+    _render(renderer) {
+      if (this._autoResolution && this._resolution !== renderer.resolution) {
+        this._resolution = renderer.resolution;
+        this.dirty = true;
+      }
+      const { distanceFieldRange, distanceFieldType, size } = BitmapFont.available[this._fontName];
+      if (distanceFieldType !== "none") {
+        const { a, b, c, d } = this.worldTransform;
+        const dx = Math.sqrt(a * a + b * b);
+        const dy = Math.sqrt(c * c + d * d);
+        const worldScale = (Math.abs(dx) + Math.abs(dy)) / 2;
+        const fontScale = this.fontSize / size;
+        const resolution = renderer._view.resolution;
+        for (const mesh of this._activePagesMeshData) {
+          mesh.mesh.shader.uniforms.uFWidth = worldScale * distanceFieldRange * fontScale * resolution;
+        }
+      }
+      super._render(renderer);
+    }
+    getLocalBounds() {
+      this.validate();
+      return super.getLocalBounds();
+    }
+    validate() {
+      const font = BitmapFont.available[this._fontName];
+      if (!font) {
+        throw new Error(`Missing BitmapFont "${this._fontName}"`);
+      }
+      if (this._font !== font) {
+        this.dirty = true;
+      }
+      if (this.dirty) {
+        this.updateText();
+      }
+    }
+    get tint() {
+      return this._tintColor.value;
+    }
+    set tint(value) {
+      if (this.tint === value)
+        return;
+      this._tintColor.setValue(value);
+      for (let i = 0; i < this._activePagesMeshData.length; i++) {
+        this._activePagesMeshData[i].mesh.tint = value;
+      }
+    }
+    get align() {
+      return this._align;
+    }
+    set align(value) {
+      if (this._align !== value) {
+        this._align = value;
+        this.dirty = true;
+      }
+    }
+    get fontName() {
+      return this._fontName;
+    }
+    set fontName(value) {
+      if (!BitmapFont.available[value]) {
+        throw new Error(`Missing BitmapFont "${value}"`);
+      }
+      if (this._fontName !== value) {
+        this._fontName = value;
+        this.dirty = true;
+      }
+    }
+    get fontSize() {
+      return this._fontSize ?? BitmapFont.available[this._fontName].size;
+    }
+    set fontSize(value) {
+      if (this._fontSize !== value) {
+        this._fontSize = value;
+        this.dirty = true;
+      }
+    }
+    get anchor() {
+      return this._anchor;
+    }
+    set anchor(value) {
+      if (typeof value === "number") {
+        this._anchor.set(value);
+      } else {
+        this._anchor.copyFrom(value);
+      }
+    }
+    get text() {
+      return this._text;
+    }
+    set text(text) {
+      text = String(text === null || text === void 0 ? "" : text);
+      if (this._text === text) {
+        return;
+      }
+      this._text = text;
+      this.dirty = true;
+    }
+    get maxWidth() {
+      return this._maxWidth;
+    }
+    set maxWidth(value) {
+      if (this._maxWidth === value) {
+        return;
+      }
+      this._maxWidth = value;
+      this.dirty = true;
+    }
+    get maxLineHeight() {
+      this.validate();
+      return this._maxLineHeight;
+    }
+    get textWidth() {
+      this.validate();
+      return this._textWidth;
+    }
+    get letterSpacing() {
+      return this._letterSpacing;
+    }
+    set letterSpacing(value) {
+      if (this._letterSpacing !== value) {
+        this._letterSpacing = value;
+        this.dirty = true;
+      }
+    }
+    get roundPixels() {
+      return this._roundPixels;
+    }
+    set roundPixels(value) {
+      if (value !== this._roundPixels) {
+        this._roundPixels = value;
+        this.dirty = true;
+      }
+    }
+    get textHeight() {
+      this.validate();
+      return this._textHeight;
+    }
+    get resolution() {
+      return this._resolution;
+    }
+    set resolution(value) {
+      this._autoResolution = false;
+      if (this._resolution === value) {
+        return;
+      }
+      this._resolution = value;
+      this.dirty = true;
+    }
+    destroy(options) {
+      const { _textureCache } = this;
+      const data = BitmapFont.available[this._fontName];
+      const pageMeshDataPool = data.distanceFieldType === "none" ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;
+      pageMeshDataPool.push(...this._activePagesMeshData);
+      for (const pageMeshData of this._activePagesMeshData) {
+        this.removeChild(pageMeshData.mesh);
+      }
+      this._activePagesMeshData = [];
+      pageMeshDataPool.filter((page) => _textureCache[page.mesh.texture.baseTexture.uid]).forEach((page) => {
+        page.mesh.texture = Texture.EMPTY;
+      });
+      for (const id in _textureCache) {
+        const texture = _textureCache[id];
+        texture.destroy();
+        delete _textureCache[id];
+      }
+      this._font = null;
+      this._tintColor = null;
+      this._textureCache = null;
+      super.destroy(options);
+    }
+  };
+  let BitmapText = _BitmapText;
+  BitmapText.styleDefaults = {
+    align: "left",
+    tint: 16777215,
+    maxWidth: 0,
+    letterSpacing: 0
+  };
+
+  const validExtensions = [".xml", ".fnt"];
+  const loadBitmapFont = {
+    extension: {
+      type: ExtensionType.LoadParser,
+      priority: LoaderParserPriority.Normal
+    },
+    name: "loadBitmapFont",
+    test(url) {
+      return validExtensions.includes(path.extname(url).toLowerCase());
+    },
+    async testParse(data) {
+      return TextFormat.test(data) || XMLStringFormat.test(data);
+    },
+    async parse(asset, data, loader) {
+      const fontData = TextFormat.test(asset) ? TextFormat.parse(asset) : XMLStringFormat.parse(asset);
+      const { src } = data;
+      const { page: pages } = fontData;
+      const textureUrls = [];
+      for (let i = 0; i < pages.length; ++i) {
+        const pageFile = pages[i].file;
+        let imagePath = path.join(path.dirname(src), pageFile);
+        imagePath = copySearchParams(imagePath, src);
+        textureUrls.push(imagePath);
+      }
+      const loadedTextures = await loader.load(textureUrls);
+      const textures = textureUrls.map((url) => loadedTextures[url]);
+      return BitmapFont.install(fontData, textures, true);
+    },
+    async load(url, _options) {
+      const response = await settings.ADAPTER.fetch(url);
+      return response.text();
+    },
+    unload(bitmapFont) {
+      bitmapFont.destroy();
+    }
+  };
+  extensions$1.add(loadBitmapFont);
+
+  const _HTMLTextStyle = class extends TextStyle {
+    constructor() {
+      super(...arguments);
+      this._fonts = [];
+      this._overrides = [];
+      this._stylesheet = "";
+      this.fontsDirty = false;
+    }
+    static from(originalStyle) {
+      return new _HTMLTextStyle(Object.keys(_HTMLTextStyle.defaultOptions).reduce((obj, prop) => ({ ...obj, [prop]: originalStyle[prop] }), {}));
+    }
+    cleanFonts() {
+      if (this._fonts.length > 0) {
+        this._fonts.forEach((font) => {
+          URL.revokeObjectURL(font.src);
+          font.refs--;
+          if (font.refs === 0) {
+            if (font.fontFace) {
+              document.fonts.delete(font.fontFace);
+            }
+            delete _HTMLTextStyle.availableFonts[font.originalUrl];
+          }
+        });
+        this.fontFamily = "Arial";
+        this._fonts.length = 0;
+        this.styleID++;
+        this.fontsDirty = true;
+      }
+    }
+    loadFont(url, options = {}) {
+      const { availableFonts } = _HTMLTextStyle;
+      if (availableFonts[url]) {
+        const font = availableFonts[url];
+        this._fonts.push(font);
+        font.refs++;
+        this.styleID++;
+        this.fontsDirty = true;
+        return Promise.resolve();
+      }
+      return settings.ADAPTER.fetch(url).then((response) => response.blob()).then(async (blob) => new Promise((resolve, reject) => {
+        const src = URL.createObjectURL(blob);
+        const reader = new FileReader();
+        reader.onload = () => resolve([src, reader.result]);
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+      })).then(async ([src, dataSrc]) => {
+        const font = Object.assign({
+          family: path.basename(url, path.extname(url)),
+          weight: "normal",
+          style: "normal",
+          src,
+          dataSrc,
+          refs: 1,
+          originalUrl: url,
+          fontFace: null
+        }, options);
+        availableFonts[url] = font;
+        this._fonts.push(font);
+        this.styleID++;
+        const fontFace = new FontFace(font.family, `url(${font.src})`, {
+          weight: font.weight,
+          style: font.style
+        });
+        font.fontFace = fontFace;
+        await fontFace.load();
+        document.fonts.add(fontFace);
+        await document.fonts.ready;
+        this.styleID++;
+        this.fontsDirty = true;
+      });
+    }
+    addOverride(...value) {
+      const toAdd = value.filter((v) => !this._overrides.includes(v));
+      if (toAdd.length > 0) {
+        this._overrides.push(...toAdd);
+        this.styleID++;
+      }
+    }
+    removeOverride(...value) {
+      const toRemove = value.filter((v) => this._overrides.includes(v));
+      if (toRemove.length > 0) {
+        this._overrides = this._overrides.filter((v) => !toRemove.includes(v));
+        this.styleID++;
+      }
+    }
+    toCSS(scale) {
+      return [
+        `transform: scale(${scale})`,
+        `transform-origin: top left`,
+        "display: inline-block",
+        `color: ${this.normalizeColor(this.fill)}`,
+        `font-size: ${this.fontSize}px`,
+        `font-family: ${this.fontFamily}`,
+        `font-weight: ${this.fontWeight}`,
+        `font-style: ${this.fontStyle}`,
+        `font-variant: ${this.fontVariant}`,
+        `letter-spacing: ${this.letterSpacing}px`,
+        `text-align: ${this.align}`,
+        `padding: ${this.padding}px`,
+        `white-space: ${this.whiteSpace}`,
+        ...this.lineHeight ? [`line-height: ${this.lineHeight}px`] : [],
+        ...this.wordWrap ? [
+          `word-wrap: ${this.breakWords ? "break-all" : "break-word"}`,
+          `max-width: ${this.wordWrapWidth}px`
+        ] : [],
+        ...this.strokeThickness ? [
+          `-webkit-text-stroke-width: ${this.strokeThickness}px`,
+          `-webkit-text-stroke-color: ${this.normalizeColor(this.stroke)}`,
+          `text-stroke-width: ${this.strokeThickness}px`,
+          `text-stroke-color: ${this.normalizeColor(this.stroke)}`,
+          "paint-order: stroke"
+        ] : [],
+        ...this.dropShadow ? [this.dropShadowToCSS()] : [],
+        ...this._overrides
+      ].join(";");
+    }
+    toGlobalCSS() {
+      return this._fonts.reduce((result, font) => `${result}
+            @font-face {
+                font-family: "${font.family}";
+                src: url('${font.dataSrc}');
+                font-weight: ${font.weight};
+                font-style: ${font.style}; 
+            }`, this._stylesheet);
+    }
+    get stylesheet() {
+      return this._stylesheet;
+    }
+    set stylesheet(value) {
+      if (this._stylesheet !== value) {
+        this._stylesheet = value;
+        this.styleID++;
+      }
+    }
+    normalizeColor(color) {
+      if (Array.isArray(color)) {
+        color = rgb2hex(color);
+      }
+      if (typeof color === "number") {
+        return hex2string(color);
+      }
+      return color;
+    }
+    dropShadowToCSS() {
+      let color = this.normalizeColor(this.dropShadowColor);
+      const alpha = this.dropShadowAlpha;
+      const x = Math.round(Math.cos(this.dropShadowAngle) * this.dropShadowDistance);
+      const y = Math.round(Math.sin(this.dropShadowAngle) * this.dropShadowDistance);
+      if (color.startsWith("#") && alpha < 1) {
+        color += (alpha * 255 | 0).toString(16).padStart(2, "0");
+      }
+      const position = `${x}px ${y}px`;
+      if (this.dropShadowBlur > 0) {
+        return `text-shadow: ${position} ${this.dropShadowBlur}px ${color}`;
+      }
+      return `text-shadow: ${position} ${color}`;
+    }
+    reset() {
+      Object.assign(this, _HTMLTextStyle.defaultOptions);
+    }
+    onBeforeDraw() {
+      const { fontsDirty: prevFontsDirty } = this;
+      this.fontsDirty = false;
+      if (this.isSafari && this._fonts.length > 0 && prevFontsDirty) {
+        return new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      return Promise.resolve();
+    }
+    get isSafari() {
+      const { userAgent } = settings.ADAPTER.getNavigator();
+      return /^((?!chrome|android).)*safari/i.test(userAgent);
+    }
+    set fillGradientStops(_value) {
+      console.warn("[HTMLTextStyle] fillGradientStops is not supported by HTMLText");
+    }
+    get fillGradientStops() {
+      return super.fillGradientStops;
+    }
+    set fillGradientType(_value) {
+      console.warn("[HTMLTextStyle] fillGradientType is not supported by HTMLText");
+    }
+    get fillGradientType() {
+      return super.fillGradientType;
+    }
+    set miterLimit(_value) {
+      console.warn("[HTMLTextStyle] miterLimit is not supported by HTMLText");
+    }
+    get miterLimit() {
+      return super.miterLimit;
+    }
+    set trim(_value) {
+      console.warn("[HTMLTextStyle] trim is not supported by HTMLText");
+    }
+    get trim() {
+      return super.trim;
+    }
+    set textBaseline(_value) {
+      console.warn("[HTMLTextStyle] textBaseline is not supported by HTMLText");
+    }
+    get textBaseline() {
+      return super.textBaseline;
+    }
+    set leading(_value) {
+      console.warn("[HTMLTextStyle] leading is not supported by HTMLText");
+    }
+    get leading() {
+      return super.leading;
+    }
+    set lineJoin(_value) {
+      console.warn("[HTMLTextStyle] lineJoin is not supported by HTMLText");
+    }
+    get lineJoin() {
+      return super.lineJoin;
+    }
+  };
+  let HTMLTextStyle = _HTMLTextStyle;
+  HTMLTextStyle.availableFonts = {};
+  HTMLTextStyle.defaultOptions = {
+    align: "left",
+    breakWords: false,
+    dropShadow: false,
+    dropShadowAlpha: 1,
+    dropShadowAngle: Math.PI / 6,
+    dropShadowBlur: 0,
+    dropShadowColor: "black",
+    dropShadowDistance: 5,
+    fill: "black",
+    fontFamily: "Arial",
+    fontSize: 26,
+    fontStyle: "normal",
+    fontVariant: "normal",
+    fontWeight: "normal",
+    letterSpacing: 0,
+    lineHeight: 0,
+    padding: 0,
+    stroke: "black",
+    strokeThickness: 0,
+    whiteSpace: "normal",
+    wordWrap: false,
+    wordWrapWidth: 100
+  };
+
+  const _HTMLText = class extends Sprite {
+    constructor(text = "", style = {}) {
+      super(Texture.EMPTY);
+      this._text = null;
+      this._style = null;
+      this._autoResolution = true;
+      this._loading = false;
+      this.localStyleID = -1;
+      this.dirty = false;
+      this.ownsStyle = false;
+      const image = new Image();
+      const texture = Texture.from(image, {
+        scaleMode: settings.SCALE_MODE,
+        resourceOptions: {
+          autoLoad: false
+        }
+      });
+      texture.orig = new Rectangle();
+      texture.trim = new Rectangle();
+      this.texture = texture;
+      const nssvg = "http://www.w3.org/2000/svg";
+      const nsxhtml = "http://www.w3.org/1999/xhtml";
+      const svgRoot = document.createElementNS(nssvg, "svg");
+      const foreignObject = document.createElementNS(nssvg, "foreignObject");
+      const domElement = document.createElementNS(nsxhtml, "div");
+      const styleElement = document.createElementNS(nsxhtml, "style");
+      foreignObject.setAttribute("width", "10000");
+      foreignObject.setAttribute("height", "10000");
+      foreignObject.style.overflow = "hidden";
+      svgRoot.appendChild(foreignObject);
+      this.maxWidth = _HTMLText.defaultMaxWidth;
+      this.maxHeight = _HTMLText.defaultMaxHeight;
+      this._domElement = domElement;
+      this._styleElement = styleElement;
+      this._svgRoot = svgRoot;
+      this._foreignObject = foreignObject;
+      this._foreignObject.appendChild(styleElement);
+      this._foreignObject.appendChild(domElement);
+      this._image = image;
+      this._loadImage = new Image();
+      this._autoResolution = _HTMLText.defaultAutoResolution;
+      this._resolution = _HTMLText.defaultResolution ?? settings.RESOLUTION;
+      this.text = text;
+      this.style = style;
+    }
+    measureText(overrides) {
+      const { text, style, resolution } = Object.assign({
+        text: this._text,
+        style: this._style,
+        resolution: this._resolution
+      }, overrides);
+      Object.assign(this._domElement, {
+        innerHTML: text,
+        style: style.toCSS(resolution)
+      });
+      this._styleElement.textContent = style.toGlobalCSS();
+      document.body.appendChild(this._svgRoot);
+      const contentBounds = this._domElement.getBoundingClientRect();
+      this._svgRoot.remove();
+      const contentWidth = Math.min(this.maxWidth, Math.ceil(contentBounds.width));
+      const contentHeight = Math.min(this.maxHeight, Math.ceil(contentBounds.height));
+      this._svgRoot.setAttribute("width", contentWidth.toString());
+      this._svgRoot.setAttribute("height", contentHeight.toString());
+      if (text !== this._text) {
+        this._domElement.innerHTML = this._text;
+      }
+      if (style !== this._style) {
+        Object.assign(this._domElement, { style: this._style?.toCSS(resolution) });
+        this._styleElement.textContent = this._style?.toGlobalCSS();
+      }
+      return {
+        width: contentWidth + style.padding * 2,
+        height: contentHeight + style.padding * 2
+      };
+    }
+    async updateText(respectDirty = true) {
+      const { style, _image: image, _loadImage: loadImage } = this;
+      if (this.localStyleID !== style.styleID) {
+        this.dirty = true;
+        this.localStyleID = style.styleID;
+      }
+      if (!this.dirty && respectDirty) {
+        return;
+      }
+      const { width, height } = this.measureText();
+      image.width = loadImage.width = Math.ceil(Math.max(1, width));
+      image.height = loadImage.height = Math.ceil(Math.max(1, height));
+      if (!this._loading) {
+        this._loading = true;
+        await new Promise((resolve) => {
+          loadImage.onload = async () => {
+            await style.onBeforeDraw();
+            this._loading = false;
+            image.src = loadImage.src;
+            loadImage.onload = null;
+            loadImage.src = "";
+            this.updateTexture();
+            resolve();
+          };
+          const svgURL = new XMLSerializer().serializeToString(this._svgRoot);
+          loadImage.src = `data:image/svg+xml;charset=utf8,${encodeURIComponent(svgURL)}`;
+        });
+      }
+    }
+    get source() {
+      return this._image;
+    }
+    updateTexture() {
+      const { style, texture, _image: image, resolution } = this;
+      const { padding } = style;
+      const { baseTexture } = texture;
+      texture.trim.width = texture._frame.width = image.width / resolution;
+      texture.trim.height = texture._frame.height = image.height / resolution;
+      texture.trim.x = -padding;
+      texture.trim.y = -padding;
+      texture.orig.width = texture._frame.width - padding * 2;
+      texture.orig.height = texture._frame.height - padding * 2;
+      this._onTextureUpdate();
+      baseTexture.setRealSize(image.width, image.height, resolution);
+      this.dirty = false;
+    }
+    _render(renderer) {
+      if (this._autoResolution && this._resolution !== renderer.resolution) {
+        this._resolution = renderer.resolution;
+        this.dirty = true;
+      }
+      this.updateText(true);
+      super._render(renderer);
+    }
+    _renderCanvas(renderer) {
+      if (this._autoResolution && this._resolution !== renderer.resolution) {
+        this._resolution = renderer.resolution;
+        this.dirty = true;
+      }
+      this.updateText(true);
+      super._renderCanvas(renderer);
+    }
+    getLocalBounds(rect) {
+      this.updateText(true);
+      return super.getLocalBounds(rect);
+    }
+    _calculateBounds() {
+      this.updateText(true);
+      this.calculateVertices();
+      this._bounds.addQuad(this.vertexData);
+    }
+    _onStyleChange() {
+      this.dirty = true;
+    }
+    destroy(options) {
+      if (typeof options === "boolean") {
+        options = { children: options };
+      }
+      options = Object.assign({}, _HTMLText.defaultDestroyOptions, options);
+      super.destroy(options);
+      const forceClear = null;
+      if (this.ownsStyle) {
+        this._style?.cleanFonts();
+      }
+      this._style = forceClear;
+      this._svgRoot?.remove();
+      this._svgRoot = forceClear;
+      this._domElement?.remove();
+      this._domElement = forceClear;
+      this._foreignObject?.remove();
+      this._foreignObject = forceClear;
+      this._styleElement?.remove();
+      this._styleElement = forceClear;
+      this._loadImage.src = "";
+      this._loadImage.onload = null;
+      this._loadImage = forceClear;
+      this._image.src = "";
+      this._image = forceClear;
+    }
+    get width() {
+      this.updateText(true);
+      return Math.abs(this.scale.x) * this._image.width / this.resolution;
+    }
+    set width(value) {
+      this.updateText(true);
+      const s = sign(this.scale.x) || 1;
+      this.scale.x = s * value / this._image.width / this.resolution;
+      this._width = value;
+    }
+    get height() {
+      this.updateText(true);
+      return Math.abs(this.scale.y) * this._image.height / this.resolution;
+    }
+    set height(value) {
+      this.updateText(true);
+      const s = sign(this.scale.y) || 1;
+      this.scale.y = s * value / this._image.height / this.resolution;
+      this._height = value;
+    }
+    get style() {
+      return this._style;
+    }
+    set style(style) {
+      if (this._style === style) {
+        return;
+      }
+      style = style || {};
+      if (style instanceof HTMLTextStyle) {
+        this.ownsStyle = false;
+        this._style = style;
+      } else if (style instanceof TextStyle) {
+        console.warn("[HTMLText] Cloning TextStyle, if this is not what you want, use HTMLTextStyle");
+        this.ownsStyle = true;
+        this._style = HTMLTextStyle.from(style);
+      } else {
+        this.ownsStyle = true;
+        this._style = new HTMLTextStyle(style);
+      }
+      this.localStyleID = -1;
+      this.dirty = true;
+    }
+    get text() {
+      return this._text;
+    }
+    set text(text) {
+      text = String(text === "" || text === null || text === void 0 ? " " : text);
+      text = this.sanitiseText(text);
+      if (this._text === text) {
+        return;
+      }
+      this._text = text;
+      this.dirty = true;
+    }
+    get resolution() {
+      return this._resolution;
+    }
+    set resolution(value) {
+      this._autoResolution = false;
+      if (this._resolution === value) {
+        return;
+      }
+      this._resolution = value;
+      this.dirty = true;
+    }
+    sanitiseText(text) {
+      return text.replace(/<br>/gi, "<br/>").replace(/<hr>/gi, "<hr/>").replace(/&nbsp;/gi, "&#160;");
+    }
+  };
+  let HTMLText = _HTMLText;
+  HTMLText.defaultDestroyOptions = {
+    texture: true,
+    children: false,
+    baseTexture: true
+  };
+  HTMLText.defaultMaxWidth = 2024;
+  HTMLText.defaultMaxHeight = 2024;
+  HTMLText.defaultAutoResolution = true;
+
+  const TEMP_RECT = new Rectangle();
+  class CanvasExtract {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    async image(target, format, quality) {
+      const image = new Image();
+      image.src = await this.base64(target, format, quality);
+      return image;
+    }
+    async base64(target, format, quality) {
+      const canvas = this.canvas(target);
+      if (canvas.toBlob !== void 0) {
+        return new Promise((resolve, reject) => {
+          canvas.toBlob((blob) => {
+            if (!blob) {
+              reject(new Error("ICanvas.toBlob failed!"));
+              return;
+            }
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+          }, format, quality);
+        });
+      }
+      if (canvas.toDataURL !== void 0) {
+        return canvas.toDataURL(format, quality);
+      }
+      if (canvas.convertToBlob !== void 0) {
+        const blob = await canvas.convertToBlob({ type: format, quality });
+        return new Promise((resolve, reject) => {
+          const reader = new FileReader();
+          reader.onload = () => resolve(reader.result);
+          reader.onerror = reject;
+          reader.readAsDataURL(blob);
+        });
+      }
+      throw new Error("CanvasExtract.base64() requires ICanvas.toDataURL, ICanvas.toBlob, or ICanvas.convertToBlob to be implemented");
+    }
+    canvas(target, frame) {
+      const renderer = this.renderer;
+      if (!renderer) {
+        throw new Error("The CanvasExtract has already been destroyed");
+      }
+      let context;
+      let resolution;
+      let renderTexture;
+      if (target) {
+        if (target instanceof RenderTexture) {
+          renderTexture = target;
+        } else {
+          renderTexture = renderer.generateTexture(target, {
+            resolution: renderer.resolution
+          });
+        }
+      }
+      if (renderTexture) {
+        context = renderTexture.baseTexture._canvasRenderTarget.context;
+        resolution = renderTexture.baseTexture._canvasRenderTarget.resolution;
+        frame = frame ?? renderTexture.frame;
+      } else {
+        context = renderer.canvasContext.rootContext;
+        resolution = renderer._view.resolution;
+        if (!frame) {
+          frame = TEMP_RECT;
+          frame.width = renderer.width / resolution;
+          frame.height = renderer.height / resolution;
+        }
+      }
+      const x = Math.round(frame.x * resolution);
+      const y = Math.round(frame.y * resolution);
+      const width = Math.round(frame.width * resolution);
+      const height = Math.round(frame.height * resolution);
+      const canvasBuffer = new CanvasRenderTarget(width, height, 1);
+      const canvasData = context.getImageData(x, y, width, height);
+      canvasBuffer.context.putImageData(canvasData, 0, 0);
+      return canvasBuffer.canvas;
+    }
+    pixels(target, frame) {
+      const renderer = this.renderer;
+      if (!renderer) {
+        throw new Error("The CanvasExtract has already been destroyed");
+      }
+      let context;
+      let resolution;
+      let renderTexture;
+      if (target) {
+        if (target instanceof RenderTexture) {
+          renderTexture = target;
+        } else {
+          renderTexture = renderer.generateTexture(target, {
+            resolution: renderer.resolution
+          });
+        }
+      }
+      if (renderTexture) {
+        context = renderTexture.baseTexture._canvasRenderTarget.context;
+        resolution = renderTexture.baseTexture._canvasRenderTarget.resolution;
+        frame = frame ?? renderTexture.frame;
+      } else {
+        context = renderer.canvasContext.rootContext;
+        resolution = renderer.resolution;
+        if (!frame) {
+          frame = TEMP_RECT;
+          frame.width = renderer.width / resolution;
+          frame.height = renderer.height / resolution;
+        }
+      }
+      const x = Math.round(frame.x * resolution);
+      const y = Math.round(frame.y * resolution);
+      const width = Math.round(frame.width * resolution);
+      const height = Math.round(frame.height * resolution);
+      return context.getImageData(x, y, width, height).data;
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  CanvasExtract.extension = {
+    name: "extract",
+    type: ExtensionType.CanvasRendererSystem
+  };
+  extensions$1.add(CanvasExtract);
+
+  let canvasRenderer;
+  const tempMatrix = new Matrix();
+  Graphics.prototype.generateCanvasTexture = function generateCanvasTexture(scaleMode, resolution = 1) {
+    const bounds = this.getLocalBounds();
+    const canvasBuffer = RenderTexture.create({
+      width: bounds.width,
+      height: bounds.height,
+      scaleMode,
+      resolution
+    });
+    if (!canvasRenderer) {
+      canvasRenderer = new CanvasRenderer();
+    }
+    this.transform.updateLocalTransform();
+    this.transform.localTransform.copyTo(tempMatrix);
+    tempMatrix.invert();
+    tempMatrix.tx -= bounds.x;
+    tempMatrix.ty -= bounds.y;
+    canvasRenderer.render(this, { renderTexture: canvasBuffer, clear: true, transform: tempMatrix });
+    const texture = Texture.from(canvasBuffer.baseTexture._canvasRenderTarget.canvas, { scaleMode });
+    texture.baseTexture.setResolution(resolution);
+    return texture;
+  };
+  Graphics.prototype.cachedGraphicsData = [];
+  Graphics.prototype._renderCanvas = function _renderCanvas(renderer) {
+    if (this.isMask === true) {
+      return;
+    }
+    this.finishPoly();
+    renderer.plugins.graphics.render(this);
+  };
+
+  class PolygonUtils {
+    static offsetPolygon(points, offset) {
+      const offsetPoints = [];
+      const length = points.length;
+      offset = PolygonUtils.isPolygonClockwise(points) ? offset : -1 * offset;
+      for (let j = 0; j < length; j += 2) {
+        let i = j - 2;
+        if (i < 0) {
+          i += length;
+        }
+        const k = (j + 2) % length;
+        let v1x = points[j] - points[i];
+        let v1y = points[j + 1] - points[i + 1];
+        let len = Math.sqrt(v1x * v1x + v1y * v1y);
+        v1x /= len;
+        v1y /= len;
+        v1x *= offset;
+        v1y *= offset;
+        const norm1x = -v1y;
+        const norm1y = v1x;
+        const pij1 = [points[i] + norm1x, points[i + 1] + norm1y];
+        const pij2 = [points[j] + norm1x, points[j + 1] + norm1y];
+        let v2x = points[k] - points[j];
+        let v2y = points[k + 1] - points[j + 1];
+        len = Math.sqrt(v2x * v2x + v2y * v2y);
+        v2x /= len;
+        v2y /= len;
+        v2x *= offset;
+        v2y *= offset;
+        const norm2x = -v2y;
+        const norm2y = v2x;
+        const pjk1 = [points[j] + norm2x, points[j + 1] + norm2y];
+        const pjk2 = [points[k] + norm2x, points[k + 1] + norm2y];
+        const intersectPoint = PolygonUtils.findIntersection(pij1[0], pij1[1], pij2[0], pij2[1], pjk1[0], pjk1[1], pjk2[0], pjk2[1]);
+        if (intersectPoint) {
+          offsetPoints.push(...intersectPoint);
+        }
+      }
+      return offsetPoints;
+    }
+    static findIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {
+      const denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+      const numeratorA = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+      const numeratorB = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+      if (denominator === 0) {
+        if (numeratorA === 0 && numeratorB === 0) {
+          return [(x1 + x2) / 2, (y1 + y2) / 2];
+        }
+        return null;
+      }
+      const uA = numeratorA / denominator;
+      return [x1 + uA * (x2 - x1), y1 + uA * (y2 - y1)];
+    }
+    static isPolygonClockwise(polygon) {
+      let sum = 0;
+      for (let i = 0, j = polygon.length - 2; i < polygon.length; j = i, i += 2) {
+        sum += (polygon[i] - polygon[j]) * (polygon[i + 1] + polygon[j + 1]);
+      }
+      return sum > 0;
+    }
+  }
+
+  class CanvasGraphicsRenderer {
+    constructor(renderer) {
+      this._svgMatrix = null;
+      this._tempMatrix = new Matrix();
+      this.renderer = renderer;
+    }
+    _calcCanvasStyle(style, tint) {
+      let res;
+      if (style.texture && style.texture.baseTexture !== Texture.WHITE.baseTexture) {
+        if (style.texture.valid) {
+          res = canvasUtils.getTintedPattern(style.texture, tint);
+          this.setPatternTransform(res, style.matrix || Matrix.IDENTITY);
+        } else {
+          res = "#808080";
+        }
+      } else {
+        res = `#${`00000${(tint | 0).toString(16)}`.slice(-6)}`;
+      }
+      return res;
+    }
+    render(graphics) {
+      const renderer = this.renderer;
+      const context = renderer.canvasContext.activeContext;
+      const worldAlpha = graphics.worldAlpha;
+      const transform = graphics.transform.worldTransform;
+      renderer.canvasContext.setContextTransform(transform);
+      renderer.canvasContext.setBlendMode(graphics.blendMode);
+      const graphicsData = graphics.geometry.graphicsData;
+      let contextFillStyle;
+      let contextStrokeStyle;
+      const tint = Color.shared.setValue(graphics.tint).toArray();
+      for (let i = 0; i < graphicsData.length; i++) {
+        const data = graphicsData[i];
+        const shape = data.shape;
+        const fillStyle = data.fillStyle;
+        const lineStyle = data.lineStyle;
+        const fillColor = data.fillStyle.color | 0;
+        const lineColor = data.lineStyle.color | 0;
+        if (data.matrix) {
+          renderer.canvasContext.setContextTransform(transform.copyTo(this._tempMatrix).append(data.matrix));
+        }
+        if (fillStyle.visible) {
+          contextFillStyle = this._calcCanvasStyle(fillStyle, Color.shared.setValue(fillColor).multiply(tint).toNumber());
+        }
+        if (lineStyle.visible) {
+          contextStrokeStyle = this._calcCanvasStyle(lineStyle, Color.shared.setValue(lineColor).multiply(tint).toNumber());
+        }
+        context.lineWidth = lineStyle.width;
+        context.lineCap = lineStyle.cap;
+        context.lineJoin = lineStyle.join;
+        context.miterLimit = lineStyle.miterLimit;
+        if (data.type === SHAPES.POLY) {
+          context.beginPath();
+          const tempShape = shape;
+          let points = tempShape.points;
+          const holes = data.holes;
+          let outerArea;
+          let innerArea;
+          let px;
+          let py;
+          let holesDirection;
+          context.moveTo(points[0], points[1]);
+          for (let j = 2; j < points.length; j += 2) {
+            context.lineTo(points[j], points[j + 1]);
+          }
+          if (tempShape.closeStroke) {
+            context.closePath();
+          }
+          if (holes.length > 0) {
+            holesDirection = [];
+            outerArea = 0;
+            px = points[0];
+            py = points[1];
+            for (let j = 2; j + 2 < points.length; j += 2) {
+              outerArea += (points[j] - px) * (points[j + 3] - py) - (points[j + 2] - px) * (points[j + 1] - py);
+            }
+            for (let k = 0; k < holes.length; k++) {
+              points = holes[k].shape.points;
+              if (!points) {
+                continue;
+              }
+              innerArea = 0;
+              px = points[0];
+              py = points[1];
+              for (let j = 2; j + 2 < points.length; j += 2) {
+                innerArea += (points[j] - px) * (points[j + 3] - py) - (points[j + 2] - px) * (points[j + 1] - py);
+              }
+              if (innerArea * outerArea < 0) {
+                context.moveTo(points[0], points[1]);
+                for (let j = 2; j < points.length; j += 2) {
+                  context.lineTo(points[j], points[j + 1]);
+                }
+              } else {
+                context.moveTo(points[points.length - 2], points[points.length - 1]);
+                for (let j = points.length - 4; j >= 0; j -= 2) {
+                  context.lineTo(points[j], points[j + 1]);
+                }
+              }
+              if (holes[k].shape.closeStroke) {
+                context.closePath();
+              }
+              holesDirection[k] = innerArea * outerArea < 0;
+            }
+          }
+          if (fillStyle.visible) {
+            context.globalAlpha = fillStyle.alpha * worldAlpha;
+            context.fillStyle = contextFillStyle;
+            context.fill();
+          }
+          if (lineStyle.visible) {
+            this.paintPolygonStroke(tempShape, lineStyle, contextStrokeStyle, holes, holesDirection, worldAlpha, context);
+          }
+        } else if (data.type === SHAPES.RECT) {
+          const tempShape = shape;
+          if (fillStyle.visible) {
+            context.globalAlpha = fillStyle.alpha * worldAlpha;
+            context.fillStyle = contextFillStyle;
+            context.fillRect(tempShape.x, tempShape.y, tempShape.width, tempShape.height);
+          }
+          if (lineStyle.visible) {
+            const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));
+            const width = tempShape.width + 2 * alignmentOffset;
+            const height = tempShape.height + 2 * alignmentOffset;
+            context.globalAlpha = lineStyle.alpha * worldAlpha;
+            context.strokeStyle = contextStrokeStyle;
+            context.strokeRect(tempShape.x - alignmentOffset, tempShape.y - alignmentOffset, width, height);
+          }
+        } else if (data.type === SHAPES.CIRC) {
+          const tempShape = shape;
+          context.beginPath();
+          context.arc(tempShape.x, tempShape.y, tempShape.radius, 0, 2 * Math.PI);
+          context.closePath();
+          if (fillStyle.visible) {
+            context.globalAlpha = fillStyle.alpha * worldAlpha;
+            context.fillStyle = contextFillStyle;
+            context.fill();
+          }
+          if (lineStyle.visible) {
+            if (lineStyle.alignment !== 0.5) {
+              const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));
+              context.beginPath();
+              context.arc(tempShape.x, tempShape.y, tempShape.radius + alignmentOffset, 0, 2 * Math.PI);
+              context.closePath();
+            }
+            context.globalAlpha = lineStyle.alpha * worldAlpha;
+            context.strokeStyle = contextStrokeStyle;
+            context.stroke();
+          }
+        } else if (data.type === SHAPES.ELIP) {
+          const tempShape = shape;
+          const drawShapeOverStroke = lineStyle.alignment === 1;
+          if (!drawShapeOverStroke) {
+            this.paintEllipse(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);
+          }
+          if (lineStyle.visible) {
+            if (lineStyle.alignment !== 0.5) {
+              const kappa = 0.5522848;
+              const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));
+              const sW = (tempShape.width + alignmentOffset) * 2;
+              const sH = (tempShape.height + alignmentOffset) * 2;
+              const sX = tempShape.x - sW / 2;
+              const sY = tempShape.y - sH / 2;
+              const sOx = sW / 2 * kappa;
+              const sOy = sH / 2 * kappa;
+              const sXe = sX + sW;
+              const sYe = sY + sH;
+              const sXm = sX + sW / 2;
+              const sYm = sY + sH / 2;
+              context.beginPath();
+              context.moveTo(sX, sYm);
+              context.bezierCurveTo(sX, sYm - sOy, sXm - sOx, sY, sXm, sY);
+              context.bezierCurveTo(sXm + sOx, sY, sXe, sYm - sOy, sXe, sYm);
+              context.bezierCurveTo(sXe, sYm + sOy, sXm + sOx, sYe, sXm, sYe);
+              context.bezierCurveTo(sXm - sOx, sYe, sX, sYm + sOy, sX, sYm);
+              context.closePath();
+            }
+            context.globalAlpha = lineStyle.alpha * worldAlpha;
+            context.strokeStyle = contextStrokeStyle;
+            context.stroke();
+          }
+          if (drawShapeOverStroke) {
+            this.paintEllipse(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);
+          }
+        } else if (data.type === SHAPES.RREC) {
+          const tempShape = shape;
+          const drawShapeOverStroke = lineStyle.alignment === 1;
+          if (!drawShapeOverStroke) {
+            this.paintRoundedRectangle(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);
+          }
+          if (lineStyle.visible) {
+            if (lineStyle.alignment !== 0.5) {
+              const width = tempShape.width;
+              const height = tempShape.height;
+              const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));
+              const sRx = tempShape.x - alignmentOffset;
+              const sRy = tempShape.y - alignmentOffset;
+              const sWidth = tempShape.width + 2 * alignmentOffset;
+              const sHeight = tempShape.height + 2 * alignmentOffset;
+              const radiusOffset = alignmentOffset * (lineStyle.alignment >= 1 ? Math.min(sWidth / width, sHeight / height) : Math.min(width / sWidth, height / sHeight));
+              let sRadius = tempShape.radius + radiusOffset;
+              const sMaxRadius = Math.min(sWidth, sHeight) / 2;
+              sRadius = sRadius > sMaxRadius ? sMaxRadius : sRadius;
+              context.beginPath();
+              context.moveTo(sRx, sRy + sRadius);
+              context.lineTo(sRx, sRy + sHeight - sRadius);
+              context.quadraticCurveTo(sRx, sRy + sHeight, sRx + sRadius, sRy + sHeight);
+              context.lineTo(sRx + sWidth - sRadius, sRy + sHeight);
+              context.quadraticCurveTo(sRx + sWidth, sRy + sHeight, sRx + sWidth, sRy + sHeight - sRadius);
+              context.lineTo(sRx + sWidth, sRy + sRadius);
+              context.quadraticCurveTo(sRx + sWidth, sRy, sRx + sWidth - sRadius, sRy);
+              context.lineTo(sRx + sRadius, sRy);
+              context.quadraticCurveTo(sRx, sRy, sRx, sRy + sRadius);
+              context.closePath();
+            }
+            context.globalAlpha = lineStyle.alpha * worldAlpha;
+            context.strokeStyle = contextStrokeStyle;
+            context.stroke();
+          }
+          if (drawShapeOverStroke) {
+            this.paintRoundedRectangle(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);
+          }
+        }
+      }
+    }
+    paintPolygonStroke(shape, lineStyle, contextStrokeStyle, holes, holesDirection, worldAlpha, context) {
+      if (lineStyle.alignment !== 0.5) {
+        const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));
+        let offsetPoints = PolygonUtils.offsetPolygon(shape.points, alignmentOffset);
+        let points;
+        context.beginPath();
+        context.moveTo(offsetPoints[0], offsetPoints[1]);
+        for (let j = 2; j < offsetPoints.length; j += 2) {
+          context.lineTo(offsetPoints[j], offsetPoints[j + 1]);
+        }
+        if (shape.closeStroke) {
+          context.closePath();
+        }
+        for (let k = 0; k < holes.length; k++) {
+          points = holes[k].shape.points;
+          offsetPoints = PolygonUtils.offsetPolygon(points, alignmentOffset);
+          if (holesDirection[k]) {
+            context.moveTo(offsetPoints[0], offsetPoints[1]);
+            for (let j = 2; j < offsetPoints.length; j += 2) {
+              context.lineTo(offsetPoints[j], offsetPoints[j + 1]);
+            }
+          } else {
+            context.moveTo(offsetPoints[offsetPoints.length - 2], offsetPoints[offsetPoints.length - 1]);
+            for (let j = offsetPoints.length - 4; j >= 0; j -= 2) {
+              context.lineTo(offsetPoints[j], offsetPoints[j + 1]);
+            }
+          }
+          if (holes[k].shape.closeStroke) {
+            context.closePath();
+          }
+        }
+      }
+      context.globalAlpha = lineStyle.alpha * worldAlpha;
+      context.strokeStyle = contextStrokeStyle;
+      context.stroke();
+    }
+    paintEllipse(shape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context) {
+      const w = shape.width * 2;
+      const h = shape.height * 2;
+      const x = shape.x - w / 2;
+      const y = shape.y - h / 2;
+      const kappa = 0.5522848;
+      const ox = w / 2 * kappa;
+      const oy = h / 2 * kappa;
+      const xe = x + w;
+      const ye = y + h;
+      const xm = x + w / 2;
+      const ym = y + h / 2;
+      if (lineStyle.alignment === 0) {
+        context.save();
+      }
+      context.beginPath();
+      context.moveTo(x, ym);
+      context.bezierCurveTo(x, ym - oy, xm - ox, y, xm, y);
+      context.bezierCurveTo(xm + ox, y, xe, ym - oy, xe, ym);
+      context.bezierCurveTo(xe, ym + oy, xm + ox, ye, xm, ye);
+      context.bezierCurveTo(xm - ox, ye, x, ym + oy, x, ym);
+      context.closePath();
+      if (lineStyle.alignment === 0) {
+        context.clip();
+      }
+      if (fillStyle.visible) {
+        context.globalAlpha = fillStyle.alpha * worldAlpha;
+        context.fillStyle = contextFillStyle;
+        context.fill();
+      }
+      if (lineStyle.alignment === 0) {
+        context.restore();
+      }
+    }
+    paintRoundedRectangle(shape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context) {
+      const rx = shape.x;
+      const ry = shape.y;
+      const width = shape.width;
+      const height = shape.height;
+      let radius = shape.radius;
+      const maxRadius = Math.min(width, height) / 2;
+      radius = radius > maxRadius ? maxRadius : radius;
+      if (lineStyle.alignment === 0) {
+        context.save();
+      }
+      context.beginPath();
+      context.moveTo(rx, ry + radius);
+      context.lineTo(rx, ry + height - radius);
+      context.quadraticCurveTo(rx, ry + height, rx + radius, ry + height);
+      context.lineTo(rx + width - radius, ry + height);
+      context.quadraticCurveTo(rx + width, ry + height, rx + width, ry + height - radius);
+      context.lineTo(rx + width, ry + radius);
+      context.quadraticCurveTo(rx + width, ry, rx + width - radius, ry);
+      context.lineTo(rx + radius, ry);
+      context.quadraticCurveTo(rx, ry, rx, ry + radius);
+      context.closePath();
+      if (lineStyle.alignment === 0) {
+        context.clip();
+      }
+      if (fillStyle.visible) {
+        context.globalAlpha = fillStyle.alpha * worldAlpha;
+        context.fillStyle = contextFillStyle;
+        context.fill();
+      }
+      if (lineStyle.alignment === 0) {
+        context.restore();
+      }
+    }
+    setPatternTransform(pattern, matrix) {
+      if (this._svgMatrix === false) {
+        return;
+      }
+      if (!this._svgMatrix) {
+        const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+        if (svg?.createSVGMatrix) {
+          this._svgMatrix = svg.createSVGMatrix();
+        }
+        if (!this._svgMatrix || !pattern.setTransform) {
+          this._svgMatrix = false;
+          return;
+        }
+      }
+      this._svgMatrix.a = matrix.a;
+      this._svgMatrix.b = matrix.b;
+      this._svgMatrix.c = matrix.c;
+      this._svgMatrix.d = matrix.d;
+      this._svgMatrix.e = matrix.tx;
+      this._svgMatrix.f = matrix.ty;
+      pattern.setTransform(this._svgMatrix.inverse());
+    }
+    destroy() {
+      this.renderer = null;
+      this._svgMatrix = null;
+      this._tempMatrix = null;
+    }
+  }
+  CanvasGraphicsRenderer.extension = {
+    name: "graphics",
+    type: ExtensionType.CanvasRendererPlugin
+  };
+  extensions$1.add(CanvasGraphicsRenderer);
+
+  Object.defineProperties(settings, {
+    MESH_CANVAS_PADDING: {
+      get() {
+        return Mesh.defaultCanvasPadding;
+      },
+      set(value) {
+        deprecation$1("7.1.0", "settings.MESH_CANVAS_PADDING is deprecated, use Mesh.defaultCanvasPadding");
+        Mesh.defaultCanvasPadding = value;
+      }
+    }
+  });
+
+  MeshMaterial.prototype._renderCanvas = function _renderCanvas(renderer, mesh) {
+    renderer.plugins.mesh.render(mesh);
+  };
+
+  NineSlicePlane.prototype._cachedTint = 16777215;
+  NineSlicePlane.prototype._tintedCanvas = null;
+  NineSlicePlane.prototype._canvasUvs = null;
+  NineSlicePlane.prototype._renderCanvas = function _renderCanvas(renderer) {
+    const context = renderer.canvasContext.activeContext;
+    const transform = this.worldTransform;
+    const isTinted = this.tintValue !== 16777215;
+    const texture = this.texture;
+    if (!texture.valid) {
+      return;
+    }
+    if (isTinted) {
+      if (this._cachedTint !== this.tintValue) {
+        this._cachedTint = this.tintValue;
+        this._tintedCanvas = canvasUtils.getTintedCanvas(this, this.tintValue);
+      }
+    }
+    const textureSource = !isTinted ? texture.baseTexture.getDrawableSource() : this._tintedCanvas;
+    if (!this._canvasUvs) {
+      this._canvasUvs = [0, 0, 0, 0, 0, 0, 0, 0];
+    }
+    const vertices = this.vertices;
+    const uvs = this._canvasUvs;
+    const u0 = isTinted ? 0 : texture.frame.x;
+    const v0 = isTinted ? 0 : texture.frame.y;
+    const u1 = u0 + texture.frame.width;
+    const v1 = v0 + texture.frame.height;
+    uvs[0] = u0;
+    uvs[1] = u0 + this._leftWidth;
+    uvs[2] = u1 - this._rightWidth;
+    uvs[3] = u1;
+    uvs[4] = v0;
+    uvs[5] = v0 + this._topHeight;
+    uvs[6] = v1 - this._bottomHeight;
+    uvs[7] = v1;
+    for (let i = 0; i < 8; i++) {
+      uvs[i] *= texture.baseTexture.resolution;
+    }
+    context.globalAlpha = this.worldAlpha;
+    renderer.canvasContext.setBlendMode(this.blendMode);
+    renderer.canvasContext.setContextTransform(transform, this.roundPixels);
+    for (let row = 0; row < 3; row++) {
+      for (let col = 0; col < 3; col++) {
+        const ind = col * 2 + row * 8;
+        const sw = Math.max(1, uvs[col + 1] - uvs[col]);
+        const sh = Math.max(1, uvs[row + 5] - uvs[row + 4]);
+        const dw = Math.max(1, vertices[ind + 10] - vertices[ind]);
+        const dh = Math.max(1, vertices[ind + 11] - vertices[ind + 1]);
+        context.drawImage(textureSource, uvs[col], uvs[row + 4], sw, sh, vertices[ind], vertices[ind + 1], dw, dh);
+      }
+    }
+  };
+
+  let warned = false;
+  Mesh.prototype._cachedTint = 16777215;
+  Mesh.prototype._tintedCanvas = null;
+  Mesh.prototype._cachedTexture = null;
+  Mesh.prototype._renderCanvas = function _renderCanvas(renderer) {
+    if (this.shader.uvMatrix) {
+      this.shader.uvMatrix.update();
+      this.calculateUvs();
+    }
+    if (this.material._renderCanvas) {
+      this.material._renderCanvas(renderer, this);
+    } else if (!warned) {
+      warned = true;
+      globalThis.console.warn("Mesh with custom shaders are not supported in CanvasRenderer.");
+    }
+  };
+  Mesh.prototype._canvasPadding = null;
+  Mesh.defaultCanvasPadding = 0;
+  Object.defineProperty(Mesh.prototype, "canvasPadding", {
+    get() {
+      return this._canvasPadding ?? Mesh.defaultCanvasPadding;
+    },
+    set(value) {
+      this._canvasPadding = value;
+    }
+  });
+
+  SimpleMesh.prototype._renderCanvas = function _renderCanvas(renderer) {
+    if (this.autoUpdate) {
+      this.geometry.getBuffer("aVertexPosition").update();
+    }
+    if (this.shader.update) {
+      this.shader.update();
+    }
+    this.calculateUvs();
+    this.material._renderCanvas(renderer, this);
+  };
+
+  SimpleRope.prototype._renderCanvas = function _renderCanvas(renderer) {
+    if (this.autoUpdate || this.geometry._width !== this.shader.texture.height) {
+      this.geometry._width = this.shader.texture.height;
+      this.geometry.update();
+    }
+    if (this.shader.update) {
+      this.shader.update();
+    }
+    this.calculateUvs();
+    this.material._renderCanvas(renderer, this);
+  };
+
+  class CanvasMeshRenderer {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    render(mesh) {
+      const renderer = this.renderer;
+      const transform = mesh.worldTransform;
+      renderer.canvasContext.activeContext.globalAlpha = mesh.worldAlpha;
+      renderer.canvasContext.setBlendMode(mesh.blendMode);
+      renderer.canvasContext.setContextTransform(transform, mesh.roundPixels);
+      if (mesh.drawMode !== DRAW_MODES.TRIANGLES) {
+        this._renderTriangleMesh(mesh);
+      } else {
+        this._renderTriangles(mesh);
+      }
+    }
+    _renderTriangleMesh(mesh) {
+      const length = mesh.geometry.buffers[0].data.length;
+      for (let i = 0; i < length - 2; i++) {
+        const index = i * 2;
+        this._renderDrawTriangle(mesh, index, index + 2, index + 4);
+      }
+    }
+    _renderTriangles(mesh) {
+      const indices = mesh.geometry.getIndex().data;
+      const length = indices.length;
+      for (let i = 0; i < length; i += 3) {
+        const index0 = indices[i] * 2;
+        const index1 = indices[i + 1] * 2;
+        const index2 = indices[i + 2] * 2;
+        this._renderDrawTriangle(mesh, index0, index1, index2);
+      }
+    }
+    _renderDrawTriangle(mesh, index0, index1, index2) {
+      const context = this.renderer.canvasContext.activeContext;
+      const vertices = mesh.geometry.buffers[0].data;
+      const { uvs, texture } = mesh;
+      if (!texture.valid) {
+        return;
+      }
+      const isTinted = mesh.tintValue !== 16777215;
+      const base = texture.baseTexture;
+      const textureWidth = base.width;
+      const textureHeight = base.height;
+      if (mesh._cachedTexture && mesh._cachedTexture.baseTexture !== base) {
+        mesh._cachedTint = 16777215;
+        mesh._cachedTexture?.destroy();
+        mesh._cachedTexture = null;
+        mesh._tintedCanvas = null;
+      }
+      if (isTinted) {
+        if (mesh._cachedTint !== mesh.tintValue) {
+          mesh._cachedTint = mesh.tintValue;
+          mesh._cachedTexture = mesh._cachedTexture || new Texture(base);
+          mesh._tintedCanvas = canvasUtils.getTintedCanvas({ texture: mesh._cachedTexture }, mesh.tintValue);
+        }
+      }
+      const textureSource = isTinted ? mesh._tintedCanvas : base.getDrawableSource();
+      const u0 = uvs[index0] * base.width;
+      const u1 = uvs[index1] * base.width;
+      const u2 = uvs[index2] * base.width;
+      const v0 = uvs[index0 + 1] * base.height;
+      const v1 = uvs[index1 + 1] * base.height;
+      const v2 = uvs[index2 + 1] * base.height;
+      let x0 = vertices[index0];
+      let x1 = vertices[index1];
+      let x2 = vertices[index2];
+      let y0 = vertices[index0 + 1];
+      let y1 = vertices[index1 + 1];
+      let y2 = vertices[index2 + 1];
+      const screenPadding = mesh.canvasPadding / this.renderer.canvasContext.activeResolution;
+      if (screenPadding > 0) {
+        const { a, b, c, d } = mesh.worldTransform;
+        const centerX = (x0 + x1 + x2) / 3;
+        const centerY = (y0 + y1 + y2) / 3;
+        let normX = x0 - centerX;
+        let normY = y0 - centerY;
+        let screenX = a * normX + c * normY;
+        let screenY = b * normX + d * normY;
+        let screenDist = Math.sqrt(screenX * screenX + screenY * screenY);
+        let paddingFactor = 1 + screenPadding / screenDist;
+        x0 = centerX + normX * paddingFactor;
+        y0 = centerY + normY * paddingFactor;
+        normX = x1 - centerX;
+        normY = y1 - centerY;
+        screenX = a * normX + c * normY;
+        screenY = b * normX + d * normY;
+        screenDist = Math.sqrt(screenX * screenX + screenY * screenY);
+        paddingFactor = 1 + screenPadding / screenDist;
+        x1 = centerX + normX * paddingFactor;
+        y1 = centerY + normY * paddingFactor;
+        normX = x2 - centerX;
+        normY = y2 - centerY;
+        screenX = a * normX + c * normY;
+        screenY = b * normX + d * normY;
+        screenDist = Math.sqrt(screenX * screenX + screenY * screenY);
+        paddingFactor = 1 + screenPadding / screenDist;
+        x2 = centerX + normX * paddingFactor;
+        y2 = centerY + normY * paddingFactor;
+      }
+      context.save();
+      context.beginPath();
+      context.moveTo(x0, y0);
+      context.lineTo(x1, y1);
+      context.lineTo(x2, y2);
+      context.closePath();
+      context.clip();
+      const delta = u0 * v1 + v0 * u2 + u1 * v2 - v1 * u2 - v0 * u1 - u0 * v2;
+      const deltaA = x0 * v1 + v0 * x2 + x1 * v2 - v1 * x2 - v0 * x1 - x0 * v2;
+      const deltaB = u0 * x1 + x0 * u2 + u1 * x2 - x1 * u2 - x0 * u1 - u0 * x2;
+      const deltaC = u0 * v1 * x2 + v0 * x1 * u2 + x0 * u1 * v2 - x0 * v1 * u2 - v0 * u1 * x2 - u0 * x1 * v2;
+      const deltaD = y0 * v1 + v0 * y2 + y1 * v2 - v1 * y2 - v0 * y1 - y0 * v2;
+      const deltaE = u0 * y1 + y0 * u2 + u1 * y2 - y1 * u2 - y0 * u1 - u0 * y2;
+      const deltaF = u0 * v1 * y2 + v0 * y1 * u2 + y0 * u1 * v2 - y0 * v1 * u2 - v0 * u1 * y2 - u0 * y1 * v2;
+      context.transform(deltaA / delta, deltaD / delta, deltaB / delta, deltaE / delta, deltaC / delta, deltaF / delta);
+      context.drawImage(textureSource, 0, 0, textureWidth * base.resolution, textureHeight * base.resolution, 0, 0, textureWidth, textureHeight);
+      context.restore();
+      this.renderer.canvasContext.invalidateBlendMode();
+    }
+    renderMeshFlat(mesh) {
+      const context = this.renderer.canvasContext.activeContext;
+      const vertices = mesh.geometry.getBuffer("aVertexPosition").data;
+      const length = vertices.length / 2;
+      context.beginPath();
+      for (let i = 1; i < length - 2; ++i) {
+        const index = i * 2;
+        const x0 = vertices[index];
+        const y0 = vertices[index + 1];
+        const x1 = vertices[index + 2];
+        const y1 = vertices[index + 3];
+        const x2 = vertices[index + 4];
+        const y2 = vertices[index + 5];
+        context.moveTo(x0, y0);
+        context.lineTo(x1, y1);
+        context.lineTo(x2, y2);
+      }
+      context.fillStyle = "#FF0000";
+      context.fill();
+      context.closePath();
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  CanvasMeshRenderer.extension = {
+    name: "mesh",
+    type: ExtensionType.CanvasRendererPlugin
+  };
+  extensions$1.add(CanvasMeshRenderer);
+
+  const CANVAS_START_SIZE = 16;
+  function uploadBaseTextures(prepare, item) {
+    const tempPrepare = prepare;
+    if (item instanceof BaseTexture) {
+      const image = item.source;
+      const imageWidth = image.width === 0 ? tempPrepare.canvas.width : Math.min(tempPrepare.canvas.width, image.width);
+      const imageHeight = image.height === 0 ? tempPrepare.canvas.height : Math.min(tempPrepare.canvas.height, image.height);
+      tempPrepare.ctx.drawImage(image, 0, 0, imageWidth, imageHeight, 0, 0, tempPrepare.canvas.width, tempPrepare.canvas.height);
+      return true;
+    }
+    return false;
+  }
+  class CanvasPrepare extends BasePrepare {
+    constructor(renderer) {
+      super(renderer);
+      this.uploadHookHelper = this;
+      this.canvas = settings.ADAPTER.createCanvas(CANVAS_START_SIZE, CANVAS_START_SIZE);
+      this.ctx = this.canvas.getContext("2d");
+      this.registerUploadHook(uploadBaseTextures);
+    }
+    destroy() {
+      super.destroy();
+      this.ctx = null;
+      this.canvas = null;
+    }
+  }
+  CanvasPrepare.extension = {
+    name: "prepare",
+    type: ExtensionType.CanvasRendererSystem
+  };
+  extensions$1.add(CanvasPrepare);
+
+  Sprite.prototype._tintedCanvas = null;
+  Sprite.prototype._renderCanvas = function _renderCanvas(renderer) {
+    renderer.plugins.sprite.render(this);
+  };
+
+  const canvasRenderWorldTransform = new Matrix();
+  class CanvasSpriteRenderer {
+    constructor(renderer) {
+      this.renderer = renderer;
+    }
+    render(sprite) {
+      const texture = sprite._texture;
+      const renderer = this.renderer;
+      const context = renderer.canvasContext.activeContext;
+      const activeResolution = renderer.canvasContext.activeResolution;
+      if (!texture.valid) {
+        return;
+      }
+      const sourceWidth = texture._frame.width;
+      const sourceHeight = texture._frame.height;
+      let destWidth = texture._frame.width;
+      let destHeight = texture._frame.height;
+      if (texture.trim) {
+        destWidth = texture.trim.width;
+        destHeight = texture.trim.height;
+      }
+      let wt = sprite.transform.worldTransform;
+      let dx = 0;
+      let dy = 0;
+      const source = texture.baseTexture.getDrawableSource();
+      if (texture.orig.width <= 0 || texture.orig.height <= 0 || !texture.valid || !source) {
+        return;
+      }
+      renderer.canvasContext.setBlendMode(sprite.blendMode, true);
+      context.globalAlpha = sprite.worldAlpha;
+      const smoothingEnabled = texture.baseTexture.scaleMode === SCALE_MODES.LINEAR;
+      const smoothProperty = renderer.canvasContext.smoothProperty;
+      if (smoothProperty && context[smoothProperty] !== smoothingEnabled) {
+        context[smoothProperty] = smoothingEnabled;
+      }
+      if (texture.trim) {
+        dx = texture.trim.width / 2 + texture.trim.x - sprite.anchor.x * texture.orig.width;
+        dy = texture.trim.height / 2 + texture.trim.y - sprite.anchor.y * texture.orig.height;
+      } else {
+        dx = (0.5 - sprite.anchor.x) * texture.orig.width;
+        dy = (0.5 - sprite.anchor.y) * texture.orig.height;
+      }
+      if (texture.rotate) {
+        wt.copyTo(canvasRenderWorldTransform);
+        wt = canvasRenderWorldTransform;
+        groupD8.matrixAppendRotationInv(wt, texture.rotate, dx, dy);
+        dx = 0;
+        dy = 0;
+      }
+      dx -= destWidth / 2;
+      dy -= destHeight / 2;
+      renderer.canvasContext.setContextTransform(wt, sprite.roundPixels, 1);
+      if (sprite.roundPixels) {
+        dx = dx | 0;
+        dy = dy | 0;
+      }
+      const resolution = texture.baseTexture.resolution;
+      const outerBlend = renderer.canvasContext._outerBlend;
+      if (outerBlend) {
+        context.save();
+        context.beginPath();
+        context.rect(dx * activeResolution, dy * activeResolution, destWidth * activeResolution, destHeight * activeResolution);
+        context.clip();
+      }
+      if (sprite.tint !== 16777215) {
+        if (sprite._cachedTint !== sprite.tintValue || sprite._tintedCanvas.tintId !== sprite._texture._updateID) {
+          sprite._cachedTint = sprite.tintValue;
+          sprite._tintedCanvas = canvasUtils.getTintedCanvas(sprite, sprite.tintValue);
+        }
+        context.drawImage(sprite._tintedCanvas, 0, 0, Math.floor(sourceWidth * resolution), Math.floor(sourceHeight * resolution), Math.floor(dx * activeResolution), Math.floor(dy * activeResolution), Math.floor(destWidth * activeResolution), Math.floor(destHeight * activeResolution));
+      } else {
+        context.drawImage(source, texture._frame.x * resolution, texture._frame.y * resolution, Math.floor(sourceWidth * resolution), Math.floor(sourceHeight * resolution), Math.floor(dx * activeResolution), Math.floor(dy * activeResolution), Math.floor(destWidth * activeResolution), Math.floor(destHeight * activeResolution));
+      }
+      if (outerBlend) {
+        context.restore();
+      }
+      renderer.canvasContext.setBlendMode(BLEND_MODES.NORMAL);
+    }
+    destroy() {
+      this.renderer = null;
+    }
+  }
+  CanvasSpriteRenderer.extension = {
+    name: "sprite",
+    type: ExtensionType.CanvasRendererPlugin
+  };
+  extensions$1.add(CanvasSpriteRenderer);
+
+  exports.ALPHA_MODES = ALPHA_MODES;
+  exports.AbstractMultiResource = AbstractMultiResource;
+  exports.AccessibilityManager = AccessibilityManager;
+  exports.AlphaFilter = AlphaFilter;
+  exports.AnimatedSprite = AnimatedSprite;
+  exports.Application = Application;
+  exports.ArrayResource = ArrayResource;
+  exports.Assets = Assets;
+  exports.AssetsClass = AssetsClass;
+  exports.Attribute = Attribute;
+  exports.BLEND_MODES = BLEND_MODES;
+  exports.BUFFER_BITS = BUFFER_BITS;
+  exports.BUFFER_TYPE = BUFFER_TYPE;
+  exports.BackgroundSystem = BackgroundSystem;
+  exports.BaseImageResource = BaseImageResource;
+  exports.BasePrepare = BasePrepare;
+  exports.BaseRenderTexture = BaseRenderTexture;
+  exports.BaseTexture = BaseTexture;
+  exports.BatchDrawCall = BatchDrawCall;
+  exports.BatchGeometry = BatchGeometry;
+  exports.BatchRenderer = BatchRenderer;
+  exports.BatchShaderGenerator = BatchShaderGenerator;
+  exports.BatchSystem = BatchSystem;
+  exports.BatchTextureArray = BatchTextureArray;
+  exports.BitmapFont = BitmapFont;
+  exports.BitmapFontData = BitmapFontData;
+  exports.BitmapText = BitmapText;
+  exports.BlobResource = BlobResource;
+  exports.BlurFilter = BlurFilter;
+  exports.BlurFilterPass = BlurFilterPass;
+  exports.Bounds = Bounds;
+  exports.BrowserAdapter = BrowserAdapter;
+  exports.Buffer = Buffer;
+  exports.BufferResource = BufferResource;
+  exports.BufferSystem = BufferSystem;
+  exports.CLEAR_MODES = CLEAR_MODES;
+  exports.COLOR_MASK_BITS = COLOR_MASK_BITS;
+  exports.Cache = Cache;
+  exports.CanvasContextSystem = CanvasContextSystem;
+  exports.CanvasExtract = CanvasExtract;
+  exports.CanvasGraphicsRenderer = CanvasGraphicsRenderer;
+  exports.CanvasMaskSystem = CanvasMaskSystem;
+  exports.CanvasMeshRenderer = CanvasMeshRenderer;
+  exports.CanvasObjectRendererSystem = CanvasObjectRendererSystem;
+  exports.CanvasPrepare = CanvasPrepare;
+  exports.CanvasRenderer = CanvasRenderer;
+  exports.CanvasResource = CanvasResource;
+  exports.CanvasSpriteRenderer = CanvasSpriteRenderer;
+  exports.Circle = Circle;
+  exports.Color = Color;
+  exports.ColorMatrixFilter = ColorMatrixFilter;
+  exports.CompressedTextureResource = CompressedTextureResource;
+  exports.Container = Container;
+  exports.ContextSystem = ContextSystem;
+  exports.CountLimiter = CountLimiter;
+  exports.CubeResource = CubeResource;
+  exports.DEG_TO_RAD = DEG_TO_RAD;
+  exports.DRAW_MODES = DRAW_MODES;
+  exports.DisplacementFilter = DisplacementFilter;
+  exports.DisplayObject = DisplayObject;
+  exports.ENV = ENV;
+  exports.Ellipse = Ellipse;
+  exports.EventBoundary = EventBoundary;
+  exports.EventSystem = EventSystem;
+  exports.ExtensionType = ExtensionType;
+  exports.Extract = Extract;
+  exports.FORMATS = FORMATS;
+  exports.FORMATS_TO_COMPONENTS = FORMATS_TO_COMPONENTS;
+  exports.FXAAFilter = FXAAFilter;
+  exports.FederatedDisplayObject = FederatedDisplayObject;
+  exports.FederatedEvent = FederatedEvent;
+  exports.FederatedMouseEvent = FederatedMouseEvent;
+  exports.FederatedPointerEvent = FederatedPointerEvent;
+  exports.FederatedWheelEvent = FederatedWheelEvent;
+  exports.FillStyle = FillStyle;
+  exports.Filter = Filter;
+  exports.FilterState = FilterState;
+  exports.FilterSystem = FilterSystem;
+  exports.Framebuffer = Framebuffer;
+  exports.FramebufferSystem = FramebufferSystem;
+  exports.GC_MODES = GC_MODES;
+  exports.GLFramebuffer = GLFramebuffer;
+  exports.GLProgram = GLProgram;
+  exports.GLTexture = GLTexture;
+  exports.GRAPHICS_CURVES = GRAPHICS_CURVES;
+  exports.GenerateTextureSystem = GenerateTextureSystem;
+  exports.Geometry = Geometry;
+  exports.GeometrySystem = GeometrySystem;
+  exports.Graphics = Graphics;
+  exports.GraphicsData = GraphicsData;
+  exports.GraphicsGeometry = GraphicsGeometry;
+  exports.HTMLText = HTMLText;
+  exports.HTMLTextStyle = HTMLTextStyle;
+  exports.IGLUniformData = IGLUniformData;
+  exports.INSTALLED = INSTALLED;
+  exports.INTERNAL_FORMATS = INTERNAL_FORMATS;
+  exports.INTERNAL_FORMAT_TO_BYTES_PER_PIXEL = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL;
+  exports.ImageBitmapResource = ImageBitmapResource;
+  exports.ImageResource = ImageResource;
+  exports.LINE_CAP = LINE_CAP;
+  exports.LINE_JOIN = LINE_JOIN;
+  exports.LineStyle = LineStyle;
+  exports.LoaderParserPriority = LoaderParserPriority;
+  exports.MASK_TYPES = MASK_TYPES;
+  exports.MIPMAP_MODES = MIPMAP_MODES;
+  exports.MSAA_QUALITY = MSAA_QUALITY;
+  exports.MaskData = MaskData;
+  exports.MaskSystem = MaskSystem;
+  exports.Matrix = Matrix;
+  exports.Mesh = Mesh;
+  exports.MeshBatchUvs = MeshBatchUvs;
+  exports.MeshGeometry = MeshGeometry;
+  exports.MeshMaterial = MeshMaterial;
+  exports.MultisampleSystem = MultisampleSystem;
+  exports.NineSlicePlane = NineSlicePlane;
+  exports.NoiseFilter = NoiseFilter;
+  exports.ObjectRenderer = ObjectRenderer;
+  exports.ObjectRendererSystem = ObjectRendererSystem;
+  exports.ObservablePoint = ObservablePoint;
+  exports.PI_2 = PI_2;
+  exports.PRECISION = PRECISION;
+  exports.ParticleContainer = ParticleContainer;
+  exports.ParticleRenderer = ParticleRenderer;
+  exports.PlaneGeometry = PlaneGeometry;
+  exports.PluginSystem = PluginSystem;
+  exports.Point = Point;
+  exports.Polygon = Polygon;
+  exports.Prepare = Prepare;
+  exports.Program = Program;
+  exports.ProjectionSystem = ProjectionSystem;
+  exports.Quad = Quad;
+  exports.QuadUv = QuadUv;
+  exports.RAD_TO_DEG = RAD_TO_DEG;
+  exports.RENDERER_TYPE = RENDERER_TYPE;
+  exports.Rectangle = Rectangle;
+  exports.RenderTexture = RenderTexture;
+  exports.RenderTexturePool = RenderTexturePool;
+  exports.RenderTextureSystem = RenderTextureSystem;
+  exports.Renderer = Renderer;
+  exports.ResizePlugin = ResizePlugin;
+  exports.Resource = Resource;
+  exports.RopeGeometry = RopeGeometry;
+  exports.RoundedRectangle = RoundedRectangle;
+  exports.Runner = Runner;
+  exports.SAMPLER_TYPES = SAMPLER_TYPES;
+  exports.SCALE_MODES = SCALE_MODES;
+  exports.SHAPES = SHAPES;
+  exports.SVGResource = SVGResource;
+  exports.ScissorSystem = ScissorSystem;
+  exports.Shader = Shader;
+  exports.ShaderSystem = ShaderSystem;
+  exports.SimpleMesh = SimpleMesh;
+  exports.SimplePlane = SimplePlane;
+  exports.SimpleRope = SimpleRope;
+  exports.Sprite = Sprite;
+  exports.SpriteMaskFilter = SpriteMaskFilter;
+  exports.Spritesheet = Spritesheet;
+  exports.StartupSystem = StartupSystem;
+  exports.State = State;
+  exports.StateSystem = StateSystem;
+  exports.StencilSystem = StencilSystem;
+  exports.SystemManager = SystemManager;
+  exports.TARGETS = TARGETS;
+  exports.TEXT_GRADIENT = TEXT_GRADIENT;
+  exports.TYPES = TYPES;
+  exports.TYPES_TO_BYTES_PER_COMPONENT = TYPES_TO_BYTES_PER_COMPONENT;
+  exports.TYPES_TO_BYTES_PER_PIXEL = TYPES_TO_BYTES_PER_PIXEL;
+  exports.TemporaryDisplayObject = TemporaryDisplayObject;
+  exports.Text = Text;
+  exports.TextFormat = TextFormat;
+  exports.TextMetrics = TextMetrics;
+  exports.TextStyle = TextStyle;
+  exports.Texture = Texture;
+  exports.TextureGCSystem = TextureGCSystem;
+  exports.TextureMatrix = TextureMatrix;
+  exports.TextureSystem = TextureSystem;
+  exports.TextureUvs = TextureUvs;
+  exports.Ticker = Ticker;
+  exports.TickerPlugin = TickerPlugin;
+  exports.TilingSprite = TilingSprite;
+  exports.TilingSpriteRenderer = TilingSpriteRenderer;
+  exports.TimeLimiter = TimeLimiter;
+  exports.Transform = Transform;
+  exports.TransformFeedback = TransformFeedback;
+  exports.TransformFeedbackSystem = TransformFeedbackSystem;
+  exports.UPDATE_PRIORITY = UPDATE_PRIORITY;
+  exports.UniformGroup = UniformGroup;
+  exports.VERSION = VERSION;
+  exports.VideoResource = VideoResource;
+  exports.ViewSystem = ViewSystem;
+  exports.ViewableBuffer = ViewableBuffer;
+  exports.WRAP_MODES = WRAP_MODES;
+  exports.XMLFormat = XMLFormat;
+  exports.XMLStringFormat = XMLStringFormat;
+  exports.accessibleTarget = accessibleTarget;
+  exports.autoDetectFormat = autoDetectFormat;
+  exports.autoDetectRenderer = autoDetectRenderer;
+  exports.autoDetectResource = autoDetectResource;
+  exports.cacheTextureArray = cacheTextureArray;
+  exports.canUseNewCanvasBlendModes = canUseNewCanvasBlendModes;
+  exports.canvasUtils = canvasUtils;
+  exports.checkDataUrl = checkDataUrl;
+  exports.checkExtension = checkExtension;
+  exports.checkMaxIfStatementsInShader = checkMaxIfStatementsInShader;
+  exports.convertToList = convertToList;
+  exports.copySearchParams = copySearchParams;
+  exports.createStringVariations = createStringVariations;
+  exports.createTexture = createTexture;
+  exports.createUBOElements = createUBOElements;
+  exports.curves = curves;
+  exports.defaultFilterVertex = defaultFilterVertex;
+  exports.defaultVertex = defaultVertex;
+  exports.detectAvif = detectAvif;
+  exports.detectCompressedTextures = detectCompressedTextures;
+  exports.detectDefaults = detectDefaults;
+  exports.detectWebp = detectWebp;
+  exports.extensions = extensions$1;
+  exports.filters = filters;
+  exports.generateProgram = generateProgram;
+  exports.generateUniformBufferSync = generateUniformBufferSync;
+  exports.getFontFamilyName = getFontFamilyName;
+  exports.getTestContext = getTestContext;
+  exports.getUBOData = getUBOData;
+  exports.graphicsUtils = graphicsUtils;
+  exports.groupD8 = groupD8;
+  exports.isMobile = isMobile;
+  exports.isSingleItem = isSingleItem;
+  exports.loadBitmapFont = loadBitmapFont;
+  exports.loadDDS = loadDDS;
+  exports.loadImageBitmap = loadImageBitmap;
+  exports.loadJson = loadJson;
+  exports.loadKTX = loadKTX;
+  exports.loadSVG = loadSVG;
+  exports.loadTextures = loadTextures;
+  exports.loadTxt = loadTxt;
+  exports.loadWebFont = loadWebFont;
+  exports.parseDDS = parseDDS;
+  exports.parseKTX = parseKTX;
+  exports.resolveCompressedTextureUrl = resolveCompressedTextureUrl;
+  exports.resolveTextureUrl = resolveTextureUrl;
+  exports.settings = settings;
+  exports.spritesheetAsset = spritesheetAsset;
+  exports.uniformParsers = uniformParsers;
+  exports.unsafeEvalSupported = unsafeEvalSupported;
+  exports.utils = utils;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+  return exports;
+
+})({});
+//# sourceMappingURL=pixi-legacy.js.map
diff --git a/IDE/public/scope/js/pixi.js b/IDE/public/scope/js/pixi.js
deleted file mode 100644
index 52fd42b73..000000000
--- a/IDE/public/scope/js/pixi.js
+++ /dev/null
@@ -1,38831 +0,0 @@
-/*!
- * pixi.js - v6.5.10
- * Compiled Thu, 06 Jul 2023 15:25:11 UTC
- *
- * pixi.js is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- */
-var PIXI = (function (exports) {
-  'use strict';
-
-  /**
-   * @this {Promise}
-   */
-  function finallyConstructor(callback) {
-    var constructor = this.constructor;
-    return this.then(
-      function(value) {
-        // @ts-ignore
-        return constructor.resolve(callback()).then(function() {
-          return value;
-        });
-      },
-      function(reason) {
-        // @ts-ignore
-        return constructor.resolve(callback()).then(function() {
-          // @ts-ignore
-          return constructor.reject(reason);
-        });
-      }
-    );
-  }
-
-  function allSettled(arr) {
-    var P = this;
-    return new P(function(resolve, reject) {
-      if (!(arr && typeof arr.length !== 'undefined')) {
-        return reject(
-          new TypeError(
-            typeof arr +
-              ' ' +
-              arr +
-              ' is not iterable(cannot read property Symbol(Symbol.iterator))'
-          )
-        );
-      }
-      var args = Array.prototype.slice.call(arr);
-      if (args.length === 0) { return resolve([]); }
-      var remaining = args.length;
-
-      function res(i, val) {
-        if (val && (typeof val === 'object' || typeof val === 'function')) {
-          var then = val.then;
-          if (typeof then === 'function') {
-            then.call(
-              val,
-              function(val) {
-                res(i, val);
-              },
-              function(e) {
-                args[i] = { status: 'rejected', reason: e };
-                if (--remaining === 0) {
-                  resolve(args);
-                }
-              }
-            );
-            return;
-          }
-        }
-        args[i] = { status: 'fulfilled', value: val };
-        if (--remaining === 0) {
-          resolve(args);
-        }
-      }
-
-      for (var i = 0; i < args.length; i++) {
-        res(i, args[i]);
-      }
-    });
-  }
-
-  // Store setTimeout reference so promise-polyfill will be unaffected by
-  // other code modifying setTimeout (like sinon.useFakeTimers())
-  var setTimeoutFunc = setTimeout;
-
-  function isArray(x) {
-    return Boolean(x && typeof x.length !== 'undefined');
-  }
-
-  function noop() {}
-
-  // Polyfill for Function.prototype.bind
-  function bind(fn, thisArg) {
-    return function() {
-      fn.apply(thisArg, arguments);
-    };
-  }
-
-  /**
-   * @constructor
-   * @param {Function} fn
-   */
-  function Promise$1(fn) {
-    if (!(this instanceof Promise$1))
-      { throw new TypeError('Promises must be constructed via new'); }
-    if (typeof fn !== 'function') { throw new TypeError('not a function'); }
-    /** @type {!number} */
-    this._state = 0;
-    /** @type {!boolean} */
-    this._handled = false;
-    /** @type {Promise|undefined} */
-    this._value = undefined;
-    /** @type {!Array<!Function>} */
-    this._deferreds = [];
-
-    doResolve(fn, this);
-  }
-
-  function handle(self, deferred) {
-    while (self._state === 3) {
-      self = self._value;
-    }
-    if (self._state === 0) {
-      self._deferreds.push(deferred);
-      return;
-    }
-    self._handled = true;
-    Promise$1._immediateFn(function() {
-      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
-      if (cb === null) {
-        (self._state === 1 ? resolve$1 : reject)(deferred.promise, self._value);
-        return;
-      }
-      var ret;
-      try {
-        ret = cb(self._value);
-      } catch (e) {
-        reject(deferred.promise, e);
-        return;
-      }
-      resolve$1(deferred.promise, ret);
-    });
-  }
-
-  function resolve$1(self, newValue) {
-    try {
-      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
-      if (newValue === self)
-        { throw new TypeError('A promise cannot be resolved with itself.'); }
-      if (
-        newValue &&
-        (typeof newValue === 'object' || typeof newValue === 'function')
-      ) {
-        var then = newValue.then;
-        if (newValue instanceof Promise$1) {
-          self._state = 3;
-          self._value = newValue;
-          finale(self);
-          return;
-        } else if (typeof then === 'function') {
-          doResolve(bind(then, newValue), self);
-          return;
-        }
-      }
-      self._state = 1;
-      self._value = newValue;
-      finale(self);
-    } catch (e) {
-      reject(self, e);
-    }
-  }
-
-  function reject(self, newValue) {
-    self._state = 2;
-    self._value = newValue;
-    finale(self);
-  }
-
-  function finale(self) {
-    if (self._state === 2 && self._deferreds.length === 0) {
-      Promise$1._immediateFn(function() {
-        if (!self._handled) {
-          Promise$1._unhandledRejectionFn(self._value);
-        }
-      });
-    }
-
-    for (var i = 0, len = self._deferreds.length; i < len; i++) {
-      handle(self, self._deferreds[i]);
-    }
-    self._deferreds = null;
-  }
-
-  /**
-   * @constructor
-   */
-  function Handler(onFulfilled, onRejected, promise) {
-    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
-    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
-    this.promise = promise;
-  }
-
-  /**
-   * Take a potentially misbehaving resolver function and make sure
-   * onFulfilled and onRejected are only called once.
-   *
-   * Makes no guarantees about asynchrony.
-   */
-  function doResolve(fn, self) {
-    var done = false;
-    try {
-      fn(
-        function(value) {
-          if (done) { return; }
-          done = true;
-          resolve$1(self, value);
-        },
-        function(reason) {
-          if (done) { return; }
-          done = true;
-          reject(self, reason);
-        }
-      );
-    } catch (ex) {
-      if (done) { return; }
-      done = true;
-      reject(self, ex);
-    }
-  }
-
-  Promise$1.prototype['catch'] = function(onRejected) {
-    return this.then(null, onRejected);
-  };
-
-  Promise$1.prototype.then = function(onFulfilled, onRejected) {
-    // @ts-ignore
-    var prom = new this.constructor(noop);
-
-    handle(this, new Handler(onFulfilled, onRejected, prom));
-    return prom;
-  };
-
-  Promise$1.prototype['finally'] = finallyConstructor;
-
-  Promise$1.all = function(arr) {
-    return new Promise$1(function(resolve, reject) {
-      if (!isArray(arr)) {
-        return reject(new TypeError('Promise.all accepts an array'));
-      }
-
-      var args = Array.prototype.slice.call(arr);
-      if (args.length === 0) { return resolve([]); }
-      var remaining = args.length;
-
-      function res(i, val) {
-        try {
-          if (val && (typeof val === 'object' || typeof val === 'function')) {
-            var then = val.then;
-            if (typeof then === 'function') {
-              then.call(
-                val,
-                function(val) {
-                  res(i, val);
-                },
-                reject
-              );
-              return;
-            }
-          }
-          args[i] = val;
-          if (--remaining === 0) {
-            resolve(args);
-          }
-        } catch (ex) {
-          reject(ex);
-        }
-      }
-
-      for (var i = 0; i < args.length; i++) {
-        res(i, args[i]);
-      }
-    });
-  };
-
-  Promise$1.allSettled = allSettled;
-
-  Promise$1.resolve = function(value) {
-    if (value && typeof value === 'object' && value.constructor === Promise$1) {
-      return value;
-    }
-
-    return new Promise$1(function(resolve) {
-      resolve(value);
-    });
-  };
-
-  Promise$1.reject = function(value) {
-    return new Promise$1(function(resolve, reject) {
-      reject(value);
-    });
-  };
-
-  Promise$1.race = function(arr) {
-    return new Promise$1(function(resolve, reject) {
-      if (!isArray(arr)) {
-        return reject(new TypeError('Promise.race accepts an array'));
-      }
-
-      for (var i = 0, len = arr.length; i < len; i++) {
-        Promise$1.resolve(arr[i]).then(resolve, reject);
-      }
-    });
-  };
-
-  // Use polyfill for setImmediate for performance gains
-  Promise$1._immediateFn =
-    // @ts-ignore
-    (typeof setImmediate === 'function' &&
-      function(fn) {
-        // @ts-ignore
-        setImmediate(fn);
-      }) ||
-    function(fn) {
-      setTimeoutFunc(fn, 0);
-    };
-
-  Promise$1._unhandledRejectionFn = function _unhandledRejectionFn(err) {
-    if (typeof console !== 'undefined' && console) {
-      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
-    }
-  };
-
-  /*
-  object-assign
-  (c) Sindre Sorhus
-  @license MIT
-  */
-
-  'use strict';
-  /* eslint-disable no-unused-vars */
-  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-  var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-  var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-
-  function toObject(val) {
-  	if (val === null || val === undefined) {
-  		throw new TypeError('Object.assign cannot be called with null or undefined');
-  	}
-
-  	return Object(val);
-  }
-
-  function shouldUseNative() {
-  	try {
-  		if (!Object.assign) {
-  			return false;
-  		}
-
-  		// Detect buggy property enumeration order in older V8 versions.
-
-  		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
-  		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
-  		test1[5] = 'de';
-  		if (Object.getOwnPropertyNames(test1)[0] === '5') {
-  			return false;
-  		}
-
-  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-  		var test2 = {};
-  		for (var i = 0; i < 10; i++) {
-  			test2['_' + String.fromCharCode(i)] = i;
-  		}
-  		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
-  			return test2[n];
-  		});
-  		if (order2.join('') !== '0123456789') {
-  			return false;
-  		}
-
-  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-  		var test3 = {};
-  		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
-  			test3[letter] = letter;
-  		});
-  		if (Object.keys(Object.assign({}, test3)).join('') !==
-  				'abcdefghijklmnopqrst') {
-  			return false;
-  		}
-
-  		return true;
-  	} catch (err) {
-  		// We don't expect any of the above to throw, but better to be safe.
-  		return false;
-  	}
-  }
-
-  var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
-  	var arguments$1 = arguments;
-
-  	var from;
-  	var to = toObject(target);
-  	var symbols;
-
-  	for (var s = 1; s < arguments.length; s++) {
-  		from = Object(arguments$1[s]);
-
-  		for (var key in from) {
-  			if (hasOwnProperty$1.call(from, key)) {
-  				to[key] = from[key];
-  			}
-  		}
-
-  		if (getOwnPropertySymbols) {
-  			symbols = getOwnPropertySymbols(from);
-  			for (var i = 0; i < symbols.length; i++) {
-  				if (propIsEnumerable.call(from, symbols[i])) {
-  					to[symbols[i]] = from[symbols[i]];
-  				}
-  			}
-  		}
-  	}
-
-  	return to;
-  };
-
-  /*!
-   * @pixi/polyfill - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/polyfill is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  if (typeof globalThis === 'undefined') {
-      if (typeof self !== 'undefined') {
-          // covers browsers
-          // @ts-expect-error not-writable ts(2540) error only on node
-          self.globalThis = self;
-      }
-      else if (typeof global !== 'undefined') {
-          // covers versions of Node < 12
-          // @ts-expect-error not-writable ts(2540) error only on node
-          global.globalThis = global;
-      }
-  }
-
-  // Support for IE 9 - 11 which does not include Promises
-  if (!globalThis.Promise) {
-      globalThis.Promise = Promise$1;
-  }
-
-  // References:
-  if (!Object.assign) {
-      Object.assign = objectAssign;
-  }
-
-  // References:
-  // http://paulirish.com/2011/requestanimationframe-for-smart-animating/
-  // https://gist.github.com/1579671
-  // http://updates.html5rocks.com/2012/05/requestAnimationFrame-API-now-with-sub-millisecond-precision
-  // https://gist.github.com/timhall/4078614
-  // https://github.com/Financial-Times/polyfill-service/tree/master/polyfills/requestAnimationFrame
-  // Expected to be used with Browserfiy
-  // Browserify automatically detects the use of `global` and passes the
-  // correct reference of `global`, `globalThis`, and finally `window`
-  var ONE_FRAME_TIME = 16;
-  // Date.now
-  if (!(Date.now && Date.prototype.getTime)) {
-      Date.now = function now() {
-          return new Date().getTime();
-      };
-  }
-  // performance.now
-  if (!(globalThis.performance && globalThis.performance.now)) {
-      var startTime_1 = Date.now();
-      if (!globalThis.performance) {
-          globalThis.performance = {};
-      }
-      globalThis.performance.now = function () { return Date.now() - startTime_1; };
-  }
-  // requestAnimationFrame
-  var lastTime = Date.now();
-  var vendors = ['ms', 'moz', 'webkit', 'o'];
-  for (var x = 0; x < vendors.length && !globalThis.requestAnimationFrame; ++x) {
-      var p = vendors[x];
-      globalThis.requestAnimationFrame = globalThis[p + "RequestAnimationFrame"];
-      globalThis.cancelAnimationFrame = globalThis[p + "CancelAnimationFrame"]
-          || globalThis[p + "CancelRequestAnimationFrame"];
-  }
-  if (!globalThis.requestAnimationFrame) {
-      globalThis.requestAnimationFrame = function (callback) {
-          if (typeof callback !== 'function') {
-              throw new TypeError(callback + "is not a function");
-          }
-          var currentTime = Date.now();
-          var delay = ONE_FRAME_TIME + lastTime - currentTime;
-          if (delay < 0) {
-              delay = 0;
-          }
-          lastTime = currentTime;
-          return globalThis.self.setTimeout(function () {
-              lastTime = Date.now();
-              callback(performance.now());
-          }, delay);
-      };
-  }
-  if (!globalThis.cancelAnimationFrame) {
-      globalThis.cancelAnimationFrame = function (id) { return clearTimeout(id); };
-  }
-
-  // References:
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
-  if (!Math.sign) {
-      Math.sign = function mathSign(x) {
-          x = Number(x);
-          if (x === 0 || isNaN(x)) {
-              return x;
-          }
-          return x > 0 ? 1 : -1;
-      };
-  }
-
-  // References:
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
-  if (!Number.isInteger) {
-      Number.isInteger = function numberIsInteger(value) {
-          return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
-      };
-  }
-
-  if (!globalThis.ArrayBuffer) {
-      globalThis.ArrayBuffer = Array;
-  }
-  if (!globalThis.Float32Array) {
-      globalThis.Float32Array = Array;
-  }
-  if (!globalThis.Uint32Array) {
-      globalThis.Uint32Array = Array;
-  }
-  if (!globalThis.Uint16Array) {
-      globalThis.Uint16Array = Array;
-  }
-  if (!globalThis.Uint8Array) {
-      globalThis.Uint8Array = Array;
-  }
-  if (!globalThis.Int32Array) {
-      globalThis.Int32Array = Array;
-  }
-
-  /*!
-   * @pixi/constants - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/constants is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-  /**
-   * Different types of environments for WebGL.
-   * @static
-   * @memberof PIXI
-   * @name ENV
-   * @enum {number}
-   * @property {number} WEBGL_LEGACY - Used for older v1 WebGL devices. PixiJS will aim to ensure compatibility
-   *  with older / less advanced devices. If you experience unexplained flickering prefer this environment.
-   * @property {number} WEBGL - Version 1 of WebGL
-   * @property {number} WEBGL2 - Version 2 of WebGL
-   */
-  exports.ENV = void 0;
-  (function (ENV) {
-      ENV[ENV["WEBGL_LEGACY"] = 0] = "WEBGL_LEGACY";
-      ENV[ENV["WEBGL"] = 1] = "WEBGL";
-      ENV[ENV["WEBGL2"] = 2] = "WEBGL2";
-  })(exports.ENV || (exports.ENV = {}));
-  /**
-   * Constant to identify the Renderer Type.
-   * @static
-   * @memberof PIXI
-   * @name RENDERER_TYPE
-   * @enum {number}
-   * @property {number} UNKNOWN - Unknown render type.
-   * @property {number} WEBGL - WebGL render type.
-   * @property {number} CANVAS - Canvas render type.
-   */
-  exports.RENDERER_TYPE = void 0;
-  (function (RENDERER_TYPE) {
-      RENDERER_TYPE[RENDERER_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
-      RENDERER_TYPE[RENDERER_TYPE["WEBGL"] = 1] = "WEBGL";
-      RENDERER_TYPE[RENDERER_TYPE["CANVAS"] = 2] = "CANVAS";
-  })(exports.RENDERER_TYPE || (exports.RENDERER_TYPE = {}));
-  /**
-   * Bitwise OR of masks that indicate the buffers to be cleared.
-   * @static
-   * @memberof PIXI
-   * @name BUFFER_BITS
-   * @enum {number}
-   * @property {number} COLOR - Indicates the buffers currently enabled for color writing.
-   * @property {number} DEPTH - Indicates the depth buffer.
-   * @property {number} STENCIL - Indicates the stencil buffer.
-   */
-  exports.BUFFER_BITS = void 0;
-  (function (BUFFER_BITS) {
-      BUFFER_BITS[BUFFER_BITS["COLOR"] = 16384] = "COLOR";
-      BUFFER_BITS[BUFFER_BITS["DEPTH"] = 256] = "DEPTH";
-      BUFFER_BITS[BUFFER_BITS["STENCIL"] = 1024] = "STENCIL";
-  })(exports.BUFFER_BITS || (exports.BUFFER_BITS = {}));
-  /**
-   * Various blend modes supported by PIXI.
-   *
-   * IMPORTANT - The WebGL renderer only supports the NORMAL, ADD, MULTIPLY and SCREEN blend modes.
-   * Anything else will silently act like NORMAL.
-   * @memberof PIXI
-   * @name BLEND_MODES
-   * @enum {number}
-   * @property {number} NORMAL -
-   * @property {number} ADD -
-   * @property {number} MULTIPLY -
-   * @property {number} SCREEN -
-   * @property {number} OVERLAY -
-   * @property {number} DARKEN -
-   * @property {number} LIGHTEN -
-   * @property {number} COLOR_DODGE -
-   * @property {number} COLOR_BURN -
-   * @property {number} HARD_LIGHT -
-   * @property {number} SOFT_LIGHT -
-   * @property {number} DIFFERENCE -
-   * @property {number} EXCLUSION -
-   * @property {number} HUE -
-   * @property {number} SATURATION -
-   * @property {number} COLOR -
-   * @property {number} LUMINOSITY -
-   * @property {number} NORMAL_NPM -
-   * @property {number} ADD_NPM -
-   * @property {number} SCREEN_NPM -
-   * @property {number} NONE -
-   * @property {number} SRC_IN -
-   * @property {number} SRC_OUT -
-   * @property {number} SRC_ATOP -
-   * @property {number} DST_OVER -
-   * @property {number} DST_IN -
-   * @property {number} DST_OUT -
-   * @property {number} DST_ATOP -
-   * @property {number} SUBTRACT -
-   * @property {number} SRC_OVER -
-   * @property {number} ERASE -
-   * @property {number} XOR -
-   */
-  exports.BLEND_MODES = void 0;
-  (function (BLEND_MODES) {
-      BLEND_MODES[BLEND_MODES["NORMAL"] = 0] = "NORMAL";
-      BLEND_MODES[BLEND_MODES["ADD"] = 1] = "ADD";
-      BLEND_MODES[BLEND_MODES["MULTIPLY"] = 2] = "MULTIPLY";
-      BLEND_MODES[BLEND_MODES["SCREEN"] = 3] = "SCREEN";
-      BLEND_MODES[BLEND_MODES["OVERLAY"] = 4] = "OVERLAY";
-      BLEND_MODES[BLEND_MODES["DARKEN"] = 5] = "DARKEN";
-      BLEND_MODES[BLEND_MODES["LIGHTEN"] = 6] = "LIGHTEN";
-      BLEND_MODES[BLEND_MODES["COLOR_DODGE"] = 7] = "COLOR_DODGE";
-      BLEND_MODES[BLEND_MODES["COLOR_BURN"] = 8] = "COLOR_BURN";
-      BLEND_MODES[BLEND_MODES["HARD_LIGHT"] = 9] = "HARD_LIGHT";
-      BLEND_MODES[BLEND_MODES["SOFT_LIGHT"] = 10] = "SOFT_LIGHT";
-      BLEND_MODES[BLEND_MODES["DIFFERENCE"] = 11] = "DIFFERENCE";
-      BLEND_MODES[BLEND_MODES["EXCLUSION"] = 12] = "EXCLUSION";
-      BLEND_MODES[BLEND_MODES["HUE"] = 13] = "HUE";
-      BLEND_MODES[BLEND_MODES["SATURATION"] = 14] = "SATURATION";
-      BLEND_MODES[BLEND_MODES["COLOR"] = 15] = "COLOR";
-      BLEND_MODES[BLEND_MODES["LUMINOSITY"] = 16] = "LUMINOSITY";
-      BLEND_MODES[BLEND_MODES["NORMAL_NPM"] = 17] = "NORMAL_NPM";
-      BLEND_MODES[BLEND_MODES["ADD_NPM"] = 18] = "ADD_NPM";
-      BLEND_MODES[BLEND_MODES["SCREEN_NPM"] = 19] = "SCREEN_NPM";
-      BLEND_MODES[BLEND_MODES["NONE"] = 20] = "NONE";
-      BLEND_MODES[BLEND_MODES["SRC_OVER"] = 0] = "SRC_OVER";
-      BLEND_MODES[BLEND_MODES["SRC_IN"] = 21] = "SRC_IN";
-      BLEND_MODES[BLEND_MODES["SRC_OUT"] = 22] = "SRC_OUT";
-      BLEND_MODES[BLEND_MODES["SRC_ATOP"] = 23] = "SRC_ATOP";
-      BLEND_MODES[BLEND_MODES["DST_OVER"] = 24] = "DST_OVER";
-      BLEND_MODES[BLEND_MODES["DST_IN"] = 25] = "DST_IN";
-      BLEND_MODES[BLEND_MODES["DST_OUT"] = 26] = "DST_OUT";
-      BLEND_MODES[BLEND_MODES["DST_ATOP"] = 27] = "DST_ATOP";
-      BLEND_MODES[BLEND_MODES["ERASE"] = 26] = "ERASE";
-      BLEND_MODES[BLEND_MODES["SUBTRACT"] = 28] = "SUBTRACT";
-      BLEND_MODES[BLEND_MODES["XOR"] = 29] = "XOR";
-  })(exports.BLEND_MODES || (exports.BLEND_MODES = {}));
-  /**
-   * Various webgl draw modes. These can be used to specify which GL drawMode to use
-   * under certain situations and renderers.
-   * @memberof PIXI
-   * @static
-   * @name DRAW_MODES
-   * @enum {number}
-   * @property {number} POINTS -
-   * @property {number} LINES -
-   * @property {number} LINE_LOOP -
-   * @property {number} LINE_STRIP -
-   * @property {number} TRIANGLES -
-   * @property {number} TRIANGLE_STRIP -
-   * @property {number} TRIANGLE_FAN -
-   */
-  exports.DRAW_MODES = void 0;
-  (function (DRAW_MODES) {
-      DRAW_MODES[DRAW_MODES["POINTS"] = 0] = "POINTS";
-      DRAW_MODES[DRAW_MODES["LINES"] = 1] = "LINES";
-      DRAW_MODES[DRAW_MODES["LINE_LOOP"] = 2] = "LINE_LOOP";
-      DRAW_MODES[DRAW_MODES["LINE_STRIP"] = 3] = "LINE_STRIP";
-      DRAW_MODES[DRAW_MODES["TRIANGLES"] = 4] = "TRIANGLES";
-      DRAW_MODES[DRAW_MODES["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
-      DRAW_MODES[DRAW_MODES["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
-  })(exports.DRAW_MODES || (exports.DRAW_MODES = {}));
-  /**
-   * Various GL texture/resources formats.
-   * @memberof PIXI
-   * @static
-   * @name FORMATS
-   * @enum {number}
-   * @property {number} [RGBA=6408] -
-   * @property {number} [RGB=6407] -
-   * @property {number} [RG=33319] -
-   * @property {number} [RED=6403] -
-   * @property {number} [RGBA_INTEGER=36249] -
-   * @property {number} [RGB_INTEGER=36248] -
-   * @property {number} [RG_INTEGER=33320] -
-   * @property {number} [RED_INTEGER=36244] -
-   * @property {number} [ALPHA=6406] -
-   * @property {number} [LUMINANCE=6409] -
-   * @property {number} [LUMINANCE_ALPHA=6410] -
-   * @property {number} [DEPTH_COMPONENT=6402] -
-   * @property {number} [DEPTH_STENCIL=34041] -
-   */
-  exports.FORMATS = void 0;
-  (function (FORMATS) {
-      FORMATS[FORMATS["RGBA"] = 6408] = "RGBA";
-      FORMATS[FORMATS["RGB"] = 6407] = "RGB";
-      FORMATS[FORMATS["RG"] = 33319] = "RG";
-      FORMATS[FORMATS["RED"] = 6403] = "RED";
-      FORMATS[FORMATS["RGBA_INTEGER"] = 36249] = "RGBA_INTEGER";
-      FORMATS[FORMATS["RGB_INTEGER"] = 36248] = "RGB_INTEGER";
-      FORMATS[FORMATS["RG_INTEGER"] = 33320] = "RG_INTEGER";
-      FORMATS[FORMATS["RED_INTEGER"] = 36244] = "RED_INTEGER";
-      FORMATS[FORMATS["ALPHA"] = 6406] = "ALPHA";
-      FORMATS[FORMATS["LUMINANCE"] = 6409] = "LUMINANCE";
-      FORMATS[FORMATS["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
-      FORMATS[FORMATS["DEPTH_COMPONENT"] = 6402] = "DEPTH_COMPONENT";
-      FORMATS[FORMATS["DEPTH_STENCIL"] = 34041] = "DEPTH_STENCIL";
-  })(exports.FORMATS || (exports.FORMATS = {}));
-  /**
-   * Various GL target types.
-   * @memberof PIXI
-   * @static
-   * @name TARGETS
-   * @enum {number}
-   * @property {number} [TEXTURE_2D=3553] -
-   * @property {number} [TEXTURE_CUBE_MAP=34067] -
-   * @property {number} [TEXTURE_2D_ARRAY=35866] -
-   * @property {number} [TEXTURE_CUBE_MAP_POSITIVE_X=34069] -
-   * @property {number} [TEXTURE_CUBE_MAP_NEGATIVE_X=34070] -
-   * @property {number} [TEXTURE_CUBE_MAP_POSITIVE_Y=34071] -
-   * @property {number} [TEXTURE_CUBE_MAP_NEGATIVE_Y=34072] -
-   * @property {number} [TEXTURE_CUBE_MAP_POSITIVE_Z=34073] -
-   * @property {number} [TEXTURE_CUBE_MAP_NEGATIVE_Z=34074] -
-   */
-  exports.TARGETS = void 0;
-  (function (TARGETS) {
-      TARGETS[TARGETS["TEXTURE_2D"] = 3553] = "TEXTURE_2D";
-      TARGETS[TARGETS["TEXTURE_CUBE_MAP"] = 34067] = "TEXTURE_CUBE_MAP";
-      TARGETS[TARGETS["TEXTURE_2D_ARRAY"] = 35866] = "TEXTURE_2D_ARRAY";
-      TARGETS[TARGETS["TEXTURE_CUBE_MAP_POSITIVE_X"] = 34069] = "TEXTURE_CUBE_MAP_POSITIVE_X";
-      TARGETS[TARGETS["TEXTURE_CUBE_MAP_NEGATIVE_X"] = 34070] = "TEXTURE_CUBE_MAP_NEGATIVE_X";
-      TARGETS[TARGETS["TEXTURE_CUBE_MAP_POSITIVE_Y"] = 34071] = "TEXTURE_CUBE_MAP_POSITIVE_Y";
-      TARGETS[TARGETS["TEXTURE_CUBE_MAP_NEGATIVE_Y"] = 34072] = "TEXTURE_CUBE_MAP_NEGATIVE_Y";
-      TARGETS[TARGETS["TEXTURE_CUBE_MAP_POSITIVE_Z"] = 34073] = "TEXTURE_CUBE_MAP_POSITIVE_Z";
-      TARGETS[TARGETS["TEXTURE_CUBE_MAP_NEGATIVE_Z"] = 34074] = "TEXTURE_CUBE_MAP_NEGATIVE_Z";
-  })(exports.TARGETS || (exports.TARGETS = {}));
-  /**
-   * Various GL data format types.
-   * @memberof PIXI
-   * @static
-   * @name TYPES
-   * @enum {number}
-   * @property {number} [UNSIGNED_BYTE=5121] -
-   * @property {number} [UNSIGNED_SHORT=5123] -
-   * @property {number} [UNSIGNED_SHORT_5_6_5=33635] -
-   * @property {number} [UNSIGNED_SHORT_4_4_4_4=32819] -
-   * @property {number} [UNSIGNED_SHORT_5_5_5_1=32820] -
-   * @property {number} [UNSIGNED_INT=5125] -
-   * @property {number} [UNSIGNED_INT_10F_11F_11F_REV=35899] -
-   * @property {number} [UNSIGNED_INT_2_10_10_10_REV=33640] -
-   * @property {number} [UNSIGNED_INT_24_8=34042] -
-   * @property {number} [UNSIGNED_INT_5_9_9_9_REV=35902] -
-   * @property {number} [BYTE=5120] -
-   * @property {number} [SHORT=5122] -
-   * @property {number} [INT=5124] -
-   * @property {number} [FLOAT=5126] -
-   * @property {number} [FLOAT_32_UNSIGNED_INT_24_8_REV=36269] -
-   * @property {number} [HALF_FLOAT=36193] -
-   */
-  exports.TYPES = void 0;
-  (function (TYPES) {
-      TYPES[TYPES["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
-      TYPES[TYPES["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
-      TYPES[TYPES["UNSIGNED_SHORT_5_6_5"] = 33635] = "UNSIGNED_SHORT_5_6_5";
-      TYPES[TYPES["UNSIGNED_SHORT_4_4_4_4"] = 32819] = "UNSIGNED_SHORT_4_4_4_4";
-      TYPES[TYPES["UNSIGNED_SHORT_5_5_5_1"] = 32820] = "UNSIGNED_SHORT_5_5_5_1";
-      TYPES[TYPES["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
-      TYPES[TYPES["UNSIGNED_INT_10F_11F_11F_REV"] = 35899] = "UNSIGNED_INT_10F_11F_11F_REV";
-      TYPES[TYPES["UNSIGNED_INT_2_10_10_10_REV"] = 33640] = "UNSIGNED_INT_2_10_10_10_REV";
-      TYPES[TYPES["UNSIGNED_INT_24_8"] = 34042] = "UNSIGNED_INT_24_8";
-      TYPES[TYPES["UNSIGNED_INT_5_9_9_9_REV"] = 35902] = "UNSIGNED_INT_5_9_9_9_REV";
-      TYPES[TYPES["BYTE"] = 5120] = "BYTE";
-      TYPES[TYPES["SHORT"] = 5122] = "SHORT";
-      TYPES[TYPES["INT"] = 5124] = "INT";
-      TYPES[TYPES["FLOAT"] = 5126] = "FLOAT";
-      TYPES[TYPES["FLOAT_32_UNSIGNED_INT_24_8_REV"] = 36269] = "FLOAT_32_UNSIGNED_INT_24_8_REV";
-      TYPES[TYPES["HALF_FLOAT"] = 36193] = "HALF_FLOAT";
-  })(exports.TYPES || (exports.TYPES = {}));
-  /**
-   * Various sampler types. Correspond to `sampler`, `isampler`, `usampler` GLSL types respectively.
-   * WebGL1 works only with FLOAT.
-   * @memberof PIXI
-   * @static
-   * @name SAMPLER_TYPES
-   * @enum {number}
-   * @property {number} [FLOAT=0] -
-   * @property {number} [INT=1] -
-   * @property {number} [UINT=2] -
-   */
-  exports.SAMPLER_TYPES = void 0;
-  (function (SAMPLER_TYPES) {
-      SAMPLER_TYPES[SAMPLER_TYPES["FLOAT"] = 0] = "FLOAT";
-      SAMPLER_TYPES[SAMPLER_TYPES["INT"] = 1] = "INT";
-      SAMPLER_TYPES[SAMPLER_TYPES["UINT"] = 2] = "UINT";
-  })(exports.SAMPLER_TYPES || (exports.SAMPLER_TYPES = {}));
-  /**
-   * The scale modes that are supported by pixi.
-   *
-   * The {@link PIXI.settings.SCALE_MODE} scale mode affects the default scaling mode of future operations.
-   * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
-   * @memberof PIXI
-   * @static
-   * @name SCALE_MODES
-   * @enum {number}
-   * @property {number} LINEAR Smooth scaling
-   * @property {number} NEAREST Pixelating scaling
-   */
-  exports.SCALE_MODES = void 0;
-  (function (SCALE_MODES) {
-      SCALE_MODES[SCALE_MODES["NEAREST"] = 0] = "NEAREST";
-      SCALE_MODES[SCALE_MODES["LINEAR"] = 1] = "LINEAR";
-  })(exports.SCALE_MODES || (exports.SCALE_MODES = {}));
-  /**
-   * The wrap modes that are supported by pixi.
-   *
-   * The {@link PIXI.settings.WRAP_MODE} wrap mode affects the default wrapping mode of future operations.
-   * It can be re-assigned to either CLAMP or REPEAT, depending upon suitability.
-   * If the texture is non power of two then clamp will be used regardless as WebGL can
-   * only use REPEAT if the texture is po2.
-   *
-   * This property only affects WebGL.
-   * @name WRAP_MODES
-   * @memberof PIXI
-   * @static
-   * @enum {number}
-   * @property {number} CLAMP - The textures uvs are clamped
-   * @property {number} REPEAT - The texture uvs tile and repeat
-   * @property {number} MIRRORED_REPEAT - The texture uvs tile and repeat with mirroring
-   */
-  exports.WRAP_MODES = void 0;
-  (function (WRAP_MODES) {
-      WRAP_MODES[WRAP_MODES["CLAMP"] = 33071] = "CLAMP";
-      WRAP_MODES[WRAP_MODES["REPEAT"] = 10497] = "REPEAT";
-      WRAP_MODES[WRAP_MODES["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
-  })(exports.WRAP_MODES || (exports.WRAP_MODES = {}));
-  /**
-   * Mipmap filtering modes that are supported by pixi.
-   *
-   * The {@link PIXI.settings.MIPMAP_TEXTURES} affects default texture filtering.
-   * Mipmaps are generated for a baseTexture if its `mipmap` field is `ON`,
-   * or its `POW2` and texture dimensions are powers of 2.
-   * Due to platform restriction, `ON` option will work like `POW2` for webgl-1.
-   *
-   * This property only affects WebGL.
-   * @name MIPMAP_MODES
-   * @memberof PIXI
-   * @static
-   * @enum {number}
-   * @property {number} OFF - No mipmaps
-   * @property {number} POW2 - Generate mipmaps if texture dimensions are pow2
-   * @property {number} ON - Always generate mipmaps
-   * @property {number} ON_MANUAL - Use mipmaps, but do not auto-generate them; this is used with a resource
-   *   that supports buffering each level-of-detail.
-   */
-  exports.MIPMAP_MODES = void 0;
-  (function (MIPMAP_MODES) {
-      MIPMAP_MODES[MIPMAP_MODES["OFF"] = 0] = "OFF";
-      MIPMAP_MODES[MIPMAP_MODES["POW2"] = 1] = "POW2";
-      MIPMAP_MODES[MIPMAP_MODES["ON"] = 2] = "ON";
-      MIPMAP_MODES[MIPMAP_MODES["ON_MANUAL"] = 3] = "ON_MANUAL";
-  })(exports.MIPMAP_MODES || (exports.MIPMAP_MODES = {}));
-  /**
-   * How to treat textures with premultiplied alpha
-   * @name ALPHA_MODES
-   * @memberof PIXI
-   * @static
-   * @enum {number}
-   * @property {number} NO_PREMULTIPLIED_ALPHA - Source is not premultiplied, leave it like that.
-   *  Option for compressed and data textures that are created from typed arrays.
-   * @property {number} PREMULTIPLY_ON_UPLOAD - Source is not premultiplied, premultiply on upload.
-   *  Default option, used for all loaded images.
-   * @property {number} PREMULTIPLIED_ALPHA - Source is already premultiplied
-   *  Example: spine atlases with `_pma` suffix.
-   * @property {number} NPM - Alias for NO_PREMULTIPLIED_ALPHA.
-   * @property {number} UNPACK - Default option, alias for PREMULTIPLY_ON_UPLOAD.
-   * @property {number} PMA - Alias for PREMULTIPLIED_ALPHA.
-   */
-  exports.ALPHA_MODES = void 0;
-  (function (ALPHA_MODES) {
-      ALPHA_MODES[ALPHA_MODES["NPM"] = 0] = "NPM";
-      ALPHA_MODES[ALPHA_MODES["UNPACK"] = 1] = "UNPACK";
-      ALPHA_MODES[ALPHA_MODES["PMA"] = 2] = "PMA";
-      ALPHA_MODES[ALPHA_MODES["NO_PREMULTIPLIED_ALPHA"] = 0] = "NO_PREMULTIPLIED_ALPHA";
-      ALPHA_MODES[ALPHA_MODES["PREMULTIPLY_ON_UPLOAD"] = 1] = "PREMULTIPLY_ON_UPLOAD";
-      ALPHA_MODES[ALPHA_MODES["PREMULTIPLY_ALPHA"] = 2] = "PREMULTIPLY_ALPHA";
-      ALPHA_MODES[ALPHA_MODES["PREMULTIPLIED_ALPHA"] = 2] = "PREMULTIPLIED_ALPHA";
-  })(exports.ALPHA_MODES || (exports.ALPHA_MODES = {}));
-  /**
-   * Configure whether filter textures are cleared after binding.
-   *
-   * Filter textures need not be cleared if the filter does not use pixel blending. {@link CLEAR_MODES.BLIT} will detect
-   * this and skip clearing as an optimization.
-   * @name CLEAR_MODES
-   * @memberof PIXI
-   * @static
-   * @enum {number}
-   * @property {number} BLEND - Do not clear the filter texture. The filter's output will blend on top of the output texture.
-   * @property {number} CLEAR - Always clear the filter texture.
-   * @property {number} BLIT - Clear only if {@link FilterSystem.forceClear} is set or if the filter uses pixel blending.
-   * @property {number} NO - Alias for BLEND, same as `false` in earlier versions
-   * @property {number} YES - Alias for CLEAR, same as `true` in earlier versions
-   * @property {number} AUTO - Alias for BLIT
-   */
-  exports.CLEAR_MODES = void 0;
-  (function (CLEAR_MODES) {
-      CLEAR_MODES[CLEAR_MODES["NO"] = 0] = "NO";
-      CLEAR_MODES[CLEAR_MODES["YES"] = 1] = "YES";
-      CLEAR_MODES[CLEAR_MODES["AUTO"] = 2] = "AUTO";
-      CLEAR_MODES[CLEAR_MODES["BLEND"] = 0] = "BLEND";
-      CLEAR_MODES[CLEAR_MODES["CLEAR"] = 1] = "CLEAR";
-      CLEAR_MODES[CLEAR_MODES["BLIT"] = 2] = "BLIT";
-  })(exports.CLEAR_MODES || (exports.CLEAR_MODES = {}));
-  /**
-   * The gc modes that are supported by pixi.
-   *
-   * The {@link PIXI.settings.GC_MODE} Garbage Collection mode for PixiJS textures is AUTO
-   * If set to GC_MODE, the renderer will occasionally check textures usage. If they are not
-   * used for a specified period of time they will be removed from the GPU. They will of course
-   * be uploaded again when they are required. This is a silent behind the scenes process that
-   * should ensure that the GPU does not  get filled up.
-   *
-   * Handy for mobile devices!
-   * This property only affects WebGL.
-   * @name GC_MODES
-   * @enum {number}
-   * @static
-   * @memberof PIXI
-   * @property {number} AUTO - Garbage collection will happen periodically automatically
-   * @property {number} MANUAL - Garbage collection will need to be called manually
-   */
-  exports.GC_MODES = void 0;
-  (function (GC_MODES) {
-      GC_MODES[GC_MODES["AUTO"] = 0] = "AUTO";
-      GC_MODES[GC_MODES["MANUAL"] = 1] = "MANUAL";
-  })(exports.GC_MODES || (exports.GC_MODES = {}));
-  /**
-   * Constants that specify float precision in shaders.
-   * @name PRECISION
-   * @memberof PIXI
-   * @constant
-   * @static
-   * @enum {string}
-   * @property {string} [LOW='lowp'] -
-   * @property {string} [MEDIUM='mediump'] -
-   * @property {string} [HIGH='highp'] -
-   */
-  exports.PRECISION = void 0;
-  (function (PRECISION) {
-      PRECISION["LOW"] = "lowp";
-      PRECISION["MEDIUM"] = "mediump";
-      PRECISION["HIGH"] = "highp";
-  })(exports.PRECISION || (exports.PRECISION = {}));
-  /**
-   * Constants for mask implementations.
-   * We use `type` suffix because it leads to very different behaviours
-   * @name MASK_TYPES
-   * @memberof PIXI
-   * @static
-   * @enum {number}
-   * @property {number} NONE - Mask is ignored
-   * @property {number} SCISSOR - Scissor mask, rectangle on screen, cheap
-   * @property {number} STENCIL - Stencil mask, 1-bit, medium, works only if renderer supports stencil
-   * @property {number} SPRITE - Mask that uses SpriteMaskFilter, uses temporary RenderTexture
-   * @property {number} COLOR - Color mask (RGBA)
-   */
-  exports.MASK_TYPES = void 0;
-  (function (MASK_TYPES) {
-      MASK_TYPES[MASK_TYPES["NONE"] = 0] = "NONE";
-      MASK_TYPES[MASK_TYPES["SCISSOR"] = 1] = "SCISSOR";
-      MASK_TYPES[MASK_TYPES["STENCIL"] = 2] = "STENCIL";
-      MASK_TYPES[MASK_TYPES["SPRITE"] = 3] = "SPRITE";
-      MASK_TYPES[MASK_TYPES["COLOR"] = 4] = "COLOR";
-  })(exports.MASK_TYPES || (exports.MASK_TYPES = {}));
-  /**
-   * Bitwise OR of masks that indicate the color channels that are rendered to.
-   * @static
-   * @memberof PIXI
-   * @name COLOR_MASK_BITS
-   * @enum {number}
-   * @property {number} RED - Red channel.
-   * @property {number} GREEN - Green channel
-   * @property {number} BLUE - Blue channel.
-   * @property {number} ALPHA - Alpha channel.
-   */
-  exports.COLOR_MASK_BITS = void 0;
-  (function (COLOR_MASK_BITS) {
-      COLOR_MASK_BITS[COLOR_MASK_BITS["RED"] = 1] = "RED";
-      COLOR_MASK_BITS[COLOR_MASK_BITS["GREEN"] = 2] = "GREEN";
-      COLOR_MASK_BITS[COLOR_MASK_BITS["BLUE"] = 4] = "BLUE";
-      COLOR_MASK_BITS[COLOR_MASK_BITS["ALPHA"] = 8] = "ALPHA";
-  })(exports.COLOR_MASK_BITS || (exports.COLOR_MASK_BITS = {}));
-  /**
-   * Constants for multi-sampling antialiasing.
-   * @see PIXI.Framebuffer#multisample
-   * @name MSAA_QUALITY
-   * @memberof PIXI
-   * @static
-   * @enum {number}
-   * @property {number} NONE - No multisampling for this renderTexture
-   * @property {number} LOW - Try 2 samples
-   * @property {number} MEDIUM - Try 4 samples
-   * @property {number} HIGH - Try 8 samples
-   */
-  exports.MSAA_QUALITY = void 0;
-  (function (MSAA_QUALITY) {
-      MSAA_QUALITY[MSAA_QUALITY["NONE"] = 0] = "NONE";
-      MSAA_QUALITY[MSAA_QUALITY["LOW"] = 2] = "LOW";
-      MSAA_QUALITY[MSAA_QUALITY["MEDIUM"] = 4] = "MEDIUM";
-      MSAA_QUALITY[MSAA_QUALITY["HIGH"] = 8] = "HIGH";
-  })(exports.MSAA_QUALITY || (exports.MSAA_QUALITY = {}));
-  /**
-   * Constants for various buffer types in Pixi
-   * @see PIXI.BUFFER_TYPE
-   * @name BUFFER_TYPE
-   * @memberof PIXI
-   * @static
-   * @enum {number}
-   * @property {number} ELEMENT_ARRAY_BUFFER - buffer type for using as an index buffer
-   * @property {number} ARRAY_BUFFER - buffer type for using attribute data
-   * @property {number} UNIFORM_BUFFER - the buffer type is for uniform buffer objects
-   */
-  exports.BUFFER_TYPE = void 0;
-  (function (BUFFER_TYPE) {
-      BUFFER_TYPE[BUFFER_TYPE["ELEMENT_ARRAY_BUFFER"] = 34963] = "ELEMENT_ARRAY_BUFFER";
-      BUFFER_TYPE[BUFFER_TYPE["ARRAY_BUFFER"] = 34962] = "ARRAY_BUFFER";
-      // NOT YET SUPPORTED
-      BUFFER_TYPE[BUFFER_TYPE["UNIFORM_BUFFER"] = 35345] = "UNIFORM_BUFFER";
-  })(exports.BUFFER_TYPE || (exports.BUFFER_TYPE = {}));
-
-  /*!
-   * @pixi/settings - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/settings is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  var BrowserAdapter = {
-      /**
-       * Creates a canvas element of the given size.
-       * This canvas is created using the browser's native canvas element.
-       * @param width - width of the canvas
-       * @param height - height of the canvas
-       */
-      createCanvas: function (width, height) {
-          var canvas = document.createElement('canvas');
-          canvas.width = width;
-          canvas.height = height;
-          return canvas;
-      },
-      getWebGLRenderingContext: function () { return WebGLRenderingContext; },
-      getNavigator: function () { return navigator; },
-      getBaseUrl: function () { var _a; return ((_a = document.baseURI) !== null && _a !== void 0 ? _a : window.location.href); },
-      fetch: function (url, options) { return fetch(url, options); },
-  };
-
-  var appleIphone = /iPhone/i;
-  var appleIpod = /iPod/i;
-  var appleTablet = /iPad/i;
-  var appleUniversal = /\biOS-universal(?:.+)Mac\b/i;
-  var androidPhone = /\bAndroid(?:.+)Mobile\b/i;
-  var androidTablet = /Android/i;
-  var amazonPhone = /(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i;
-  var amazonTablet = /Silk/i;
-  var windowsPhone = /Windows Phone/i;
-  var windowsTablet = /\bWindows(?:.+)ARM\b/i;
-  var otherBlackBerry = /BlackBerry/i;
-  var otherBlackBerry10 = /BB10/i;
-  var otherOpera = /Opera Mini/i;
-  var otherChrome = /\b(CriOS|Chrome)(?:.+)Mobile/i;
-  var otherFirefox = /Mobile(?:.+)Firefox\b/i;
-  var isAppleTabletOnIos13 = function (navigator) {
-      return (typeof navigator !== 'undefined' &&
-          navigator.platform === 'MacIntel' &&
-          typeof navigator.maxTouchPoints === 'number' &&
-          navigator.maxTouchPoints > 1 &&
-          typeof MSStream === 'undefined');
-  };
-  function createMatch(userAgent) {
-      return function (regex) { return regex.test(userAgent); };
-  }
-  function isMobile$1(param) {
-      var nav = {
-          userAgent: '',
-          platform: '',
-          maxTouchPoints: 0
-      };
-      if (!param && typeof navigator !== 'undefined') {
-          nav = {
-              userAgent: navigator.userAgent,
-              platform: navigator.platform,
-              maxTouchPoints: navigator.maxTouchPoints || 0
-          };
-      }
-      else if (typeof param === 'string') {
-          nav.userAgent = param;
-      }
-      else if (param && param.userAgent) {
-          nav = {
-              userAgent: param.userAgent,
-              platform: param.platform,
-              maxTouchPoints: param.maxTouchPoints || 0
-          };
-      }
-      var userAgent = nav.userAgent;
-      var tmp = userAgent.split('[FBAN');
-      if (typeof tmp[1] !== 'undefined') {
-          userAgent = tmp[0];
-      }
-      tmp = userAgent.split('Twitter');
-      if (typeof tmp[1] !== 'undefined') {
-          userAgent = tmp[0];
-      }
-      var match = createMatch(userAgent);
-      var result = {
-          apple: {
-              phone: match(appleIphone) && !match(windowsPhone),
-              ipod: match(appleIpod),
-              tablet: !match(appleIphone) &&
-                  (match(appleTablet) || isAppleTabletOnIos13(nav)) &&
-                  !match(windowsPhone),
-              universal: match(appleUniversal),
-              device: (match(appleIphone) ||
-                  match(appleIpod) ||
-                  match(appleTablet) ||
-                  match(appleUniversal) ||
-                  isAppleTabletOnIos13(nav)) &&
-                  !match(windowsPhone)
-          },
-          amazon: {
-              phone: match(amazonPhone),
-              tablet: !match(amazonPhone) && match(amazonTablet),
-              device: match(amazonPhone) || match(amazonTablet)
-          },
-          android: {
-              phone: (!match(windowsPhone) && match(amazonPhone)) ||
-                  (!match(windowsPhone) && match(androidPhone)),
-              tablet: !match(windowsPhone) &&
-                  !match(amazonPhone) &&
-                  !match(androidPhone) &&
-                  (match(amazonTablet) || match(androidTablet)),
-              device: (!match(windowsPhone) &&
-                  (match(amazonPhone) ||
-                      match(amazonTablet) ||
-                      match(androidPhone) ||
-                      match(androidTablet))) ||
-                  match(/\bokhttp\b/i)
-          },
-          windows: {
-              phone: match(windowsPhone),
-              tablet: match(windowsTablet),
-              device: match(windowsPhone) || match(windowsTablet)
-          },
-          other: {
-              blackberry: match(otherBlackBerry),
-              blackberry10: match(otherBlackBerry10),
-              opera: match(otherOpera),
-              firefox: match(otherFirefox),
-              chrome: match(otherChrome),
-              device: match(otherBlackBerry) ||
-                  match(otherBlackBerry10) ||
-                  match(otherOpera) ||
-                  match(otherFirefox) ||
-                  match(otherChrome)
-          },
-          any: false,
-          phone: false,
-          tablet: false
-      };
-      result.any =
-          result.apple.device ||
-              result.android.device ||
-              result.windows.device ||
-              result.other.device;
-      result.phone =
-          result.apple.phone || result.android.phone || result.windows.phone;
-      result.tablet =
-          result.apple.tablet || result.android.tablet || result.windows.tablet;
-      return result;
-  }
-
-  var isMobile = isMobile$1(globalThis.navigator);
-
-  /**
-   * Uploading the same buffer multiple times in a single frame can cause performance issues.
-   * Apparent on iOS so only check for that at the moment
-   * This check may become more complex if this issue pops up elsewhere.
-   * @private
-   * @returns {boolean} `true` if the same buffer may be uploaded more than once.
-   */
-  function canUploadSameBuffer() {
-      return !isMobile.apple.device;
-  }
-
-  /**
-   * The maximum recommended texture units to use.
-   * In theory the bigger the better, and for desktop we'll use as many as we can.
-   * But some mobile devices slow down if there is to many branches in the shader.
-   * So in practice there seems to be a sweet spot size that varies depending on the device.
-   *
-   * In v4, all mobile devices were limited to 4 texture units because for this.
-   * In v5, we allow all texture units to be used on modern Apple or Android devices.
-   * @private
-   * @param {number} max
-   * @returns {number} The maximum recommended texture units to use.
-   */
-  function maxRecommendedTextures(max) {
-      var allowMax = true;
-      if (isMobile.tablet || isMobile.phone) {
-          if (isMobile.apple.device) {
-              var match = (navigator.userAgent).match(/OS (\d+)_(\d+)?/);
-              if (match) {
-                  var majorVersion = parseInt(match[1], 10);
-                  // Limit texture units on devices below iOS 11, which will be older hardware
-                  if (majorVersion < 11) {
-                      allowMax = false;
-                  }
-              }
-          }
-          if (isMobile.android.device) {
-              var match = (navigator.userAgent).match(/Android\s([0-9.]*)/);
-              if (match) {
-                  var majorVersion = parseInt(match[1], 10);
-                  // Limit texture units on devices below Android 7 (Nougat), which will be older hardware
-                  if (majorVersion < 7) {
-                      allowMax = false;
-                  }
-              }
-          }
-      }
-      return allowMax ? max : 4;
-  }
-
-  /**
-   * User's customizable globals for overriding the default PIXI settings, such
-   * as a renderer's default resolution, framerate, float precision, etc.
-   * @example
-   * // Use the native window resolution as the default resolution
-   * // will support high-density displays when rendering
-   * PIXI.settings.RESOLUTION = window.devicePixelRatio;
-   *
-   * // Disable interpolation when scaling, will make texture be pixelated
-   * PIXI.settings.SCALE_MODE = PIXI.SCALE_MODES.NEAREST;
-   * @namespace PIXI.settings
-   */
-  var settings = {
-      /**
-       * This adapter is used to call methods that are platform dependent.
-       * For example `document.createElement` only runs on the web but fails in node environments.
-       * This allows us to support more platforms by abstracting away specific implementations per platform.
-       *
-       * By default the adapter is set to work in the browser. However you can create your own
-       * by implementing the `IAdapter` interface. See `IAdapter` for more information.
-       * @name ADAPTER
-       * @memberof PIXI.settings
-       * @type {PIXI.IAdapter}
-       * @default PIXI.BrowserAdapter
-       */
-      ADAPTER: BrowserAdapter,
-      /**
-       * If set to true WebGL will attempt make textures mimpaped by default.
-       * Mipmapping will only succeed if the base texture uploaded has power of two dimensions.
-       * @static
-       * @name MIPMAP_TEXTURES
-       * @memberof PIXI.settings
-       * @type {PIXI.MIPMAP_MODES}
-       * @default PIXI.MIPMAP_MODES.POW2
-       */
-      MIPMAP_TEXTURES: exports.MIPMAP_MODES.POW2,
-      /**
-       * Default anisotropic filtering level of textures.
-       * Usually from 0 to 16
-       * @static
-       * @name ANISOTROPIC_LEVEL
-       * @memberof PIXI.settings
-       * @type {number}
-       * @default 0
-       */
-      ANISOTROPIC_LEVEL: 0,
-      /**
-       * Default resolution / device pixel ratio of the renderer.
-       * @static
-       * @name RESOLUTION
-       * @memberof PIXI.settings
-       * @type {number}
-       * @default 1
-       */
-      RESOLUTION: 1,
-      /**
-       * Default filter resolution.
-       * @static
-       * @name FILTER_RESOLUTION
-       * @memberof PIXI.settings
-       * @type {number}
-       * @default 1
-       */
-      FILTER_RESOLUTION: 1,
-      /**
-       * Default filter samples.
-       * @static
-       * @name FILTER_MULTISAMPLE
-       * @memberof PIXI.settings
-       * @type {PIXI.MSAA_QUALITY}
-       * @default PIXI.MSAA_QUALITY.NONE
-       */
-      FILTER_MULTISAMPLE: exports.MSAA_QUALITY.NONE,
-      /**
-       * The maximum textures that this device supports.
-       * @static
-       * @name SPRITE_MAX_TEXTURES
-       * @memberof PIXI.settings
-       * @type {number}
-       * @default 32
-       */
-      SPRITE_MAX_TEXTURES: maxRecommendedTextures(32),
-      // TODO: maybe change to SPRITE.BATCH_SIZE: 2000
-      // TODO: maybe add PARTICLE.BATCH_SIZE: 15000
-      /**
-       * The default sprite batch size.
-       *
-       * The default aims to balance desktop and mobile devices.
-       * @static
-       * @name SPRITE_BATCH_SIZE
-       * @memberof PIXI.settings
-       * @type {number}
-       * @default 4096
-       */
-      SPRITE_BATCH_SIZE: 4096,
-      /**
-       * The default render options if none are supplied to {@link PIXI.Renderer}
-       * or {@link PIXI.CanvasRenderer}.
-       * @static
-       * @name RENDER_OPTIONS
-       * @memberof PIXI.settings
-       * @type {object}
-       * @property {boolean} [antialias=false] - {@link PIXI.IRendererOptions.antialias}
-       * @property {boolean} [autoDensity=false] - {@link PIXI.IRendererOptions.autoDensity}
-       * @property {number} [backgroundAlpha=1] - {@link PIXI.IRendererOptions.backgroundAlpha}
-       * @property {number} [backgroundColor=0x000000] - {@link PIXI.IRendererOptions.backgroundColor}
-       * @property {boolean} [clearBeforeRender=true] - {@link PIXI.IRendererOptions.clearBeforeRender}
-       * @property {number} [height=600] - {@link PIXI.IRendererOptions.height}
-       * @property {boolean} [preserveDrawingBuffer=false] - {@link PIXI.IRendererOptions.preserveDrawingBuffer}
-       * @property {boolean|'notMultiplied'} [useContextAlpha=true] - {@link PIXI.IRendererOptions.useContextAlpha}
-       * @property {HTMLCanvasElement} [view=null] - {@link PIXI.IRendererOptions.view}
-       * @property {number} [width=800] - {@link PIXI.IRendererOptions.width}
-       */
-      RENDER_OPTIONS: {
-          view: null,
-          width: 800,
-          height: 600,
-          autoDensity: false,
-          backgroundColor: 0x000000,
-          backgroundAlpha: 1,
-          useContextAlpha: true,
-          clearBeforeRender: true,
-          antialias: false,
-          preserveDrawingBuffer: false,
-      },
-      /**
-       * Default Garbage Collection mode.
-       * @static
-       * @name GC_MODE
-       * @memberof PIXI.settings
-       * @type {PIXI.GC_MODES}
-       * @default PIXI.GC_MODES.AUTO
-       */
-      GC_MODE: exports.GC_MODES.AUTO,
-      /**
-       * Default Garbage Collection max idle.
-       * @static
-       * @name GC_MAX_IDLE
-       * @memberof PIXI.settings
-       * @type {number}
-       * @default 3600
-       */
-      GC_MAX_IDLE: 60 * 60,
-      /**
-       * Default Garbage Collection maximum check count.
-       * @static
-       * @name GC_MAX_CHECK_COUNT
-       * @memberof PIXI.settings
-       * @type {number}
-       * @default 600
-       */
-      GC_MAX_CHECK_COUNT: 60 * 10,
-      /**
-       * Default wrap modes that are supported by pixi.
-       * @static
-       * @name WRAP_MODE
-       * @memberof PIXI.settings
-       * @type {PIXI.WRAP_MODES}
-       * @default PIXI.WRAP_MODES.CLAMP
-       */
-      WRAP_MODE: exports.WRAP_MODES.CLAMP,
-      /**
-       * Default scale mode for textures.
-       * @static
-       * @name SCALE_MODE
-       * @memberof PIXI.settings
-       * @type {PIXI.SCALE_MODES}
-       * @default PIXI.SCALE_MODES.LINEAR
-       */
-      SCALE_MODE: exports.SCALE_MODES.LINEAR,
-      /**
-       * Default specify float precision in vertex shader.
-       * @static
-       * @name PRECISION_VERTEX
-       * @memberof PIXI.settings
-       * @type {PIXI.PRECISION}
-       * @default PIXI.PRECISION.HIGH
-       */
-      PRECISION_VERTEX: exports.PRECISION.HIGH,
-      /**
-       * Default specify float precision in fragment shader.
-       * iOS is best set at highp due to https://github.com/pixijs/pixi.js/issues/3742
-       * @static
-       * @name PRECISION_FRAGMENT
-       * @memberof PIXI.settings
-       * @type {PIXI.PRECISION}
-       * @default PIXI.PRECISION.MEDIUM
-       */
-      PRECISION_FRAGMENT: isMobile.apple.device ? exports.PRECISION.HIGH : exports.PRECISION.MEDIUM,
-      /**
-       * Can we upload the same buffer in a single frame?
-       * @static
-       * @name CAN_UPLOAD_SAME_BUFFER
-       * @memberof PIXI.settings
-       * @type {boolean}
-       */
-      CAN_UPLOAD_SAME_BUFFER: canUploadSameBuffer(),
-      /**
-       * Enables bitmap creation before image load. This feature is experimental.
-       * @static
-       * @name CREATE_IMAGE_BITMAP
-       * @memberof PIXI.settings
-       * @type {boolean}
-       * @default false
-       */
-      CREATE_IMAGE_BITMAP: false,
-      /**
-       * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
-       * Advantages can include sharper image quality (like text) and faster rendering on canvas.
-       * The main disadvantage is movement of objects may appear less smooth.
-       * @static
-       * @constant
-       * @memberof PIXI.settings
-       * @type {boolean}
-       * @default false
-       */
-      ROUND_PIXELS: false,
-  };
-
-  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-  function getDefaultExportFromCjs (x) {
-  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-  }
-
-  function createCommonjsModule(fn, basedir, module) {
-  	return module = {
-  		path: basedir,
-  		exports: {},
-  		require: function (path, base) {
-  			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-  		}
-  	}, fn(module, module.exports), module.exports;
-  }
-
-  function getDefaultExportFromNamespaceIfPresent (n) {
-  	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
-  }
-
-  function getDefaultExportFromNamespaceIfNotNamed (n) {
-  	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
-  }
-
-  function getAugmentedNamespace(n) {
-  	if (n.__esModule) return n;
-  	var a = Object.defineProperty({}, '__esModule', {value: true});
-  	Object.keys(n).forEach(function (k) {
-  		var d = Object.getOwnPropertyDescriptor(n, k);
-  		Object.defineProperty(a, k, d.get ? d : {
-  			enumerable: true,
-  			get: function () {
-  				return n[k];
-  			}
-  		});
-  	});
-  	return a;
-  }
-
-  function commonjsRequire () {
-  	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-  }
-
-  var eventemitter3 = createCommonjsModule(function (module) {
-  'use strict';
-
-  var has = Object.prototype.hasOwnProperty
-    , prefix = '~';
-
-  /**
-   * Constructor to create a storage for our `EE` objects.
-   * An `Events` instance is a plain object whose properties are event names.
-   *
-   * @constructor
-   * @private
-   */
-  function Events() {}
-
-  //
-  // We try to not inherit from `Object.prototype`. In some engines creating an
-  // instance in this way is faster than calling `Object.create(null)` directly.
-  // If `Object.create(null)` is not supported we prefix the event names with a
-  // character to make sure that the built-in object properties are not
-  // overridden or used as an attack vector.
-  //
-  if (Object.create) {
-    Events.prototype = Object.create(null);
-
-    //
-    // This hack is needed because the `__proto__` property is still inherited in
-    // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
-    //
-    if (!new Events().__proto__) { prefix = false; }
-  }
-
-  /**
-   * Representation of a single event listener.
-   *
-   * @param {Function} fn The listener function.
-   * @param {*} context The context to invoke the listener with.
-   * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
-   * @constructor
-   * @private
-   */
-  function EE(fn, context, once) {
-    this.fn = fn;
-    this.context = context;
-    this.once = once || false;
-  }
-
-  /**
-   * Add a listener for a given event.
-   *
-   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-   * @param {(String|Symbol)} event The event name.
-   * @param {Function} fn The listener function.
-   * @param {*} context The context to invoke the listener with.
-   * @param {Boolean} once Specify if the listener is a one-time listener.
-   * @returns {EventEmitter}
-   * @private
-   */
-  function addListener(emitter, event, fn, context, once) {
-    if (typeof fn !== 'function') {
-      throw new TypeError('The listener must be a function');
-    }
-
-    var listener = new EE(fn, context || emitter, once)
-      , evt = prefix ? prefix + event : event;
-
-    if (!emitter._events[evt]) { emitter._events[evt] = listener, emitter._eventsCount++; }
-    else if (!emitter._events[evt].fn) { emitter._events[evt].push(listener); }
-    else { emitter._events[evt] = [emitter._events[evt], listener]; }
-
-    return emitter;
-  }
-
-  /**
-   * Clear event by name.
-   *
-   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-   * @param {(String|Symbol)} evt The Event name.
-   * @private
-   */
-  function clearEvent(emitter, evt) {
-    if (--emitter._eventsCount === 0) { emitter._events = new Events(); }
-    else { delete emitter._events[evt]; }
-  }
-
-  /**
-   * Minimal `EventEmitter` interface that is molded against the Node.js
-   * `EventEmitter` interface.
-   *
-   * @constructor
-   * @public
-   */
-  function EventEmitter() {
-    this._events = new Events();
-    this._eventsCount = 0;
-  }
-
-  /**
-   * Return an array listing the events for which the emitter has registered
-   * listeners.
-   *
-   * @returns {Array}
-   * @public
-   */
-  EventEmitter.prototype.eventNames = function eventNames() {
-    var names = []
-      , events
-      , name;
-
-    if (this._eventsCount === 0) { return names; }
-
-    for (name in (events = this._events)) {
-      if (has.call(events, name)) { names.push(prefix ? name.slice(1) : name); }
-    }
-
-    if (Object.getOwnPropertySymbols) {
-      return names.concat(Object.getOwnPropertySymbols(events));
-    }
-
-    return names;
-  };
-
-  /**
-   * Return the listeners registered for a given event.
-   *
-   * @param {(String|Symbol)} event The event name.
-   * @returns {Array} The registered listeners.
-   * @public
-   */
-  EventEmitter.prototype.listeners = function listeners(event) {
-    var evt = prefix ? prefix + event : event
-      , handlers = this._events[evt];
-
-    if (!handlers) { return []; }
-    if (handlers.fn) { return [handlers.fn]; }
-
-    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
-      ee[i] = handlers[i].fn;
-    }
-
-    return ee;
-  };
-
-  /**
-   * Return the number of listeners listening to a given event.
-   *
-   * @param {(String|Symbol)} event The event name.
-   * @returns {Number} The number of listeners.
-   * @public
-   */
-  EventEmitter.prototype.listenerCount = function listenerCount(event) {
-    var evt = prefix ? prefix + event : event
-      , listeners = this._events[evt];
-
-    if (!listeners) { return 0; }
-    if (listeners.fn) { return 1; }
-    return listeners.length;
-  };
-
-  /**
-   * Calls each of the listeners registered for a given event.
-   *
-   * @param {(String|Symbol)} event The event name.
-   * @returns {Boolean} `true` if the event had listeners, else `false`.
-   * @public
-   */
-  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-    var arguments$1 = arguments;
-
-    var evt = prefix ? prefix + event : event;
-
-    if (!this._events[evt]) { return false; }
-
-    var listeners = this._events[evt]
-      , len = arguments.length
-      , args
-      , i;
-
-    if (listeners.fn) {
-      if (listeners.once) { this.removeListener(event, listeners.fn, undefined, true); }
-
-      switch (len) {
-        case 1: return listeners.fn.call(listeners.context), true;
-        case 2: return listeners.fn.call(listeners.context, a1), true;
-        case 3: return listeners.fn.call(listeners.context, a1, a2), true;
-        case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
-        case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-        case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-      }
-
-      for (i = 1, args = new Array(len -1); i < len; i++) {
-        args[i - 1] = arguments$1[i];
-      }
-
-      listeners.fn.apply(listeners.context, args);
-    } else {
-      var length = listeners.length
-        , j;
-
-      for (i = 0; i < length; i++) {
-        if (listeners[i].once) { this.removeListener(event, listeners[i].fn, undefined, true); }
-
-        switch (len) {
-          case 1: listeners[i].fn.call(listeners[i].context); break;
-          case 2: listeners[i].fn.call(listeners[i].context, a1); break;
-          case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
-          case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
-          default:
-            if (!args) { for (j = 1, args = new Array(len -1); j < len; j++) {
-              args[j - 1] = arguments$1[j];
-            } }
-
-            listeners[i].fn.apply(listeners[i].context, args);
-        }
-      }
-    }
-
-    return true;
-  };
-
-  /**
-   * Add a listener for a given event.
-   *
-   * @param {(String|Symbol)} event The event name.
-   * @param {Function} fn The listener function.
-   * @param {*} [context=this] The context to invoke the listener with.
-   * @returns {EventEmitter} `this`.
-   * @public
-   */
-  EventEmitter.prototype.on = function on(event, fn, context) {
-    return addListener(this, event, fn, context, false);
-  };
-
-  /**
-   * Add a one-time listener for a given event.
-   *
-   * @param {(String|Symbol)} event The event name.
-   * @param {Function} fn The listener function.
-   * @param {*} [context=this] The context to invoke the listener with.
-   * @returns {EventEmitter} `this`.
-   * @public
-   */
-  EventEmitter.prototype.once = function once(event, fn, context) {
-    return addListener(this, event, fn, context, true);
-  };
-
-  /**
-   * Remove the listeners of a given event.
-   *
-   * @param {(String|Symbol)} event The event name.
-   * @param {Function} fn Only remove the listeners that match this function.
-   * @param {*} context Only remove the listeners that have this context.
-   * @param {Boolean} once Only remove one-time listeners.
-   * @returns {EventEmitter} `this`.
-   * @public
-   */
-  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-    var evt = prefix ? prefix + event : event;
-
-    if (!this._events[evt]) { return this; }
-    if (!fn) {
-      clearEvent(this, evt);
-      return this;
-    }
-
-    var listeners = this._events[evt];
-
-    if (listeners.fn) {
-      if (
-        listeners.fn === fn &&
-        (!once || listeners.once) &&
-        (!context || listeners.context === context)
-      ) {
-        clearEvent(this, evt);
-      }
-    } else {
-      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-        if (
-          listeners[i].fn !== fn ||
-          (once && !listeners[i].once) ||
-          (context && listeners[i].context !== context)
-        ) {
-          events.push(listeners[i]);
-        }
-      }
-
-      //
-      // Reset the array, or remove it completely if we have no more listeners.
-      //
-      if (events.length) { this._events[evt] = events.length === 1 ? events[0] : events; }
-      else { clearEvent(this, evt); }
-    }
-
-    return this;
-  };
-
-  /**
-   * Remove all listeners, or those of the specified event.
-   *
-   * @param {(String|Symbol)} [event] The event name.
-   * @returns {EventEmitter} `this`.
-   * @public
-   */
-  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-    var evt;
-
-    if (event) {
-      evt = prefix ? prefix + event : event;
-      if (this._events[evt]) { clearEvent(this, evt); }
-    } else {
-      this._events = new Events();
-      this._eventsCount = 0;
-    }
-
-    return this;
-  };
-
-  //
-  // Alias methods names because people roll like that.
-  //
-  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-  //
-  // Expose the prefix.
-  //
-  EventEmitter.prefixed = prefix;
-
-  //
-  // Allow `EventEmitter` to be imported as module namespace.
-  //
-  EventEmitter.EventEmitter = EventEmitter;
-
-  //
-  // Expose the module.
-  //
-  if ('undefined' !== 'object') {
-    module.exports = EventEmitter;
-  }
-  });
-
-  'use strict';
-
-  var earcut_1 = earcut;
-  var _default = earcut;
-
-  function earcut(data, holeIndices, dim) {
-
-      dim = dim || 2;
-
-      var hasHoles = holeIndices && holeIndices.length,
-          outerLen = hasHoles ? holeIndices[0] * dim : data.length,
-          outerNode = linkedList(data, 0, outerLen, dim, true),
-          triangles = [];
-
-      if (!outerNode || outerNode.next === outerNode.prev) { return triangles; }
-
-      var minX, minY, maxX, maxY, x, y, invSize;
-
-      if (hasHoles) { outerNode = eliminateHoles(data, holeIndices, outerNode, dim); }
-
-      // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-      if (data.length > 80 * dim) {
-          minX = maxX = data[0];
-          minY = maxY = data[1];
-
-          for (var i = dim; i < outerLen; i += dim) {
-              x = data[i];
-              y = data[i + 1];
-              if (x < minX) { minX = x; }
-              if (y < minY) { minY = y; }
-              if (x > maxX) { maxX = x; }
-              if (y > maxY) { maxY = y; }
-          }
-
-          // minX, minY and invSize are later used to transform coords into integers for z-order calculation
-          invSize = Math.max(maxX - minX, maxY - minY);
-          invSize = invSize !== 0 ? 32767 / invSize : 0;
-      }
-
-      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
-
-      return triangles;
-  }
-
-  // create a circular doubly linked list from polygon points in the specified winding order
-  function linkedList(data, start, end, dim, clockwise) {
-      var i, last;
-
-      if (clockwise === (signedArea(data, start, end, dim) > 0)) {
-          for (i = start; i < end; i += dim) { last = insertNode(i, data[i], data[i + 1], last); }
-      } else {
-          for (i = end - dim; i >= start; i -= dim) { last = insertNode(i, data[i], data[i + 1], last); }
-      }
-
-      if (last && equals(last, last.next)) {
-          removeNode(last);
-          last = last.next;
-      }
-
-      return last;
-  }
-
-  // eliminate colinear or duplicate points
-  function filterPoints(start, end) {
-      if (!start) { return start; }
-      if (!end) { end = start; }
-
-      var p = start,
-          again;
-      do {
-          again = false;
-
-          if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-              removeNode(p);
-              p = end = p.prev;
-              if (p === p.next) { break; }
-              again = true;
-
-          } else {
-              p = p.next;
-          }
-      } while (again || p !== end);
-
-      return end;
-  }
-
-  // main ear slicing loop which triangulates a polygon (given as a linked list)
-  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
-      if (!ear) { return; }
-
-      // interlink polygon nodes in z-order
-      if (!pass && invSize) { indexCurve(ear, minX, minY, invSize); }
-
-      var stop = ear,
-          prev, next;
-
-      // iterate through ears, slicing them one by one
-      while (ear.prev !== ear.next) {
-          prev = ear.prev;
-          next = ear.next;
-
-          if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-              // cut off the triangle
-              triangles.push(prev.i / dim | 0);
-              triangles.push(ear.i / dim | 0);
-              triangles.push(next.i / dim | 0);
-
-              removeNode(ear);
-
-              // skipping the next vertex leads to less sliver triangles
-              ear = next.next;
-              stop = next.next;
-
-              continue;
-          }
-
-          ear = next;
-
-          // if we looped through the whole remaining polygon and can't find any more ears
-          if (ear === stop) {
-              // try filtering points and slicing again
-              if (!pass) {
-                  earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
-
-              // if this didn't work, try curing all small self-intersections locally
-              } else if (pass === 1) {
-                  ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
-                  earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
-
-              // as a last resort, try splitting the remaining polygon into two
-              } else if (pass === 2) {
-                  splitEarcut(ear, triangles, dim, minX, minY, invSize);
-              }
-
-              break;
-          }
-      }
-  }
-
-  // check whether a polygon node forms a valid ear with adjacent nodes
-  function isEar(ear) {
-      var a = ear.prev,
-          b = ear,
-          c = ear.next;
-
-      if (area(a, b, c) >= 0) { return false; } // reflex, can't be an ear
-
-      // now make sure we don't have other points inside the potential ear
-      var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-      // triangle bbox; min & max are calculated like this for speed
-      var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
-          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
-          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
-          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
-
-      var p = c.next;
-      while (p !== a) {
-          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
-              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
-              area(p.prev, p, p.next) >= 0) { return false; }
-          p = p.next;
-      }
-
-      return true;
-  }
-
-  function isEarHashed(ear, minX, minY, invSize) {
-      var a = ear.prev,
-          b = ear,
-          c = ear.next;
-
-      if (area(a, b, c) >= 0) { return false; } // reflex, can't be an ear
-
-      var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-      // triangle bbox; min & max are calculated like this for speed
-      var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
-          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
-          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
-          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
-
-      // z-order range for the current triangle bbox;
-      var minZ = zOrder(x0, y0, minX, minY, invSize),
-          maxZ = zOrder(x1, y1, minX, minY, invSize);
-
-      var p = ear.prevZ,
-          n = ear.nextZ;
-
-      // look for points inside the triangle in both directions
-      while (p && p.z >= minZ && n && n.z <= maxZ) {
-          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) { return false; }
-          p = p.prevZ;
-
-          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) { return false; }
-          n = n.nextZ;
-      }
-
-      // look for remaining points in decreasing z-order
-      while (p && p.z >= minZ) {
-          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) { return false; }
-          p = p.prevZ;
-      }
-
-      // look for remaining points in increasing z-order
-      while (n && n.z <= maxZ) {
-          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) { return false; }
-          n = n.nextZ;
-      }
-
-      return true;
-  }
-
-  // go through all polygon nodes and cure small local self-intersections
-  function cureLocalIntersections(start, triangles, dim) {
-      var p = start;
-      do {
-          var a = p.prev,
-              b = p.next.next;
-
-          if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-
-              triangles.push(a.i / dim | 0);
-              triangles.push(p.i / dim | 0);
-              triangles.push(b.i / dim | 0);
-
-              // remove two nodes involved
-              removeNode(p);
-              removeNode(p.next);
-
-              p = start = b;
-          }
-          p = p.next;
-      } while (p !== start);
-
-      return filterPoints(p);
-  }
-
-  // try splitting polygon into two and triangulate them independently
-  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
-      // look for a valid diagonal that divides the polygon into two
-      var a = start;
-      do {
-          var b = a.next.next;
-          while (b !== a.prev) {
-              if (a.i !== b.i && isValidDiagonal(a, b)) {
-                  // split the polygon in two by the diagonal
-                  var c = splitPolygon(a, b);
-
-                  // filter colinear points around the cuts
-                  a = filterPoints(a, a.next);
-                  c = filterPoints(c, c.next);
-
-                  // run earcut on each half
-                  earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
-                  earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
-                  return;
-              }
-              b = b.next;
-          }
-          a = a.next;
-      } while (a !== start);
-  }
-
-  // link every hole into the outer loop, producing a single-ring polygon without holes
-  function eliminateHoles(data, holeIndices, outerNode, dim) {
-      var queue = [],
-          i, len, start, end, list;
-
-      for (i = 0, len = holeIndices.length; i < len; i++) {
-          start = holeIndices[i] * dim;
-          end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-          list = linkedList(data, start, end, dim, false);
-          if (list === list.next) { list.steiner = true; }
-          queue.push(getLeftmost(list));
-      }
-
-      queue.sort(compareX);
-
-      // process holes from left to right
-      for (i = 0; i < queue.length; i++) {
-          outerNode = eliminateHole(queue[i], outerNode);
-      }
-
-      return outerNode;
-  }
-
-  function compareX(a, b) {
-      return a.x - b.x;
-  }
-
-  // find a bridge between vertices that connects hole with an outer ring and and link it
-  function eliminateHole(hole, outerNode) {
-      var bridge = findHoleBridge(hole, outerNode);
-      if (!bridge) {
-          return outerNode;
-      }
-
-      var bridgeReverse = splitPolygon(bridge, hole);
-
-      // filter collinear points around the cuts
-      filterPoints(bridgeReverse, bridgeReverse.next);
-      return filterPoints(bridge, bridge.next);
-  }
-
-  // David Eberly's algorithm for finding a bridge between hole and outer polygon
-  function findHoleBridge(hole, outerNode) {
-      var p = outerNode,
-          hx = hole.x,
-          hy = hole.y,
-          qx = -Infinity,
-          m;
-
-      // find a segment intersected by a ray from the hole's leftmost point to the left;
-      // segment's endpoint with lesser x will be potential connection point
-      do {
-          if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-              var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-              if (x <= hx && x > qx) {
-                  qx = x;
-                  m = p.x < p.next.x ? p : p.next;
-                  if (x === hx) { return m; } // hole touches outer segment; pick leftmost endpoint
-              }
-          }
-          p = p.next;
-      } while (p !== outerNode);
-
-      if (!m) { return null; }
-
-      // look for points inside the triangle of hole point, segment intersection and endpoint;
-      // if there are no points found, we have a valid connection;
-      // otherwise choose the point of the minimum angle with the ray as connection point
-
-      var stop = m,
-          mx = m.x,
-          my = m.y,
-          tanMin = Infinity,
-          tan;
-
-      p = m;
-
-      do {
-          if (hx >= p.x && p.x >= mx && hx !== p.x &&
-                  pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
-
-              tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
-
-              if (locallyInside(p, hole) &&
-                  (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
-                  m = p;
-                  tanMin = tan;
-              }
-          }
-
-          p = p.next;
-      } while (p !== stop);
-
-      return m;
-  }
-
-  // whether sector in vertex m contains sector in vertex p in the same coordinates
-  function sectorContainsSector(m, p) {
-      return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
-  }
-
-  // interlink polygon nodes in z-order
-  function indexCurve(start, minX, minY, invSize) {
-      var p = start;
-      do {
-          if (p.z === 0) { p.z = zOrder(p.x, p.y, minX, minY, invSize); }
-          p.prevZ = p.prev;
-          p.nextZ = p.next;
-          p = p.next;
-      } while (p !== start);
-
-      p.prevZ.nextZ = null;
-      p.prevZ = null;
-
-      sortLinked(p);
-  }
-
-  // Simon Tatham's linked list merge sort algorithm
-  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-  function sortLinked(list) {
-      var i, p, q, e, tail, numMerges, pSize, qSize,
-          inSize = 1;
-
-      do {
-          p = list;
-          list = null;
-          tail = null;
-          numMerges = 0;
-
-          while (p) {
-              numMerges++;
-              q = p;
-              pSize = 0;
-              for (i = 0; i < inSize; i++) {
-                  pSize++;
-                  q = q.nextZ;
-                  if (!q) { break; }
-              }
-              qSize = inSize;
-
-              while (pSize > 0 || (qSize > 0 && q)) {
-
-                  if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
-                      e = p;
-                      p = p.nextZ;
-                      pSize--;
-                  } else {
-                      e = q;
-                      q = q.nextZ;
-                      qSize--;
-                  }
-
-                  if (tail) { tail.nextZ = e; }
-                  else { list = e; }
-
-                  e.prevZ = tail;
-                  tail = e;
-              }
-
-              p = q;
-          }
-
-          tail.nextZ = null;
-          inSize *= 2;
-
-      } while (numMerges > 1);
-
-      return list;
-  }
-
-  // z-order of a point given coords and inverse of the longer side of data bbox
-  function zOrder(x, y, minX, minY, invSize) {
-      // coords are transformed into non-negative 15-bit integer range
-      x = (x - minX) * invSize | 0;
-      y = (y - minY) * invSize | 0;
-
-      x = (x | (x << 8)) & 0x00FF00FF;
-      x = (x | (x << 4)) & 0x0F0F0F0F;
-      x = (x | (x << 2)) & 0x33333333;
-      x = (x | (x << 1)) & 0x55555555;
-
-      y = (y | (y << 8)) & 0x00FF00FF;
-      y = (y | (y << 4)) & 0x0F0F0F0F;
-      y = (y | (y << 2)) & 0x33333333;
-      y = (y | (y << 1)) & 0x55555555;
-
-      return x | (y << 1);
-  }
-
-  // find the leftmost node of a polygon ring
-  function getLeftmost(start) {
-      var p = start,
-          leftmost = start;
-      do {
-          if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) { leftmost = p; }
-          p = p.next;
-      } while (p !== start);
-
-      return leftmost;
-  }
-
-  // check if a point lies within a convex triangle
-  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
-      return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
-             (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
-             (bx - px) * (cy - py) >= (cx - px) * (by - py);
-  }
-
-  // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
-  function isValidDiagonal(a, b) {
-      return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
-             (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
-              (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
-              equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
-  }
-
-  // signed area of a triangle
-  function area(p, q, r) {
-      return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-  }
-
-  // check if two points are equal
-  function equals(p1, p2) {
-      return p1.x === p2.x && p1.y === p2.y;
-  }
-
-  // check if two segments intersect
-  function intersects(p1, q1, p2, q2) {
-      var o1 = sign$1(area(p1, q1, p2));
-      var o2 = sign$1(area(p1, q1, q2));
-      var o3 = sign$1(area(p2, q2, p1));
-      var o4 = sign$1(area(p2, q2, q1));
-
-      if (o1 !== o2 && o3 !== o4) { return true; } // general case
-
-      if (o1 === 0 && onSegment(p1, p2, q1)) { return true; } // p1, q1 and p2 are collinear and p2 lies on p1q1
-      if (o2 === 0 && onSegment(p1, q2, q1)) { return true; } // p1, q1 and q2 are collinear and q2 lies on p1q1
-      if (o3 === 0 && onSegment(p2, p1, q2)) { return true; } // p2, q2 and p1 are collinear and p1 lies on p2q2
-      if (o4 === 0 && onSegment(p2, q1, q2)) { return true; } // p2, q2 and q1 are collinear and q1 lies on p2q2
-
-      return false;
-  }
-
-  // for collinear points p, q, r, check if point q lies on segment pr
-  function onSegment(p, q, r) {
-      return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
-  }
-
-  function sign$1(num) {
-      return num > 0 ? 1 : num < 0 ? -1 : 0;
-  }
-
-  // check if a polygon diagonal intersects any polygon segments
-  function intersectsPolygon(a, b) {
-      var p = a;
-      do {
-          if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
-                  intersects(p, p.next, a, b)) { return true; }
-          p = p.next;
-      } while (p !== a);
-
-      return false;
-  }
-
-  // check if a polygon diagonal is locally inside the polygon
-  function locallyInside(a, b) {
-      return area(a.prev, a, a.next) < 0 ?
-          area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
-          area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
-  }
-
-  // check if the middle point of a polygon diagonal is inside the polygon
-  function middleInside(a, b) {
-      var p = a,
-          inside = false,
-          px = (a.x + b.x) / 2,
-          py = (a.y + b.y) / 2;
-      do {
-          if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
-                  (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
-              { inside = !inside; }
-          p = p.next;
-      } while (p !== a);
-
-      return inside;
-  }
-
-  // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
-  // if one belongs to the outer ring and another to a hole, it merges it into a single ring
-  function splitPolygon(a, b) {
-      var a2 = new Node(a.i, a.x, a.y),
-          b2 = new Node(b.i, b.x, b.y),
-          an = a.next,
-          bp = b.prev;
-
-      a.next = b;
-      b.prev = a;
-
-      a2.next = an;
-      an.prev = a2;
-
-      b2.next = a2;
-      a2.prev = b2;
-
-      bp.next = b2;
-      b2.prev = bp;
-
-      return b2;
-  }
-
-  // create a node and optionally link it with previous one (in a circular doubly linked list)
-  function insertNode(i, x, y, last) {
-      var p = new Node(i, x, y);
-
-      if (!last) {
-          p.prev = p;
-          p.next = p;
-
-      } else {
-          p.next = last.next;
-          p.prev = last;
-          last.next.prev = p;
-          last.next = p;
-      }
-      return p;
-  }
-
-  function removeNode(p) {
-      p.next.prev = p.prev;
-      p.prev.next = p.next;
-
-      if (p.prevZ) { p.prevZ.nextZ = p.nextZ; }
-      if (p.nextZ) { p.nextZ.prevZ = p.prevZ; }
-  }
-
-  function Node(i, x, y) {
-      // vertex index in coordinates array
-      this.i = i;
-
-      // vertex coordinates
-      this.x = x;
-      this.y = y;
-
-      // previous and next vertex nodes in a polygon ring
-      this.prev = null;
-      this.next = null;
-
-      // z-order curve value
-      this.z = 0;
-
-      // previous and next nodes in z-order
-      this.prevZ = null;
-      this.nextZ = null;
-
-      // indicates whether this is a steiner point
-      this.steiner = false;
-  }
-
-  // return a percentage difference between the polygon area and its triangulation area;
-  // used to verify correctness of triangulation
-  earcut.deviation = function (data, holeIndices, dim, triangles) {
-      var hasHoles = holeIndices && holeIndices.length;
-      var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-
-      var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
-      if (hasHoles) {
-          for (var i = 0, len = holeIndices.length; i < len; i++) {
-              var start = holeIndices[i] * dim;
-              var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-              polygonArea -= Math.abs(signedArea(data, start, end, dim));
-          }
-      }
-
-      var trianglesArea = 0;
-      for (i = 0; i < triangles.length; i += 3) {
-          var a = triangles[i] * dim;
-          var b = triangles[i + 1] * dim;
-          var c = triangles[i + 2] * dim;
-          trianglesArea += Math.abs(
-              (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
-              (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
-      }
-
-      return polygonArea === 0 && trianglesArea === 0 ? 0 :
-          Math.abs((trianglesArea - polygonArea) / polygonArea);
-  };
-
-  function signedArea(data, start, end, dim) {
-      var sum = 0;
-      for (var i = start, j = end - dim; i < end; i += dim) {
-          sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
-          j = i;
-      }
-      return sum;
-  }
-
-  // turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
-  earcut.flatten = function (data) {
-      var dim = data[0][0].length,
-          result = {vertices: [], holes: [], dimensions: dim},
-          holeIndex = 0;
-
-      for (var i = 0; i < data.length; i++) {
-          for (var j = 0; j < data[i].length; j++) {
-              for (var d = 0; d < dim; d++) { result.vertices.push(data[i][j][d]); }
-          }
-          if (i > 0) {
-              holeIndex += data[i - 1].length;
-              result.holes.push(holeIndex);
-          }
-      }
-      return result;
-  };
-  earcut_1.default = _default;
-
-  var punycode = createCommonjsModule(function (module, exports) {
-  /*! https://mths.be/punycode v1.3.2 by @mathias */
-  ;(function(root) {
-
-  	/** Detect free variables */
-  	var freeExports = 'object' == 'object' && exports &&
-  		!exports.nodeType && exports;
-  	var freeModule = 'object' == 'object' && module &&
-  		!module.nodeType && module;
-  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-  	if (
-  		freeGlobal.global === freeGlobal ||
-  		freeGlobal.window === freeGlobal ||
-  		freeGlobal.self === freeGlobal
-  	) {
-  		root = freeGlobal;
-  	}
-
-  	/**
-  	 * The `punycode` object.
-  	 * @name punycode
-  	 * @type Object
-  	 */
-  	var punycode,
-
-  	/** Highest positive signed 32-bit float value */
-  	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
-
-  	/** Bootstring parameters */
-  	base = 36,
-  	tMin = 1,
-  	tMax = 26,
-  	skew = 38,
-  	damp = 700,
-  	initialBias = 72,
-  	initialN = 128, // 0x80
-  	delimiter = '-', // '\x2D'
-
-  	/** Regular expressions */
-  	regexPunycode = /^xn--/,
-  	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
-  	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
-
-  	/** Error messages */
-  	errors = {
-  		'overflow': 'Overflow: input needs wider integers to process',
-  		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
-  		'invalid-input': 'Invalid input'
-  	},
-
-  	/** Convenience shortcuts */
-  	baseMinusTMin = base - tMin,
-  	floor = Math.floor,
-  	stringFromCharCode = String.fromCharCode,
-
-  	/** Temporary variable */
-  	key;
-
-  	/*--------------------------------------------------------------------------*/
-
-  	/**
-  	 * A generic error utility function.
-  	 * @private
-  	 * @param {String} type The error type.
-  	 * @returns {Error} Throws a `RangeError` with the applicable error message.
-  	 */
-  	function error(type) {
-  		throw RangeError(errors[type]);
-  	}
-
-  	/**
-  	 * A generic `Array#map` utility function.
-  	 * @private
-  	 * @param {Array} array The array to iterate over.
-  	 * @param {Function} callback The function that gets called for every array
-  	 * item.
-  	 * @returns {Array} A new array of values returned by the callback function.
-  	 */
-  	function map(array, fn) {
-  		var length = array.length;
-  		var result = [];
-  		while (length--) {
-  			result[length] = fn(array[length]);
-  		}
-  		return result;
-  	}
-
-  	/**
-  	 * A simple `Array#map`-like wrapper to work with domain name strings or email
-  	 * addresses.
-  	 * @private
-  	 * @param {String} domain The domain name or email address.
-  	 * @param {Function} callback The function that gets called for every
-  	 * character.
-  	 * @returns {Array} A new string of characters returned by the callback
-  	 * function.
-  	 */
-  	function mapDomain(string, fn) {
-  		var parts = string.split('@');
-  		var result = '';
-  		if (parts.length > 1) {
-  			// In email addresses, only the domain name should be punycoded. Leave
-  			// the local part (i.e. everything up to `@`) intact.
-  			result = parts[0] + '@';
-  			string = parts[1];
-  		}
-  		// Avoid `split(regex)` for IE8 compatibility. See #17.
-  		string = string.replace(regexSeparators, '\x2E');
-  		var labels = string.split('.');
-  		var encoded = map(labels, fn).join('.');
-  		return result + encoded;
-  	}
-
-  	/**
-  	 * Creates an array containing the numeric code points of each Unicode
-  	 * character in the string. While JavaScript uses UCS-2 internally,
-  	 * this function will convert a pair of surrogate halves (each of which
-  	 * UCS-2 exposes as separate characters) into a single code point,
-  	 * matching UTF-16.
-  	 * @see `punycode.ucs2.encode`
-  	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
-  	 * @memberOf punycode.ucs2
-  	 * @name decode
-  	 * @param {String} string The Unicode input string (UCS-2).
-  	 * @returns {Array} The new array of code points.
-  	 */
-  	function ucs2decode(string) {
-  		var output = [],
-  		    counter = 0,
-  		    length = string.length,
-  		    value,
-  		    extra;
-  		while (counter < length) {
-  			value = string.charCodeAt(counter++);
-  			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
-  				// high surrogate, and there is a next character
-  				extra = string.charCodeAt(counter++);
-  				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
-  					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-  				} else {
-  					// unmatched surrogate; only append this code unit, in case the next
-  					// code unit is the high surrogate of a surrogate pair
-  					output.push(value);
-  					counter--;
-  				}
-  			} else {
-  				output.push(value);
-  			}
-  		}
-  		return output;
-  	}
-
-  	/**
-  	 * Creates a string based on an array of numeric code points.
-  	 * @see `punycode.ucs2.decode`
-  	 * @memberOf punycode.ucs2
-  	 * @name encode
-  	 * @param {Array} codePoints The array of numeric code points.
-  	 * @returns {String} The new Unicode string (UCS-2).
-  	 */
-  	function ucs2encode(array) {
-  		return map(array, function(value) {
-  			var output = '';
-  			if (value > 0xFFFF) {
-  				value -= 0x10000;
-  				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
-  				value = 0xDC00 | value & 0x3FF;
-  			}
-  			output += stringFromCharCode(value);
-  			return output;
-  		}).join('');
-  	}
-
-  	/**
-  	 * Converts a basic code point into a digit/integer.
-  	 * @see `digitToBasic()`
-  	 * @private
-  	 * @param {Number} codePoint The basic numeric code point value.
-  	 * @returns {Number} The numeric value of a basic code point (for use in
-  	 * representing integers) in the range `0` to `base - 1`, or `base` if
-  	 * the code point does not represent a value.
-  	 */
-  	function basicToDigit(codePoint) {
-  		if (codePoint - 48 < 10) {
-  			return codePoint - 22;
-  		}
-  		if (codePoint - 65 < 26) {
-  			return codePoint - 65;
-  		}
-  		if (codePoint - 97 < 26) {
-  			return codePoint - 97;
-  		}
-  		return base;
-  	}
-
-  	/**
-  	 * Converts a digit/integer into a basic code point.
-  	 * @see `basicToDigit()`
-  	 * @private
-  	 * @param {Number} digit The numeric value of a basic code point.
-  	 * @returns {Number} The basic code point whose value (when used for
-  	 * representing integers) is `digit`, which needs to be in the range
-  	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
-  	 * used; else, the lowercase form is used. The behavior is undefined
-  	 * if `flag` is non-zero and `digit` has no uppercase form.
-  	 */
-  	function digitToBasic(digit, flag) {
-  		//  0..25 map to ASCII a..z or A..Z
-  		// 26..35 map to ASCII 0..9
-  		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
-  	}
-
-  	/**
-  	 * Bias adaptation function as per section 3.4 of RFC 3492.
-  	 * http://tools.ietf.org/html/rfc3492#section-3.4
-  	 * @private
-  	 */
-  	function adapt(delta, numPoints, firstTime) {
-  		var k = 0;
-  		delta = firstTime ? floor(delta / damp) : delta >> 1;
-  		delta += floor(delta / numPoints);
-  		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
-  			delta = floor(delta / baseMinusTMin);
-  		}
-  		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
-  	}
-
-  	/**
-  	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
-  	 * symbols.
-  	 * @memberOf punycode
-  	 * @param {String} input The Punycode string of ASCII-only symbols.
-  	 * @returns {String} The resulting string of Unicode symbols.
-  	 */
-  	function decode(input) {
-  		// Don't use UCS-2
-  		var output = [],
-  		    inputLength = input.length,
-  		    out,
-  		    i = 0,
-  		    n = initialN,
-  		    bias = initialBias,
-  		    basic,
-  		    j,
-  		    index,
-  		    oldi,
-  		    w,
-  		    k,
-  		    digit,
-  		    t,
-  		    /** Cached calculation results */
-  		    baseMinusT;
-
-  		// Handle the basic code points: let `basic` be the number of input code
-  		// points before the last delimiter, or `0` if there is none, then copy
-  		// the first basic code points to the output.
-
-  		basic = input.lastIndexOf(delimiter);
-  		if (basic < 0) {
-  			basic = 0;
-  		}
-
-  		for (j = 0; j < basic; ++j) {
-  			// if it's not a basic code point
-  			if (input.charCodeAt(j) >= 0x80) {
-  				error('not-basic');
-  			}
-  			output.push(input.charCodeAt(j));
-  		}
-
-  		// Main decoding loop: start just after the last delimiter if any basic code
-  		// points were copied; start at the beginning otherwise.
-
-  		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
-
-  			// `index` is the index of the next character to be consumed.
-  			// Decode a generalized variable-length integer into `delta`,
-  			// which gets added to `i`. The overflow checking is easier
-  			// if we increase `i` as we go, then subtract off its starting
-  			// value at the end to obtain `delta`.
-  			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
-
-  				if (index >= inputLength) {
-  					error('invalid-input');
-  				}
-
-  				digit = basicToDigit(input.charCodeAt(index++));
-
-  				if (digit >= base || digit > floor((maxInt - i) / w)) {
-  					error('overflow');
-  				}
-
-  				i += digit * w;
-  				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-
-  				if (digit < t) {
-  					break;
-  				}
-
-  				baseMinusT = base - t;
-  				if (w > floor(maxInt / baseMinusT)) {
-  					error('overflow');
-  				}
-
-  				w *= baseMinusT;
-
-  			}
-
-  			out = output.length + 1;
-  			bias = adapt(i - oldi, out, oldi == 0);
-
-  			// `i` was supposed to wrap around from `out` to `0`,
-  			// incrementing `n` each time, so we'll fix that now:
-  			if (floor(i / out) > maxInt - n) {
-  				error('overflow');
-  			}
-
-  			n += floor(i / out);
-  			i %= out;
-
-  			// Insert `n` at position `i` of the output
-  			output.splice(i++, 0, n);
-
-  		}
-
-  		return ucs2encode(output);
-  	}
-
-  	/**
-  	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
-  	 * Punycode string of ASCII-only symbols.
-  	 * @memberOf punycode
-  	 * @param {String} input The string of Unicode symbols.
-  	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
-  	 */
-  	function encode(input) {
-  		var n,
-  		    delta,
-  		    handledCPCount,
-  		    basicLength,
-  		    bias,
-  		    j,
-  		    m,
-  		    q,
-  		    k,
-  		    t,
-  		    currentValue,
-  		    output = [],
-  		    /** `inputLength` will hold the number of code points in `input`. */
-  		    inputLength,
-  		    /** Cached calculation results */
-  		    handledCPCountPlusOne,
-  		    baseMinusT,
-  		    qMinusT;
-
-  		// Convert the input in UCS-2 to Unicode
-  		input = ucs2decode(input);
-
-  		// Cache the length
-  		inputLength = input.length;
-
-  		// Initialize the state
-  		n = initialN;
-  		delta = 0;
-  		bias = initialBias;
-
-  		// Handle the basic code points
-  		for (j = 0; j < inputLength; ++j) {
-  			currentValue = input[j];
-  			if (currentValue < 0x80) {
-  				output.push(stringFromCharCode(currentValue));
-  			}
-  		}
-
-  		handledCPCount = basicLength = output.length;
-
-  		// `handledCPCount` is the number of code points that have been handled;
-  		// `basicLength` is the number of basic code points.
-
-  		// Finish the basic string - if it is not empty - with a delimiter
-  		if (basicLength) {
-  			output.push(delimiter);
-  		}
-
-  		// Main encoding loop:
-  		while (handledCPCount < inputLength) {
-
-  			// All non-basic code points < n have been handled already. Find the next
-  			// larger one:
-  			for (m = maxInt, j = 0; j < inputLength; ++j) {
-  				currentValue = input[j];
-  				if (currentValue >= n && currentValue < m) {
-  					m = currentValue;
-  				}
-  			}
-
-  			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
-  			// but guard against overflow
-  			handledCPCountPlusOne = handledCPCount + 1;
-  			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
-  				error('overflow');
-  			}
-
-  			delta += (m - n) * handledCPCountPlusOne;
-  			n = m;
-
-  			for (j = 0; j < inputLength; ++j) {
-  				currentValue = input[j];
-
-  				if (currentValue < n && ++delta > maxInt) {
-  					error('overflow');
-  				}
-
-  				if (currentValue == n) {
-  					// Represent delta as a generalized variable-length integer
-  					for (q = delta, k = base; /* no condition */; k += base) {
-  						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
-  						if (q < t) {
-  							break;
-  						}
-  						qMinusT = q - t;
-  						baseMinusT = base - t;
-  						output.push(
-  							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
-  						);
-  						q = floor(qMinusT / baseMinusT);
-  					}
-
-  					output.push(stringFromCharCode(digitToBasic(q, 0)));
-  					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
-  					delta = 0;
-  					++handledCPCount;
-  				}
-  			}
-
-  			++delta;
-  			++n;
-
-  		}
-  		return output.join('');
-  	}
-
-  	/**
-  	 * Converts a Punycode string representing a domain name or an email address
-  	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
-  	 * it doesn't matter if you call it on a string that has already been
-  	 * converted to Unicode.
-  	 * @memberOf punycode
-  	 * @param {String} input The Punycoded domain name or email address to
-  	 * convert to Unicode.
-  	 * @returns {String} The Unicode representation of the given Punycode
-  	 * string.
-  	 */
-  	function toUnicode(input) {
-  		return mapDomain(input, function(string) {
-  			return regexPunycode.test(string)
-  				? decode(string.slice(4).toLowerCase())
-  				: string;
-  		});
-  	}
-
-  	/**
-  	 * Converts a Unicode string representing a domain name or an email address to
-  	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
-  	 * i.e. it doesn't matter if you call it with a domain that's already in
-  	 * ASCII.
-  	 * @memberOf punycode
-  	 * @param {String} input The domain name or email address to convert, as a
-  	 * Unicode string.
-  	 * @returns {String} The Punycode representation of the given domain name or
-  	 * email address.
-  	 */
-  	function toASCII(input) {
-  		return mapDomain(input, function(string) {
-  			return regexNonASCII.test(string)
-  				? 'xn--' + encode(string)
-  				: string;
-  		});
-  	}
-
-  	/*--------------------------------------------------------------------------*/
-
-  	/** Define the public API */
-  	punycode = {
-  		/**
-  		 * A string representing the current Punycode.js version number.
-  		 * @memberOf punycode
-  		 * @type String
-  		 */
-  		'version': '1.3.2',
-  		/**
-  		 * An object of methods to convert from JavaScript's internal character
-  		 * representation (UCS-2) to Unicode code points, and back.
-  		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
-  		 * @memberOf punycode
-  		 * @type Object
-  		 */
-  		'ucs2': {
-  			'decode': ucs2decode,
-  			'encode': ucs2encode
-  		},
-  		'decode': decode,
-  		'encode': encode,
-  		'toASCII': toASCII,
-  		'toUnicode': toUnicode
-  	};
-
-  	/** Expose `punycode` */
-  	// Some AMD build optimizers, like r.js, check for specific condition patterns
-  	// like the following:
-  	if (
-  		typeof undefined == 'function' &&
-  		typeof undefined.amd == 'object' &&
-  		undefined.amd
-  	) {
-  		undefined('punycode', function() {
-  			return punycode;
-  		});
-  	} else if (freeExports && freeModule) {
-  		if (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+
-  			freeModule.exports = punycode;
-  		} else { // in Narwhal or RingoJS v0.7.0-
-  			for (key in punycode) {
-  				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
-  			}
-  		}
-  	} else { // in Rhino or a web browser
-  		root.punycode = punycode;
-  	}
-
-  }(commonjsGlobal));
-  });
-
-  'use strict';
-
-  var util = {
-    isString: function(arg) {
-      return typeof(arg) === 'string';
-    },
-    isObject: function(arg) {
-      return typeof(arg) === 'object' && arg !== null;
-    },
-    isNull: function(arg) {
-      return arg === null;
-    },
-    isNullOrUndefined: function(arg) {
-      return arg == null;
-    }
-  };
-
-  // Copyright Joyent, Inc. and other Node contributors.
-  //
-  // 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.
-
-  'use strict';
-
-  // If obj.hasOwnProperty has been overridden, then calling
-  // obj.hasOwnProperty(prop) will break.
-  // See: https://github.com/joyent/node/issues/1707
-  function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-  }
-
-  var decode = function(qs, sep, eq, options) {
-    sep = sep || '&';
-    eq = eq || '=';
-    var obj = {};
-
-    if (typeof qs !== 'string' || qs.length === 0) {
-      return obj;
-    }
-
-    var regexp = /\+/g;
-    qs = qs.split(sep);
-
-    var maxKeys = 1000;
-    if (options && typeof options.maxKeys === 'number') {
-      maxKeys = options.maxKeys;
-    }
-
-    var len = qs.length;
-    // maxKeys <= 0 means that we should not limit keys count
-    if (maxKeys > 0 && len > maxKeys) {
-      len = maxKeys;
-    }
-
-    for (var i = 0; i < len; ++i) {
-      var x = qs[i].replace(regexp, '%20'),
-          idx = x.indexOf(eq),
-          kstr, vstr, k, v;
-
-      if (idx >= 0) {
-        kstr = x.substr(0, idx);
-        vstr = x.substr(idx + 1);
-      } else {
-        kstr = x;
-        vstr = '';
-      }
-
-      k = decodeURIComponent(kstr);
-      v = decodeURIComponent(vstr);
-
-      if (!hasOwnProperty(obj, k)) {
-        obj[k] = v;
-      } else if (Array.isArray(obj[k])) {
-        obj[k].push(v);
-      } else {
-        obj[k] = [obj[k], v];
-      }
-    }
-
-    return obj;
-  };
-
-  // Copyright Joyent, Inc. and other Node contributors.
-  //
-  // 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.
-
-  'use strict';
-
-  var stringifyPrimitive = function(v) {
-    switch (typeof v) {
-      case 'string':
-        return v;
-
-      case 'boolean':
-        return v ? 'true' : 'false';
-
-      case 'number':
-        return isFinite(v) ? v : '';
-
-      default:
-        return '';
-    }
-  };
-
-  var encode = function(obj, sep, eq, name) {
-    sep = sep || '&';
-    eq = eq || '=';
-    if (obj === null) {
-      obj = undefined;
-    }
-
-    if (typeof obj === 'object') {
-      return Object.keys(obj).map(function(k) {
-        var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
-        if (Array.isArray(obj[k])) {
-          return obj[k].map(function(v) {
-            return ks + encodeURIComponent(stringifyPrimitive(v));
-          }).join(sep);
-        } else {
-          return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
-        }
-      }).join(sep);
-
-    }
-
-    if (!name) { return ''; }
-    return encodeURIComponent(stringifyPrimitive(name)) + eq +
-           encodeURIComponent(stringifyPrimitive(obj));
-  };
-
-  var querystring = createCommonjsModule(function (module, exports) {
-  'use strict';
-
-  exports.decode = exports.parse = decode;
-  exports.encode = exports.stringify = encode;
-  });
-
-  // Copyright Joyent, Inc. and other Node contributors.
-  //
-  // 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.
-
-  'use strict';
-
-
-
-
-  var parse = urlParse;
-  var resolve = urlResolve;
-  var resolveObject = urlResolveObject;
-  var format = urlFormat;
-
-  var Url_1 = Url;
-
-  function Url() {
-    this.protocol = null;
-    this.slashes = null;
-    this.auth = null;
-    this.host = null;
-    this.port = null;
-    this.hostname = null;
-    this.hash = null;
-    this.search = null;
-    this.query = null;
-    this.pathname = null;
-    this.path = null;
-    this.href = null;
-  }
-
-  // Reference: RFC 3986, RFC 1808, RFC 2396
-
-  // define these here so at least they only have to be
-  // compiled once on the first module load.
-  var protocolPattern = /^([a-z0-9.+-]+:)/i,
-      portPattern = /:[0-9]*$/,
-
-      // Special case for a simple path URL
-      simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
-
-      // RFC 2396: characters reserved for delimiting URLs.
-      // We actually just auto-escape these.
-      delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
-
-      // RFC 2396: characters not allowed for various reasons.
-      unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
-
-      // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
-      autoEscape = ['\''].concat(unwise),
-      // Characters that are never ever allowed in a hostname.
-      // Note that any invalid chars are also handled, but these
-      // are the ones that are *expected* to be seen, so we fast-path
-      // them.
-      nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
-      hostEndingChars = ['/', '?', '#'],
-      hostnameMaxLen = 255,
-      hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
-      hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
-      // protocols that can allow "unsafe" and "unwise" chars.
-      unsafeProtocol = {
-        'javascript': true,
-        'javascript:': true
-      },
-      // protocols that never have a hostname.
-      hostlessProtocol = {
-        'javascript': true,
-        'javascript:': true
-      },
-      // protocols that always contain a // bit.
-      slashedProtocol = {
-        'http': true,
-        'https': true,
-        'ftp': true,
-        'gopher': true,
-        'file': true,
-        'http:': true,
-        'https:': true,
-        'ftp:': true,
-        'gopher:': true,
-        'file:': true
-      };
-
-  function urlParse(url, parseQueryString, slashesDenoteHost) {
-    if (url && util.isObject(url) && url instanceof Url) { return url; }
-
-    var u = new Url;
-    u.parse(url, parseQueryString, slashesDenoteHost);
-    return u;
-  }
-
-  Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
-    if (!util.isString(url)) {
-      throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
-    }
-
-    // Copy chrome, IE, opera backslash-handling behavior.
-    // Back slashes before the query string get converted to forward slashes
-    // See: https://code.google.com/p/chromium/issues/detail?id=25916
-    var queryIndex = url.indexOf('?'),
-        splitter =
-            (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
-        uSplit = url.split(splitter),
-        slashRegex = /\\/g;
-    uSplit[0] = uSplit[0].replace(slashRegex, '/');
-    url = uSplit.join(splitter);
-
-    var rest = url;
-
-    // trim before proceeding.
-    // This is to support parse stuff like "  http://foo.com  \n"
-    rest = rest.trim();
-
-    if (!slashesDenoteHost && url.split('#').length === 1) {
-      // Try fast path regexp
-      var simplePath = simplePathPattern.exec(rest);
-      if (simplePath) {
-        this.path = rest;
-        this.href = rest;
-        this.pathname = simplePath[1];
-        if (simplePath[2]) {
-          this.search = simplePath[2];
-          if (parseQueryString) {
-            this.query = querystring.parse(this.search.substr(1));
-          } else {
-            this.query = this.search.substr(1);
-          }
-        } else if (parseQueryString) {
-          this.search = '';
-          this.query = {};
-        }
-        return this;
-      }
-    }
-
-    var proto = protocolPattern.exec(rest);
-    if (proto) {
-      proto = proto[0];
-      var lowerProto = proto.toLowerCase();
-      this.protocol = lowerProto;
-      rest = rest.substr(proto.length);
-    }
-
-    // figure out if it's got a host
-    // user@server is *always* interpreted as a hostname, and url
-    // resolution will treat //foo/bar as host=foo,path=bar because that's
-    // how the browser resolves relative URLs.
-    if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
-      var slashes = rest.substr(0, 2) === '//';
-      if (slashes && !(proto && hostlessProtocol[proto])) {
-        rest = rest.substr(2);
-        this.slashes = true;
-      }
-    }
-
-    if (!hostlessProtocol[proto] &&
-        (slashes || (proto && !slashedProtocol[proto]))) {
-
-      // there's a hostname.
-      // the first instance of /, ?, ;, or # ends the host.
-      //
-      // If there is an @ in the hostname, then non-host chars *are* allowed
-      // to the left of the last @ sign, unless some host-ending character
-      // comes *before* the @-sign.
-      // URLs are obnoxious.
-      //
-      // ex:
-      // http://a@b@c/ => user:a@b host:c
-      // http://a@b?@c => user:a host:c path:/?@c
-
-      // v0.12 TODO(isaacs): This is not quite how Chrome does things.
-      // Review our test case against browsers more comprehensively.
-
-      // find the first instance of any hostEndingChars
-      var hostEnd = -1;
-      for (var i = 0; i < hostEndingChars.length; i++) {
-        var hec = rest.indexOf(hostEndingChars[i]);
-        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
-          { hostEnd = hec; }
-      }
-
-      // at this point, either we have an explicit point where the
-      // auth portion cannot go past, or the last @ char is the decider.
-      var auth, atSign;
-      if (hostEnd === -1) {
-        // atSign can be anywhere.
-        atSign = rest.lastIndexOf('@');
-      } else {
-        // atSign must be in auth portion.
-        // http://a@b/c@d => host:b auth:a path:/c@d
-        atSign = rest.lastIndexOf('@', hostEnd);
-      }
-
-      // Now we have a portion which is definitely the auth.
-      // Pull that off.
-      if (atSign !== -1) {
-        auth = rest.slice(0, atSign);
-        rest = rest.slice(atSign + 1);
-        this.auth = decodeURIComponent(auth);
-      }
-
-      // the host is the remaining to the left of the first non-host char
-      hostEnd = -1;
-      for (var i = 0; i < nonHostChars.length; i++) {
-        var hec = rest.indexOf(nonHostChars[i]);
-        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
-          { hostEnd = hec; }
-      }
-      // if we still have not hit it, then the entire thing is a host.
-      if (hostEnd === -1)
-        { hostEnd = rest.length; }
-
-      this.host = rest.slice(0, hostEnd);
-      rest = rest.slice(hostEnd);
-
-      // pull out port.
-      this.parseHost();
-
-      // we've indicated that there is a hostname,
-      // so even if it's empty, it has to be present.
-      this.hostname = this.hostname || '';
-
-      // if hostname begins with [ and ends with ]
-      // assume that it's an IPv6 address.
-      var ipv6Hostname = this.hostname[0] === '[' &&
-          this.hostname[this.hostname.length - 1] === ']';
-
-      // validate a little.
-      if (!ipv6Hostname) {
-        var hostparts = this.hostname.split(/\./);
-        for (var i = 0, l = hostparts.length; i < l; i++) {
-          var part = hostparts[i];
-          if (!part) { continue; }
-          if (!part.match(hostnamePartPattern)) {
-            var newpart = '';
-            for (var j = 0, k = part.length; j < k; j++) {
-              if (part.charCodeAt(j) > 127) {
-                // we replace non-ASCII char with a temporary placeholder
-                // we need this to make sure size of hostname is not
-                // broken by replacing non-ASCII by nothing
-                newpart += 'x';
-              } else {
-                newpart += part[j];
-              }
-            }
-            // we test again with ASCII char only
-            if (!newpart.match(hostnamePartPattern)) {
-              var validParts = hostparts.slice(0, i);
-              var notHost = hostparts.slice(i + 1);
-              var bit = part.match(hostnamePartStart);
-              if (bit) {
-                validParts.push(bit[1]);
-                notHost.unshift(bit[2]);
-              }
-              if (notHost.length) {
-                rest = '/' + notHost.join('.') + rest;
-              }
-              this.hostname = validParts.join('.');
-              break;
-            }
-          }
-        }
-      }
-
-      if (this.hostname.length > hostnameMaxLen) {
-        this.hostname = '';
-      } else {
-        // hostnames are always lower case.
-        this.hostname = this.hostname.toLowerCase();
-      }
-
-      if (!ipv6Hostname) {
-        // IDNA Support: Returns a punycoded representation of "domain".
-        // It only converts parts of the domain name that
-        // have non-ASCII characters, i.e. it doesn't matter if
-        // you call it with a domain that already is ASCII-only.
-        this.hostname = punycode.toASCII(this.hostname);
-      }
-
-      var p = this.port ? ':' + this.port : '';
-      var h = this.hostname || '';
-      this.host = h + p;
-      this.href += this.host;
-
-      // strip [ and ] from the hostname
-      // the host field still retains them, though
-      if (ipv6Hostname) {
-        this.hostname = this.hostname.substr(1, this.hostname.length - 2);
-        if (rest[0] !== '/') {
-          rest = '/' + rest;
-        }
-      }
-    }
-
-    // now rest is set to the post-host stuff.
-    // chop off any delim chars.
-    if (!unsafeProtocol[lowerProto]) {
-
-      // First, make 100% sure that any "autoEscape" chars get
-      // escaped, even if encodeURIComponent doesn't think they
-      // need to be.
-      for (var i = 0, l = autoEscape.length; i < l; i++) {
-        var ae = autoEscape[i];
-        if (rest.indexOf(ae) === -1)
-          { continue; }
-        var esc = encodeURIComponent(ae);
-        if (esc === ae) {
-          esc = escape(ae);
-        }
-        rest = rest.split(ae).join(esc);
-      }
-    }
-
-
-    // chop off from the tail first.
-    var hash = rest.indexOf('#');
-    if (hash !== -1) {
-      // got a fragment string.
-      this.hash = rest.substr(hash);
-      rest = rest.slice(0, hash);
-    }
-    var qm = rest.indexOf('?');
-    if (qm !== -1) {
-      this.search = rest.substr(qm);
-      this.query = rest.substr(qm + 1);
-      if (parseQueryString) {
-        this.query = querystring.parse(this.query);
-      }
-      rest = rest.slice(0, qm);
-    } else if (parseQueryString) {
-      // no query string, but parseQueryString still requested
-      this.search = '';
-      this.query = {};
-    }
-    if (rest) { this.pathname = rest; }
-    if (slashedProtocol[lowerProto] &&
-        this.hostname && !this.pathname) {
-      this.pathname = '/';
-    }
-
-    //to support http.request
-    if (this.pathname || this.search) {
-      var p = this.pathname || '';
-      var s = this.search || '';
-      this.path = p + s;
-    }
-
-    // finally, reconstruct the href based on what has been validated.
-    this.href = this.format();
-    return this;
-  };
-
-  // format a parsed object into a url string
-  function urlFormat(obj) {
-    // ensure it's an object, and not a string url.
-    // If it's an obj, this is a no-op.
-    // this way, you can call url_format() on strings
-    // to clean up potentially wonky urls.
-    if (util.isString(obj)) { obj = urlParse(obj); }
-    if (!(obj instanceof Url)) { return Url.prototype.format.call(obj); }
-    return obj.format();
-  }
-
-  Url.prototype.format = function() {
-    var auth = this.auth || '';
-    if (auth) {
-      auth = encodeURIComponent(auth);
-      auth = auth.replace(/%3A/i, ':');
-      auth += '@';
-    }
-
-    var protocol = this.protocol || '',
-        pathname = this.pathname || '',
-        hash = this.hash || '',
-        host = false,
-        query = '';
-
-    if (this.host) {
-      host = auth + this.host;
-    } else if (this.hostname) {
-      host = auth + (this.hostname.indexOf(':') === -1 ?
-          this.hostname :
-          '[' + this.hostname + ']');
-      if (this.port) {
-        host += ':' + this.port;
-      }
-    }
-
-    if (this.query &&
-        util.isObject(this.query) &&
-        Object.keys(this.query).length) {
-      query = querystring.stringify(this.query);
-    }
-
-    var search = this.search || (query && ('?' + query)) || '';
-
-    if (protocol && protocol.substr(-1) !== ':') { protocol += ':'; }
-
-    // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
-    // unless they had them to begin with.
-    if (this.slashes ||
-        (!protocol || slashedProtocol[protocol]) && host !== false) {
-      host = '//' + (host || '');
-      if (pathname && pathname.charAt(0) !== '/') { pathname = '/' + pathname; }
-    } else if (!host) {
-      host = '';
-    }
-
-    if (hash && hash.charAt(0) !== '#') { hash = '#' + hash; }
-    if (search && search.charAt(0) !== '?') { search = '?' + search; }
-
-    pathname = pathname.replace(/[?#]/g, function(match) {
-      return encodeURIComponent(match);
-    });
-    search = search.replace('#', '%23');
-
-    return protocol + host + pathname + search + hash;
-  };
-
-  function urlResolve(source, relative) {
-    return urlParse(source, false, true).resolve(relative);
-  }
-
-  Url.prototype.resolve = function(relative) {
-    return this.resolveObject(urlParse(relative, false, true)).format();
-  };
-
-  function urlResolveObject(source, relative) {
-    if (!source) { return relative; }
-    return urlParse(source, false, true).resolveObject(relative);
-  }
-
-  Url.prototype.resolveObject = function(relative) {
-    if (util.isString(relative)) {
-      var rel = new Url();
-      rel.parse(relative, false, true);
-      relative = rel;
-    }
-
-    var result = new Url();
-    var tkeys = Object.keys(this);
-    for (var tk = 0; tk < tkeys.length; tk++) {
-      var tkey = tkeys[tk];
-      result[tkey] = this[tkey];
-    }
-
-    // hash is always overridden, no matter what.
-    // even href="" will remove it.
-    result.hash = relative.hash;
-
-    // if the relative url is empty, then there's nothing left to do here.
-    if (relative.href === '') {
-      result.href = result.format();
-      return result;
-    }
-
-    // hrefs like //foo/bar always cut to the protocol.
-    if (relative.slashes && !relative.protocol) {
-      // take everything except the protocol from relative
-      var rkeys = Object.keys(relative);
-      for (var rk = 0; rk < rkeys.length; rk++) {
-        var rkey = rkeys[rk];
-        if (rkey !== 'protocol')
-          { result[rkey] = relative[rkey]; }
-      }
-
-      //urlParse appends trailing / to urls like http://www.example.com
-      if (slashedProtocol[result.protocol] &&
-          result.hostname && !result.pathname) {
-        result.path = result.pathname = '/';
-      }
-
-      result.href = result.format();
-      return result;
-    }
-
-    if (relative.protocol && relative.protocol !== result.protocol) {
-      // if it's a known url protocol, then changing
-      // the protocol does weird things
-      // first, if it's not file:, then we MUST have a host,
-      // and if there was a path
-      // to begin with, then we MUST have a path.
-      // if it is file:, then the host is dropped,
-      // because that's known to be hostless.
-      // anything else is assumed to be absolute.
-      if (!slashedProtocol[relative.protocol]) {
-        var keys = Object.keys(relative);
-        for (var v = 0; v < keys.length; v++) {
-          var k = keys[v];
-          result[k] = relative[k];
-        }
-        result.href = result.format();
-        return result;
-      }
-
-      result.protocol = relative.protocol;
-      if (!relative.host && !hostlessProtocol[relative.protocol]) {
-        var relPath = (relative.pathname || '').split('/');
-        while (relPath.length && !(relative.host = relPath.shift())){ ; }
-        if (!relative.host) { relative.host = ''; }
-        if (!relative.hostname) { relative.hostname = ''; }
-        if (relPath[0] !== '') { relPath.unshift(''); }
-        if (relPath.length < 2) { relPath.unshift(''); }
-        result.pathname = relPath.join('/');
-      } else {
-        result.pathname = relative.pathname;
-      }
-      result.search = relative.search;
-      result.query = relative.query;
-      result.host = relative.host || '';
-      result.auth = relative.auth;
-      result.hostname = relative.hostname || relative.host;
-      result.port = relative.port;
-      // to support http.request
-      if (result.pathname || result.search) {
-        var p = result.pathname || '';
-        var s = result.search || '';
-        result.path = p + s;
-      }
-      result.slashes = result.slashes || relative.slashes;
-      result.href = result.format();
-      return result;
-    }
-
-    var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
-        isRelAbs = (
-            relative.host ||
-            relative.pathname && relative.pathname.charAt(0) === '/'
-        ),
-        mustEndAbs = (isRelAbs || isSourceAbs ||
-                      (result.host && relative.pathname)),
-        removeAllDots = mustEndAbs,
-        srcPath = result.pathname && result.pathname.split('/') || [],
-        relPath = relative.pathname && relative.pathname.split('/') || [],
-        psychotic = result.protocol && !slashedProtocol[result.protocol];
-
-    // if the url is a non-slashed url, then relative
-    // links like ../.. should be able
-    // to crawl up to the hostname, as well.  This is strange.
-    // result.protocol has already been set by now.
-    // Later on, put the first path part into the host field.
-    if (psychotic) {
-      result.hostname = '';
-      result.port = null;
-      if (result.host) {
-        if (srcPath[0] === '') { srcPath[0] = result.host; }
-        else { srcPath.unshift(result.host); }
-      }
-      result.host = '';
-      if (relative.protocol) {
-        relative.hostname = null;
-        relative.port = null;
-        if (relative.host) {
-          if (relPath[0] === '') { relPath[0] = relative.host; }
-          else { relPath.unshift(relative.host); }
-        }
-        relative.host = null;
-      }
-      mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
-    }
-
-    if (isRelAbs) {
-      // it's absolute.
-      result.host = (relative.host || relative.host === '') ?
-                    relative.host : result.host;
-      result.hostname = (relative.hostname || relative.hostname === '') ?
-                        relative.hostname : result.hostname;
-      result.search = relative.search;
-      result.query = relative.query;
-      srcPath = relPath;
-      // fall through to the dot-handling below.
-    } else if (relPath.length) {
-      // it's relative
-      // throw away the existing file, and take the new path instead.
-      if (!srcPath) { srcPath = []; }
-      srcPath.pop();
-      srcPath = srcPath.concat(relPath);
-      result.search = relative.search;
-      result.query = relative.query;
-    } else if (!util.isNullOrUndefined(relative.search)) {
-      // just pull out the search.
-      // like href='?foo'.
-      // Put this after the other two cases because it simplifies the booleans
-      if (psychotic) {
-        result.hostname = result.host = srcPath.shift();
-        //occationaly the auth can get stuck only in host
-        //this especially happens in cases like
-        //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
-        var authInHost = result.host && result.host.indexOf('@') > 0 ?
-                         result.host.split('@') : false;
-        if (authInHost) {
-          result.auth = authInHost.shift();
-          result.host = result.hostname = authInHost.shift();
-        }
-      }
-      result.search = relative.search;
-      result.query = relative.query;
-      //to support http.request
-      if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
-        result.path = (result.pathname ? result.pathname : '') +
-                      (result.search ? result.search : '');
-      }
-      result.href = result.format();
-      return result;
-    }
-
-    if (!srcPath.length) {
-      // no path at all.  easy.
-      // we've already handled the other stuff above.
-      result.pathname = null;
-      //to support http.request
-      if (result.search) {
-        result.path = '/' + result.search;
-      } else {
-        result.path = null;
-      }
-      result.href = result.format();
-      return result;
-    }
-
-    // if a url ENDs in . or .., then it must get a trailing slash.
-    // however, if it ends in anything else non-slashy,
-    // then it must NOT get a trailing slash.
-    var last = srcPath.slice(-1)[0];
-    var hasTrailingSlash = (
-        (result.host || relative.host || srcPath.length > 1) &&
-        (last === '.' || last === '..') || last === '');
-
-    // strip single dots, resolve double dots to parent dir
-    // if the path tries to go above the root, `up` ends up > 0
-    var up = 0;
-    for (var i = srcPath.length; i >= 0; i--) {
-      last = srcPath[i];
-      if (last === '.') {
-        srcPath.splice(i, 1);
-      } else if (last === '..') {
-        srcPath.splice(i, 1);
-        up++;
-      } else if (up) {
-        srcPath.splice(i, 1);
-        up--;
-      }
-    }
-
-    // if the path is allowed to go above the root, restore leading ..s
-    if (!mustEndAbs && !removeAllDots) {
-      for (; up--; up) {
-        srcPath.unshift('..');
-      }
-    }
-
-    if (mustEndAbs && srcPath[0] !== '' &&
-        (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
-      srcPath.unshift('');
-    }
-
-    if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
-      srcPath.push('');
-    }
-
-    var isAbsolute = srcPath[0] === '' ||
-        (srcPath[0] && srcPath[0].charAt(0) === '/');
-
-    // put the host back
-    if (psychotic) {
-      result.hostname = result.host = isAbsolute ? '' :
-                                      srcPath.length ? srcPath.shift() : '';
-      //occationaly the auth can get stuck only in host
-      //this especially happens in cases like
-      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
-      var authInHost = result.host && result.host.indexOf('@') > 0 ?
-                       result.host.split('@') : false;
-      if (authInHost) {
-        result.auth = authInHost.shift();
-        result.host = result.hostname = authInHost.shift();
-      }
-    }
-
-    mustEndAbs = mustEndAbs || (result.host && srcPath.length);
-
-    if (mustEndAbs && !isAbsolute) {
-      srcPath.unshift('');
-    }
-
-    if (!srcPath.length) {
-      result.pathname = null;
-      result.path = null;
-    } else {
-      result.pathname = srcPath.join('/');
-    }
-
-    //to support request.http
-    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
-      result.path = (result.pathname ? result.pathname : '') +
-                    (result.search ? result.search : '');
-    }
-    result.auth = relative.auth || result.auth;
-    result.slashes = result.slashes || relative.slashes;
-    result.href = result.format();
-    return result;
-  };
-
-  Url.prototype.parseHost = function() {
-    var host = this.host;
-    var port = portPattern.exec(host);
-    if (port) {
-      port = port[0];
-      if (port !== ':') {
-        this.port = port.substr(1);
-      }
-      host = host.substr(0, host.length - port.length);
-    }
-    if (host) { this.hostname = host; }
-  };
-
-  var url$1 = {
-  	parse: parse,
-  	resolve: resolve,
-  	resolveObject: resolveObject,
-  	format: format,
-  	Url: Url_1
-  };
-
-  /*!
-   * @pixi/utils - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/utils is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * This file contains redeclared types for Node `url` and `querystring` modules. These modules
-   * don't provide their own typings but instead are a part of the full Node typings. The purpose of
-   * this file is to redeclare the required types to avoid having the whole Node types as a
-   * dependency.
-   */
-  var url = {
-      parse: parse,
-      format: format,
-      resolve: resolve,
-  };
-
-  function assertPath(path) {
-      if (typeof path !== 'string') {
-          throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
-      }
-  }
-  function removeUrlParams(url) {
-      var re = url.split('?')[0];
-      return re.split('#')[0];
-  }
-  function escapeRegExp(string) {
-      return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-  }
-  function replaceAll(str, find, replace) {
-      return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
-  }
-  // Resolves . and .. elements in a path with directory names
-  function normalizeStringPosix(path, allowAboveRoot) {
-      var res = '';
-      var lastSegmentLength = 0;
-      var lastSlash = -1;
-      var dots = 0;
-      var code;
-      for (var i = 0; i <= path.length; ++i) {
-          if (i < path.length) {
-              code = path.charCodeAt(i);
-          }
-          else if (code === 47) {
-              break;
-          }
-          else {
-              code = 47;
-          }
-          if (code === 47) {
-              if (lastSlash === i - 1 || dots === 1) { ; }
-              else if (lastSlash !== i - 1 && dots === 2) {
-                  if (res.length < 2
-                      || lastSegmentLength !== 2
-                      || res.charCodeAt(res.length - 1) !== 46
-                      || res.charCodeAt(res.length - 2) !== 46) {
-                      if (res.length > 2) {
-                          var lastSlashIndex = res.lastIndexOf('/');
-                          if (lastSlashIndex !== res.length - 1) {
-                              if (lastSlashIndex === -1) {
-                                  res = '';
-                                  lastSegmentLength = 0;
-                              }
-                              else {
-                                  res = res.slice(0, lastSlashIndex);
-                                  lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
-                              }
-                              lastSlash = i;
-                              dots = 0;
-                              continue;
-                          }
-                      }
-                      else if (res.length === 2 || res.length === 1) {
-                          res = '';
-                          lastSegmentLength = 0;
-                          lastSlash = i;
-                          dots = 0;
-                          continue;
-                      }
-                  }
-                  if (allowAboveRoot) {
-                      if (res.length > 0) {
-                          res += '/..';
-                      }
-                      else {
-                          res = '..';
-                      }
-                      lastSegmentLength = 2;
-                  }
-              }
-              else {
-                  if (res.length > 0) {
-                      res += "/" + path.slice(lastSlash + 1, i);
-                  }
-                  else {
-                      res = path.slice(lastSlash + 1, i);
-                  }
-                  lastSegmentLength = i - lastSlash - 1;
-              }
-              lastSlash = i;
-              dots = 0;
-          }
-          else if (code === 46 && dots !== -1) {
-              ++dots;
-          }
-          else {
-              dots = -1;
-          }
-      }
-      return res;
-  }
-  var path = {
-      /**
-       * Converts a path to posix format.
-       * @param path - The path to convert to posix
-       */
-      toPosix: function (path) { return replaceAll(path, '\\', '/'); },
-      /**
-       * Checks if the path is a URL
-       * @param path - The path to check
-       */
-      isUrl: function (path) { return (/^https?:/).test(this.toPosix(path)); },
-      /**
-       * Checks if the path is a data URL
-       * @param path - The path to check
-       */
-      isDataUrl: function (path) {
-          // eslint-disable-next-line max-len
-          return (/^data:([a-z]+\/[a-z0-9-+.]+(;[a-z0-9-.!#$%*+.{}|~`]+=[a-z0-9-.!#$%*+.{}()_|~`]+)*)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s<>]*?)$/i)
-              .test(path);
-      },
-      /**
-       * Checks if the path has a protocol e.g. http://
-       * This will return true for windows file paths
-       * @param path - The path to check
-       */
-      hasProtocol: function (path) { return (/^[^/:]+:\//).test(this.toPosix(path)); },
-      /**
-       * Returns the protocol of the path e.g. http://, C:/, file:///
-       * @param path - The path to get the protocol from
-       */
-      getProtocol: function (path) {
-          assertPath(path);
-          path = this.toPosix(path);
-          var protocol = '';
-          var isFile = (/^file:\/\/\//).exec(path);
-          var isHttp = (/^[^/:]+:\/\//).exec(path);
-          var isWindows = (/^[^/:]+:\//).exec(path);
-          if (isFile || isHttp || isWindows) {
-              var arr = (isFile === null || isFile === void 0 ? void 0 : isFile[0]) || (isHttp === null || isHttp === void 0 ? void 0 : isHttp[0]) || (isWindows === null || isWindows === void 0 ? void 0 : isWindows[0]);
-              protocol = arr;
-              path = path.slice(arr.length);
-          }
-          return protocol;
-      },
-      /**
-       * Converts URL to an absolute path.
-       * When loading from a Web Worker, we must use absolute paths.
-       * If the URL is already absolute we return it as is
-       * If it's not, we convert it
-       * @param url - The URL to test
-       * @param customBaseUrl - The base URL to use
-       * @param customRootUrl - The root URL to use
-       */
-      toAbsolute: function (url, customBaseUrl, customRootUrl) {
-          if (this.isDataUrl(url))
-              { return url; }
-          var baseUrl = removeUrlParams(this.toPosix(customBaseUrl !== null && customBaseUrl !== void 0 ? customBaseUrl : settings.ADAPTER.getBaseUrl()));
-          var rootUrl = removeUrlParams(this.toPosix(customRootUrl !== null && customRootUrl !== void 0 ? customRootUrl : this.rootname(baseUrl)));
-          assertPath(url);
-          url = this.toPosix(url);
-          // root relative url
-          if (url.startsWith('/')) {
-              return path.join(rootUrl, url.slice(1));
-          }
-          var absolutePath = this.isAbsolute(url) ? url : this.join(baseUrl, url);
-          return absolutePath;
-      },
-      /**
-       * Normalizes the given path, resolving '..' and '.' segments
-       * @param path - The path to normalize
-       */
-      normalize: function (path) {
-          path = this.toPosix(path);
-          assertPath(path);
-          if (path.length === 0)
-              { return '.'; }
-          var protocol = '';
-          var isAbsolute = path.startsWith('/');
-          if (this.hasProtocol(path)) {
-              protocol = this.rootname(path);
-              path = path.slice(protocol.length);
-          }
-          var trailingSeparator = path.endsWith('/');
-          // Normalize the path
-          path = normalizeStringPosix(path, false);
-          if (path.length > 0 && trailingSeparator)
-              { path += '/'; }
-          if (isAbsolute)
-              { return "/" + path; }
-          return protocol + path;
-      },
-      /**
-       * Determines if path is an absolute path.
-       * Absolute paths can be urls, data urls, or paths on disk
-       * @param path - The path to test
-       */
-      isAbsolute: function (path) {
-          assertPath(path);
-          path = this.toPosix(path);
-          if (this.hasProtocol(path))
-              { return true; }
-          return path.startsWith('/');
-      },
-      /**
-       * Joins all given path segments together using the platform-specific separator as a delimiter,
-       * then normalizes the resulting path
-       * @param segments - The segments of the path to join
-       */
-      join: function () {
-          var arguments$1 = arguments;
-
-          var _a;
-          var segments = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              segments[_i] = arguments$1[_i];
-          }
-          if (segments.length === 0) {
-              return '.';
-          }
-          var joined;
-          for (var i = 0; i < segments.length; ++i) {
-              var arg = segments[i];
-              assertPath(arg);
-              if (arg.length > 0) {
-                  if (joined === undefined)
-                      { joined = arg; }
-                  else {
-                      var prevArg = (_a = segments[i - 1]) !== null && _a !== void 0 ? _a : '';
-                      if (this.extname(prevArg)) {
-                          joined += "/../" + arg;
-                      }
-                      else {
-                          joined += "/" + arg;
-                      }
-                  }
-              }
-          }
-          if (joined === undefined) {
-              return '.';
-          }
-          return this.normalize(joined);
-      },
-      /**
-       * Returns the directory name of a path
-       * @param path - The path to parse
-       */
-      dirname: function (path) {
-          assertPath(path);
-          if (path.length === 0)
-              { return '.'; }
-          path = this.toPosix(path);
-          var code = path.charCodeAt(0);
-          var hasRoot = code === 47;
-          var end = -1;
-          var matchedSlash = true;
-          var proto = this.getProtocol(path);
-          var origpath = path;
-          path = path.slice(proto.length);
-          for (var i = path.length - 1; i >= 1; --i) {
-              code = path.charCodeAt(i);
-              if (code === 47) {
-                  if (!matchedSlash) {
-                      end = i;
-                      break;
-                  }
-              }
-              else {
-                  // We saw the first non-path separator
-                  matchedSlash = false;
-              }
-          }
-          // if end is -1 and its a url then we need to add the path back
-          // eslint-disable-next-line no-nested-ternary
-          if (end === -1)
-              { return hasRoot ? '/' : this.isUrl(origpath) ? proto + path : proto; }
-          if (hasRoot && end === 1)
-              { return '//'; }
-          return proto + path.slice(0, end);
-      },
-      /**
-       * Returns the root of the path e.g. /, C:/, file:///, http://domain.com/
-       * @param path - The path to parse
-       */
-      rootname: function (path) {
-          assertPath(path);
-          path = this.toPosix(path);
-          var root = '';
-          if (path.startsWith('/'))
-              { root = '/'; }
-          else {
-              root = this.getProtocol(path);
-          }
-          if (this.isUrl(path)) {
-              // need to find the first path separator
-              var index = path.indexOf('/', root.length);
-              if (index !== -1) {
-                  root = path.slice(0, index);
-              }
-              else
-                  { root = path; }
-              if (!root.endsWith('/'))
-                  { root += '/'; }
-          }
-          return root;
-      },
-      /**
-       * Returns the last portion of a path
-       * @param path - The path to test
-       * @param ext - Optional extension to remove
-       */
-      basename: function (path, ext) {
-          assertPath(path);
-          if (ext)
-              { assertPath(ext); }
-          path = this.toPosix(path);
-          var start = 0;
-          var end = -1;
-          var matchedSlash = true;
-          var i;
-          if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
-              if (ext.length === path.length && ext === path)
-                  { return ''; }
-              var extIdx = ext.length - 1;
-              var firstNonSlashEnd = -1;
-              for (i = path.length - 1; i >= 0; --i) {
-                  var code = path.charCodeAt(i);
-                  if (code === 47) {
-                      // If we reached a path separator that was not part of a set of path
-                      // separators at the end of the string, stop now
-                      if (!matchedSlash) {
-                          start = i + 1;
-                          break;
-                      }
-                  }
-                  else {
-                      if (firstNonSlashEnd === -1) {
-                          // We saw the first non-path separator, remember this index in case
-                          // we need it if the extension ends up not matching
-                          matchedSlash = false;
-                          firstNonSlashEnd = i + 1;
-                      }
-                      if (extIdx >= 0) {
-                          // Try to match the explicit extension
-                          if (code === ext.charCodeAt(extIdx)) {
-                              if (--extIdx === -1) {
-                                  // We matched the extension, so mark this as the end of our path
-                                  // component
-                                  end = i;
-                              }
-                          }
-                          else {
-                              // Extension does not match, so our result is the entire path
-                              // component
-                              extIdx = -1;
-                              end = firstNonSlashEnd;
-                          }
-                      }
-                  }
-              }
-              if (start === end)
-                  { end = firstNonSlashEnd; }
-              else if (end === -1)
-                  { end = path.length; }
-              return path.slice(start, end);
-          }
-          for (i = path.length - 1; i >= 0; --i) {
-              if (path.charCodeAt(i) === 47) {
-                  // If we reached a path separator that was not part of a set of path
-                  // separators at the end of the string, stop now
-                  if (!matchedSlash) {
-                      start = i + 1;
-                      break;
-                  }
-              }
-              else if (end === -1) {
-                  // We saw the first non-path separator, mark this as the end of our
-                  // path component
-                  matchedSlash = false;
-                  end = i + 1;
-              }
-          }
-          if (end === -1)
-              { return ''; }
-          return path.slice(start, end);
-      },
-      /**
-       * Returns the extension of the path, from the last occurrence of the . (period) character to end of string in the last
-       * portion of the path. If there is no . in the last portion of the path, or if there are no . characters other than
-       * the first character of the basename of path, an empty string is returned.
-       * @param path - The path to parse
-       */
-      extname: function (path) {
-          assertPath(path);
-          path = this.toPosix(path);
-          var startDot = -1;
-          var startPart = 0;
-          var end = -1;
-          var matchedSlash = true;
-          // Track the state of characters (if any) we see before our first dot and
-          // after any path separator we find
-          var preDotState = 0;
-          for (var i = path.length - 1; i >= 0; --i) {
-              var code = path.charCodeAt(i);
-              if (code === 47) {
-                  // If we reached a path separator that was not part of a set of path
-                  // separators at the end of the string, stop now
-                  if (!matchedSlash) {
-                      startPart = i + 1;
-                      break;
-                  }
-                  continue;
-              }
-              if (end === -1) {
-                  // We saw the first non-path separator, mark this as the end of our
-                  // extension
-                  matchedSlash = false;
-                  end = i + 1;
-              }
-              if (code === 46) {
-                  // If this is our first dot, mark it as the start of our extension
-                  if (startDot === -1)
-                      { startDot = i; }
-                  else if (preDotState !== 1)
-                      { preDotState = 1; }
-              }
-              else if (startDot !== -1) {
-                  // We saw a non-dot and non-path separator before our dot, so we should
-                  // have a good chance at having a non-empty extension
-                  preDotState = -1;
-              }
-          }
-          if (startDot === -1 || end === -1
-              // We saw a non-dot character immediately before the dot
-              || preDotState === 0
-              // The (right-most) trimmed path component is exactly '..'
-              // eslint-disable-next-line no-mixed-operators
-              || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-              return '';
-          }
-          return path.slice(startDot, end);
-      },
-      /**
-       * Parses a path into an object containing the 'root', `dir`, `base`, `ext`, and `name` properties.
-       * @param path - The path to parse
-       */
-      parse: function (path) {
-          assertPath(path);
-          var ret = { root: '', dir: '', base: '', ext: '', name: '' };
-          if (path.length === 0)
-              { return ret; }
-          path = this.toPosix(path);
-          var code = path.charCodeAt(0);
-          var isAbsolute = this.isAbsolute(path);
-          var start;
-          ret.root = this.rootname(path);
-          if (isAbsolute || this.hasProtocol(path)) {
-              start = 1;
-          }
-          else {
-              start = 0;
-          }
-          var startDot = -1;
-          var startPart = 0;
-          var end = -1;
-          var matchedSlash = true;
-          var i = path.length - 1;
-          // Track the state of characters (if any) we see before our first dot and
-          // after any path separator we find
-          var preDotState = 0;
-          // Get non-dir info
-          for (; i >= start; --i) {
-              code = path.charCodeAt(i);
-              if (code === 47) {
-                  // If we reached a path separator that was not part of a set of path
-                  // separators at the end of the string, stop now
-                  if (!matchedSlash) {
-                      startPart = i + 1;
-                      break;
-                  }
-                  continue;
-              }
-              if (end === -1) {
-                  // We saw the first non-path separator, mark this as the end of our
-                  // extension
-                  matchedSlash = false;
-                  end = i + 1;
-              }
-              if (code === 46) {
-                  // If this is our first dot, mark it as the start of our extension
-                  if (startDot === -1)
-                      { startDot = i; }
-                  else if (preDotState !== 1)
-                      { preDotState = 1; }
-              }
-              else if (startDot !== -1) {
-                  // We saw a non-dot and non-path separator before our dot, so we should
-                  // have a good chance at having a non-empty extension
-                  preDotState = -1;
-              }
-          }
-          if (startDot === -1 || end === -1
-              // We saw a non-dot character immediately before the dot
-              || preDotState === 0
-              // The (right-most) trimmed path component is exactly '..'
-              // eslint-disable-next-line no-mixed-operators
-              || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-              if (end !== -1) {
-                  if (startPart === 0 && isAbsolute)
-                      { ret.base = ret.name = path.slice(1, end); }
-                  else
-                      { ret.base = ret.name = path.slice(startPart, end); }
-              }
-          }
-          else {
-              if (startPart === 0 && isAbsolute) {
-                  ret.name = path.slice(1, startDot);
-                  ret.base = path.slice(1, end);
-              }
-              else {
-                  ret.name = path.slice(startPart, startDot);
-                  ret.base = path.slice(startPart, end);
-              }
-              ret.ext = path.slice(startDot, end);
-          }
-          ret.dir = this.dirname(path);
-          return ret;
-      },
-      sep: '/',
-      delimiter: ':'
-  };
-
-  /**
-   * The prefix that denotes a URL is for a retina asset.
-   * @static
-   * @name RETINA_PREFIX
-   * @memberof PIXI.settings
-   * @type {RegExp}
-   * @default /@([0-9\.]+)x/
-   * @example `@2x`
-   */
-  settings.RETINA_PREFIX = /@([0-9\.]+)x/;
-  /**
-   * Should the `failIfMajorPerformanceCaveat` flag be enabled as a context option used in the `isWebGLSupported` function.
-   * If set to true, a WebGL renderer can fail to be created if the browser thinks there could be performance issues when
-   * using WebGL.
-   *
-   * In PixiJS v6 this has changed from true to false by default, to allow WebGL to work in as many scenarios as possible.
-   * However, some users may have a poor experience, for example, if a user has a gpu or driver version blacklisted by the
-   * browser.
-   *
-   * If your application requires high performance rendering, you may wish to set this to false.
-   * We recommend one of two options if you decide to set this flag to false:
-   *
-   * 1: Use the `pixi.js-legacy` package, which includes a Canvas renderer as a fallback in case high performance WebGL is
-   *    not supported.
-   *
-   * 2: Call `isWebGLSupported` (which if found in the PIXI.utils package) in your code before attempting to create a PixiJS
-   *    renderer, and show an error message to the user if the function returns false, explaining that their device & browser
-   *    combination does not support high performance WebGL.
-   *    This is a much better strategy than trying to create a PixiJS renderer and finding it then fails.
-   * @static
-   * @name FAIL_IF_MAJOR_PERFORMANCE_CAVEAT
-   * @memberof PIXI.settings
-   * @type {boolean}
-   * @default false
-   */
-  settings.FAIL_IF_MAJOR_PERFORMANCE_CAVEAT = false;
-
-  var saidHello = false;
-  var VERSION$1 = '6.5.10';
-  /**
-   * Skips the hello message of renderers that are created after this is run.
-   * @function skipHello
-   * @memberof PIXI.utils
-   */
-  function skipHello() {
-      saidHello = true;
-  }
-  /**
-   * Logs out the version and renderer information for this running instance of PIXI.
-   * If you don't want to see this message you can run `PIXI.utils.skipHello()` before
-   * creating your renderer. Keep in mind that doing that will forever make you a jerk face.
-   * @static
-   * @function sayHello
-   * @memberof PIXI.utils
-   * @param {string} type - The string renderer type to log.
-   */
-  function sayHello(type) {
-      var _a;
-      if (saidHello) {
-          return;
-      }
-      if (settings.ADAPTER.getNavigator().userAgent.toLowerCase().indexOf('chrome') > -1) {
-          var args = [
-              "\n %c %c %c PixiJS " + VERSION$1 + " - \u2730 " + type + " \u2730  %c  %c  http://www.pixijs.com/  %c %c \u2665%c\u2665%c\u2665 \n\n",
-              'background: #ff66a5; padding:5px 0;',
-              'background: #ff66a5; padding:5px 0;',
-              'color: #ff66a5; background: #030307; padding:5px 0;',
-              'background: #ff66a5; padding:5px 0;',
-              'background: #ffc3dc; padding:5px 0;',
-              'background: #ff66a5; padding:5px 0;',
-              'color: #ff2424; background: #fff; padding:5px 0;',
-              'color: #ff2424; background: #fff; padding:5px 0;',
-              'color: #ff2424; background: #fff; padding:5px 0;' ];
-          (_a = globalThis.console).log.apply(_a, args);
-      }
-      else if (globalThis.console) {
-          globalThis.console.log("PixiJS " + VERSION$1 + " - " + type + " - http://www.pixijs.com/");
-      }
-      saidHello = true;
-  }
-
-  var supported;
-  /**
-   * Helper for checking for WebGL support.
-   * @memberof PIXI.utils
-   * @function isWebGLSupported
-   * @returns {boolean} Is WebGL supported.
-   */
-  function isWebGLSupported() {
-      if (typeof supported === 'undefined') {
-          supported = (function supported() {
-              var contextOptions = {
-                  stencil: true,
-                  failIfMajorPerformanceCaveat: settings.FAIL_IF_MAJOR_PERFORMANCE_CAVEAT,
-              };
-              try {
-                  if (!settings.ADAPTER.getWebGLRenderingContext()) {
-                      return false;
-                  }
-                  var canvas = settings.ADAPTER.createCanvas();
-                  var gl = (canvas.getContext('webgl', contextOptions)
-                      || canvas.getContext('experimental-webgl', contextOptions));
-                  var success = !!(gl && gl.getContextAttributes().stencil);
-                  if (gl) {
-                      var loseContext = gl.getExtension('WEBGL_lose_context');
-                      if (loseContext) {
-                          loseContext.loseContext();
-                      }
-                  }
-                  gl = null;
-                  return success;
-              }
-              catch (e) {
-                  return false;
-              }
-          })();
-      }
-      return supported;
-  }
-
-  var aliceblue = "#f0f8ff";
-  var antiquewhite = "#faebd7";
-  var aqua = "#00ffff";
-  var aquamarine = "#7fffd4";
-  var azure = "#f0ffff";
-  var beige = "#f5f5dc";
-  var bisque = "#ffe4c4";
-  var black = "#000000";
-  var blanchedalmond = "#ffebcd";
-  var blue = "#0000ff";
-  var blueviolet = "#8a2be2";
-  var brown = "#a52a2a";
-  var burlywood = "#deb887";
-  var cadetblue = "#5f9ea0";
-  var chartreuse = "#7fff00";
-  var chocolate = "#d2691e";
-  var coral = "#ff7f50";
-  var cornflowerblue = "#6495ed";
-  var cornsilk = "#fff8dc";
-  var crimson = "#dc143c";
-  var cyan = "#00ffff";
-  var darkblue = "#00008b";
-  var darkcyan = "#008b8b";
-  var darkgoldenrod = "#b8860b";
-  var darkgray = "#a9a9a9";
-  var darkgreen = "#006400";
-  var darkgrey = "#a9a9a9";
-  var darkkhaki = "#bdb76b";
-  var darkmagenta = "#8b008b";
-  var darkolivegreen = "#556b2f";
-  var darkorange = "#ff8c00";
-  var darkorchid = "#9932cc";
-  var darkred = "#8b0000";
-  var darksalmon = "#e9967a";
-  var darkseagreen = "#8fbc8f";
-  var darkslateblue = "#483d8b";
-  var darkslategray = "#2f4f4f";
-  var darkslategrey = "#2f4f4f";
-  var darkturquoise = "#00ced1";
-  var darkviolet = "#9400d3";
-  var deeppink = "#ff1493";
-  var deepskyblue = "#00bfff";
-  var dimgray = "#696969";
-  var dimgrey = "#696969";
-  var dodgerblue = "#1e90ff";
-  var firebrick = "#b22222";
-  var floralwhite = "#fffaf0";
-  var forestgreen = "#228b22";
-  var fuchsia = "#ff00ff";
-  var gainsboro = "#dcdcdc";
-  var ghostwhite = "#f8f8ff";
-  var goldenrod = "#daa520";
-  var gold = "#ffd700";
-  var gray = "#808080";
-  var green = "#008000";
-  var greenyellow = "#adff2f";
-  var grey = "#808080";
-  var honeydew = "#f0fff0";
-  var hotpink = "#ff69b4";
-  var indianred = "#cd5c5c";
-  var indigo = "#4b0082";
-  var ivory = "#fffff0";
-  var khaki = "#f0e68c";
-  var lavenderblush = "#fff0f5";
-  var lavender = "#e6e6fa";
-  var lawngreen = "#7cfc00";
-  var lemonchiffon = "#fffacd";
-  var lightblue = "#add8e6";
-  var lightcoral = "#f08080";
-  var lightcyan = "#e0ffff";
-  var lightgoldenrodyellow = "#fafad2";
-  var lightgray = "#d3d3d3";
-  var lightgreen = "#90ee90";
-  var lightgrey = "#d3d3d3";
-  var lightpink = "#ffb6c1";
-  var lightsalmon = "#ffa07a";
-  var lightseagreen = "#20b2aa";
-  var lightskyblue = "#87cefa";
-  var lightslategray = "#778899";
-  var lightslategrey = "#778899";
-  var lightsteelblue = "#b0c4de";
-  var lightyellow = "#ffffe0";
-  var lime = "#00ff00";
-  var limegreen = "#32cd32";
-  var linen = "#faf0e6";
-  var magenta = "#ff00ff";
-  var maroon = "#800000";
-  var mediumaquamarine = "#66cdaa";
-  var mediumblue = "#0000cd";
-  var mediumorchid = "#ba55d3";
-  var mediumpurple = "#9370db";
-  var mediumseagreen = "#3cb371";
-  var mediumslateblue = "#7b68ee";
-  var mediumspringgreen = "#00fa9a";
-  var mediumturquoise = "#48d1cc";
-  var mediumvioletred = "#c71585";
-  var midnightblue = "#191970";
-  var mintcream = "#f5fffa";
-  var mistyrose = "#ffe4e1";
-  var moccasin = "#ffe4b5";
-  var navajowhite = "#ffdead";
-  var navy = "#000080";
-  var oldlace = "#fdf5e6";
-  var olive = "#808000";
-  var olivedrab = "#6b8e23";
-  var orange = "#ffa500";
-  var orangered = "#ff4500";
-  var orchid = "#da70d6";
-  var palegoldenrod = "#eee8aa";
-  var palegreen = "#98fb98";
-  var paleturquoise = "#afeeee";
-  var palevioletred = "#db7093";
-  var papayawhip = "#ffefd5";
-  var peachpuff = "#ffdab9";
-  var peru = "#cd853f";
-  var pink = "#ffc0cb";
-  var plum = "#dda0dd";
-  var powderblue = "#b0e0e6";
-  var purple = "#800080";
-  var rebeccapurple = "#663399";
-  var red = "#ff0000";
-  var rosybrown = "#bc8f8f";
-  var royalblue = "#4169e1";
-  var saddlebrown = "#8b4513";
-  var salmon = "#fa8072";
-  var sandybrown = "#f4a460";
-  var seagreen = "#2e8b57";
-  var seashell = "#fff5ee";
-  var sienna = "#a0522d";
-  var silver = "#c0c0c0";
-  var skyblue = "#87ceeb";
-  var slateblue = "#6a5acd";
-  var slategray = "#708090";
-  var slategrey = "#708090";
-  var snow = "#fffafa";
-  var springgreen = "#00ff7f";
-  var steelblue = "#4682b4";
-  var tan = "#d2b48c";
-  var teal = "#008080";
-  var thistle = "#d8bfd8";
-  var tomato = "#ff6347";
-  var turquoise = "#40e0d0";
-  var violet = "#ee82ee";
-  var wheat = "#f5deb3";
-  var white = "#ffffff";
-  var whitesmoke = "#f5f5f5";
-  var yellow = "#ffff00";
-  var yellowgreen = "#9acd32";
-  var cssColorNames = {
-  	aliceblue: aliceblue,
-  	antiquewhite: antiquewhite,
-  	aqua: aqua,
-  	aquamarine: aquamarine,
-  	azure: azure,
-  	beige: beige,
-  	bisque: bisque,
-  	black: black,
-  	blanchedalmond: blanchedalmond,
-  	blue: blue,
-  	blueviolet: blueviolet,
-  	brown: brown,
-  	burlywood: burlywood,
-  	cadetblue: cadetblue,
-  	chartreuse: chartreuse,
-  	chocolate: chocolate,
-  	coral: coral,
-  	cornflowerblue: cornflowerblue,
-  	cornsilk: cornsilk,
-  	crimson: crimson,
-  	cyan: cyan,
-  	darkblue: darkblue,
-  	darkcyan: darkcyan,
-  	darkgoldenrod: darkgoldenrod,
-  	darkgray: darkgray,
-  	darkgreen: darkgreen,
-  	darkgrey: darkgrey,
-  	darkkhaki: darkkhaki,
-  	darkmagenta: darkmagenta,
-  	darkolivegreen: darkolivegreen,
-  	darkorange: darkorange,
-  	darkorchid: darkorchid,
-  	darkred: darkred,
-  	darksalmon: darksalmon,
-  	darkseagreen: darkseagreen,
-  	darkslateblue: darkslateblue,
-  	darkslategray: darkslategray,
-  	darkslategrey: darkslategrey,
-  	darkturquoise: darkturquoise,
-  	darkviolet: darkviolet,
-  	deeppink: deeppink,
-  	deepskyblue: deepskyblue,
-  	dimgray: dimgray,
-  	dimgrey: dimgrey,
-  	dodgerblue: dodgerblue,
-  	firebrick: firebrick,
-  	floralwhite: floralwhite,
-  	forestgreen: forestgreen,
-  	fuchsia: fuchsia,
-  	gainsboro: gainsboro,
-  	ghostwhite: ghostwhite,
-  	goldenrod: goldenrod,
-  	gold: gold,
-  	gray: gray,
-  	green: green,
-  	greenyellow: greenyellow,
-  	grey: grey,
-  	honeydew: honeydew,
-  	hotpink: hotpink,
-  	indianred: indianred,
-  	indigo: indigo,
-  	ivory: ivory,
-  	khaki: khaki,
-  	lavenderblush: lavenderblush,
-  	lavender: lavender,
-  	lawngreen: lawngreen,
-  	lemonchiffon: lemonchiffon,
-  	lightblue: lightblue,
-  	lightcoral: lightcoral,
-  	lightcyan: lightcyan,
-  	lightgoldenrodyellow: lightgoldenrodyellow,
-  	lightgray: lightgray,
-  	lightgreen: lightgreen,
-  	lightgrey: lightgrey,
-  	lightpink: lightpink,
-  	lightsalmon: lightsalmon,
-  	lightseagreen: lightseagreen,
-  	lightskyblue: lightskyblue,
-  	lightslategray: lightslategray,
-  	lightslategrey: lightslategrey,
-  	lightsteelblue: lightsteelblue,
-  	lightyellow: lightyellow,
-  	lime: lime,
-  	limegreen: limegreen,
-  	linen: linen,
-  	magenta: magenta,
-  	maroon: maroon,
-  	mediumaquamarine: mediumaquamarine,
-  	mediumblue: mediumblue,
-  	mediumorchid: mediumorchid,
-  	mediumpurple: mediumpurple,
-  	mediumseagreen: mediumseagreen,
-  	mediumslateblue: mediumslateblue,
-  	mediumspringgreen: mediumspringgreen,
-  	mediumturquoise: mediumturquoise,
-  	mediumvioletred: mediumvioletred,
-  	midnightblue: midnightblue,
-  	mintcream: mintcream,
-  	mistyrose: mistyrose,
-  	moccasin: moccasin,
-  	navajowhite: navajowhite,
-  	navy: navy,
-  	oldlace: oldlace,
-  	olive: olive,
-  	olivedrab: olivedrab,
-  	orange: orange,
-  	orangered: orangered,
-  	orchid: orchid,
-  	palegoldenrod: palegoldenrod,
-  	palegreen: palegreen,
-  	paleturquoise: paleturquoise,
-  	palevioletred: palevioletred,
-  	papayawhip: papayawhip,
-  	peachpuff: peachpuff,
-  	peru: peru,
-  	pink: pink,
-  	plum: plum,
-  	powderblue: powderblue,
-  	purple: purple,
-  	rebeccapurple: rebeccapurple,
-  	red: red,
-  	rosybrown: rosybrown,
-  	royalblue: royalblue,
-  	saddlebrown: saddlebrown,
-  	salmon: salmon,
-  	sandybrown: sandybrown,
-  	seagreen: seagreen,
-  	seashell: seashell,
-  	sienna: sienna,
-  	silver: silver,
-  	skyblue: skyblue,
-  	slateblue: slateblue,
-  	slategray: slategray,
-  	slategrey: slategrey,
-  	snow: snow,
-  	springgreen: springgreen,
-  	steelblue: steelblue,
-  	tan: tan,
-  	teal: teal,
-  	thistle: thistle,
-  	tomato: tomato,
-  	turquoise: turquoise,
-  	violet: violet,
-  	wheat: wheat,
-  	white: white,
-  	whitesmoke: whitesmoke,
-  	yellow: yellow,
-  	yellowgreen: yellowgreen
-  };
-
-  /**
-   * Converts a hexadecimal color number to an [R, G, B] array of normalized floats (numbers from 0.0 to 1.0).
-   * @example
-   * PIXI.utils.hex2rgb(0xffffff); // returns [1, 1, 1]
-   * @memberof PIXI.utils
-   * @function hex2rgb
-   * @param {number} hex - The hexadecimal number to convert
-   * @param  {number[]} [out=[]] - If supplied, this array will be used rather than returning a new one
-   * @returns {number[]} An array representing the [R, G, B] of the color where all values are floats.
-   */
-  function hex2rgb(hex, out) {
-      if (out === void 0) { out = []; }
-      out[0] = ((hex >> 16) & 0xFF) / 255;
-      out[1] = ((hex >> 8) & 0xFF) / 255;
-      out[2] = (hex & 0xFF) / 255;
-      return out;
-  }
-  /**
-   * Converts a hexadecimal color number to a string.
-   * @example
-   * PIXI.utils.hex2string(0xffffff); // returns "#ffffff"
-   * @memberof PIXI.utils
-   * @function hex2string
-   * @param {number} hex - Number in hex (e.g., `0xffffff`)
-   * @returns {string} The string color (e.g., `"#ffffff"`).
-   */
-  function hex2string(hex) {
-      var hexString = hex.toString(16);
-      hexString = '000000'.substring(0, 6 - hexString.length) + hexString;
-      return "#" + hexString;
-  }
-  /**
-   * Converts a string to a hexadecimal color number.
-   * It can handle:
-   *  hex strings starting with #: "#ffffff"
-   *  hex strings starting with 0x: "0xffffff"
-   *  hex strings without prefix: "ffffff"
-   *  css colors: "black"
-   * @example
-   * PIXI.utils.string2hex("#ffffff"); // returns 0xffffff, which is 16777215 as an integer
-   * @memberof PIXI.utils
-   * @function string2hex
-   * @param {string} string - The string color (e.g., `"#ffffff"`)
-   * @returns {number} Number in hexadecimal.
-   */
-  function string2hex(string) {
-      if (typeof string === 'string') {
-          string = cssColorNames[string.toLowerCase()] || string;
-          if (string[0] === '#') {
-              string = string.slice(1);
-          }
-      }
-      return parseInt(string, 16);
-  }
-  /**
-   * Converts a color as an [R, G, B] array of normalized floats to a hexadecimal number.
-   * @example
-   * PIXI.utils.rgb2hex([1, 1, 1]); // returns 0xffffff, which is 16777215 as an integer
-   * @memberof PIXI.utils
-   * @function rgb2hex
-   * @param {number[]} rgb - Array of numbers where all values are normalized floats from 0.0 to 1.0.
-   * @returns {number} Number in hexadecimal.
-   */
-  function rgb2hex(rgb) {
-      return (((rgb[0] * 255) << 16) + ((rgb[1] * 255) << 8) + (rgb[2] * 255 | 0));
-  }
-
-  /**
-   * Corrects PixiJS blend, takes premultiplied alpha into account
-   * @memberof PIXI.utils
-   * @function mapPremultipliedBlendModes
-   * @private
-   * @returns {Array<number[]>} Mapped modes.
-   */
-  function mapPremultipliedBlendModes() {
-      var pm = [];
-      var npm = [];
-      for (var i = 0; i < 32; i++) {
-          pm[i] = i;
-          npm[i] = i;
-      }
-      pm[exports.BLEND_MODES.NORMAL_NPM] = exports.BLEND_MODES.NORMAL;
-      pm[exports.BLEND_MODES.ADD_NPM] = exports.BLEND_MODES.ADD;
-      pm[exports.BLEND_MODES.SCREEN_NPM] = exports.BLEND_MODES.SCREEN;
-      npm[exports.BLEND_MODES.NORMAL] = exports.BLEND_MODES.NORMAL_NPM;
-      npm[exports.BLEND_MODES.ADD] = exports.BLEND_MODES.ADD_NPM;
-      npm[exports.BLEND_MODES.SCREEN] = exports.BLEND_MODES.SCREEN_NPM;
-      var array = [];
-      array.push(npm);
-      array.push(pm);
-      return array;
-  }
-  /**
-   * maps premultiply flag and blendMode to adjusted blendMode
-   * @memberof PIXI.utils
-   * @constant premultiplyBlendMode
-   * @type {Array<number[]>}
-   */
-  var premultiplyBlendMode = mapPremultipliedBlendModes();
-  /**
-   * changes blendMode according to texture format
-   * @memberof PIXI.utils
-   * @function correctBlendMode
-   * @param {number} blendMode - supposed blend mode
-   * @param {boolean} premultiplied - whether source is premultiplied
-   * @returns {number} true blend mode for this texture
-   */
-  function correctBlendMode(blendMode, premultiplied) {
-      return premultiplyBlendMode[premultiplied ? 1 : 0][blendMode];
-  }
-  /**
-   * combines rgb and alpha to out array
-   * @memberof PIXI.utils
-   * @function premultiplyRgba
-   * @param {Float32Array|number[]} rgb - input rgb
-   * @param {number} alpha - alpha param
-   * @param {Float32Array} [out] - output
-   * @param {boolean} [premultiply=true] - do premultiply it
-   * @returns {Float32Array} vec4 rgba
-   */
-  function premultiplyRgba(rgb, alpha, out, premultiply) {
-      out = out || new Float32Array(4);
-      if (premultiply || premultiply === undefined) {
-          out[0] = rgb[0] * alpha;
-          out[1] = rgb[1] * alpha;
-          out[2] = rgb[2] * alpha;
-      }
-      else {
-          out[0] = rgb[0];
-          out[1] = rgb[1];
-          out[2] = rgb[2];
-      }
-      out[3] = alpha;
-      return out;
-  }
-  /**
-   * premultiplies tint
-   * @memberof PIXI.utils
-   * @function premultiplyTint
-   * @param {number} tint - integer RGB
-   * @param {number} alpha - floating point alpha (0.0-1.0)
-   * @returns {number} tint multiplied by alpha
-   */
-  function premultiplyTint(tint, alpha) {
-      if (alpha === 1.0) {
-          return (alpha * 255 << 24) + tint;
-      }
-      if (alpha === 0.0) {
-          return 0;
-      }
-      var R = ((tint >> 16) & 0xFF);
-      var G = ((tint >> 8) & 0xFF);
-      var B = (tint & 0xFF);
-      R = ((R * alpha) + 0.5) | 0;
-      G = ((G * alpha) + 0.5) | 0;
-      B = ((B * alpha) + 0.5) | 0;
-      return (alpha * 255 << 24) + (R << 16) + (G << 8) + B;
-  }
-  /**
-   * converts integer tint and float alpha to vec4 form, premultiplies by default
-   * @memberof PIXI.utils
-   * @function premultiplyTintToRgba
-   * @param {number} tint - input tint
-   * @param {number} alpha - alpha param
-   * @param {Float32Array} [out] - output
-   * @param {boolean} [premultiply=true] - do premultiply it
-   * @returns {Float32Array} vec4 rgba
-   */
-  function premultiplyTintToRgba(tint, alpha, out, premultiply) {
-      out = out || new Float32Array(4);
-      out[0] = ((tint >> 16) & 0xFF) / 255.0;
-      out[1] = ((tint >> 8) & 0xFF) / 255.0;
-      out[2] = (tint & 0xFF) / 255.0;
-      if (premultiply || premultiply === undefined) {
-          out[0] *= alpha;
-          out[1] *= alpha;
-          out[2] *= alpha;
-      }
-      out[3] = alpha;
-      return out;
-  }
-
-  /**
-   * Generic Mask Stack data structure
-   * @memberof PIXI.utils
-   * @function createIndicesForQuads
-   * @param {number} size - Number of quads
-   * @param {Uint16Array|Uint32Array} [outBuffer] - Buffer for output, length has to be `6 * size`
-   * @returns {Uint16Array|Uint32Array} - Resulting index buffer
-   */
-  function createIndicesForQuads(size, outBuffer) {
-      if (outBuffer === void 0) { outBuffer = null; }
-      // the total number of indices in our array, there are 6 points per quad.
-      var totalIndices = size * 6;
-      outBuffer = outBuffer || new Uint16Array(totalIndices);
-      if (outBuffer.length !== totalIndices) {
-          throw new Error("Out buffer length is incorrect, got " + outBuffer.length + " and expected " + totalIndices);
-      }
-      // fill the indices with the quads to draw
-      for (var i = 0, j = 0; i < totalIndices; i += 6, j += 4) {
-          outBuffer[i + 0] = j + 0;
-          outBuffer[i + 1] = j + 1;
-          outBuffer[i + 2] = j + 2;
-          outBuffer[i + 3] = j + 0;
-          outBuffer[i + 4] = j + 2;
-          outBuffer[i + 5] = j + 3;
-      }
-      return outBuffer;
-  }
-
-  function getBufferType(array) {
-      if (array.BYTES_PER_ELEMENT === 4) {
-          if (array instanceof Float32Array) {
-              return 'Float32Array';
-          }
-          else if (array instanceof Uint32Array) {
-              return 'Uint32Array';
-          }
-          return 'Int32Array';
-      }
-      else if (array.BYTES_PER_ELEMENT === 2) {
-          if (array instanceof Uint16Array) {
-              return 'Uint16Array';
-          }
-      }
-      else if (array.BYTES_PER_ELEMENT === 1) {
-          if (array instanceof Uint8Array) {
-              return 'Uint8Array';
-          }
-      }
-      // TODO map out the rest of the array elements!
-      return null;
-  }
-
-  /* eslint-disable object-shorthand */
-  var map$2 = { Float32Array: Float32Array, Uint32Array: Uint32Array, Int32Array: Int32Array, Uint8Array: Uint8Array };
-  function interleaveTypedArrays$1(arrays, sizes) {
-      var outSize = 0;
-      var stride = 0;
-      var views = {};
-      for (var i = 0; i < arrays.length; i++) {
-          stride += sizes[i];
-          outSize += arrays[i].length;
-      }
-      var buffer = new ArrayBuffer(outSize * 4);
-      var out = null;
-      var littleOffset = 0;
-      for (var i = 0; i < arrays.length; i++) {
-          var size = sizes[i];
-          var array = arrays[i];
-          /*
-          @todo This is unsafe casting but consistent with how the code worked previously. Should it stay this way
-                or should and `getBufferTypeUnsafe` function be exposed that throws an Error if unsupported type is passed?
-           */
-          var type = getBufferType(array);
-          if (!views[type]) {
-              views[type] = new map$2[type](buffer);
-          }
-          out = views[type];
-          for (var j = 0; j < array.length; j++) {
-              var indexStart = ((j / size | 0) * stride) + littleOffset;
-              var index = j % size;
-              out[indexStart + index] = array[j];
-          }
-          littleOffset += size;
-      }
-      return new Float32Array(buffer);
-  }
-
-  // Taken from the bit-twiddle package
-  /**
-   * Rounds to next power of two.
-   * @function nextPow2
-   * @memberof PIXI.utils
-   * @param {number} v - input value
-   * @returns {number} - next rounded power of two
-   */
-  function nextPow2(v) {
-      v += v === 0 ? 1 : 0;
-      --v;
-      v |= v >>> 1;
-      v |= v >>> 2;
-      v |= v >>> 4;
-      v |= v >>> 8;
-      v |= v >>> 16;
-      return v + 1;
-  }
-  /**
-   * Checks if a number is a power of two.
-   * @function isPow2
-   * @memberof PIXI.utils
-   * @param {number} v - input value
-   * @returns {boolean} `true` if value is power of two
-   */
-  function isPow2(v) {
-      return !(v & (v - 1)) && (!!v);
-  }
-  /**
-   * Computes ceil of log base 2
-   * @function log2
-   * @memberof PIXI.utils
-   * @param {number} v - input value
-   * @returns {number} logarithm base 2
-   */
-  function log2(v) {
-      var r = (v > 0xFFFF ? 1 : 0) << 4;
-      v >>>= r;
-      var shift = (v > 0xFF ? 1 : 0) << 3;
-      v >>>= shift;
-      r |= shift;
-      shift = (v > 0xF ? 1 : 0) << 2;
-      v >>>= shift;
-      r |= shift;
-      shift = (v > 0x3 ? 1 : 0) << 1;
-      v >>>= shift;
-      r |= shift;
-      return r | (v >> 1);
-  }
-
-  /**
-   * Remove items from a javascript array without generating garbage
-   * @function removeItems
-   * @memberof PIXI.utils
-   * @param {Array<any>} arr - Array to remove elements from
-   * @param {number} startIdx - starting index
-   * @param {number} removeCount - how many to remove
-   */
-  function removeItems(arr, startIdx, removeCount) {
-      var length = arr.length;
-      var i;
-      if (startIdx >= length || removeCount === 0) {
-          return;
-      }
-      removeCount = (startIdx + removeCount > length ? length - startIdx : removeCount);
-      var len = length - removeCount;
-      for (i = startIdx; i < len; ++i) {
-          arr[i] = arr[i + removeCount];
-      }
-      arr.length = len;
-  }
-
-  /**
-   * Returns sign of number
-   * @memberof PIXI.utils
-   * @function sign
-   * @param {number} n - the number to check the sign of
-   * @returns {number} 0 if `n` is 0, -1 if `n` is negative, 1 if `n` is positive
-   */
-  function sign(n) {
-      if (n === 0)
-          { return 0; }
-      return n < 0 ? -1 : 1;
-  }
-
-  var nextUid = 0;
-  /**
-   * Gets the next unique identifier
-   * @memberof PIXI.utils
-   * @function uid
-   * @returns {number} The next unique identifier to use.
-   */
-  function uid() {
-      return ++nextUid;
-  }
-
-  // A map of warning messages already fired
-  var warnings = {};
-  /**
-   * Helper for warning developers about deprecated features & settings.
-   * A stack track for warnings is given; useful for tracking-down where
-   * deprecated methods/properties/classes are being used within the code.
-   * @memberof PIXI.utils
-   * @function deprecation
-   * @param {string} version - The version where the feature became deprecated
-   * @param {string} message - Message should include what is deprecated, where, and the new solution
-   * @param {number} [ignoreDepth=3] - The number of steps to ignore at the top of the error stack
-   *        this is mostly to ignore internal deprecation calls.
-   */
-  function deprecation(version, message, ignoreDepth) {
-      if (ignoreDepth === void 0) { ignoreDepth = 3; }
-      // Ignore duplicat
-      if (warnings[message]) {
-          return;
-      }
-      /* eslint-disable no-console */
-      var stack = new Error().stack;
-      // Handle IE < 10 and Safari < 6
-      if (typeof stack === 'undefined') {
-          console.warn('PixiJS Deprecation Warning: ', message + "\nDeprecated since v" + version);
-      }
-      else {
-          // chop off the stack trace which includes PixiJS internal calls
-          stack = stack.split('\n').splice(ignoreDepth).join('\n');
-          if (console.groupCollapsed) {
-              console.groupCollapsed('%cPixiJS Deprecation Warning: %c%s', 'color:#614108;background:#fffbe6', 'font-weight:normal;color:#614108;background:#fffbe6', message + "\nDeprecated since v" + version);
-              console.warn(stack);
-              console.groupEnd();
-          }
-          else {
-              console.warn('PixiJS Deprecation Warning: ', message + "\nDeprecated since v" + version);
-              console.warn(stack);
-          }
-      }
-      /* eslint-enable no-console */
-      warnings[message] = true;
-  }
-
-  /**
-   * @todo Describe property usage
-   * @static
-   * @name ProgramCache
-   * @memberof PIXI.utils
-   * @type {object}
-   */
-  var ProgramCache = {};
-  /**
-   * @todo Describe property usage
-   * @static
-   * @name TextureCache
-   * @memberof PIXI.utils
-   * @type {object}
-   */
-  var TextureCache = Object.create(null);
-  /**
-   * @todo Describe property usage
-   * @static
-   * @name BaseTextureCache
-   * @memberof PIXI.utils
-   * @type {object}
-   */
-  var BaseTextureCache = Object.create(null);
-  /**
-   * Destroys all texture in the cache
-   * @memberof PIXI.utils
-   * @function destroyTextureCache
-   */
-  function destroyTextureCache() {
-      var key;
-      for (key in TextureCache) {
-          TextureCache[key].destroy();
-      }
-      for (key in BaseTextureCache) {
-          BaseTextureCache[key].destroy();
-      }
-  }
-  /**
-   * Removes all textures from cache, but does not destroy them
-   * @memberof PIXI.utils
-   * @function clearTextureCache
-   */
-  function clearTextureCache() {
-      var key;
-      for (key in TextureCache) {
-          delete TextureCache[key];
-      }
-      for (key in BaseTextureCache) {
-          delete BaseTextureCache[key];
-      }
-  }
-
-  /**
-   * Creates a Canvas element of the given size to be used as a target for rendering to.
-   * @class
-   * @memberof PIXI.utils
-   */
-  var CanvasRenderTarget = /** @class */ (function () {
-      /**
-       * @param width - the width for the newly created canvas
-       * @param height - the height for the newly created canvas
-       * @param {number} [resolution=PIXI.settings.RESOLUTION] - The resolution / device pixel ratio of the canvas
-       */
-      function CanvasRenderTarget(width, height, resolution) {
-          this.canvas = settings.ADAPTER.createCanvas();
-          this.context = this.canvas.getContext('2d');
-          this.resolution = resolution || settings.RESOLUTION;
-          this.resize(width, height);
-      }
-      /**
-       * Clears the canvas that was created by the CanvasRenderTarget class.
-       * @private
-       */
-      CanvasRenderTarget.prototype.clear = function () {
-          this.context.setTransform(1, 0, 0, 1, 0, 0);
-          this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
-      };
-      /**
-       * Resizes the canvas to the specified width and height.
-       * @param desiredWidth - the desired width of the canvas
-       * @param desiredHeight - the desired height of the canvas
-       */
-      CanvasRenderTarget.prototype.resize = function (desiredWidth, desiredHeight) {
-          this.canvas.width = Math.round(desiredWidth * this.resolution);
-          this.canvas.height = Math.round(desiredHeight * this.resolution);
-      };
-      /** Destroys this canvas. */
-      CanvasRenderTarget.prototype.destroy = function () {
-          this.context = null;
-          this.canvas = null;
-      };
-      Object.defineProperty(CanvasRenderTarget.prototype, "width", {
-          /**
-           * The width of the canvas buffer in pixels.
-           * @member {number}
-           */
-          get: function () {
-              return this.canvas.width;
-          },
-          set: function (val) {
-              this.canvas.width = Math.round(val);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(CanvasRenderTarget.prototype, "height", {
-          /**
-           * The height of the canvas buffer in pixels.
-           * @member {number}
-           */
-          get: function () {
-              return this.canvas.height;
-          },
-          set: function (val) {
-              this.canvas.height = Math.round(val);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return CanvasRenderTarget;
-  }());
-
-  /**
-   * Trim transparent borders from a canvas
-   * @memberof PIXI.utils
-   * @function trimCanvas
-   * @param {HTMLCanvasElement} canvas - the canvas to trim
-   * @returns {object} Trim data
-   */
-  function trimCanvas(canvas) {
-      // https://gist.github.com/remy/784508
-      var width = canvas.width;
-      var height = canvas.height;
-      var context = canvas.getContext('2d', {
-          willReadFrequently: true,
-      });
-      var imageData = context.getImageData(0, 0, width, height);
-      var pixels = imageData.data;
-      var len = pixels.length;
-      var bound = {
-          top: null,
-          left: null,
-          right: null,
-          bottom: null,
-      };
-      var data = null;
-      var i;
-      var x;
-      var y;
-      for (i = 0; i < len; i += 4) {
-          if (pixels[i + 3] !== 0) {
-              x = (i / 4) % width;
-              y = ~~((i / 4) / width);
-              if (bound.top === null) {
-                  bound.top = y;
-              }
-              if (bound.left === null) {
-                  bound.left = x;
-              }
-              else if (x < bound.left) {
-                  bound.left = x;
-              }
-              if (bound.right === null) {
-                  bound.right = x + 1;
-              }
-              else if (bound.right < x) {
-                  bound.right = x + 1;
-              }
-              if (bound.bottom === null) {
-                  bound.bottom = y;
-              }
-              else if (bound.bottom < y) {
-                  bound.bottom = y;
-              }
-          }
-      }
-      if (bound.top !== null) {
-          width = bound.right - bound.left;
-          height = bound.bottom - bound.top + 1;
-          data = context.getImageData(bound.left, bound.top, width, height);
-      }
-      return {
-          height: height,
-          width: width,
-          data: data,
-      };
-  }
-
-  /**
-   * Regexp for data URI.
-   * Based on: {@link https://github.com/ragingwind/data-uri-regex}
-   * @static
-   * @constant {RegExp|string} DATA_URI
-   * @memberof PIXI
-   * @example data:image/png;base64
-   */
-  var DATA_URI = /^\s*data:(?:([\w-]+)\/([\w+.-]+))?(?:;charset=([\w-]+))?(?:;(base64))?,(.*)/i;
-
-  /**
-   * @memberof PIXI.utils
-   * @interface DecomposedDataUri
-   */
-  /**
-   * type, eg. `image`
-   * @memberof PIXI.utils.DecomposedDataUri#
-   * @member {string} mediaType
-   */
-  /**
-   * Sub type, eg. `png`
-   * @memberof PIXI.utils.DecomposedDataUri#
-   * @member {string} subType
-   */
-  /**
-   * @memberof PIXI.utils.DecomposedDataUri#
-   * @member {string} charset
-   */
-  /**
-   * Data encoding, eg. `base64`
-   * @memberof PIXI.utils.DecomposedDataUri#
-   * @member {string} encoding
-   */
-  /**
-   * The actual data
-   * @memberof PIXI.utils.DecomposedDataUri#
-   * @member {string} data
-   */
-  /**
-   * Split a data URI into components. Returns undefined if
-   * parameter `dataUri` is not a valid data URI.
-   * @memberof PIXI.utils
-   * @function decomposeDataUri
-   * @param {string} dataUri - the data URI to check
-   * @returns {PIXI.utils.DecomposedDataUri|undefined} The decomposed data uri or undefined
-   */
-  function decomposeDataUri(dataUri) {
-      var dataUriMatch = DATA_URI.exec(dataUri);
-      if (dataUriMatch) {
-          return {
-              mediaType: dataUriMatch[1] ? dataUriMatch[1].toLowerCase() : undefined,
-              subType: dataUriMatch[2] ? dataUriMatch[2].toLowerCase() : undefined,
-              charset: dataUriMatch[3] ? dataUriMatch[3].toLowerCase() : undefined,
-              encoding: dataUriMatch[4] ? dataUriMatch[4].toLowerCase() : undefined,
-              data: dataUriMatch[5],
-          };
-      }
-      return undefined;
-  }
-
-  var tempAnchor$1;
-  /**
-   * Sets the `crossOrigin` property for this resource based on if the url
-   * for this resource is cross-origin. If crossOrigin was manually set, this
-   * function does nothing.
-   * Nipped from the resource loader!
-   * @ignore
-   * @param {string} url - The url to test.
-   * @param {object} [loc=window.location] - The location object to test against.
-   * @returns {string} The crossOrigin value to use (or empty string for none).
-   */
-  function determineCrossOrigin(url$1, loc) {
-      if (loc === void 0) { loc = globalThis.location; }
-      // data: and javascript: urls are considered same-origin
-      if (url$1.indexOf('data:') === 0) {
-          return '';
-      }
-      // default is window.location
-      loc = loc || globalThis.location;
-      if (!tempAnchor$1) {
-          tempAnchor$1 = document.createElement('a');
-      }
-      // let the browser determine the full href for the url of this resource and then
-      // parse with the node url lib, we can't use the properties of the anchor element
-      // because they don't work in IE9 :(
-      tempAnchor$1.href = url$1;
-      var parsedUrl = url.parse(tempAnchor$1.href);
-      var samePort = (!parsedUrl.port && loc.port === '') || (parsedUrl.port === loc.port);
-      // if cross origin
-      if (parsedUrl.hostname !== loc.hostname || !samePort || parsedUrl.protocol !== loc.protocol) {
-          return 'anonymous';
-      }
-      return '';
-  }
-
-  /**
-   * get the resolution / device pixel ratio of an asset by looking for the prefix
-   * used by spritesheets and image urls
-   * @memberof PIXI.utils
-   * @function getResolutionOfUrl
-   * @param {string} url - the image path
-   * @param {number} [defaultValue=1] - the defaultValue if no filename prefix is set.
-   * @returns {number} resolution / device pixel ratio of an asset
-   */
-  function getResolutionOfUrl(url, defaultValue) {
-      var resolution = settings.RETINA_PREFIX.exec(url);
-      if (resolution) {
-          return parseFloat(resolution[1]);
-      }
-      return defaultValue !== undefined ? defaultValue : 1;
-  }
-
-  var utils = {
-    __proto__: null,
-    BaseTextureCache: BaseTextureCache,
-    CanvasRenderTarget: CanvasRenderTarget,
-    DATA_URI: DATA_URI,
-    ProgramCache: ProgramCache,
-    TextureCache: TextureCache,
-    clearTextureCache: clearTextureCache,
-    correctBlendMode: correctBlendMode,
-    createIndicesForQuads: createIndicesForQuads,
-    decomposeDataUri: decomposeDataUri,
-    deprecation: deprecation,
-    destroyTextureCache: destroyTextureCache,
-    determineCrossOrigin: determineCrossOrigin,
-    getBufferType: getBufferType,
-    getResolutionOfUrl: getResolutionOfUrl,
-    hex2rgb: hex2rgb,
-    hex2string: hex2string,
-    interleaveTypedArrays: interleaveTypedArrays$1,
-    isPow2: isPow2,
-    isWebGLSupported: isWebGLSupported,
-    log2: log2,
-    nextPow2: nextPow2,
-    path: path,
-    premultiplyBlendMode: premultiplyBlendMode,
-    premultiplyRgba: premultiplyRgba,
-    premultiplyTint: premultiplyTint,
-    premultiplyTintToRgba: premultiplyTintToRgba,
-    removeItems: removeItems,
-    rgb2hex: rgb2hex,
-    sayHello: sayHello,
-    sign: sign,
-    skipHello: skipHello,
-    string2hex: string2hex,
-    trimCanvas: trimCanvas,
-    uid: uid,
-    url: url,
-    isMobile: isMobile,
-    EventEmitter: eventemitter3,
-    earcut: earcut_1
-  };
-
-  /*!
-   * @pixi/math - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/math is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-  /**
-   * Two Pi.
-   * @static
-   * @member {number}
-   * @memberof PIXI
-   */
-  var PI_2 = Math.PI * 2;
-  /**
-   * Conversion factor for converting radians to degrees.
-   * @static
-   * @member {number} RAD_TO_DEG
-   * @memberof PIXI
-   */
-  var RAD_TO_DEG = 180 / Math.PI;
-  /**
-   * Conversion factor for converting degrees to radians.
-   * @static
-   * @member {number}
-   * @memberof PIXI
-   */
-  var DEG_TO_RAD = Math.PI / 180;
-  /**
-   * Constants that identify shapes, mainly to prevent `instanceof` calls.
-   * @static
-   * @memberof PIXI
-   * @enum {number}
-   * @property {number} POLY Polygon
-   * @property {number} RECT Rectangle
-   * @property {number} CIRC Circle
-   * @property {number} ELIP Ellipse
-   * @property {number} RREC Rounded Rectangle
-   */
-  exports.SHAPES = void 0;
-  (function (SHAPES) {
-      SHAPES[SHAPES["POLY"] = 0] = "POLY";
-      SHAPES[SHAPES["RECT"] = 1] = "RECT";
-      SHAPES[SHAPES["CIRC"] = 2] = "CIRC";
-      SHAPES[SHAPES["ELIP"] = 3] = "ELIP";
-      SHAPES[SHAPES["RREC"] = 4] = "RREC";
-  })(exports.SHAPES || (exports.SHAPES = {}));
-
-  /**
-   * The Point object represents a location in a two-dimensional coordinate system, where `x` represents
-   * the position on the horizontal axis and `y` represents the position on the vertical axis
-   * @class
-   * @memberof PIXI
-   * @implements {IPoint}
-   */
-  var Point = /** @class */ (function () {
-      /**
-       * Creates a new `Point`
-       * @param {number} [x=0] - position of the point on the x axis
-       * @param {number} [y=0] - position of the point on the y axis
-       */
-      function Point(x, y) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          /** Position of the point on the x axis */
-          this.x = 0;
-          /** Position of the point on the y axis */
-          this.y = 0;
-          this.x = x;
-          this.y = y;
-      }
-      /**
-       * Creates a clone of this point
-       * @returns A clone of this point
-       */
-      Point.prototype.clone = function () {
-          return new Point(this.x, this.y);
-      };
-      /**
-       * Copies `x` and `y` from the given point into this point
-       * @param p - The point to copy from
-       * @returns The point instance itself
-       */
-      Point.prototype.copyFrom = function (p) {
-          this.set(p.x, p.y);
-          return this;
-      };
-      /**
-       * Copies this point's x and y into the given point (`p`).
-       * @param p - The point to copy to. Can be any of type that is or extends `IPointData`
-       * @returns The point (`p`) with values updated
-       */
-      Point.prototype.copyTo = function (p) {
-          p.set(this.x, this.y);
-          return p;
-      };
-      /**
-       * Accepts another point (`p`) and returns `true` if the given point is equal to this point
-       * @param p - The point to check
-       * @returns Returns `true` if both `x` and `y` are equal
-       */
-      Point.prototype.equals = function (p) {
-          return (p.x === this.x) && (p.y === this.y);
-      };
-      /**
-       * Sets the point to a new `x` and `y` position.
-       * If `y` is omitted, both `x` and `y` will be set to `x`.
-       * @param {number} [x=0] - position of the point on the `x` axis
-       * @param {number} [y=x] - position of the point on the `y` axis
-       * @returns The point instance itself
-       */
-      Point.prototype.set = function (x, y) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = x; }
-          this.x = x;
-          this.y = y;
-          return this;
-      };
-      Point.prototype.toString = function () {
-          return "[@pixi/math:Point x=" + this.x + " y=" + this.y + "]";
-      };
-      return Point;
-  }());
-
-  var tempPoints$1 = [new Point(), new Point(), new Point(), new Point()];
-  /**
-   * Size object, contains width and height
-   * @memberof PIXI
-   * @typedef {object} ISize
-   * @property {number} width - Width component
-   * @property {number} height - Height component
-   */
-  /**
-   * Rectangle object is an area defined by its position, as indicated by its top-left corner
-   * point (x, y) and by its width and its height.
-   * @memberof PIXI
-   */
-  var Rectangle = /** @class */ (function () {
-      /**
-       * @param x - The X coordinate of the upper-left corner of the rectangle
-       * @param y - The Y coordinate of the upper-left corner of the rectangle
-       * @param width - The overall width of the rectangle
-       * @param height - The overall height of the rectangle
-       */
-      function Rectangle(x, y, width, height) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          if (width === void 0) { width = 0; }
-          if (height === void 0) { height = 0; }
-          this.x = Number(x);
-          this.y = Number(y);
-          this.width = Number(width);
-          this.height = Number(height);
-          this.type = exports.SHAPES.RECT;
-      }
-      Object.defineProperty(Rectangle.prototype, "left", {
-          /** Returns the left edge of the rectangle. */
-          get: function () {
-              return this.x;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Rectangle.prototype, "right", {
-          /** Returns the right edge of the rectangle. */
-          get: function () {
-              return this.x + this.width;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Rectangle.prototype, "top", {
-          /** Returns the top edge of the rectangle. */
-          get: function () {
-              return this.y;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Rectangle.prototype, "bottom", {
-          /** Returns the bottom edge of the rectangle. */
-          get: function () {
-              return this.y + this.height;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Rectangle, "EMPTY", {
-          /** A constant empty rectangle. */
-          get: function () {
-              return new Rectangle(0, 0, 0, 0);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Creates a clone of this Rectangle
-       * @returns a copy of the rectangle
-       */
-      Rectangle.prototype.clone = function () {
-          return new Rectangle(this.x, this.y, this.width, this.height);
-      };
-      /**
-       * Copies another rectangle to this one.
-       * @param rectangle - The rectangle to copy from.
-       * @returns Returns itself.
-       */
-      Rectangle.prototype.copyFrom = function (rectangle) {
-          this.x = rectangle.x;
-          this.y = rectangle.y;
-          this.width = rectangle.width;
-          this.height = rectangle.height;
-          return this;
-      };
-      /**
-       * Copies this rectangle to another one.
-       * @param rectangle - The rectangle to copy to.
-       * @returns Returns given parameter.
-       */
-      Rectangle.prototype.copyTo = function (rectangle) {
-          rectangle.x = this.x;
-          rectangle.y = this.y;
-          rectangle.width = this.width;
-          rectangle.height = this.height;
-          return rectangle;
-      };
-      /**
-       * Checks whether the x and y coordinates given are contained within this Rectangle
-       * @param x - The X coordinate of the point to test
-       * @param y - The Y coordinate of the point to test
-       * @returns Whether the x/y coordinates are within this Rectangle
-       */
-      Rectangle.prototype.contains = function (x, y) {
-          if (this.width <= 0 || this.height <= 0) {
-              return false;
-          }
-          if (x >= this.x && x < this.x + this.width) {
-              if (y >= this.y && y < this.y + this.height) {
-                  return true;
-              }
-          }
-          return false;
-      };
-      /**
-       * Determines whether the `other` Rectangle transformed by `transform` intersects with `this` Rectangle object.
-       * Returns true only if the area of the intersection is >0, this means that Rectangles
-       * sharing a side are not overlapping. Another side effect is that an arealess rectangle
-       * (width or height equal to zero) can't intersect any other rectangle.
-       * @param {Rectangle} other - The Rectangle to intersect with `this`.
-       * @param {Matrix} transform - The transformation matrix of `other`.
-       * @returns {boolean} A value of `true` if the transformed `other` Rectangle intersects with `this`; otherwise `false`.
-       */
-      Rectangle.prototype.intersects = function (other, transform) {
-          if (!transform) {
-              var x0_1 = this.x < other.x ? other.x : this.x;
-              var x1_1 = this.right > other.right ? other.right : this.right;
-              if (x1_1 <= x0_1) {
-                  return false;
-              }
-              var y0_1 = this.y < other.y ? other.y : this.y;
-              var y1_1 = this.bottom > other.bottom ? other.bottom : this.bottom;
-              return y1_1 > y0_1;
-          }
-          var x0 = this.left;
-          var x1 = this.right;
-          var y0 = this.top;
-          var y1 = this.bottom;
-          if (x1 <= x0 || y1 <= y0) {
-              return false;
-          }
-          var lt = tempPoints$1[0].set(other.left, other.top);
-          var lb = tempPoints$1[1].set(other.left, other.bottom);
-          var rt = tempPoints$1[2].set(other.right, other.top);
-          var rb = tempPoints$1[3].set(other.right, other.bottom);
-          if (rt.x <= lt.x || lb.y <= lt.y) {
-              return false;
-          }
-          var s = Math.sign((transform.a * transform.d) - (transform.b * transform.c));
-          if (s === 0) {
-              return false;
-          }
-          transform.apply(lt, lt);
-          transform.apply(lb, lb);
-          transform.apply(rt, rt);
-          transform.apply(rb, rb);
-          if (Math.max(lt.x, lb.x, rt.x, rb.x) <= x0
-              || Math.min(lt.x, lb.x, rt.x, rb.x) >= x1
-              || Math.max(lt.y, lb.y, rt.y, rb.y) <= y0
-              || Math.min(lt.y, lb.y, rt.y, rb.y) >= y1) {
-              return false;
-          }
-          var nx = s * (lb.y - lt.y);
-          var ny = s * (lt.x - lb.x);
-          var n00 = (nx * x0) + (ny * y0);
-          var n10 = (nx * x1) + (ny * y0);
-          var n01 = (nx * x0) + (ny * y1);
-          var n11 = (nx * x1) + (ny * y1);
-          if (Math.max(n00, n10, n01, n11) <= (nx * lt.x) + (ny * lt.y)
-              || Math.min(n00, n10, n01, n11) >= (nx * rb.x) + (ny * rb.y)) {
-              return false;
-          }
-          var mx = s * (lt.y - rt.y);
-          var my = s * (rt.x - lt.x);
-          var m00 = (mx * x0) + (my * y0);
-          var m10 = (mx * x1) + (my * y0);
-          var m01 = (mx * x0) + (my * y1);
-          var m11 = (mx * x1) + (my * y1);
-          if (Math.max(m00, m10, m01, m11) <= (mx * lt.x) + (my * lt.y)
-              || Math.min(m00, m10, m01, m11) >= (mx * rb.x) + (my * rb.y)) {
-              return false;
-          }
-          return true;
-      };
-      /**
-       * Pads the rectangle making it grow in all directions.
-       * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
-       * @param paddingX - The horizontal padding amount.
-       * @param paddingY - The vertical padding amount.
-       * @returns Returns itself.
-       */
-      Rectangle.prototype.pad = function (paddingX, paddingY) {
-          if (paddingX === void 0) { paddingX = 0; }
-          if (paddingY === void 0) { paddingY = paddingX; }
-          this.x -= paddingX;
-          this.y -= paddingY;
-          this.width += paddingX * 2;
-          this.height += paddingY * 2;
-          return this;
-      };
-      /**
-       * Fits this rectangle around the passed one.
-       * @param rectangle - The rectangle to fit.
-       * @returns Returns itself.
-       */
-      Rectangle.prototype.fit = function (rectangle) {
-          var x1 = Math.max(this.x, rectangle.x);
-          var x2 = Math.min(this.x + this.width, rectangle.x + rectangle.width);
-          var y1 = Math.max(this.y, rectangle.y);
-          var y2 = Math.min(this.y + this.height, rectangle.y + rectangle.height);
-          this.x = x1;
-          this.width = Math.max(x2 - x1, 0);
-          this.y = y1;
-          this.height = Math.max(y2 - y1, 0);
-          return this;
-      };
-      /**
-       * Enlarges rectangle that way its corners lie on grid
-       * @param resolution - resolution
-       * @param eps - precision
-       * @returns Returns itself.
-       */
-      Rectangle.prototype.ceil = function (resolution, eps) {
-          if (resolution === void 0) { resolution = 1; }
-          if (eps === void 0) { eps = 0.001; }
-          var x2 = Math.ceil((this.x + this.width - eps) * resolution) / resolution;
-          var y2 = Math.ceil((this.y + this.height - eps) * resolution) / resolution;
-          this.x = Math.floor((this.x + eps) * resolution) / resolution;
-          this.y = Math.floor((this.y + eps) * resolution) / resolution;
-          this.width = x2 - this.x;
-          this.height = y2 - this.y;
-          return this;
-      };
-      /**
-       * Enlarges this rectangle to include the passed rectangle.
-       * @param rectangle - The rectangle to include.
-       * @returns Returns itself.
-       */
-      Rectangle.prototype.enlarge = function (rectangle) {
-          var x1 = Math.min(this.x, rectangle.x);
-          var x2 = Math.max(this.x + this.width, rectangle.x + rectangle.width);
-          var y1 = Math.min(this.y, rectangle.y);
-          var y2 = Math.max(this.y + this.height, rectangle.y + rectangle.height);
-          this.x = x1;
-          this.width = x2 - x1;
-          this.y = y1;
-          this.height = y2 - y1;
-          return this;
-      };
-      Rectangle.prototype.toString = function () {
-          return "[@pixi/math:Rectangle x=" + this.x + " y=" + this.y + " width=" + this.width + " height=" + this.height + "]";
-      };
-      return Rectangle;
-  }());
-
-  /**
-   * The Circle object is used to help draw graphics and can also be used to specify a hit area for displayObjects.
-   * @memberof PIXI
-   */
-  var Circle = /** @class */ (function () {
-      /**
-       * @param x - The X coordinate of the center of this circle
-       * @param y - The Y coordinate of the center of this circle
-       * @param radius - The radius of the circle
-       */
-      function Circle(x, y, radius) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          if (radius === void 0) { radius = 0; }
-          this.x = x;
-          this.y = y;
-          this.radius = radius;
-          this.type = exports.SHAPES.CIRC;
-      }
-      /**
-       * Creates a clone of this Circle instance
-       * @returns A copy of the Circle
-       */
-      Circle.prototype.clone = function () {
-          return new Circle(this.x, this.y, this.radius);
-      };
-      /**
-       * Checks whether the x and y coordinates given are contained within this circle
-       * @param x - The X coordinate of the point to test
-       * @param y - The Y coordinate of the point to test
-       * @returns Whether the x/y coordinates are within this Circle
-       */
-      Circle.prototype.contains = function (x, y) {
-          if (this.radius <= 0) {
-              return false;
-          }
-          var r2 = this.radius * this.radius;
-          var dx = (this.x - x);
-          var dy = (this.y - y);
-          dx *= dx;
-          dy *= dy;
-          return (dx + dy <= r2);
-      };
-      /**
-       * Returns the framing rectangle of the circle as a Rectangle object
-       * @returns The framing rectangle
-       */
-      Circle.prototype.getBounds = function () {
-          return new Rectangle(this.x - this.radius, this.y - this.radius, this.radius * 2, this.radius * 2);
-      };
-      Circle.prototype.toString = function () {
-          return "[@pixi/math:Circle x=" + this.x + " y=" + this.y + " radius=" + this.radius + "]";
-      };
-      return Circle;
-  }());
-
-  /**
-   * The Ellipse object is used to help draw graphics and can also be used to specify a hit area for displayObjects.
-   * @memberof PIXI
-   */
-  var Ellipse = /** @class */ (function () {
-      /**
-       * @param x - The X coordinate of the center of this ellipse
-       * @param y - The Y coordinate of the center of this ellipse
-       * @param halfWidth - The half width of this ellipse
-       * @param halfHeight - The half height of this ellipse
-       */
-      function Ellipse(x, y, halfWidth, halfHeight) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          if (halfWidth === void 0) { halfWidth = 0; }
-          if (halfHeight === void 0) { halfHeight = 0; }
-          this.x = x;
-          this.y = y;
-          this.width = halfWidth;
-          this.height = halfHeight;
-          this.type = exports.SHAPES.ELIP;
-      }
-      /**
-       * Creates a clone of this Ellipse instance
-       * @returns {PIXI.Ellipse} A copy of the ellipse
-       */
-      Ellipse.prototype.clone = function () {
-          return new Ellipse(this.x, this.y, this.width, this.height);
-      };
-      /**
-       * Checks whether the x and y coordinates given are contained within this ellipse
-       * @param x - The X coordinate of the point to test
-       * @param y - The Y coordinate of the point to test
-       * @returns Whether the x/y coords are within this ellipse
-       */
-      Ellipse.prototype.contains = function (x, y) {
-          if (this.width <= 0 || this.height <= 0) {
-              return false;
-          }
-          // normalize the coords to an ellipse with center 0,0
-          var normx = ((x - this.x) / this.width);
-          var normy = ((y - this.y) / this.height);
-          normx *= normx;
-          normy *= normy;
-          return (normx + normy <= 1);
-      };
-      /**
-       * Returns the framing rectangle of the ellipse as a Rectangle object
-       * @returns The framing rectangle
-       */
-      Ellipse.prototype.getBounds = function () {
-          return new Rectangle(this.x - this.width, this.y - this.height, this.width, this.height);
-      };
-      Ellipse.prototype.toString = function () {
-          return "[@pixi/math:Ellipse x=" + this.x + " y=" + this.y + " width=" + this.width + " height=" + this.height + "]";
-      };
-      return Ellipse;
-  }());
-
-  /**
-   * A class to define a shape via user defined coordinates.
-   * @memberof PIXI
-   */
-  var Polygon = /** @class */ (function () {
-      /**
-       * @param {PIXI.IPointData[]|number[]} points - This can be an array of Points
-       *  that form the polygon, a flat array of numbers that will be interpreted as [x,y, x,y, ...], or
-       *  the arguments passed can be all the points of the polygon e.g.
-       *  `new PIXI.Polygon(new PIXI.Point(), new PIXI.Point(), ...)`, or the arguments passed can be flat
-       *  x,y values e.g. `new Polygon(x,y, x,y, x,y, ...)` where `x` and `y` are Numbers.
-       */
-      function Polygon() {
-          var arguments$1 = arguments;
-
-          var points = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              points[_i] = arguments$1[_i];
-          }
-          var flat = Array.isArray(points[0]) ? points[0] : points;
-          // if this is an array of points, convert it to a flat array of numbers
-          if (typeof flat[0] !== 'number') {
-              var p = [];
-              for (var i = 0, il = flat.length; i < il; i++) {
-                  p.push(flat[i].x, flat[i].y);
-              }
-              flat = p;
-          }
-          this.points = flat;
-          this.type = exports.SHAPES.POLY;
-          this.closeStroke = true;
-      }
-      /**
-       * Creates a clone of this polygon.
-       * @returns - A copy of the polygon.
-       */
-      Polygon.prototype.clone = function () {
-          var points = this.points.slice();
-          var polygon = new Polygon(points);
-          polygon.closeStroke = this.closeStroke;
-          return polygon;
-      };
-      /**
-       * Checks whether the x and y coordinates passed to this function are contained within this polygon.
-       * @param x - The X coordinate of the point to test.
-       * @param y - The Y coordinate of the point to test.
-       * @returns - Whether the x/y coordinates are within this polygon.
-       */
-      Polygon.prototype.contains = function (x, y) {
-          var inside = false;
-          // use some raycasting to test hits
-          // https://github.com/substack/point-in-polygon/blob/master/index.js
-          var length = this.points.length / 2;
-          for (var i = 0, j = length - 1; i < length; j = i++) {
-              var xi = this.points[i * 2];
-              var yi = this.points[(i * 2) + 1];
-              var xj = this.points[j * 2];
-              var yj = this.points[(j * 2) + 1];
-              var intersect = ((yi > y) !== (yj > y)) && (x < ((xj - xi) * ((y - yi) / (yj - yi))) + xi);
-              if (intersect) {
-                  inside = !inside;
-              }
-          }
-          return inside;
-      };
-      Polygon.prototype.toString = function () {
-          return "[@pixi/math:Polygon"
-              + ("closeStroke=" + this.closeStroke)
-              + ("points=" + this.points.reduce(function (pointsDesc, currentPoint) { return pointsDesc + ", " + currentPoint; }, '') + "]");
-      };
-      return Polygon;
-  }());
-
-  /**
-   * The Rounded Rectangle object is an area that has nice rounded corners, as indicated by its
-   * top-left corner point (x, y) and by its width and its height and its radius.
-   * @memberof PIXI
-   */
-  var RoundedRectangle = /** @class */ (function () {
-      /**
-       * @param x - The X coordinate of the upper-left corner of the rounded rectangle
-       * @param y - The Y coordinate of the upper-left corner of the rounded rectangle
-       * @param width - The overall width of this rounded rectangle
-       * @param height - The overall height of this rounded rectangle
-       * @param radius - Controls the radius of the rounded corners
-       */
-      function RoundedRectangle(x, y, width, height, radius) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          if (width === void 0) { width = 0; }
-          if (height === void 0) { height = 0; }
-          if (radius === void 0) { radius = 20; }
-          this.x = x;
-          this.y = y;
-          this.width = width;
-          this.height = height;
-          this.radius = radius;
-          this.type = exports.SHAPES.RREC;
-      }
-      /**
-       * Creates a clone of this Rounded Rectangle.
-       * @returns - A copy of the rounded rectangle.
-       */
-      RoundedRectangle.prototype.clone = function () {
-          return new RoundedRectangle(this.x, this.y, this.width, this.height, this.radius);
-      };
-      /**
-       * Checks whether the x and y coordinates given are contained within this Rounded Rectangle
-       * @param x - The X coordinate of the point to test.
-       * @param y - The Y coordinate of the point to test.
-       * @returns - Whether the x/y coordinates are within this Rounded Rectangle.
-       */
-      RoundedRectangle.prototype.contains = function (x, y) {
-          if (this.width <= 0 || this.height <= 0) {
-              return false;
-          }
-          if (x >= this.x && x <= this.x + this.width) {
-              if (y >= this.y && y <= this.y + this.height) {
-                  var radius = Math.max(0, Math.min(this.radius, Math.min(this.width, this.height) / 2));
-                  if ((y >= this.y + radius && y <= this.y + this.height - radius)
-                      || (x >= this.x + radius && x <= this.x + this.width - radius)) {
-                      return true;
-                  }
-                  var dx = x - (this.x + radius);
-                  var dy = y - (this.y + radius);
-                  var radius2 = radius * radius;
-                  if ((dx * dx) + (dy * dy) <= radius2) {
-                      return true;
-                  }
-                  dx = x - (this.x + this.width - radius);
-                  if ((dx * dx) + (dy * dy) <= radius2) {
-                      return true;
-                  }
-                  dy = y - (this.y + this.height - radius);
-                  if ((dx * dx) + (dy * dy) <= radius2) {
-                      return true;
-                  }
-                  dx = x - (this.x + radius);
-                  if ((dx * dx) + (dy * dy) <= radius2) {
-                      return true;
-                  }
-              }
-          }
-          return false;
-      };
-      RoundedRectangle.prototype.toString = function () {
-          return "[@pixi/math:RoundedRectangle x=" + this.x + " y=" + this.y
-              + ("width=" + this.width + " height=" + this.height + " radius=" + this.radius + "]");
-      };
-      return RoundedRectangle;
-  }());
-
-  /**
-   * The ObservablePoint object represents a location in a two-dimensional coordinate system, where `x` represents
-   * the position on the horizontal axis and `y` represents the position on the vertical axis.
-   *
-   * An `ObservablePoint` is a point that triggers a callback when the point's position is changed.
-   * @memberof PIXI
-   */
-  var ObservablePoint = /** @class */ (function () {
-      /**
-       * Creates a new `ObservablePoint`
-       * @param cb - callback function triggered when `x` and/or `y` are changed
-       * @param scope - owner of callback
-       * @param {number} [x=0] - position of the point on the x axis
-       * @param {number} [y=0] - position of the point on the y axis
-       */
-      function ObservablePoint(cb, scope, x, y) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          this._x = x;
-          this._y = y;
-          this.cb = cb;
-          this.scope = scope;
-      }
-      /**
-       * Creates a clone of this point.
-       * The callback and scope params can be overridden otherwise they will default
-       * to the clone object's values.
-       * @override
-       * @param cb - The callback function triggered when `x` and/or `y` are changed
-       * @param scope - The owner of the callback
-       * @returns a copy of this observable point
-       */
-      ObservablePoint.prototype.clone = function (cb, scope) {
-          if (cb === void 0) { cb = this.cb; }
-          if (scope === void 0) { scope = this.scope; }
-          return new ObservablePoint(cb, scope, this._x, this._y);
-      };
-      /**
-       * Sets the point to a new `x` and `y` position.
-       * If `y` is omitted, both `x` and `y` will be set to `x`.
-       * @param {number} [x=0] - position of the point on the x axis
-       * @param {number} [y=x] - position of the point on the y axis
-       * @returns The observable point instance itself
-       */
-      ObservablePoint.prototype.set = function (x, y) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = x; }
-          if (this._x !== x || this._y !== y) {
-              this._x = x;
-              this._y = y;
-              this.cb.call(this.scope);
-          }
-          return this;
-      };
-      /**
-       * Copies x and y from the given point (`p`)
-       * @param p - The point to copy from. Can be any of type that is or extends `IPointData`
-       * @returns The observable point instance itself
-       */
-      ObservablePoint.prototype.copyFrom = function (p) {
-          if (this._x !== p.x || this._y !== p.y) {
-              this._x = p.x;
-              this._y = p.y;
-              this.cb.call(this.scope);
-          }
-          return this;
-      };
-      /**
-       * Copies this point's x and y into that of the given point (`p`)
-       * @param p - The point to copy to. Can be any of type that is or extends `IPointData`
-       * @returns The point (`p`) with values updated
-       */
-      ObservablePoint.prototype.copyTo = function (p) {
-          p.set(this._x, this._y);
-          return p;
-      };
-      /**
-       * Accepts another point (`p`) and returns `true` if the given point is equal to this point
-       * @param p - The point to check
-       * @returns Returns `true` if both `x` and `y` are equal
-       */
-      ObservablePoint.prototype.equals = function (p) {
-          return (p.x === this._x) && (p.y === this._y);
-      };
-      ObservablePoint.prototype.toString = function () {
-          return "[@pixi/math:ObservablePoint x=" + 0 + " y=" + 0 + " scope=" + this.scope + "]";
-      };
-      Object.defineProperty(ObservablePoint.prototype, "x", {
-          /** Position of the observable point on the x axis. */
-          get: function () {
-              return this._x;
-          },
-          set: function (value) {
-              if (this._x !== value) {
-                  this._x = value;
-                  this.cb.call(this.scope);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(ObservablePoint.prototype, "y", {
-          /** Position of the observable point on the y axis. */
-          get: function () {
-              return this._y;
-          },
-          set: function (value) {
-              if (this._y !== value) {
-                  this._y = value;
-                  this.cb.call(this.scope);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return ObservablePoint;
-  }());
-
-  /**
-   * The PixiJS Matrix as a class makes it a lot faster.
-   *
-   * Here is a representation of it:
-   * ```js
-   * | a | c | tx|
-   * | b | d | ty|
-   * | 0 | 0 | 1 |
-   * ```
-   * @memberof PIXI
-   */
-  var Matrix = /** @class */ (function () {
-      /**
-       * @param a - x scale
-       * @param b - y skew
-       * @param c - x skew
-       * @param d - y scale
-       * @param tx - x translation
-       * @param ty - y translation
-       */
-      function Matrix(a, b, c, d, tx, ty) {
-          if (a === void 0) { a = 1; }
-          if (b === void 0) { b = 0; }
-          if (c === void 0) { c = 0; }
-          if (d === void 0) { d = 1; }
-          if (tx === void 0) { tx = 0; }
-          if (ty === void 0) { ty = 0; }
-          this.array = null;
-          this.a = a;
-          this.b = b;
-          this.c = c;
-          this.d = d;
-          this.tx = tx;
-          this.ty = ty;
-      }
-      /**
-       * Creates a Matrix object based on the given array. The Element to Matrix mapping order is as follows:
-       *
-       * a = array[0]
-       * b = array[1]
-       * c = array[3]
-       * d = array[4]
-       * tx = array[2]
-       * ty = array[5]
-       * @param array - The array that the matrix will be populated from.
-       */
-      Matrix.prototype.fromArray = function (array) {
-          this.a = array[0];
-          this.b = array[1];
-          this.c = array[3];
-          this.d = array[4];
-          this.tx = array[2];
-          this.ty = array[5];
-      };
-      /**
-       * Sets the matrix properties.
-       * @param a - Matrix component
-       * @param b - Matrix component
-       * @param c - Matrix component
-       * @param d - Matrix component
-       * @param tx - Matrix component
-       * @param ty - Matrix component
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.set = function (a, b, c, d, tx, ty) {
-          this.a = a;
-          this.b = b;
-          this.c = c;
-          this.d = d;
-          this.tx = tx;
-          this.ty = ty;
-          return this;
-      };
-      /**
-       * Creates an array from the current Matrix object.
-       * @param transpose - Whether we need to transpose the matrix or not
-       * @param [out=new Float32Array(9)] - If provided the array will be assigned to out
-       * @returns The newly created array which contains the matrix
-       */
-      Matrix.prototype.toArray = function (transpose, out) {
-          if (!this.array) {
-              this.array = new Float32Array(9);
-          }
-          var array = out || this.array;
-          if (transpose) {
-              array[0] = this.a;
-              array[1] = this.b;
-              array[2] = 0;
-              array[3] = this.c;
-              array[4] = this.d;
-              array[5] = 0;
-              array[6] = this.tx;
-              array[7] = this.ty;
-              array[8] = 1;
-          }
-          else {
-              array[0] = this.a;
-              array[1] = this.c;
-              array[2] = this.tx;
-              array[3] = this.b;
-              array[4] = this.d;
-              array[5] = this.ty;
-              array[6] = 0;
-              array[7] = 0;
-              array[8] = 1;
-          }
-          return array;
-      };
-      /**
-       * Get a new position with the current transformation applied.
-       * Can be used to go from a child's coordinate space to the world coordinate space. (e.g. rendering)
-       * @param pos - The origin
-       * @param {PIXI.Point} [newPos] - The point that the new position is assigned to (allowed to be same as input)
-       * @returns {PIXI.Point} The new point, transformed through this matrix
-       */
-      Matrix.prototype.apply = function (pos, newPos) {
-          newPos = (newPos || new Point());
-          var x = pos.x;
-          var y = pos.y;
-          newPos.x = (this.a * x) + (this.c * y) + this.tx;
-          newPos.y = (this.b * x) + (this.d * y) + this.ty;
-          return newPos;
-      };
-      /**
-       * Get a new position with the inverse of the current transformation applied.
-       * Can be used to go from the world coordinate space to a child's coordinate space. (e.g. input)
-       * @param pos - The origin
-       * @param {PIXI.Point} [newPos] - The point that the new position is assigned to (allowed to be same as input)
-       * @returns {PIXI.Point} The new point, inverse-transformed through this matrix
-       */
-      Matrix.prototype.applyInverse = function (pos, newPos) {
-          newPos = (newPos || new Point());
-          var id = 1 / ((this.a * this.d) + (this.c * -this.b));
-          var x = pos.x;
-          var y = pos.y;
-          newPos.x = (this.d * id * x) + (-this.c * id * y) + (((this.ty * this.c) - (this.tx * this.d)) * id);
-          newPos.y = (this.a * id * y) + (-this.b * id * x) + (((-this.ty * this.a) + (this.tx * this.b)) * id);
-          return newPos;
-      };
-      /**
-       * Translates the matrix on the x and y.
-       * @param x - How much to translate x by
-       * @param y - How much to translate y by
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.translate = function (x, y) {
-          this.tx += x;
-          this.ty += y;
-          return this;
-      };
-      /**
-       * Applies a scale transformation to the matrix.
-       * @param x - The amount to scale horizontally
-       * @param y - The amount to scale vertically
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.scale = function (x, y) {
-          this.a *= x;
-          this.d *= y;
-          this.c *= x;
-          this.b *= y;
-          this.tx *= x;
-          this.ty *= y;
-          return this;
-      };
-      /**
-       * Applies a rotation transformation to the matrix.
-       * @param angle - The angle in radians.
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.rotate = function (angle) {
-          var cos = Math.cos(angle);
-          var sin = Math.sin(angle);
-          var a1 = this.a;
-          var c1 = this.c;
-          var tx1 = this.tx;
-          this.a = (a1 * cos) - (this.b * sin);
-          this.b = (a1 * sin) + (this.b * cos);
-          this.c = (c1 * cos) - (this.d * sin);
-          this.d = (c1 * sin) + (this.d * cos);
-          this.tx = (tx1 * cos) - (this.ty * sin);
-          this.ty = (tx1 * sin) + (this.ty * cos);
-          return this;
-      };
-      /**
-       * Appends the given Matrix to this Matrix.
-       * @param matrix - The matrix to append.
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.append = function (matrix) {
-          var a1 = this.a;
-          var b1 = this.b;
-          var c1 = this.c;
-          var d1 = this.d;
-          this.a = (matrix.a * a1) + (matrix.b * c1);
-          this.b = (matrix.a * b1) + (matrix.b * d1);
-          this.c = (matrix.c * a1) + (matrix.d * c1);
-          this.d = (matrix.c * b1) + (matrix.d * d1);
-          this.tx = (matrix.tx * a1) + (matrix.ty * c1) + this.tx;
-          this.ty = (matrix.tx * b1) + (matrix.ty * d1) + this.ty;
-          return this;
-      };
-      /**
-       * Sets the matrix based on all the available properties
-       * @param x - Position on the x axis
-       * @param y - Position on the y axis
-       * @param pivotX - Pivot on the x axis
-       * @param pivotY - Pivot on the y axis
-       * @param scaleX - Scale on the x axis
-       * @param scaleY - Scale on the y axis
-       * @param rotation - Rotation in radians
-       * @param skewX - Skew on the x axis
-       * @param skewY - Skew on the y axis
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.setTransform = function (x, y, pivotX, pivotY, scaleX, scaleY, rotation, skewX, skewY) {
-          this.a = Math.cos(rotation + skewY) * scaleX;
-          this.b = Math.sin(rotation + skewY) * scaleX;
-          this.c = -Math.sin(rotation - skewX) * scaleY;
-          this.d = Math.cos(rotation - skewX) * scaleY;
-          this.tx = x - ((pivotX * this.a) + (pivotY * this.c));
-          this.ty = y - ((pivotX * this.b) + (pivotY * this.d));
-          return this;
-      };
-      /**
-       * Prepends the given Matrix to this Matrix.
-       * @param matrix - The matrix to prepend
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.prepend = function (matrix) {
-          var tx1 = this.tx;
-          if (matrix.a !== 1 || matrix.b !== 0 || matrix.c !== 0 || matrix.d !== 1) {
-              var a1 = this.a;
-              var c1 = this.c;
-              this.a = (a1 * matrix.a) + (this.b * matrix.c);
-              this.b = (a1 * matrix.b) + (this.b * matrix.d);
-              this.c = (c1 * matrix.a) + (this.d * matrix.c);
-              this.d = (c1 * matrix.b) + (this.d * matrix.d);
-          }
-          this.tx = (tx1 * matrix.a) + (this.ty * matrix.c) + matrix.tx;
-          this.ty = (tx1 * matrix.b) + (this.ty * matrix.d) + matrix.ty;
-          return this;
-      };
-      /**
-       * Decomposes the matrix (x, y, scaleX, scaleY, and rotation) and sets the properties on to a transform.
-       * @param transform - The transform to apply the properties to.
-       * @returns The transform with the newly applied properties
-       */
-      Matrix.prototype.decompose = function (transform) {
-          // sort out rotation / skew..
-          var a = this.a;
-          var b = this.b;
-          var c = this.c;
-          var d = this.d;
-          var pivot = transform.pivot;
-          var skewX = -Math.atan2(-c, d);
-          var skewY = Math.atan2(b, a);
-          var delta = Math.abs(skewX + skewY);
-          if (delta < 0.00001 || Math.abs(PI_2 - delta) < 0.00001) {
-              transform.rotation = skewY;
-              transform.skew.x = transform.skew.y = 0;
-          }
-          else {
-              transform.rotation = 0;
-              transform.skew.x = skewX;
-              transform.skew.y = skewY;
-          }
-          // next set scale
-          transform.scale.x = Math.sqrt((a * a) + (b * b));
-          transform.scale.y = Math.sqrt((c * c) + (d * d));
-          // next set position
-          transform.position.x = this.tx + ((pivot.x * a) + (pivot.y * c));
-          transform.position.y = this.ty + ((pivot.x * b) + (pivot.y * d));
-          return transform;
-      };
-      /**
-       * Inverts this matrix
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.invert = function () {
-          var a1 = this.a;
-          var b1 = this.b;
-          var c1 = this.c;
-          var d1 = this.d;
-          var tx1 = this.tx;
-          var n = (a1 * d1) - (b1 * c1);
-          this.a = d1 / n;
-          this.b = -b1 / n;
-          this.c = -c1 / n;
-          this.d = a1 / n;
-          this.tx = ((c1 * this.ty) - (d1 * tx1)) / n;
-          this.ty = -((a1 * this.ty) - (b1 * tx1)) / n;
-          return this;
-      };
-      /**
-       * Resets this Matrix to an identity (default) matrix.
-       * @returns This matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.identity = function () {
-          this.a = 1;
-          this.b = 0;
-          this.c = 0;
-          this.d = 1;
-          this.tx = 0;
-          this.ty = 0;
-          return this;
-      };
-      /**
-       * Creates a new Matrix object with the same values as this one.
-       * @returns A copy of this matrix. Good for chaining method calls.
-       */
-      Matrix.prototype.clone = function () {
-          var matrix = new Matrix();
-          matrix.a = this.a;
-          matrix.b = this.b;
-          matrix.c = this.c;
-          matrix.d = this.d;
-          matrix.tx = this.tx;
-          matrix.ty = this.ty;
-          return matrix;
-      };
-      /**
-       * Changes the values of the given matrix to be the same as the ones in this matrix
-       * @param matrix - The matrix to copy to.
-       * @returns The matrix given in parameter with its values updated.
-       */
-      Matrix.prototype.copyTo = function (matrix) {
-          matrix.a = this.a;
-          matrix.b = this.b;
-          matrix.c = this.c;
-          matrix.d = this.d;
-          matrix.tx = this.tx;
-          matrix.ty = this.ty;
-          return matrix;
-      };
-      /**
-       * Changes the values of the matrix to be the same as the ones in given matrix
-       * @param {PIXI.Matrix} matrix - The matrix to copy from.
-       * @returns {PIXI.Matrix} this
-       */
-      Matrix.prototype.copyFrom = function (matrix) {
-          this.a = matrix.a;
-          this.b = matrix.b;
-          this.c = matrix.c;
-          this.d = matrix.d;
-          this.tx = matrix.tx;
-          this.ty = matrix.ty;
-          return this;
-      };
-      Matrix.prototype.toString = function () {
-          return "[@pixi/math:Matrix a=" + this.a + " b=" + this.b + " c=" + this.c + " d=" + this.d + " tx=" + this.tx + " ty=" + this.ty + "]";
-      };
-      Object.defineProperty(Matrix, "IDENTITY", {
-          /**
-           * A default (identity) matrix
-           * @readonly
-           */
-          get: function () {
-              return new Matrix();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Matrix, "TEMP_MATRIX", {
-          /**
-           * A temp matrix
-           * @readonly
-           */
-          get: function () {
-              return new Matrix();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return Matrix;
-  }());
-
-  // Your friendly neighbour https://en.wikipedia.org/wiki/Dihedral_group
-  /*
-   * Transform matrix for operation n is:
-   * | ux | vx |
-   * | uy | vy |
-   */
-  var ux = [1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1];
-  var uy = [0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, -1, -1];
-  var vx = [0, -1, -1, -1, 0, 1, 1, 1, 0, 1, 1, 1, 0, -1, -1, -1];
-  var vy = [1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, 1, 1, 1, 0, -1];
-  /**
-   * [Cayley Table]{@link https://en.wikipedia.org/wiki/Cayley_table}
-   * for the composition of each rotation in the dihederal group D8.
-   * @type {number[][]}
-   * @private
-   */
-  var rotationCayley = [];
-  /**
-   * Matrices for each `GD8Symmetry` rotation.
-   * @type {PIXI.Matrix[]}
-   * @private
-   */
-  var rotationMatrices = [];
-  /*
-   * Alias for {@code Math.sign}.
-   */
-  var signum = Math.sign;
-  /*
-   * Initializes `rotationCayley` and `rotationMatrices`. It is called
-   * only once below.
-   */
-  function init() {
-      for (var i = 0; i < 16; i++) {
-          var row = [];
-          rotationCayley.push(row);
-          for (var j = 0; j < 16; j++) {
-              /* Multiplies rotation matrices i and j. */
-              var _ux = signum((ux[i] * ux[j]) + (vx[i] * uy[j]));
-              var _uy = signum((uy[i] * ux[j]) + (vy[i] * uy[j]));
-              var _vx = signum((ux[i] * vx[j]) + (vx[i] * vy[j]));
-              var _vy = signum((uy[i] * vx[j]) + (vy[i] * vy[j]));
-              /* Finds rotation matrix matching the product and pushes it. */
-              for (var k = 0; k < 16; k++) {
-                  if (ux[k] === _ux && uy[k] === _uy
-                      && vx[k] === _vx && vy[k] === _vy) {
-                      row.push(k);
-                      break;
-                  }
-              }
-          }
-      }
-      for (var i = 0; i < 16; i++) {
-          var mat = new Matrix();
-          mat.set(ux[i], uy[i], vx[i], vy[i], 0, 0);
-          rotationMatrices.push(mat);
-      }
-  }
-  init();
-  /**
-   * @memberof PIXI
-   * @typedef {number} GD8Symmetry
-   * @see PIXI.groupD8
-   */
-  /**
-   * Implements the dihedral group D8, which is similar to
-   * [group D4]{@link http://mathworld.wolfram.com/DihedralGroupD4.html};
-   * D8 is the same but with diagonals, and it is used for texture
-   * rotations.
-   *
-   * The directions the U- and V- axes after rotation
-   * of an angle of `a: GD8Constant` are the vectors `(uX(a), uY(a))`
-   * and `(vX(a), vY(a))`. These aren't necessarily unit vectors.
-   *
-   * **Origin:**<br>
-   *  This is the small part of gameofbombs.com portal system. It works.
-   * @see PIXI.groupD8.E
-   * @see PIXI.groupD8.SE
-   * @see PIXI.groupD8.S
-   * @see PIXI.groupD8.SW
-   * @see PIXI.groupD8.W
-   * @see PIXI.groupD8.NW
-   * @see PIXI.groupD8.N
-   * @see PIXI.groupD8.NE
-   * @author Ivan @ivanpopelyshev
-   * @namespace PIXI.groupD8
-   * @memberof PIXI
-   */
-  var groupD8 = {
-      /**
-       * | Rotation | Direction |
-       * |----------|-----------|
-       * | 0°       | East      |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      E: 0,
-      /**
-       * | Rotation | Direction |
-       * |----------|-----------|
-       * | 45°↻     | Southeast |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      SE: 1,
-      /**
-       * | Rotation | Direction |
-       * |----------|-----------|
-       * | 90°↻     | South     |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      S: 2,
-      /**
-       * | Rotation | Direction |
-       * |----------|-----------|
-       * | 135°↻    | Southwest |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      SW: 3,
-      /**
-       * | Rotation | Direction |
-       * |----------|-----------|
-       * | 180°     | West      |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      W: 4,
-      /**
-       * | Rotation    | Direction    |
-       * |-------------|--------------|
-       * | -135°/225°↻ | Northwest    |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      NW: 5,
-      /**
-       * | Rotation    | Direction    |
-       * |-------------|--------------|
-       * | -90°/270°↻  | North        |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      N: 6,
-      /**
-       * | Rotation    | Direction    |
-       * |-------------|--------------|
-       * | -45°/315°↻  | Northeast    |
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      NE: 7,
-      /**
-       * Reflection about Y-axis.
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      MIRROR_VERTICAL: 8,
-      /**
-       * Reflection about the main diagonal.
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      MAIN_DIAGONAL: 10,
-      /**
-       * Reflection about X-axis.
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      MIRROR_HORIZONTAL: 12,
-      /**
-       * Reflection about reverse diagonal.
-       * @memberof PIXI.groupD8
-       * @constant {PIXI.GD8Symmetry}
-       */
-      REVERSE_DIAGONAL: 14,
-      /**
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
-       * @returns {PIXI.GD8Symmetry} The X-component of the U-axis
-       *    after rotating the axes.
-       */
-      uX: function (ind) { return ux[ind]; },
-      /**
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
-       * @returns {PIXI.GD8Symmetry} The Y-component of the U-axis
-       *    after rotating the axes.
-       */
-      uY: function (ind) { return uy[ind]; },
-      /**
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
-       * @returns {PIXI.GD8Symmetry} The X-component of the V-axis
-       *    after rotating the axes.
-       */
-      vX: function (ind) { return vx[ind]; },
-      /**
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} ind - sprite rotation angle.
-       * @returns {PIXI.GD8Symmetry} The Y-component of the V-axis
-       *    after rotating the axes.
-       */
-      vY: function (ind) { return vy[ind]; },
-      /**
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} rotation - symmetry whose opposite
-       *   is needed. Only rotations have opposite symmetries while
-       *   reflections don't.
-       * @returns {PIXI.GD8Symmetry} The opposite symmetry of `rotation`
-       */
-      inv: function (rotation) {
-          if (rotation & 8) // true only if between 8 & 15 (reflections)
-           {
-              return rotation & 15; // or rotation % 16
-          }
-          return (-rotation) & 7; // or (8 - rotation) % 8
-      },
-      /**
-       * Composes the two D8 operations.
-       *
-       * Taking `^` as reflection:
-       *
-       * |       | E=0 | S=2 | W=4 | N=6 | E^=8 | S^=10 | W^=12 | N^=14 |
-       * |-------|-----|-----|-----|-----|------|-------|-------|-------|
-       * | E=0   | E   | S   | W   | N   | E^   | S^    | W^    | N^    |
-       * | S=2   | S   | W   | N   | E   | S^   | W^    | N^    | E^    |
-       * | W=4   | W   | N   | E   | S   | W^   | N^    | E^    | S^    |
-       * | N=6   | N   | E   | S   | W   | N^   | E^    | S^    | W^    |
-       * | E^=8  | E^  | N^  | W^  | S^  | E    | N     | W     | S     |
-       * | S^=10 | S^  | E^  | N^  | W^  | S    | E     | N     | W     |
-       * | W^=12 | W^  | S^  | E^  | N^  | W    | S     | E     | N     |
-       * | N^=14 | N^  | W^  | S^  | E^  | N    | W     | S     | E     |
-       *
-       * [This is a Cayley table]{@link https://en.wikipedia.org/wiki/Cayley_table}
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} rotationSecond - Second operation, which
-       *   is the row in the above cayley table.
-       * @param {PIXI.GD8Symmetry} rotationFirst - First operation, which
-       *   is the column in the above cayley table.
-       * @returns {PIXI.GD8Symmetry} Composed operation
-       */
-      add: function (rotationSecond, rotationFirst) { return (rotationCayley[rotationSecond][rotationFirst]); },
-      /**
-       * Reverse of `add`.
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} rotationSecond - Second operation
-       * @param {PIXI.GD8Symmetry} rotationFirst - First operation
-       * @returns {PIXI.GD8Symmetry} Result
-       */
-      sub: function (rotationSecond, rotationFirst) { return (rotationCayley[rotationSecond][groupD8.inv(rotationFirst)]); },
-      /**
-       * Adds 180 degrees to rotation, which is a commutative
-       * operation.
-       * @memberof PIXI.groupD8
-       * @param {number} rotation - The number to rotate.
-       * @returns {number} Rotated number
-       */
-      rotate180: function (rotation) { return rotation ^ 4; },
-      /**
-       * Checks if the rotation angle is vertical, i.e. south
-       * or north. It doesn't work for reflections.
-       * @memberof PIXI.groupD8
-       * @param {PIXI.GD8Symmetry} rotation - The number to check.
-       * @returns {boolean} Whether or not the direction is vertical
-       */
-      isVertical: function (rotation) { return (rotation & 3) === 2; },
-      /**
-       * Approximates the vector `V(dx,dy)` into one of the
-       * eight directions provided by `groupD8`.
-       * @memberof PIXI.groupD8
-       * @param {number} dx - X-component of the vector
-       * @param {number} dy - Y-component of the vector
-       * @returns {PIXI.GD8Symmetry} Approximation of the vector into
-       *  one of the eight symmetries.
-       */
-      byDirection: function (dx, dy) {
-          if (Math.abs(dx) * 2 <= Math.abs(dy)) {
-              if (dy >= 0) {
-                  return groupD8.S;
-              }
-              return groupD8.N;
-          }
-          else if (Math.abs(dy) * 2 <= Math.abs(dx)) {
-              if (dx > 0) {
-                  return groupD8.E;
-              }
-              return groupD8.W;
-          }
-          else if (dy > 0) {
-              if (dx > 0) {
-                  return groupD8.SE;
-              }
-              return groupD8.SW;
-          }
-          else if (dx > 0) {
-              return groupD8.NE;
-          }
-          return groupD8.NW;
-      },
-      /**
-       * Helps sprite to compensate texture packer rotation.
-       * @memberof PIXI.groupD8
-       * @param {PIXI.Matrix} matrix - sprite world matrix
-       * @param {PIXI.GD8Symmetry} rotation - The rotation factor to use.
-       * @param {number} tx - sprite anchoring
-       * @param {number} ty - sprite anchoring
-       */
-      matrixAppendRotationInv: function (matrix, rotation, tx, ty) {
-          if (tx === void 0) { tx = 0; }
-          if (ty === void 0) { ty = 0; }
-          // Packer used "rotation", we use "inv(rotation)"
-          var mat = rotationMatrices[groupD8.inv(rotation)];
-          mat.tx = tx;
-          mat.ty = ty;
-          matrix.append(mat);
-      },
-  };
-
-  /**
-   * Transform that takes care about its versions.
-   * @memberof PIXI
-   */
-  var Transform = /** @class */ (function () {
-      function Transform() {
-          this.worldTransform = new Matrix();
-          this.localTransform = new Matrix();
-          this.position = new ObservablePoint(this.onChange, this, 0, 0);
-          this.scale = new ObservablePoint(this.onChange, this, 1, 1);
-          this.pivot = new ObservablePoint(this.onChange, this, 0, 0);
-          this.skew = new ObservablePoint(this.updateSkew, this, 0, 0);
-          this._rotation = 0;
-          this._cx = 1;
-          this._sx = 0;
-          this._cy = 0;
-          this._sy = 1;
-          this._localID = 0;
-          this._currentLocalID = 0;
-          this._worldID = 0;
-          this._parentID = 0;
-      }
-      /** Called when a value changes. */
-      Transform.prototype.onChange = function () {
-          this._localID++;
-      };
-      /** Called when the skew or the rotation changes. */
-      Transform.prototype.updateSkew = function () {
-          this._cx = Math.cos(this._rotation + this.skew.y);
-          this._sx = Math.sin(this._rotation + this.skew.y);
-          this._cy = -Math.sin(this._rotation - this.skew.x); // cos, added PI/2
-          this._sy = Math.cos(this._rotation - this.skew.x); // sin, added PI/2
-          this._localID++;
-      };
-      Transform.prototype.toString = function () {
-          return "[@pixi/math:Transform "
-              + ("position=(" + this.position.x + ", " + this.position.y + ") ")
-              + ("rotation=" + this.rotation + " ")
-              + ("scale=(" + this.scale.x + ", " + this.scale.y + ") ")
-              + ("skew=(" + this.skew.x + ", " + this.skew.y + ") ")
-              + "]";
-      };
-      /** Updates the local transformation matrix. */
-      Transform.prototype.updateLocalTransform = function () {
-          var lt = this.localTransform;
-          if (this._localID !== this._currentLocalID) {
-              // get the matrix values of the displayobject based on its transform properties..
-              lt.a = this._cx * this.scale.x;
-              lt.b = this._sx * this.scale.x;
-              lt.c = this._cy * this.scale.y;
-              lt.d = this._sy * this.scale.y;
-              lt.tx = this.position.x - ((this.pivot.x * lt.a) + (this.pivot.y * lt.c));
-              lt.ty = this.position.y - ((this.pivot.x * lt.b) + (this.pivot.y * lt.d));
-              this._currentLocalID = this._localID;
-              // force an update..
-              this._parentID = -1;
-          }
-      };
-      /**
-       * Updates the local and the world transformation matrices.
-       * @param parentTransform - The parent transform
-       */
-      Transform.prototype.updateTransform = function (parentTransform) {
-          var lt = this.localTransform;
-          if (this._localID !== this._currentLocalID) {
-              // get the matrix values of the displayobject based on its transform properties..
-              lt.a = this._cx * this.scale.x;
-              lt.b = this._sx * this.scale.x;
-              lt.c = this._cy * this.scale.y;
-              lt.d = this._sy * this.scale.y;
-              lt.tx = this.position.x - ((this.pivot.x * lt.a) + (this.pivot.y * lt.c));
-              lt.ty = this.position.y - ((this.pivot.x * lt.b) + (this.pivot.y * lt.d));
-              this._currentLocalID = this._localID;
-              // force an update..
-              this._parentID = -1;
-          }
-          if (this._parentID !== parentTransform._worldID) {
-              // concat the parent matrix with the objects transform.
-              var pt = parentTransform.worldTransform;
-              var wt = this.worldTransform;
-              wt.a = (lt.a * pt.a) + (lt.b * pt.c);
-              wt.b = (lt.a * pt.b) + (lt.b * pt.d);
-              wt.c = (lt.c * pt.a) + (lt.d * pt.c);
-              wt.d = (lt.c * pt.b) + (lt.d * pt.d);
-              wt.tx = (lt.tx * pt.a) + (lt.ty * pt.c) + pt.tx;
-              wt.ty = (lt.tx * pt.b) + (lt.ty * pt.d) + pt.ty;
-              this._parentID = parentTransform._worldID;
-              // update the id of the transform..
-              this._worldID++;
-          }
-      };
-      /**
-       * Decomposes a matrix and sets the transforms properties based on it.
-       * @param matrix - The matrix to decompose
-       */
-      Transform.prototype.setFromMatrix = function (matrix) {
-          matrix.decompose(this);
-          this._localID++;
-      };
-      Object.defineProperty(Transform.prototype, "rotation", {
-          /** The rotation of the object in radians. */
-          get: function () {
-              return this._rotation;
-          },
-          set: function (value) {
-              if (this._rotation !== value) {
-                  this._rotation = value;
-                  this.updateSkew();
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** A default (identity) transform. */
-      Transform.IDENTITY = new Transform();
-      return Transform;
-  }());
-
-  /*!
-   * @pixi/display - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/display is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Sets the default value for the container property 'sortableChildren'.
-   * If set to true, the container will sort its children by zIndex value
-   * when updateTransform() is called, or manually if sortChildren() is called.
-   *
-   * This actually changes the order of elements in the array, so should be treated
-   * as a basic solution that is not performant compared to other solutions,
-   * such as @link https://github.com/pixijs/pixi-display
-   *
-   * Also be aware of that this may not work nicely with the addChildAt() function,
-   * as the zIndex sorting may cause the child to automatically sorted to another position.
-   * @static
-   * @constant
-   * @name SORTABLE_CHILDREN
-   * @memberof PIXI.settings
-   * @type {boolean}
-   * @default false
-   */
-  settings.SORTABLE_CHILDREN = false;
-
-  /**
-   * 'Builder' pattern for bounds rectangles.
-   *
-   * This could be called an Axis-Aligned Bounding Box.
-   * It is not an actual shape. It is a mutable thing; no 'EMPTY' or those kind of problems.
-   * @memberof PIXI
-   */
-  var Bounds = /** @class */ (function () {
-      function Bounds() {
-          this.minX = Infinity;
-          this.minY = Infinity;
-          this.maxX = -Infinity;
-          this.maxY = -Infinity;
-          this.rect = null;
-          this.updateID = -1;
-      }
-      /**
-       * Checks if bounds are empty.
-       * @returns - True if empty.
-       */
-      Bounds.prototype.isEmpty = function () {
-          return this.minX > this.maxX || this.minY > this.maxY;
-      };
-      /** Clears the bounds and resets. */
-      Bounds.prototype.clear = function () {
-          this.minX = Infinity;
-          this.minY = Infinity;
-          this.maxX = -Infinity;
-          this.maxY = -Infinity;
-      };
-      /**
-       * Can return Rectangle.EMPTY constant, either construct new rectangle, either use your rectangle
-       * It is not guaranteed that it will return tempRect
-       * @param rect - Temporary object will be used if AABB is not empty
-       * @returns - A rectangle of the bounds
-       */
-      Bounds.prototype.getRectangle = function (rect) {
-          if (this.minX > this.maxX || this.minY > this.maxY) {
-              return Rectangle.EMPTY;
-          }
-          rect = rect || new Rectangle(0, 0, 1, 1);
-          rect.x = this.minX;
-          rect.y = this.minY;
-          rect.width = this.maxX - this.minX;
-          rect.height = this.maxY - this.minY;
-          return rect;
-      };
-      /**
-       * This function should be inlined when its possible.
-       * @param point - The point to add.
-       */
-      Bounds.prototype.addPoint = function (point) {
-          this.minX = Math.min(this.minX, point.x);
-          this.maxX = Math.max(this.maxX, point.x);
-          this.minY = Math.min(this.minY, point.y);
-          this.maxY = Math.max(this.maxY, point.y);
-      };
-      /**
-       * Adds a point, after transformed. This should be inlined when its possible.
-       * @param matrix
-       * @param point
-       */
-      Bounds.prototype.addPointMatrix = function (matrix, point) {
-          var a = matrix.a, b = matrix.b, c = matrix.c, d = matrix.d, tx = matrix.tx, ty = matrix.ty;
-          var x = (a * point.x) + (c * point.y) + tx;
-          var y = (b * point.x) + (d * point.y) + ty;
-          this.minX = Math.min(this.minX, x);
-          this.maxX = Math.max(this.maxX, x);
-          this.minY = Math.min(this.minY, y);
-          this.maxY = Math.max(this.maxY, y);
-      };
-      /**
-       * Adds a quad, not transformed
-       * @param vertices - The verts to add.
-       */
-      Bounds.prototype.addQuad = function (vertices) {
-          var minX = this.minX;
-          var minY = this.minY;
-          var maxX = this.maxX;
-          var maxY = this.maxY;
-          var x = vertices[0];
-          var y = vertices[1];
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          x = vertices[2];
-          y = vertices[3];
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          x = vertices[4];
-          y = vertices[5];
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          x = vertices[6];
-          y = vertices[7];
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          this.minX = minX;
-          this.minY = minY;
-          this.maxX = maxX;
-          this.maxY = maxY;
-      };
-      /**
-       * Adds sprite frame, transformed.
-       * @param transform - transform to apply
-       * @param x0 - left X of frame
-       * @param y0 - top Y of frame
-       * @param x1 - right X of frame
-       * @param y1 - bottom Y of frame
-       */
-      Bounds.prototype.addFrame = function (transform, x0, y0, x1, y1) {
-          this.addFrameMatrix(transform.worldTransform, x0, y0, x1, y1);
-      };
-      /**
-       * Adds sprite frame, multiplied by matrix
-       * @param matrix - matrix to apply
-       * @param x0 - left X of frame
-       * @param y0 - top Y of frame
-       * @param x1 - right X of frame
-       * @param y1 - bottom Y of frame
-       */
-      Bounds.prototype.addFrameMatrix = function (matrix, x0, y0, x1, y1) {
-          var a = matrix.a;
-          var b = matrix.b;
-          var c = matrix.c;
-          var d = matrix.d;
-          var tx = matrix.tx;
-          var ty = matrix.ty;
-          var minX = this.minX;
-          var minY = this.minY;
-          var maxX = this.maxX;
-          var maxY = this.maxY;
-          var x = (a * x0) + (c * y0) + tx;
-          var y = (b * x0) + (d * y0) + ty;
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          x = (a * x1) + (c * y0) + tx;
-          y = (b * x1) + (d * y0) + ty;
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          x = (a * x0) + (c * y1) + tx;
-          y = (b * x0) + (d * y1) + ty;
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          x = (a * x1) + (c * y1) + tx;
-          y = (b * x1) + (d * y1) + ty;
-          minX = x < minX ? x : minX;
-          minY = y < minY ? y : minY;
-          maxX = x > maxX ? x : maxX;
-          maxY = y > maxY ? y : maxY;
-          this.minX = minX;
-          this.minY = minY;
-          this.maxX = maxX;
-          this.maxY = maxY;
-      };
-      /**
-       * Adds screen vertices from array
-       * @param vertexData - calculated vertices
-       * @param beginOffset - begin offset
-       * @param endOffset - end offset, excluded
-       */
-      Bounds.prototype.addVertexData = function (vertexData, beginOffset, endOffset) {
-          var minX = this.minX;
-          var minY = this.minY;
-          var maxX = this.maxX;
-          var maxY = this.maxY;
-          for (var i = beginOffset; i < endOffset; i += 2) {
-              var x = vertexData[i];
-              var y = vertexData[i + 1];
-              minX = x < minX ? x : minX;
-              minY = y < minY ? y : minY;
-              maxX = x > maxX ? x : maxX;
-              maxY = y > maxY ? y : maxY;
-          }
-          this.minX = minX;
-          this.minY = minY;
-          this.maxX = maxX;
-          this.maxY = maxY;
-      };
-      /**
-       * Add an array of mesh vertices
-       * @param transform - mesh transform
-       * @param vertices - mesh coordinates in array
-       * @param beginOffset - begin offset
-       * @param endOffset - end offset, excluded
-       */
-      Bounds.prototype.addVertices = function (transform, vertices, beginOffset, endOffset) {
-          this.addVerticesMatrix(transform.worldTransform, vertices, beginOffset, endOffset);
-      };
-      /**
-       * Add an array of mesh vertices.
-       * @param matrix - mesh matrix
-       * @param vertices - mesh coordinates in array
-       * @param beginOffset - begin offset
-       * @param endOffset - end offset, excluded
-       * @param padX - x padding
-       * @param padY - y padding
-       */
-      Bounds.prototype.addVerticesMatrix = function (matrix, vertices, beginOffset, endOffset, padX, padY) {
-          if (padX === void 0) { padX = 0; }
-          if (padY === void 0) { padY = padX; }
-          var a = matrix.a;
-          var b = matrix.b;
-          var c = matrix.c;
-          var d = matrix.d;
-          var tx = matrix.tx;
-          var ty = matrix.ty;
-          var minX = this.minX;
-          var minY = this.minY;
-          var maxX = this.maxX;
-          var maxY = this.maxY;
-          for (var i = beginOffset; i < endOffset; i += 2) {
-              var rawX = vertices[i];
-              var rawY = vertices[i + 1];
-              var x = (a * rawX) + (c * rawY) + tx;
-              var y = (d * rawY) + (b * rawX) + ty;
-              minX = Math.min(minX, x - padX);
-              maxX = Math.max(maxX, x + padX);
-              minY = Math.min(minY, y - padY);
-              maxY = Math.max(maxY, y + padY);
-          }
-          this.minX = minX;
-          this.minY = minY;
-          this.maxX = maxX;
-          this.maxY = maxY;
-      };
-      /**
-       * Adds other {@link Bounds}.
-       * @param bounds - The Bounds to be added
-       */
-      Bounds.prototype.addBounds = function (bounds) {
-          var minX = this.minX;
-          var minY = this.minY;
-          var maxX = this.maxX;
-          var maxY = this.maxY;
-          this.minX = bounds.minX < minX ? bounds.minX : minX;
-          this.minY = bounds.minY < minY ? bounds.minY : minY;
-          this.maxX = bounds.maxX > maxX ? bounds.maxX : maxX;
-          this.maxY = bounds.maxY > maxY ? bounds.maxY : maxY;
-      };
-      /**
-       * Adds other Bounds, masked with Bounds.
-       * @param bounds - The Bounds to be added.
-       * @param mask - TODO
-       */
-      Bounds.prototype.addBoundsMask = function (bounds, mask) {
-          var _minX = bounds.minX > mask.minX ? bounds.minX : mask.minX;
-          var _minY = bounds.minY > mask.minY ? bounds.minY : mask.minY;
-          var _maxX = bounds.maxX < mask.maxX ? bounds.maxX : mask.maxX;
-          var _maxY = bounds.maxY < mask.maxY ? bounds.maxY : mask.maxY;
-          if (_minX <= _maxX && _minY <= _maxY) {
-              var minX = this.minX;
-              var minY = this.minY;
-              var maxX = this.maxX;
-              var maxY = this.maxY;
-              this.minX = _minX < minX ? _minX : minX;
-              this.minY = _minY < minY ? _minY : minY;
-              this.maxX = _maxX > maxX ? _maxX : maxX;
-              this.maxY = _maxY > maxY ? _maxY : maxY;
-          }
-      };
-      /**
-       * Adds other Bounds, multiplied by matrix. Bounds shouldn't be empty.
-       * @param bounds - other bounds
-       * @param matrix - multiplicator
-       */
-      Bounds.prototype.addBoundsMatrix = function (bounds, matrix) {
-          this.addFrameMatrix(matrix, bounds.minX, bounds.minY, bounds.maxX, bounds.maxY);
-      };
-      /**
-       * Adds other Bounds, masked with Rectangle.
-       * @param bounds - TODO
-       * @param area - TODO
-       */
-      Bounds.prototype.addBoundsArea = function (bounds, area) {
-          var _minX = bounds.minX > area.x ? bounds.minX : area.x;
-          var _minY = bounds.minY > area.y ? bounds.minY : area.y;
-          var _maxX = bounds.maxX < area.x + area.width ? bounds.maxX : (area.x + area.width);
-          var _maxY = bounds.maxY < area.y + area.height ? bounds.maxY : (area.y + area.height);
-          if (_minX <= _maxX && _minY <= _maxY) {
-              var minX = this.minX;
-              var minY = this.minY;
-              var maxX = this.maxX;
-              var maxY = this.maxY;
-              this.minX = _minX < minX ? _minX : minX;
-              this.minY = _minY < minY ? _minY : minY;
-              this.maxX = _maxX > maxX ? _maxX : maxX;
-              this.maxY = _maxY > maxY ? _maxY : maxY;
-          }
-      };
-      /**
-       * Pads bounds object, making it grow in all directions.
-       * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
-       * @param paddingX - The horizontal padding amount.
-       * @param paddingY - The vertical padding amount.
-       */
-      Bounds.prototype.pad = function (paddingX, paddingY) {
-          if (paddingX === void 0) { paddingX = 0; }
-          if (paddingY === void 0) { paddingY = paddingX; }
-          if (!this.isEmpty()) {
-              this.minX -= paddingX;
-              this.maxX += paddingX;
-              this.minY -= paddingY;
-              this.maxY += paddingY;
-          }
-      };
-      /**
-       * Adds padded frame. (x0, y0) should be strictly less than (x1, y1)
-       * @param x0 - left X of frame
-       * @param y0 - top Y of frame
-       * @param x1 - right X of frame
-       * @param y1 - bottom Y of frame
-       * @param padX - padding X
-       * @param padY - padding Y
-       */
-      Bounds.prototype.addFramePad = function (x0, y0, x1, y1, padX, padY) {
-          x0 -= padX;
-          y0 -= padY;
-          x1 += padX;
-          y1 += padY;
-          this.minX = this.minX < x0 ? this.minX : x0;
-          this.maxX = this.maxX > x1 ? this.maxX : x1;
-          this.minY = this.minY < y0 ? this.minY : y0;
-          this.maxY = this.maxY > y1 ? this.maxY : y1;
-      };
-      return Bounds;
-  }());
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$j = function(d, b) {
-      extendStatics$j = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$j(d, b);
-  };
-
-  function __extends$j(d, b) {
-      extendStatics$j(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * The base class for all objects that are rendered on the screen.
-   *
-   * This is an abstract class and can not be used on its own; rather it should be extended.
-   *
-   * ## Display objects implemented in PixiJS
-   *
-   * | Display Object                  | Description                                                           |
-   * | ------------------------------- | --------------------------------------------------------------------- |
-   * | {@link PIXI.Container}          | Adds support for `children` to DisplayObject                          |
-   * | {@link PIXI.Graphics}           | Shape-drawing display object similar to the Canvas API                |
-   * | {@link PIXI.Sprite}             | Draws textures (i.e. images)                                          |
-   * | {@link PIXI.Text}               | Draws text using the Canvas API internally                            |
-   * | {@link PIXI.BitmapText}         | More scaleable solution for text rendering, reusing glyph textures    |
-   * | {@link PIXI.TilingSprite}       | Draws textures/images in a tiled fashion                              |
-   * | {@link PIXI.AnimatedSprite}     | Draws an animation of multiple images                                 |
-   * | {@link PIXI.Mesh}               | Provides a lower-level API for drawing meshes with custom data        |
-   * | {@link PIXI.NineSlicePlane}     | Mesh-related                                                          |
-   * | {@link PIXI.SimpleMesh}         | v4-compatible mesh                                                    |
-   * | {@link PIXI.SimplePlane}        | Mesh-related                                                          |
-   * | {@link PIXI.SimpleRope}         | Mesh-related                                                          |
-   *
-   * ## Transforms
-   *
-   * The [transform]{@link DisplayObject#transform} of a display object describes the projection from its
-   * local coordinate space to its parent's local coordinate space. The following properties are derived
-   * from the transform:
-   *
-   * <table>
-   *   <thead>
-   *     <tr>
-   *       <th>Property</th>
-   *       <th>Description</th>
-   *     </tr>
-   *   </thead>
-   *   <tbody>
-   *     <tr>
-   *       <td>[pivot]{@link PIXI.DisplayObject#pivot}</td>
-   *       <td>
-   *         Invariant under rotation, scaling, and skewing. The projection of into the parent's space of the pivot
-   *         is equal to position, regardless of the other three transformations. In other words, It is the center of
-   *         rotation, scaling, and skewing.
-   *       </td>
-   *     </tr>
-   *     <tr>
-   *       <td>[position]{@link PIXI.DisplayObject#position}</td>
-   *       <td>
-   *         Translation. This is the position of the [pivot]{@link PIXI.DisplayObject#pivot} in the parent's local
-   *         space. The default value of the pivot is the origin (0,0). If the top-left corner of your display object
-   *         is (0,0) in its local space, then the position will be its top-left corner in the parent's local space.
-   *       </td>
-   *     </tr>
-   *     <tr>
-   *       <td>[scale]{@link PIXI.DisplayObject#scale}</td>
-   *       <td>
-   *         Scaling. This will stretch (or compress) the display object's projection. The scale factors are along the
-   *         local coordinate axes. In other words, the display object is scaled before rotated or skewed. The center
-   *         of scaling is the [pivot]{@link PIXI.DisplayObject#pivot}.
-   *       </td>
-   *     </tr>
-   *     <tr>
-   *       <td>[rotation]{@link PIXI.DisplayObject#rotation}</td>
-   *       <td>
-   *          Rotation. This will rotate the display object's projection by this angle (in radians).
-   *       </td>
-   *     </tr>
-   *     <tr>
-   *       <td>[skew]{@link PIXI.DisplayObject#skew}</td>
-   *       <td>
-   *         <p>Skewing. This can be used to deform a rectangular display object into a parallelogram.</p>
-   *         <p>
-   *         In PixiJS, skew has a slightly different behaviour than the conventional meaning. It can be
-   *         thought of the net rotation applied to the coordinate axes (separately). For example, if "skew.x" is
-   *         ⍺ and "skew.y" is β, then the line x = 0 will be rotated by ⍺ (y = -x*cot⍺) and the line y = 0 will be
-   *         rotated by β (y = x*tanβ). A line y = x*tanϴ (i.e. a line at angle ϴ to the x-axis in local-space) will
-   *         be rotated by an angle between ⍺ and β.
-   *         </p>
-   *         <p>
-   *         It can be observed that if skew is applied equally to both axes, then it will be equivalent to applying
-   *         a rotation. Indeed, if "skew.x" = -ϴ and "skew.y" = ϴ, it will produce an equivalent of "rotation" = ϴ.
-   *         </p>
-   *         <p>
-   *         Another quite interesting observation is that "skew.x", "skew.y", rotation are communtative operations. Indeed,
-   *         because rotation is essentially a careful combination of the two.
-   *         </p>
-   *       </td>
-   *     </tr>
-   *     <tr>
-   *       <td>angle</td>
-   *       <td>Rotation. This is an alias for [rotation]{@link PIXI.DisplayObject#rotation}, but in degrees.</td>
-   *     </tr>
-   *     <tr>
-   *       <td>x</td>
-   *       <td>Translation. This is an alias for position.x!</td>
-   *     </tr>
-   *     <tr>
-   *       <td>y</td>
-   *       <td>Translation. This is an alias for position.y!</td>
-   *     </tr>
-   *     <tr>
-   *       <td>width</td>
-   *       <td>
-   *         Implemented in [Container]{@link PIXI.Container}. Scaling. The width property calculates scale.x by dividing
-   *         the "requested" width by the local bounding box width. It is indirectly an abstraction over scale.x, and there
-   *         is no concept of user-defined width.
-   *       </td>
-   *     </tr>
-   *     <tr>
-   *       <td>height</td>
-   *       <td>
-   *         Implemented in [Container]{@link PIXI.Container}. Scaling. The height property calculates scale.y by dividing
-   *         the "requested" height by the local bounding box height. It is indirectly an abstraction over scale.y, and there
-   *         is no concept of user-defined height.
-   *       </td>
-   *     </tr>
-   *   </tbody>
-   * </table>
-   *
-   * ## Bounds
-   *
-   * The bounds of a display object is defined by the minimum axis-aligned rectangle in world space that can fit
-   * around it. The abstract `calculateBounds` method is responsible for providing it (and it should use the
-   * `worldTransform` to calculate in world space).
-   *
-   * There are a few additional types of bounding boxes:
-   *
-   * | Bounds                | Description                                                                              |
-   * | --------------------- | ---------------------------------------------------------------------------------------- |
-   * | World Bounds          | This is synonymous is the regular bounds described above. See `getBounds()`.             |
-   * | Local Bounds          | This the axis-aligned bounding box in the parent's local space. See `getLocalBounds()`.  |
-   * | Render Bounds         | The bounds, but including extra rendering effects like filter padding.                   |
-   * | Projected Bounds      | The bounds of the projected display object onto the screen. Usually equals world bounds. |
-   * | Relative Bounds       | The bounds of a display object when projected onto a ancestor's (or parent's) space.     |
-   * | Natural Bounds        | The bounds of an object in its own local space (not parent's space, like in local bounds)|
-   * | Content Bounds        | The natural bounds when excluding all children of a `Container`.                         |
-   *
-   * ### calculateBounds
-   *
-   * [Container]{@link Container} already implements `calculateBounds` in a manner that includes children.
-   *
-   * But for a non-Container display object, the `calculateBounds` method must be overridden in order for `getBounds` and
-   * `getLocalBounds` to work. This method must write the bounds into `this._bounds`.
-   *
-   * Generally, the following technique works for most simple cases: take the list of points
-   * forming the "hull" of the object (i.e. outline of the object's shape), and then add them
-   * using {@link PIXI.Bounds#addPointMatrix}.
-   *
-   * ```js
-   * calculateBounds(): void
-   * {
-   *     const points = [...];
-   *
-   *     for (let i = 0, j = points.length; i < j; i++)
-   *     {
-   *         this._bounds.addPointMatrix(this.worldTransform, points[i]);
-   *     }
-   * }
-   * ```
-   *
-   * You can optimize this for a large number of points by using {@link PIXI.Bounds#addVerticesMatrix} to pass them
-   * in one array together.
-   *
-   * ## Alpha
-   *
-   * This alpha sets a display object's **relative opacity** w.r.t its parent. For example, if the alpha of a display
-   * object is 0.5 and its parent's alpha is 0.5, then it will be rendered with 25% opacity (assuming alpha is not
-   * applied on any ancestor further up the chain).
-   *
-   * The alpha with which the display object will be rendered is called the [worldAlpha]{@link PIXI.DisplayObject#worldAlpha}.
-   *
-   * ## Renderable vs Visible
-   *
-   * The `renderable` and `visible` properties can be used to prevent a display object from being rendered to the
-   * screen. However, there is a subtle difference between the two. When using `renderable`, the transforms  of the display
-   * object (and its children subtree) will continue to be calculated. When using `visible`, the transforms will not
-   * be calculated.
-   *
-   * It is recommended that applications use the `renderable` property for culling. See
-   * [@pixi-essentials/cull]{@link https://www.npmjs.com/package/@pixi-essentials/cull} or
-   * [pixi-cull]{@link https://www.npmjs.com/package/pixi-cull} for more details.
-   *
-   * Otherwise, to prevent an object from rendering in the general-purpose sense - `visible` is the property to use. This
-   * one is also better in terms of performance.
-   * @memberof PIXI
-   */
-  var DisplayObject = /** @class */ (function (_super) {
-      __extends$j(DisplayObject, _super);
-      function DisplayObject() {
-          var _this = _super.call(this) || this;
-          _this.tempDisplayObjectParent = null;
-          // TODO: need to create Transform from factory
-          _this.transform = new Transform();
-          _this.alpha = 1;
-          _this.visible = true;
-          _this.renderable = true;
-          _this.cullable = false;
-          _this.cullArea = null;
-          _this.parent = null;
-          _this.worldAlpha = 1;
-          _this._lastSortedIndex = 0;
-          _this._zIndex = 0;
-          _this.filterArea = null;
-          _this.filters = null;
-          _this._enabledFilters = null;
-          _this._bounds = new Bounds();
-          _this._localBounds = null;
-          _this._boundsID = 0;
-          _this._boundsRect = null;
-          _this._localBoundsRect = null;
-          _this._mask = null;
-          _this._maskRefCount = 0;
-          _this._destroyed = false;
-          _this.isSprite = false;
-          _this.isMask = false;
-          return _this;
-      }
-      /**
-       * Mixes all enumerable properties and methods from a source object to DisplayObject.
-       * @param source - The source of properties and methods to mix in.
-       */
-      DisplayObject.mixin = function (source) {
-          // in ES8/ES2017, this would be really easy:
-          // Object.defineProperties(DisplayObject.prototype, Object.getOwnPropertyDescriptors(source));
-          // get all the enumerable property keys
-          var keys = Object.keys(source);
-          // loop through properties
-          for (var i = 0; i < keys.length; ++i) {
-              var propertyName = keys[i];
-              // Set the property using the property descriptor - this works for accessors and normal value properties
-              Object.defineProperty(DisplayObject.prototype, propertyName, Object.getOwnPropertyDescriptor(source, propertyName));
-          }
-      };
-      Object.defineProperty(DisplayObject.prototype, "destroyed", {
-          /**
-           * Fired when this DisplayObject is added to a Container.
-           * @instance
-           * @event added
-           * @param {PIXI.Container} container - The container added to.
-           */
-          /**
-           * Fired when this DisplayObject is removed from a Container.
-           * @instance
-           * @event removed
-           * @param {PIXI.Container} container - The container removed from.
-           */
-          /**
-           * Fired when this DisplayObject is destroyed. This event is emitted once
-           * destroy is finished.
-           * @instance
-           * @event destroyed
-           */
-          /** Readonly flag for destroyed display objects. */
-          get: function () {
-              return this._destroyed;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Recursively updates transform of all objects from the root to this one internal function for toLocal() */
-      DisplayObject.prototype._recursivePostUpdateTransform = function () {
-          if (this.parent) {
-              this.parent._recursivePostUpdateTransform();
-              this.transform.updateTransform(this.parent.transform);
-          }
-          else {
-              this.transform.updateTransform(this._tempDisplayObjectParent.transform);
-          }
-      };
-      /** Updates the object transform for rendering. TODO - Optimization pass! */
-      DisplayObject.prototype.updateTransform = function () {
-          this._boundsID++;
-          this.transform.updateTransform(this.parent.transform);
-          // multiply the alphas..
-          this.worldAlpha = this.alpha * this.parent.worldAlpha;
-      };
-      /**
-       * Calculates and returns the (world) bounds of the display object as a [Rectangle]{@link PIXI.Rectangle}.
-       *
-       * This method is expensive on containers with a large subtree (like the stage). This is because the bounds
-       * of a container depend on its children's bounds, which recursively causes all bounds in the subtree to
-       * be recalculated. The upside, however, is that calling `getBounds` once on a container will indeed update
-       * the bounds of all children (the whole subtree, in fact). This side effect should be exploited by using
-       * `displayObject._bounds.getRectangle()` when traversing through all the bounds in a scene graph. Otherwise,
-       * calling `getBounds` on each object in a subtree will cause the total cost to increase quadratically as
-       * its height increases.
-       *
-       * The transforms of all objects in a container's **subtree** and of all **ancestors** are updated.
-       * The world bounds of all display objects in a container's **subtree** will also be recalculated.
-       *
-       * The `_bounds` object stores the last calculation of the bounds. You can use to entirely skip bounds
-       * calculation if needed.
-       *
-       * ```js
-       * const lastCalculatedBounds = displayObject._bounds.getRectangle(optionalRect);
-       * ```
-       *
-       * Do know that usage of `getLocalBounds` can corrupt the `_bounds` of children (the whole subtree, actually). This
-       * is a known issue that has not been solved. See [getLocalBounds]{@link PIXI.DisplayObject#getLocalBounds} for more
-       * details.
-       *
-       * `getBounds` should be called with `skipUpdate` equal to `true` in a render() call. This is because the transforms
-       * are guaranteed to be update-to-date. In fact, recalculating inside a render() call may cause corruption in certain
-       * cases.
-       * @param skipUpdate - Setting to `true` will stop the transforms of the scene graph from
-       *  being updated. This means the calculation returned MAY be out of date BUT will give you a
-       *  nice performance boost.
-       * @param rect - Optional rectangle to store the result of the bounds calculation.
-       * @returns - The minimum axis-aligned rectangle in world space that fits around this object.
-       */
-      DisplayObject.prototype.getBounds = function (skipUpdate, rect) {
-          if (!skipUpdate) {
-              if (!this.parent) {
-                  this.parent = this._tempDisplayObjectParent;
-                  this.updateTransform();
-                  this.parent = null;
-              }
-              else {
-                  this._recursivePostUpdateTransform();
-                  this.updateTransform();
-              }
-          }
-          if (this._bounds.updateID !== this._boundsID) {
-              this.calculateBounds();
-              this._bounds.updateID = this._boundsID;
-          }
-          if (!rect) {
-              if (!this._boundsRect) {
-                  this._boundsRect = new Rectangle();
-              }
-              rect = this._boundsRect;
-          }
-          return this._bounds.getRectangle(rect);
-      };
-      /**
-       * Retrieves the local bounds of the displayObject as a rectangle object.
-       * @param rect - Optional rectangle to store the result of the bounds calculation.
-       * @returns - The rectangular bounding area.
-       */
-      DisplayObject.prototype.getLocalBounds = function (rect) {
-          if (!rect) {
-              if (!this._localBoundsRect) {
-                  this._localBoundsRect = new Rectangle();
-              }
-              rect = this._localBoundsRect;
-          }
-          if (!this._localBounds) {
-              this._localBounds = new Bounds();
-          }
-          var transformRef = this.transform;
-          var parentRef = this.parent;
-          this.parent = null;
-          this.transform = this._tempDisplayObjectParent.transform;
-          var worldBounds = this._bounds;
-          var worldBoundsID = this._boundsID;
-          this._bounds = this._localBounds;
-          var bounds = this.getBounds(false, rect);
-          this.parent = parentRef;
-          this.transform = transformRef;
-          this._bounds = worldBounds;
-          this._bounds.updateID += this._boundsID - worldBoundsID; // reflect side-effects
-          return bounds;
-      };
-      /**
-       * Calculates the global position of the display object.
-       * @param position - The world origin to calculate from.
-       * @param point - A Point object in which to store the value, optional
-       *  (otherwise will create a new Point).
-       * @param skipUpdate - Should we skip the update transform.
-       * @returns - A point object representing the position of this object.
-       */
-      DisplayObject.prototype.toGlobal = function (position, point, skipUpdate) {
-          if (skipUpdate === void 0) { skipUpdate = false; }
-          if (!skipUpdate) {
-              this._recursivePostUpdateTransform();
-              // this parent check is for just in case the item is a root object.
-              // If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
-              // this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
-              if (!this.parent) {
-                  this.parent = this._tempDisplayObjectParent;
-                  this.displayObjectUpdateTransform();
-                  this.parent = null;
-              }
-              else {
-                  this.displayObjectUpdateTransform();
-              }
-          }
-          // don't need to update the lot
-          return this.worldTransform.apply(position, point);
-      };
-      /**
-       * Calculates the local position of the display object relative to another point.
-       * @param position - The world origin to calculate from.
-       * @param from - The DisplayObject to calculate the global position from.
-       * @param point - A Point object in which to store the value, optional
-       *  (otherwise will create a new Point).
-       * @param skipUpdate - Should we skip the update transform
-       * @returns - A point object representing the position of this object
-       */
-      DisplayObject.prototype.toLocal = function (position, from, point, skipUpdate) {
-          if (from) {
-              position = from.toGlobal(position, point, skipUpdate);
-          }
-          if (!skipUpdate) {
-              this._recursivePostUpdateTransform();
-              // this parent check is for just in case the item is a root object.
-              // If it is we need to give it a temporary parent so that displayObjectUpdateTransform works correctly
-              // this is mainly to avoid a parent check in the main loop. Every little helps for performance :)
-              if (!this.parent) {
-                  this.parent = this._tempDisplayObjectParent;
-                  this.displayObjectUpdateTransform();
-                  this.parent = null;
-              }
-              else {
-                  this.displayObjectUpdateTransform();
-              }
-          }
-          // simply apply the matrix..
-          return this.worldTransform.applyInverse(position, point);
-      };
-      /**
-       * Set the parent Container of this DisplayObject.
-       * @param container - The Container to add this DisplayObject to.
-       * @returns - The Container that this DisplayObject was added to.
-       */
-      DisplayObject.prototype.setParent = function (container) {
-          if (!container || !container.addChild) {
-              throw new Error('setParent: Argument must be a Container');
-          }
-          container.addChild(this);
-          return container;
-      };
-      /**
-       * Convenience function to set the position, scale, skew and pivot at once.
-       * @param x - The X position
-       * @param y - The Y position
-       * @param scaleX - The X scale value
-       * @param scaleY - The Y scale value
-       * @param rotation - The rotation
-       * @param skewX - The X skew value
-       * @param skewY - The Y skew value
-       * @param pivotX - The X pivot value
-       * @param pivotY - The Y pivot value
-       * @returns - The DisplayObject instance
-       */
-      DisplayObject.prototype.setTransform = function (x, y, scaleX, scaleY, rotation, skewX, skewY, pivotX, pivotY) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          if (scaleX === void 0) { scaleX = 1; }
-          if (scaleY === void 0) { scaleY = 1; }
-          if (rotation === void 0) { rotation = 0; }
-          if (skewX === void 0) { skewX = 0; }
-          if (skewY === void 0) { skewY = 0; }
-          if (pivotX === void 0) { pivotX = 0; }
-          if (pivotY === void 0) { pivotY = 0; }
-          this.position.x = x;
-          this.position.y = y;
-          this.scale.x = !scaleX ? 1 : scaleX;
-          this.scale.y = !scaleY ? 1 : scaleY;
-          this.rotation = rotation;
-          this.skew.x = skewX;
-          this.skew.y = skewY;
-          this.pivot.x = pivotX;
-          this.pivot.y = pivotY;
-          return this;
-      };
-      /**
-       * Base destroy method for generic display objects. This will automatically
-       * remove the display object from its parent Container as well as remove
-       * all current event listeners and internal references. Do not use a DisplayObject
-       * after calling `destroy()`.
-       * @param _options
-       */
-      DisplayObject.prototype.destroy = function (_options) {
-          if (this.parent) {
-              this.parent.removeChild(this);
-          }
-          this._destroyed = true;
-          this.transform = null;
-          this.parent = null;
-          this._bounds = null;
-          this.mask = null;
-          this.cullArea = null;
-          this.filters = null;
-          this.filterArea = null;
-          this.hitArea = null;
-          this.interactive = false;
-          this.interactiveChildren = false;
-          this.emit('destroyed');
-          this.removeAllListeners();
-      };
-      Object.defineProperty(DisplayObject.prototype, "_tempDisplayObjectParent", {
-          /**
-           * @protected
-           * @member {PIXI.Container}
-           */
-          get: function () {
-              if (this.tempDisplayObjectParent === null) {
-                  // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                  this.tempDisplayObjectParent = new TemporaryDisplayObject();
-              }
-              return this.tempDisplayObjectParent;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Used in Renderer, cacheAsBitmap and other places where you call an `updateTransform` on root
-       *
-       * ```
-       * const cacheParent = elem.enableTempParent();
-       * elem.updateTransform();
-       * elem.disableTempParent(cacheParent);
-       * ```
-       * @returns - current parent
-       */
-      DisplayObject.prototype.enableTempParent = function () {
-          var myParent = this.parent;
-          this.parent = this._tempDisplayObjectParent;
-          return myParent;
-      };
-      /**
-       * Pair method for `enableTempParent`
-       * @param cacheParent - Actual parent of element
-       */
-      DisplayObject.prototype.disableTempParent = function (cacheParent) {
-          this.parent = cacheParent;
-      };
-      Object.defineProperty(DisplayObject.prototype, "x", {
-          /**
-           * The position of the displayObject on the x axis relative to the local coordinates of the parent.
-           * An alias to position.x
-           */
-          get: function () {
-              return this.position.x;
-          },
-          set: function (value) {
-              this.transform.position.x = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "y", {
-          /**
-           * The position of the displayObject on the y axis relative to the local coordinates of the parent.
-           * An alias to position.y
-           */
-          get: function () {
-              return this.position.y;
-          },
-          set: function (value) {
-              this.transform.position.y = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "worldTransform", {
-          /**
-           * Current transform of the object based on world (parent) factors.
-           * @readonly
-           */
-          get: function () {
-              return this.transform.worldTransform;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "localTransform", {
-          /**
-           * Current transform of the object based on local factors: position, scale, other stuff.
-           * @readonly
-           */
-          get: function () {
-              return this.transform.localTransform;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "position", {
-          /**
-           * The coordinate of the object relative to the local coordinates of the parent.
-           * @since 4.0.0
-           */
-          get: function () {
-              return this.transform.position;
-          },
-          set: function (value) {
-              this.transform.position.copyFrom(value);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "scale", {
-          /**
-           * The scale factors of this object along the local coordinate axes.
-           *
-           * The default scale is (1, 1).
-           * @since 4.0.0
-           */
-          get: function () {
-              return this.transform.scale;
-          },
-          set: function (value) {
-              this.transform.scale.copyFrom(value);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "pivot", {
-          /**
-           * The center of rotation, scaling, and skewing for this display object in its local space. The `position`
-           * is the projection of `pivot` in the parent's local space.
-           *
-           * By default, the pivot is the origin (0, 0).
-           * @since 4.0.0
-           */
-          get: function () {
-              return this.transform.pivot;
-          },
-          set: function (value) {
-              this.transform.pivot.copyFrom(value);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "skew", {
-          /**
-           * The skew factor for the object in radians.
-           * @since 4.0.0
-           */
-          get: function () {
-              return this.transform.skew;
-          },
-          set: function (value) {
-              this.transform.skew.copyFrom(value);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "rotation", {
-          /**
-           * The rotation of the object in radians.
-           * 'rotation' and 'angle' have the same effect on a display object; rotation is in radians, angle is in degrees.
-           */
-          get: function () {
-              return this.transform.rotation;
-          },
-          set: function (value) {
-              this.transform.rotation = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "angle", {
-          /**
-           * The angle of the object in degrees.
-           * 'rotation' and 'angle' have the same effect on a display object; rotation is in radians, angle is in degrees.
-           */
-          get: function () {
-              return this.transform.rotation * RAD_TO_DEG;
-          },
-          set: function (value) {
-              this.transform.rotation = value * DEG_TO_RAD;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "zIndex", {
-          /**
-           * The zIndex of the displayObject.
-           *
-           * If a container has the sortableChildren property set to true, children will be automatically
-           * sorted by zIndex value; a higher value will mean it will be moved towards the end of the array,
-           * and thus rendered on top of other display objects within the same container.
-           * @see PIXI.Container#sortableChildren
-           */
-          get: function () {
-              return this._zIndex;
-          },
-          set: function (value) {
-              this._zIndex = value;
-              if (this.parent) {
-                  this.parent.sortDirty = true;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "worldVisible", {
-          /**
-           * Indicates if the object is globally visible.
-           * @readonly
-           */
-          get: function () {
-              var item = this;
-              do {
-                  if (!item.visible) {
-                      return false;
-                  }
-                  item = item.parent;
-              } while (item);
-              return true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(DisplayObject.prototype, "mask", {
-          /**
-           * Sets a mask for the displayObject. A mask is an object that limits the visibility of an
-           * object to the shape of the mask applied to it. In PixiJS a regular mask must be a
-           * {@link PIXI.Graphics} or a {@link PIXI.Sprite} object. This allows for much faster masking in canvas as it
-           * utilities shape clipping. Furthermore, a mask of an object must be in the subtree of its parent.
-           * Otherwise, `getLocalBounds` may calculate incorrect bounds, which makes the container's width and height wrong.
-           * To remove a mask, set this property to `null`.
-           *
-           * For sprite mask both alpha and red channel are used. Black mask is the same as transparent mask.
-           * @example
-           * const graphics = new PIXI.Graphics();
-           * graphics.beginFill(0xFF3300);
-           * graphics.drawRect(50, 250, 100, 100);
-           * graphics.endFill();
-           *
-           * const sprite = new PIXI.Sprite(texture);
-           * sprite.mask = graphics;
-           * @todo At the moment, PIXI.CanvasRenderer doesn't support PIXI.Sprite as mask.
-           */
-          get: function () {
-              return this._mask;
-          },
-          set: function (value) {
-              if (this._mask === value) {
-                  return;
-              }
-              if (this._mask) {
-                  var maskObject = (this._mask.isMaskData
-                      ? this._mask.maskObject : this._mask);
-                  if (maskObject) {
-                      maskObject._maskRefCount--;
-                      if (maskObject._maskRefCount === 0) {
-                          maskObject.renderable = true;
-                          maskObject.isMask = false;
-                      }
-                  }
-              }
-              this._mask = value;
-              if (this._mask) {
-                  var maskObject = (this._mask.isMaskData
-                      ? this._mask.maskObject : this._mask);
-                  if (maskObject) {
-                      if (maskObject._maskRefCount === 0) {
-                          maskObject.renderable = false;
-                          maskObject.isMask = true;
-                      }
-                      maskObject._maskRefCount++;
-                  }
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return DisplayObject;
-  }(eventemitter3));
-  /**
-   * @private
-   */
-  var TemporaryDisplayObject = /** @class */ (function (_super) {
-      __extends$j(TemporaryDisplayObject, _super);
-      function TemporaryDisplayObject() {
-          var _this = _super !== null && _super.apply(this, arguments) || this;
-          _this.sortDirty = null;
-          return _this;
-      }
-      return TemporaryDisplayObject;
-  }(DisplayObject));
-  /**
-   * DisplayObject default updateTransform, does not update children of container.
-   * Will crash if there's no parent element.
-   * @memberof PIXI.DisplayObject#
-   * @method displayObjectUpdateTransform
-   */
-  DisplayObject.prototype.displayObjectUpdateTransform = DisplayObject.prototype.updateTransform;
-
-  function sortChildren(a, b) {
-      if (a.zIndex === b.zIndex) {
-          return a._lastSortedIndex - b._lastSortedIndex;
-      }
-      return a.zIndex - b.zIndex;
-  }
-  /**
-   * Container is a general-purpose display object that holds children. It also adds built-in support for advanced
-   * rendering features like masking and filtering.
-   *
-   * It is the base class of all display objects that act as a container for other objects, including Graphics
-   * and Sprite.
-   *
-   * ```js
-   * import { BlurFilter } from '@pixi/filter-blur';
-   * import { Container } from '@pixi/display';
-   * import { Graphics } from '@pixi/graphics';
-   * import { Sprite } from '@pixi/sprite';
-   *
-   * let container = new Container();
-   * let sprite = Sprite.from("https://s3-us-west-2.amazonaws.com/s.cdpn.io/693612/IaUrttj.png");
-   *
-   * sprite.width = 512;
-   * sprite.height = 512;
-   *
-   * // Adds a sprite as a child to this container. As a result, the sprite will be rendered whenever the container
-   * // is rendered.
-   * container.addChild(sprite);
-   *
-   * // Blurs whatever is rendered by the container
-   * container.filters = [new BlurFilter()];
-   *
-   * // Only the contents within a circle at the center should be rendered onto the screen.
-   * container.mask = new Graphics()
-   *  .beginFill(0xffffff)
-   *  .drawCircle(sprite.width / 2, sprite.height / 2, Math.min(sprite.width, sprite.height) / 2)
-   *  .endFill();
-   * ```
-   * @memberof PIXI
-   */
-  var Container = /** @class */ (function (_super) {
-      __extends$j(Container, _super);
-      function Container() {
-          var _this = _super.call(this) || this;
-          _this.children = [];
-          _this.sortableChildren = settings.SORTABLE_CHILDREN;
-          _this.sortDirty = false;
-          return _this;
-          /**
-           * Fired when a DisplayObject is added to this Container.
-           * @event PIXI.Container#childAdded
-           * @param {PIXI.DisplayObject} child - The child added to the Container.
-           * @param {PIXI.Container} container - The container that added the child.
-           * @param {number} index - The children's index of the added child.
-           */
-          /**
-           * Fired when a DisplayObject is removed from this Container.
-           * @event PIXI.DisplayObject#childRemoved
-           * @param {PIXI.DisplayObject} child - The child removed from the Container.
-           * @param {PIXI.Container} container - The container that removed the child.
-           * @param {number} index - The former children's index of the removed child
-           */
-      }
-      /**
-       * Overridable method that can be used by Container subclasses whenever the children array is modified.
-       * @param _length
-       */
-      Container.prototype.onChildrenChange = function (_length) {
-          /* empty */
-      };
-      /**
-       * Adds one or more children to the container.
-       *
-       * Multiple items can be added like so: `myContainer.addChild(thingOne, thingTwo, thingThree)`
-       * @param {...PIXI.DisplayObject} children - The DisplayObject(s) to add to the container
-       * @returns {PIXI.DisplayObject} - The first child that was added.
-       */
-      Container.prototype.addChild = function () {
-          var arguments$1 = arguments;
-
-          var children = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              children[_i] = arguments$1[_i];
-          }
-          // if there is only one argument we can bypass looping through the them
-          if (children.length > 1) {
-              // loop through the array and add all children
-              for (var i = 0; i < children.length; i++) {
-                  // eslint-disable-next-line prefer-rest-params
-                  this.addChild(children[i]);
-              }
-          }
-          else {
-              var child = children[0];
-              // if the child has a parent then lets remove it as PixiJS objects can only exist in one place
-              if (child.parent) {
-                  child.parent.removeChild(child);
-              }
-              child.parent = this;
-              this.sortDirty = true;
-              // ensure child transform will be recalculated
-              child.transform._parentID = -1;
-              this.children.push(child);
-              // ensure bounds will be recalculated
-              this._boundsID++;
-              // TODO - lets either do all callbacks or all events.. not both!
-              this.onChildrenChange(this.children.length - 1);
-              this.emit('childAdded', child, this, this.children.length - 1);
-              child.emit('added', this);
-          }
-          return children[0];
-      };
-      /**
-       * Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
-       * @param {PIXI.DisplayObject} child - The child to add
-       * @param {number} index - The index to place the child in
-       * @returns {PIXI.DisplayObject} The child that was added.
-       */
-      Container.prototype.addChildAt = function (child, index) {
-          if (index < 0 || index > this.children.length) {
-              throw new Error(child + "addChildAt: The index " + index + " supplied is out of bounds " + this.children.length);
-          }
-          if (child.parent) {
-              child.parent.removeChild(child);
-          }
-          child.parent = this;
-          this.sortDirty = true;
-          // ensure child transform will be recalculated
-          child.transform._parentID = -1;
-          this.children.splice(index, 0, child);
-          // ensure bounds will be recalculated
-          this._boundsID++;
-          // TODO - lets either do all callbacks or all events.. not both!
-          this.onChildrenChange(index);
-          child.emit('added', this);
-          this.emit('childAdded', child, this, index);
-          return child;
-      };
-      /**
-       * Swaps the position of 2 Display Objects within this container.
-       * @param child - First display object to swap
-       * @param child2 - Second display object to swap
-       */
-      Container.prototype.swapChildren = function (child, child2) {
-          if (child === child2) {
-              return;
-          }
-          var index1 = this.getChildIndex(child);
-          var index2 = this.getChildIndex(child2);
-          this.children[index1] = child2;
-          this.children[index2] = child;
-          this.onChildrenChange(index1 < index2 ? index1 : index2);
-      };
-      /**
-       * Returns the index position of a child DisplayObject instance
-       * @param child - The DisplayObject instance to identify
-       * @returns - The index position of the child display object to identify
-       */
-      Container.prototype.getChildIndex = function (child) {
-          var index = this.children.indexOf(child);
-          if (index === -1) {
-              throw new Error('The supplied DisplayObject must be a child of the caller');
-          }
-          return index;
-      };
-      /**
-       * Changes the position of an existing child in the display object container
-       * @param child - The child DisplayObject instance for which you want to change the index number
-       * @param index - The resulting index number for the child display object
-       */
-      Container.prototype.setChildIndex = function (child, index) {
-          if (index < 0 || index >= this.children.length) {
-              throw new Error("The index " + index + " supplied is out of bounds " + this.children.length);
-          }
-          var currentIndex = this.getChildIndex(child);
-          removeItems(this.children, currentIndex, 1); // remove from old position
-          this.children.splice(index, 0, child); // add at new position
-          this.onChildrenChange(index);
-      };
-      /**
-       * Returns the child at the specified index
-       * @param index - The index to get the child at
-       * @returns - The child at the given index, if any.
-       */
-      Container.prototype.getChildAt = function (index) {
-          if (index < 0 || index >= this.children.length) {
-              throw new Error("getChildAt: Index (" + index + ") does not exist.");
-          }
-          return this.children[index];
-      };
-      /**
-       * Removes one or more children from the container.
-       * @param {...PIXI.DisplayObject} children - The DisplayObject(s) to remove
-       * @returns {PIXI.DisplayObject} The first child that was removed.
-       */
-      Container.prototype.removeChild = function () {
-          var arguments$1 = arguments;
-
-          var children = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              children[_i] = arguments$1[_i];
-          }
-          // if there is only one argument we can bypass looping through the them
-          if (children.length > 1) {
-              // loop through the arguments property and remove all children
-              for (var i = 0; i < children.length; i++) {
-                  this.removeChild(children[i]);
-              }
-          }
-          else {
-              var child = children[0];
-              var index = this.children.indexOf(child);
-              if (index === -1)
-                  { return null; }
-              child.parent = null;
-              // ensure child transform will be recalculated
-              child.transform._parentID = -1;
-              removeItems(this.children, index, 1);
-              // ensure bounds will be recalculated
-              this._boundsID++;
-              // TODO - lets either do all callbacks or all events.. not both!
-              this.onChildrenChange(index);
-              child.emit('removed', this);
-              this.emit('childRemoved', child, this, index);
-          }
-          return children[0];
-      };
-      /**
-       * Removes a child from the specified index position.
-       * @param index - The index to get the child from
-       * @returns The child that was removed.
-       */
-      Container.prototype.removeChildAt = function (index) {
-          var child = this.getChildAt(index);
-          // ensure child transform will be recalculated..
-          child.parent = null;
-          child.transform._parentID = -1;
-          removeItems(this.children, index, 1);
-          // ensure bounds will be recalculated
-          this._boundsID++;
-          // TODO - lets either do all callbacks or all events.. not both!
-          this.onChildrenChange(index);
-          child.emit('removed', this);
-          this.emit('childRemoved', child, this, index);
-          return child;
-      };
-      /**
-       * Removes all children from this container that are within the begin and end indexes.
-       * @param beginIndex - The beginning position.
-       * @param endIndex - The ending position. Default value is size of the container.
-       * @returns - List of removed children
-       */
-      Container.prototype.removeChildren = function (beginIndex, endIndex) {
-          if (beginIndex === void 0) { beginIndex = 0; }
-          if (endIndex === void 0) { endIndex = this.children.length; }
-          var begin = beginIndex;
-          var end = endIndex;
-          var range = end - begin;
-          var removed;
-          if (range > 0 && range <= end) {
-              removed = this.children.splice(begin, range);
-              for (var i = 0; i < removed.length; ++i) {
-                  removed[i].parent = null;
-                  if (removed[i].transform) {
-                      removed[i].transform._parentID = -1;
-                  }
-              }
-              this._boundsID++;
-              this.onChildrenChange(beginIndex);
-              for (var i = 0; i < removed.length; ++i) {
-                  removed[i].emit('removed', this);
-                  this.emit('childRemoved', removed[i], this, i);
-              }
-              return removed;
-          }
-          else if (range === 0 && this.children.length === 0) {
-              return [];
-          }
-          throw new RangeError('removeChildren: numeric values are outside the acceptable range.');
-      };
-      /** Sorts children by zIndex. Previous order is maintained for 2 children with the same zIndex. */
-      Container.prototype.sortChildren = function () {
-          var sortRequired = false;
-          for (var i = 0, j = this.children.length; i < j; ++i) {
-              var child = this.children[i];
-              child._lastSortedIndex = i;
-              if (!sortRequired && child.zIndex !== 0) {
-                  sortRequired = true;
-              }
-          }
-          if (sortRequired && this.children.length > 1) {
-              this.children.sort(sortChildren);
-          }
-          this.sortDirty = false;
-      };
-      /** Updates the transform on all children of this container for rendering. */
-      Container.prototype.updateTransform = function () {
-          if (this.sortableChildren && this.sortDirty) {
-              this.sortChildren();
-          }
-          this._boundsID++;
-          this.transform.updateTransform(this.parent.transform);
-          // TODO: check render flags, how to process stuff here
-          this.worldAlpha = this.alpha * this.parent.worldAlpha;
-          for (var i = 0, j = this.children.length; i < j; ++i) {
-              var child = this.children[i];
-              if (child.visible) {
-                  child.updateTransform();
-              }
-          }
-      };
-      /**
-       * Recalculates the bounds of the container.
-       *
-       * This implementation will automatically fit the children's bounds into the calculation. Each child's bounds
-       * is limited to its mask's bounds or filterArea, if any is applied.
-       */
-      Container.prototype.calculateBounds = function () {
-          this._bounds.clear();
-          this._calculateBounds();
-          for (var i = 0; i < this.children.length; i++) {
-              var child = this.children[i];
-              if (!child.visible || !child.renderable) {
-                  continue;
-              }
-              child.calculateBounds();
-              // TODO: filter+mask, need to mask both somehow
-              if (child._mask) {
-                  var maskObject = (child._mask.isMaskData
-                      ? child._mask.maskObject : child._mask);
-                  if (maskObject) {
-                      maskObject.calculateBounds();
-                      this._bounds.addBoundsMask(child._bounds, maskObject._bounds);
-                  }
-                  else {
-                      this._bounds.addBounds(child._bounds);
-                  }
-              }
-              else if (child.filterArea) {
-                  this._bounds.addBoundsArea(child._bounds, child.filterArea);
-              }
-              else {
-                  this._bounds.addBounds(child._bounds);
-              }
-          }
-          this._bounds.updateID = this._boundsID;
-      };
-      /**
-       * Retrieves the local bounds of the displayObject as a rectangle object.
-       *
-       * Calling `getLocalBounds` may invalidate the `_bounds` of the whole subtree below. If using it inside a render()
-       * call, it is advised to call `getBounds()` immediately after to recalculate the world bounds of the subtree.
-       * @param rect - Optional rectangle to store the result of the bounds calculation.
-       * @param skipChildrenUpdate - Setting to `true` will stop re-calculation of children transforms,
-       *  it was default behaviour of pixi 4.0-5.2 and caused many problems to users.
-       * @returns - The rectangular bounding area.
-       */
-      Container.prototype.getLocalBounds = function (rect, skipChildrenUpdate) {
-          if (skipChildrenUpdate === void 0) { skipChildrenUpdate = false; }
-          var result = _super.prototype.getLocalBounds.call(this, rect);
-          if (!skipChildrenUpdate) {
-              for (var i = 0, j = this.children.length; i < j; ++i) {
-                  var child = this.children[i];
-                  if (child.visible) {
-                      child.updateTransform();
-                  }
-              }
-          }
-          return result;
-      };
-      /**
-       * Recalculates the content bounds of this object. This should be overriden to
-       * calculate the bounds of this specific object (not including children).
-       * @protected
-       */
-      Container.prototype._calculateBounds = function () {
-          // FILL IN//
-      };
-      /**
-       * Renders this object and its children with culling.
-       * @protected
-       * @param {PIXI.Renderer} renderer - The renderer
-       */
-      Container.prototype._renderWithCulling = function (renderer) {
-          var sourceFrame = renderer.renderTexture.sourceFrame;
-          // If the source frame is empty, stop rendering.
-          if (!(sourceFrame.width > 0 && sourceFrame.height > 0)) {
-              return;
-          }
-          // Render the content of the container only if its bounds intersect with the source frame.
-          // All filters are on the stack at this point, and the filter source frame is bound:
-          // therefore, even if the bounds to non intersect the filter frame, the filter
-          // is still applied and any filter padding that is in the frame is rendered correctly.
-          var bounds;
-          var transform;
-          // If cullArea is set, we use this rectangle instead of the bounds of the object. The cullArea
-          // rectangle must completely contain the container and its children including filter padding.
-          if (this.cullArea) {
-              bounds = this.cullArea;
-              transform = this.worldTransform;
-          }
-          // If the container doesn't override _render, we can skip the bounds calculation and intersection test.
-          else if (this._render !== Container.prototype._render) {
-              bounds = this.getBounds(true);
-          }
-          // Render the container if the source frame intersects the bounds.
-          if (bounds && sourceFrame.intersects(bounds, transform)) {
-              this._render(renderer);
-          }
-          // If the bounds are defined by cullArea and do not intersect with the source frame, stop rendering.
-          else if (this.cullArea) {
-              return;
-          }
-          // Unless cullArea is set, we cannot skip the children if the bounds of the container do not intersect
-          // the source frame, because the children might have filters with nonzero padding, which may intersect
-          // with the source frame while the bounds do not: filter padding is not included in the bounds.
-          // If cullArea is not set, render the children with culling temporarily enabled so that they are not rendered
-          // if they are out of frame; otherwise, render the children normally.
-          for (var i = 0, j = this.children.length; i < j; ++i) {
-              var child = this.children[i];
-              var childCullable = child.cullable;
-              child.cullable = childCullable || !this.cullArea;
-              child.render(renderer);
-              child.cullable = childCullable;
-          }
-      };
-      /**
-       * Renders the object using the WebGL renderer.
-       *
-       * The [_render]{@link PIXI.Container#_render} method is be overriden for rendering the contents of the
-       * container itself. This `render` method will invoke it, and also invoke the `render` methods of all
-       * children afterward.
-       *
-       * If `renderable` or `visible` is false or if `worldAlpha` is not positive or if `cullable` is true and
-       * the bounds of this object are out of frame, this implementation will entirely skip rendering.
-       * See {@link PIXI.DisplayObject} for choosing between `renderable` or `visible`. Generally,
-       * setting alpha to zero is not recommended for purely skipping rendering.
-       *
-       * When your scene becomes large (especially when it is larger than can be viewed in a single screen), it is
-       * advised to employ **culling** to automatically skip rendering objects outside of the current screen.
-       * See [cullable]{@link PIXI.DisplayObject#cullable} and [cullArea]{@link PIXI.DisplayObject#cullArea}.
-       * Other culling methods might be better suited for a large number static objects; see
-       * [@pixi-essentials/cull]{@link https://www.npmjs.com/package/@pixi-essentials/cull} and
-       * [pixi-cull]{@link https://www.npmjs.com/package/pixi-cull}.
-       *
-       * The [renderAdvanced]{@link PIXI.Container#renderAdvanced} method is internally used when when masking or
-       * filtering is applied on a container. This does, however, break batching and can affect performance when
-       * masking and filtering is applied extensively throughout the scene graph.
-       * @param renderer - The renderer
-       */
-      Container.prototype.render = function (renderer) {
-          // if the object is not visible or the alpha is 0 then no need to render this element
-          if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
-              return;
-          }
-          // do a quick check to see if this element has a mask or a filter.
-          if (this._mask || (this.filters && this.filters.length)) {
-              this.renderAdvanced(renderer);
-          }
-          else if (this.cullable) {
-              this._renderWithCulling(renderer);
-          }
-          else {
-              this._render(renderer);
-              for (var i = 0, j = this.children.length; i < j; ++i) {
-                  this.children[i].render(renderer);
-              }
-          }
-      };
-      /**
-       * Render the object using the WebGL renderer and advanced features.
-       * @param renderer - The renderer
-       */
-      Container.prototype.renderAdvanced = function (renderer) {
-          var filters = this.filters;
-          var mask = this._mask;
-          // push filter first as we need to ensure the stencil buffer is correct for any masking
-          if (filters) {
-              if (!this._enabledFilters) {
-                  this._enabledFilters = [];
-              }
-              this._enabledFilters.length = 0;
-              for (var i = 0; i < filters.length; i++) {
-                  if (filters[i].enabled) {
-                      this._enabledFilters.push(filters[i]);
-                  }
-              }
-          }
-          var flush = (filters && this._enabledFilters && this._enabledFilters.length)
-              || (mask && (!mask.isMaskData
-                  || (mask.enabled && (mask.autoDetect || mask.type !== exports.MASK_TYPES.NONE))));
-          if (flush) {
-              renderer.batch.flush();
-          }
-          if (filters && this._enabledFilters && this._enabledFilters.length) {
-              renderer.filter.push(this, this._enabledFilters);
-          }
-          if (mask) {
-              renderer.mask.push(this, this._mask);
-          }
-          if (this.cullable) {
-              this._renderWithCulling(renderer);
-          }
-          else {
-              this._render(renderer);
-              for (var i = 0, j = this.children.length; i < j; ++i) {
-                  this.children[i].render(renderer);
-              }
-          }
-          if (flush) {
-              renderer.batch.flush();
-          }
-          if (mask) {
-              renderer.mask.pop(this);
-          }
-          if (filters && this._enabledFilters && this._enabledFilters.length) {
-              renderer.filter.pop();
-          }
-      };
-      /**
-       * To be overridden by the subclasses.
-       * @param _renderer - The renderer
-       */
-      Container.prototype._render = function (_renderer) {
-          // this is where content itself gets rendered...
-      };
-      /**
-       * Removes all internal references and listeners as well as removes children from the display list.
-       * Do not use a Container after calling `destroy`.
-       * @param options - Options parameter. A boolean will act as if all options
-       *  have been set to that value
-       * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
-       *  method called as well. 'options' will be passed on to those calls.
-       * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
-       *  Should it destroy the texture of the child sprite
-       * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
-       *  Should it destroy the base texture of the child sprite
-       */
-      Container.prototype.destroy = function (options) {
-          _super.prototype.destroy.call(this);
-          this.sortDirty = false;
-          var destroyChildren = typeof options === 'boolean' ? options : options && options.children;
-          var oldChildren = this.removeChildren(0, this.children.length);
-          if (destroyChildren) {
-              for (var i = 0; i < oldChildren.length; ++i) {
-                  oldChildren[i].destroy(options);
-              }
-          }
-      };
-      Object.defineProperty(Container.prototype, "width", {
-          /** The width of the Container, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              return this.scale.x * this.getLocalBounds().width;
-          },
-          set: function (value) {
-              var width = this.getLocalBounds().width;
-              if (width !== 0) {
-                  this.scale.x = value / width;
-              }
-              else {
-                  this.scale.x = 1;
-              }
-              this._width = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Container.prototype, "height", {
-          /** The height of the Container, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              return this.scale.y * this.getLocalBounds().height;
-          },
-          set: function (value) {
-              var height = this.getLocalBounds().height;
-              if (height !== 0) {
-                  this.scale.y = value / height;
-              }
-              else {
-                  this.scale.y = 1;
-              }
-              this._height = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return Container;
-  }(DisplayObject));
-  /**
-   * Container default updateTransform, does update children of container.
-   * Will crash if there's no parent element.
-   * @memberof PIXI.Container#
-   * @method containerUpdateTransform
-   */
-  Container.prototype.containerUpdateTransform = Container.prototype.updateTransform;
-
-  /*!
-   * @pixi/extensions - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/extensions is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-
-  var __assign$1 = function() {
-      __assign$1 = Object.assign || function __assign(t) {
-          var arguments$1 = arguments;
-
-          for (var s, i = 1, n = arguments.length; i < n; i++) {
-              s = arguments$1[i];
-              for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p)) { t[p] = s[p]; } }
-          }
-          return t;
-      };
-      return __assign$1.apply(this, arguments);
-  };
-
-  /**
-   * Collection of valid extension types.
-   * @memberof PIXI
-   * @property {string} Application - Application plugins
-   * @property {string} RendererPlugin - Plugins for Renderer
-   * @property {string} CanvasRendererPlugin - Plugins for CanvasRenderer
-   * @property {string} Loader - Plugins to use with Loader
-   * @property {string} LoadParser - Parsers for Assets loader.
-   * @property {string} ResolveParser - Parsers for Assets resolvers.
-   * @property {string} CacheParser - Parsers for Assets cache.
-   */
-  exports.ExtensionType = void 0;
-  (function (ExtensionType) {
-      ExtensionType["Application"] = "application";
-      ExtensionType["RendererPlugin"] = "renderer-webgl-plugin";
-      ExtensionType["CanvasRendererPlugin"] = "renderer-canvas-plugin";
-      ExtensionType["Loader"] = "loader";
-      ExtensionType["LoadParser"] = "load-parser";
-      ExtensionType["ResolveParser"] = "resolve-parser";
-      ExtensionType["CacheParser"] = "cache-parser";
-      ExtensionType["DetectionParser"] = "detection-parser";
-  })(exports.ExtensionType || (exports.ExtensionType = {}));
-  /**
-   * Convert input into extension format data.
-   * @ignore
-   */
-  var normalizeExtension = function (ext) {
-      // Class/Object submission, use extension object
-      if (typeof ext === 'function' || (typeof ext === 'object' && ext.extension)) {
-          if (!ext.extension) {
-              throw new Error('Extension class must have an extension object');
-          }
-          var metadata = (typeof ext.extension !== 'object')
-              ? { type: ext.extension }
-              : ext.extension;
-          ext = __assign$1(__assign$1({}, metadata), { ref: ext });
-      }
-      if (typeof ext === 'object') {
-          ext = __assign$1({}, ext);
-      }
-      else {
-          throw new Error('Invalid extension type');
-      }
-      if (typeof ext.type === 'string') {
-          ext.type = [ext.type];
-      }
-      return ext;
-  };
-  /**
-   * Global registration of all PixiJS extensions. One-stop-shop for extensibility.
-   * @memberof PIXI
-   * @namespace extensions
-   */
-  var extensions = {
-      /** @ignore */
-      _addHandlers: null,
-      /** @ignore */
-      _removeHandlers: null,
-      /** @ignore */
-      _queue: {},
-      /**
-       * Remove extensions from PixiJS.
-       * @param extensions - Extensions to be removed.
-       * @returns {PIXI.extensions} For chaining.
-       */
-      remove: function () {
-          var arguments$1 = arguments;
-
-          var _this = this;
-          var extensions = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              extensions[_i] = arguments$1[_i];
-          }
-          extensions.map(normalizeExtension).forEach(function (ext) {
-              ext.type.forEach(function (type) { var _a, _b; return (_b = (_a = _this._removeHandlers)[type]) === null || _b === void 0 ? void 0 : _b.call(_a, ext); });
-          });
-          return this;
-      },
-      /**
-       * Register new extensions with PixiJS.
-       * @param extensions - The spread of extensions to add to PixiJS.
-       * @returns {PIXI.extensions} For chaining.
-       */
-      add: function () {
-          var arguments$1 = arguments;
-
-          var _this = this;
-          var extensions = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              extensions[_i] = arguments$1[_i];
-          }
-          // Handle any extensions either passed as class w/ data or as data
-          extensions.map(normalizeExtension).forEach(function (ext) {
-              ext.type.forEach(function (type) {
-                  var handlers = _this._addHandlers;
-                  var queue = _this._queue;
-                  if (!handlers[type]) {
-                      queue[type] = queue[type] || [];
-                      queue[type].push(ext);
-                  }
-                  else {
-                      handlers[type](ext);
-                  }
-              });
-          });
-          return this;
-      },
-      /**
-       * Internal method to handle extensions by name.
-       * @param type - The extension type.
-       * @param onAdd  - Function for handling when extensions are added/registered passes {@link PIXI.ExtensionFormat}.
-       * @param onRemove  - Function for handling when extensions are removed/unregistered passes {@link PIXI.ExtensionFormat}.
-       * @returns {PIXI.extensions} For chaining.
-       */
-      handle: function (type, onAdd, onRemove) {
-          var addHandlers = this._addHandlers = this._addHandlers || {};
-          var removeHandlers = this._removeHandlers = this._removeHandlers || {};
-          if (addHandlers[type] || removeHandlers[type]) {
-              throw new Error("Extension type " + type + " already has a handler");
-          }
-          addHandlers[type] = onAdd;
-          removeHandlers[type] = onRemove;
-          // Process the queue
-          var queue = this._queue;
-          // Process any plugins that have been registered before the handler
-          if (queue[type]) {
-              queue[type].forEach(function (ext) { return onAdd(ext); });
-              delete queue[type];
-          }
-          return this;
-      },
-      /**
-       * Handle a type, but using a map by `name` property.
-       * @param type - Type of extension to handle.
-       * @param map - The object map of named extensions.
-       * @returns {PIXI.extensions} For chaining.
-       */
-      handleByMap: function (type, map) {
-          return this.handle(type, function (extension) {
-              map[extension.name] = extension.ref;
-          }, function (extension) {
-              delete map[extension.name];
-          });
-      },
-      /**
-       * Handle a type, but using a list of extensions.
-       * @param type - Type of extension to handle.
-       * @param list - The list of extensions.
-       * @returns {PIXI.extensions} For chaining.
-       */
-      handleByList: function (type, list) {
-          return this.handle(type, function (extension) {
-              var _a, _b;
-              if (list.includes(extension.ref)) {
-                  return;
-              }
-              list.push(extension.ref);
-              // TODO: remove me later, only added for @pixi/loaders
-              if (type === exports.ExtensionType.Loader) {
-                  (_b = (_a = extension.ref).add) === null || _b === void 0 ? void 0 : _b.call(_a);
-              }
-          }, function (extension) {
-              var index = list.indexOf(extension.ref);
-              if (index !== -1) {
-                  list.splice(index, 1);
-              }
-          });
-      },
-  };
-
-  /*!
-   * @pixi/runner - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/runner is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-  /**
-   * A Runner is a highly performant and simple alternative to signals. Best used in situations
-   * where events are dispatched to many objects at high frequency (say every frame!)
-   *
-   *
-   * like a signal..
-   * ```
-   * import { Runner } from '@pixi/runner';
-   *
-   * const myObject = {
-   *     loaded: new Runner('loaded')
-   * }
-   *
-   * const listener = {
-   *     loaded: function(){
-   *         // thin
-   *     }
-   * }
-   *
-   * myObject.loaded.add(listener);
-   *
-   * myObject.loaded.emit();
-   * ```
-   *
-   * Or for handling calling the same function on many items
-   * ```
-   * import { Runner } from '@pixi/runner';
-   *
-   * const myGame = {
-   *     update: new Runner('update')
-   * }
-   *
-   * const gameObject = {
-   *     update: function(time){
-   *         // update my gamey state
-   *     }
-   * }
-   *
-   * myGame.update.add(gameObject);
-   *
-   * myGame.update.emit(time);
-   * ```
-   * @memberof PIXI
-   */
-  var Runner = /** @class */ (function () {
-      /**
-       * @param name - The function name that will be executed on the listeners added to this Runner.
-       */
-      function Runner(name) {
-          this.items = [];
-          this._name = name;
-          this._aliasCount = 0;
-      }
-      /* eslint-disable jsdoc/require-param, jsdoc/check-param-names */
-      /**
-       * Dispatch/Broadcast Runner to all listeners added to the queue.
-       * @param {...any} params - (optional) parameters to pass to each listener
-       */
-      /*  eslint-enable jsdoc/require-param, jsdoc/check-param-names */
-      Runner.prototype.emit = function (a0, a1, a2, a3, a4, a5, a6, a7) {
-          if (arguments.length > 8) {
-              throw new Error('max arguments reached');
-          }
-          var _a = this, name = _a.name, items = _a.items;
-          this._aliasCount++;
-          for (var i = 0, len = items.length; i < len; i++) {
-              items[i][name](a0, a1, a2, a3, a4, a5, a6, a7);
-          }
-          if (items === this.items) {
-              this._aliasCount--;
-          }
-          return this;
-      };
-      Runner.prototype.ensureNonAliasedItems = function () {
-          if (this._aliasCount > 0 && this.items.length > 1) {
-              this._aliasCount = 0;
-              this.items = this.items.slice(0);
-          }
-      };
-      /**
-       * Add a listener to the Runner
-       *
-       * Runners do not need to have scope or functions passed to them.
-       * All that is required is to pass the listening object and ensure that it has contains a function that has the same name
-       * as the name provided to the Runner when it was created.
-       *
-       * Eg A listener passed to this Runner will require a 'complete' function.
-       *
-       * ```
-       * import { Runner } from '@pixi/runner';
-       *
-       * const complete = new Runner('complete');
-       * ```
-       *
-       * The scope used will be the object itself.
-       * @param {any} item - The object that will be listening.
-       */
-      Runner.prototype.add = function (item) {
-          if (item[this._name]) {
-              this.ensureNonAliasedItems();
-              this.remove(item);
-              this.items.push(item);
-          }
-          return this;
-      };
-      /**
-       * Remove a single listener from the dispatch queue.
-       * @param {any} item - The listener that you would like to remove.
-       */
-      Runner.prototype.remove = function (item) {
-          var index = this.items.indexOf(item);
-          if (index !== -1) {
-              this.ensureNonAliasedItems();
-              this.items.splice(index, 1);
-          }
-          return this;
-      };
-      /**
-       * Check to see if the listener is already in the Runner
-       * @param {any} item - The listener that you would like to check.
-       */
-      Runner.prototype.contains = function (item) {
-          return this.items.indexOf(item) !== -1;
-      };
-      /** Remove all listeners from the Runner */
-      Runner.prototype.removeAll = function () {
-          this.ensureNonAliasedItems();
-          this.items.length = 0;
-          return this;
-      };
-      /** Remove all references, don't use after this. */
-      Runner.prototype.destroy = function () {
-          this.removeAll();
-          this.items = null;
-          this._name = null;
-      };
-      Object.defineProperty(Runner.prototype, "empty", {
-          /**
-           * `true` if there are no this Runner contains no listeners
-           * @readonly
-           */
-          get: function () {
-              return this.items.length === 0;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Runner.prototype, "name", {
-          /**
-           * The name of the runner.
-           * @readonly
-           */
-          get: function () {
-              return this._name;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return Runner;
-  }());
-  Object.defineProperties(Runner.prototype, {
-      /**
-       * Alias for `emit`
-       * @memberof PIXI.Runner#
-       * @method dispatch
-       * @see PIXI.Runner#emit
-       */
-      dispatch: { value: Runner.prototype.emit },
-      /**
-       * Alias for `emit`
-       * @memberof PIXI.Runner#
-       * @method run
-       * @see PIXI.Runner#emit
-       */
-      run: { value: Runner.prototype.emit },
-  });
-
-  /*!
-   * @pixi/ticker - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/ticker is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Target frames per millisecond.
-   * @static
-   * @name TARGET_FPMS
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default 0.06
-   */
-  settings.TARGET_FPMS = 0.06;
-
-  /**
-   * Represents the update priorities used by internal PIXI classes when registered with
-   * the {@link PIXI.Ticker} object. Higher priority items are updated first and lower
-   * priority items, such as render, should go later.
-   * @static
-   * @constant
-   * @name UPDATE_PRIORITY
-   * @memberof PIXI
-   * @enum {number}
-   * @property {number} [INTERACTION=50] Highest priority, used for {@link PIXI.InteractionManager}
-   * @property {number} [HIGH=25] High priority updating, {@link PIXI.VideoBaseTexture} and {@link PIXI.AnimatedSprite}
-   * @property {number} [NORMAL=0] Default priority for ticker events, see {@link PIXI.Ticker#add}.
-   * @property {number} [LOW=-25] Low priority used for {@link PIXI.Application} rendering.
-   * @property {number} [UTILITY=-50] Lowest priority used for {@link PIXI.BasePrepare} utility.
-   */
-  exports.UPDATE_PRIORITY = void 0;
-  (function (UPDATE_PRIORITY) {
-      UPDATE_PRIORITY[UPDATE_PRIORITY["INTERACTION"] = 50] = "INTERACTION";
-      UPDATE_PRIORITY[UPDATE_PRIORITY["HIGH"] = 25] = "HIGH";
-      UPDATE_PRIORITY[UPDATE_PRIORITY["NORMAL"] = 0] = "NORMAL";
-      UPDATE_PRIORITY[UPDATE_PRIORITY["LOW"] = -25] = "LOW";
-      UPDATE_PRIORITY[UPDATE_PRIORITY["UTILITY"] = -50] = "UTILITY";
-  })(exports.UPDATE_PRIORITY || (exports.UPDATE_PRIORITY = {}));
-
-  /**
-   * Internal class for handling the priority sorting of ticker handlers.
-   * @private
-   * @class
-   * @memberof PIXI
-   */
-  var TickerListener = /** @class */ (function () {
-      /**
-       * Constructor
-       * @private
-       * @param fn - The listener function to be added for one update
-       * @param context - The listener context
-       * @param priority - The priority for emitting
-       * @param once - If the handler should fire once
-       */
-      function TickerListener(fn, context, priority, once) {
-          if (context === void 0) { context = null; }
-          if (priority === void 0) { priority = 0; }
-          if (once === void 0) { once = false; }
-          /** The next item in chain. */
-          this.next = null;
-          /** The previous item in chain. */
-          this.previous = null;
-          /** `true` if this listener has been destroyed already. */
-          this._destroyed = false;
-          this.fn = fn;
-          this.context = context;
-          this.priority = priority;
-          this.once = once;
-      }
-      /**
-       * Simple compare function to figure out if a function and context match.
-       * @private
-       * @param fn - The listener function to be added for one update
-       * @param context - The listener context
-       * @returns `true` if the listener match the arguments
-       */
-      TickerListener.prototype.match = function (fn, context) {
-          if (context === void 0) { context = null; }
-          return this.fn === fn && this.context === context;
-      };
-      /**
-       * Emit by calling the current function.
-       * @private
-       * @param deltaTime - time since the last emit.
-       * @returns Next ticker
-       */
-      TickerListener.prototype.emit = function (deltaTime) {
-          if (this.fn) {
-              if (this.context) {
-                  this.fn.call(this.context, deltaTime);
-              }
-              else {
-                  this.fn(deltaTime);
-              }
-          }
-          var redirect = this.next;
-          if (this.once) {
-              this.destroy(true);
-          }
-          // Soft-destroying should remove
-          // the next reference
-          if (this._destroyed) {
-              this.next = null;
-          }
-          return redirect;
-      };
-      /**
-       * Connect to the list.
-       * @private
-       * @param previous - Input node, previous listener
-       */
-      TickerListener.prototype.connect = function (previous) {
-          this.previous = previous;
-          if (previous.next) {
-              previous.next.previous = this;
-          }
-          this.next = previous.next;
-          previous.next = this;
-      };
-      /**
-       * Destroy and don't use after this.
-       * @private
-       * @param hard - `true` to remove the `next` reference, this
-       *        is considered a hard destroy. Soft destroy maintains the next reference.
-       * @returns The listener to redirect while emitting or removing.
-       */
-      TickerListener.prototype.destroy = function (hard) {
-          if (hard === void 0) { hard = false; }
-          this._destroyed = true;
-          this.fn = null;
-          this.context = null;
-          // Disconnect, hook up next and previous
-          if (this.previous) {
-              this.previous.next = this.next;
-          }
-          if (this.next) {
-              this.next.previous = this.previous;
-          }
-          // Redirect to the next item
-          var redirect = this.next;
-          // Remove references
-          this.next = hard ? null : redirect;
-          this.previous = null;
-          return redirect;
-      };
-      return TickerListener;
-  }());
-
-  /**
-   * A Ticker class that runs an update loop that other objects listen to.
-   *
-   * This class is composed around listeners meant for execution on the next requested animation frame.
-   * Animation frames are requested only when necessary, e.g. When the ticker is started and the emitter has listeners.
-   * @class
-   * @memberof PIXI
-   */
-  var Ticker = /** @class */ (function () {
-      function Ticker() {
-          var _this = this;
-          /**
-           * Whether or not this ticker should invoke the method
-           * {@link PIXI.Ticker#start} automatically
-           * when a listener is added.
-           */
-          this.autoStart = false;
-          /**
-           * Scalar time value from last frame to this frame.
-           * This value is capped by setting {@link PIXI.Ticker#minFPS}
-           * and is scaled with {@link PIXI.Ticker#speed}.
-           * **Note:** The cap may be exceeded by scaling.
-           */
-          this.deltaTime = 1;
-          /**
-           * The last time {@link PIXI.Ticker#update} was invoked.
-           * This value is also reset internally outside of invoking
-           * update, but only when a new animation frame is requested.
-           * If the platform supports DOMHighResTimeStamp,
-           * this value will have a precision of 1 µs.
-           */
-          this.lastTime = -1;
-          /**
-           * Factor of current {@link PIXI.Ticker#deltaTime}.
-           * @example
-           * // Scales ticker.deltaTime to what would be
-           * // the equivalent of approximately 120 FPS
-           * ticker.speed = 2;
-           */
-          this.speed = 1;
-          /**
-           * Whether or not this ticker has been started.
-           * `true` if {@link PIXI.Ticker#start} has been called.
-           * `false` if {@link PIXI.Ticker#stop} has been called.
-           * While `false`, this value may change to `true` in the
-           * event of {@link PIXI.Ticker#autoStart} being `true`
-           * and a listener is added.
-           */
-          this.started = false;
-          /** Internal current frame request ID */
-          this._requestId = null;
-          /**
-           * Internal value managed by minFPS property setter and getter.
-           * This is the maximum allowed milliseconds between updates.
-           */
-          this._maxElapsedMS = 100;
-          /**
-           * Internal value managed by minFPS property setter and getter.
-           * This is the minimum allowed milliseconds between updates.
-           */
-          this._minElapsedMS = 0;
-          /** If enabled, deleting is disabled.*/
-          this._protected = false;
-          /** The last time keyframe was executed. Maintains a relatively fixed interval with the previous value. */
-          this._lastFrame = -1;
-          this._head = new TickerListener(null, null, Infinity);
-          this.deltaMS = 1 / settings.TARGET_FPMS;
-          this.elapsedMS = 1 / settings.TARGET_FPMS;
-          this._tick = function (time) {
-              _this._requestId = null;
-              if (_this.started) {
-                  // Invoke listeners now
-                  _this.update(time);
-                  // Listener side effects may have modified ticker state.
-                  if (_this.started && _this._requestId === null && _this._head.next) {
-                      _this._requestId = requestAnimationFrame(_this._tick);
-                  }
-              }
-          };
-      }
-      /**
-       * Conditionally requests a new animation frame.
-       * If a frame has not already been requested, and if the internal
-       * emitter has listeners, a new frame is requested.
-       * @private
-       */
-      Ticker.prototype._requestIfNeeded = function () {
-          if (this._requestId === null && this._head.next) {
-              // ensure callbacks get correct delta
-              this.lastTime = performance.now();
-              this._lastFrame = this.lastTime;
-              this._requestId = requestAnimationFrame(this._tick);
-          }
-      };
-      /**
-       * Conditionally cancels a pending animation frame.
-       * @private
-       */
-      Ticker.prototype._cancelIfNeeded = function () {
-          if (this._requestId !== null) {
-              cancelAnimationFrame(this._requestId);
-              this._requestId = null;
-          }
-      };
-      /**
-       * Conditionally requests a new animation frame.
-       * If the ticker has been started it checks if a frame has not already
-       * been requested, and if the internal emitter has listeners. If these
-       * conditions are met, a new frame is requested. If the ticker has not
-       * been started, but autoStart is `true`, then the ticker starts now,
-       * and continues with the previous conditions to request a new frame.
-       * @private
-       */
-      Ticker.prototype._startIfPossible = function () {
-          if (this.started) {
-              this._requestIfNeeded();
-          }
-          else if (this.autoStart) {
-              this.start();
-          }
-      };
-      /**
-       * Register a handler for tick events. Calls continuously unless
-       * it is removed or the ticker is stopped.
-       * @param fn - The listener function to be added for updates
-       * @param context - The listener context
-       * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
-       * @returns This instance of a ticker
-       */
-      Ticker.prototype.add = function (fn, context, priority) {
-          if (priority === void 0) { priority = exports.UPDATE_PRIORITY.NORMAL; }
-          return this._addListener(new TickerListener(fn, context, priority));
-      };
-      /**
-       * Add a handler for the tick event which is only execute once.
-       * @param fn - The listener function to be added for one update
-       * @param context - The listener context
-       * @param {number} [priority=PIXI.UPDATE_PRIORITY.NORMAL] - The priority for emitting
-       * @returns This instance of a ticker
-       */
-      Ticker.prototype.addOnce = function (fn, context, priority) {
-          if (priority === void 0) { priority = exports.UPDATE_PRIORITY.NORMAL; }
-          return this._addListener(new TickerListener(fn, context, priority, true));
-      };
-      /**
-       * Internally adds the event handler so that it can be sorted by priority.
-       * Priority allows certain handler (user, AnimatedSprite, Interaction) to be run
-       * before the rendering.
-       * @private
-       * @param listener - Current listener being added.
-       * @returns This instance of a ticker
-       */
-      Ticker.prototype._addListener = function (listener) {
-          // For attaching to head
-          var current = this._head.next;
-          var previous = this._head;
-          // Add the first item
-          if (!current) {
-              listener.connect(previous);
-          }
-          else {
-              // Go from highest to lowest priority
-              while (current) {
-                  if (listener.priority > current.priority) {
-                      listener.connect(previous);
-                      break;
-                  }
-                  previous = current;
-                  current = current.next;
-              }
-              // Not yet connected
-              if (!listener.previous) {
-                  listener.connect(previous);
-              }
-          }
-          this._startIfPossible();
-          return this;
-      };
-      /**
-       * Removes any handlers matching the function and context parameters.
-       * If no handlers are left after removing, then it cancels the animation frame.
-       * @param fn - The listener function to be removed
-       * @param context - The listener context to be removed
-       * @returns This instance of a ticker
-       */
-      Ticker.prototype.remove = function (fn, context) {
-          var listener = this._head.next;
-          while (listener) {
-              // We found a match, lets remove it
-              // no break to delete all possible matches
-              // incase a listener was added 2+ times
-              if (listener.match(fn, context)) {
-                  listener = listener.destroy();
-              }
-              else {
-                  listener = listener.next;
-              }
-          }
-          if (!this._head.next) {
-              this._cancelIfNeeded();
-          }
-          return this;
-      };
-      Object.defineProperty(Ticker.prototype, "count", {
-          /**
-           * The number of listeners on this ticker, calculated by walking through linked list
-           * @readonly
-           * @member {number}
-           */
-          get: function () {
-              if (!this._head) {
-                  return 0;
-              }
-              var count = 0;
-              var current = this._head;
-              while ((current = current.next)) {
-                  count++;
-              }
-              return count;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Starts the ticker. If the ticker has listeners a new animation frame is requested at this point. */
-      Ticker.prototype.start = function () {
-          if (!this.started) {
-              this.started = true;
-              this._requestIfNeeded();
-          }
-      };
-      /** Stops the ticker. If the ticker has requested an animation frame it is canceled at this point. */
-      Ticker.prototype.stop = function () {
-          if (this.started) {
-              this.started = false;
-              this._cancelIfNeeded();
-          }
-      };
-      /** Destroy the ticker and don't use after this. Calling this method removes all references to internal events. */
-      Ticker.prototype.destroy = function () {
-          if (!this._protected) {
-              this.stop();
-              var listener = this._head.next;
-              while (listener) {
-                  listener = listener.destroy(true);
-              }
-              this._head.destroy();
-              this._head = null;
-          }
-      };
-      /**
-       * Triggers an update. An update entails setting the
-       * current {@link PIXI.Ticker#elapsedMS},
-       * the current {@link PIXI.Ticker#deltaTime},
-       * invoking all listeners with current deltaTime,
-       * and then finally setting {@link PIXI.Ticker#lastTime}
-       * with the value of currentTime that was provided.
-       * This method will be called automatically by animation
-       * frame callbacks if the ticker instance has been started
-       * and listeners are added.
-       * @param {number} [currentTime=performance.now()] - the current time of execution
-       */
-      Ticker.prototype.update = function (currentTime) {
-          if (currentTime === void 0) { currentTime = performance.now(); }
-          var elapsedMS;
-          // If the difference in time is zero or negative, we ignore most of the work done here.
-          // If there is no valid difference, then should be no reason to let anyone know about it.
-          // A zero delta, is exactly that, nothing should update.
-          //
-          // The difference in time can be negative, and no this does not mean time traveling.
-          // This can be the result of a race condition between when an animation frame is requested
-          // on the current JavaScript engine event loop, and when the ticker's start method is invoked
-          // (which invokes the internal _requestIfNeeded method). If a frame is requested before
-          // _requestIfNeeded is invoked, then the callback for the animation frame the ticker requests,
-          // can receive a time argument that can be less than the lastTime value that was set within
-          // _requestIfNeeded. This difference is in microseconds, but this is enough to cause problems.
-          //
-          // This check covers this browser engine timing issue, as well as if consumers pass an invalid
-          // currentTime value. This may happen if consumers opt-out of the autoStart, and update themselves.
-          if (currentTime > this.lastTime) {
-              // Save uncapped elapsedMS for measurement
-              elapsedMS = this.elapsedMS = currentTime - this.lastTime;
-              // cap the milliseconds elapsed used for deltaTime
-              if (elapsedMS > this._maxElapsedMS) {
-                  elapsedMS = this._maxElapsedMS;
-              }
-              elapsedMS *= this.speed;
-              // If not enough time has passed, exit the function.
-              // Get ready for next frame by setting _lastFrame, but based on _minElapsedMS
-              // adjustment to ensure a relatively stable interval.
-              if (this._minElapsedMS) {
-                  var delta = currentTime - this._lastFrame | 0;
-                  if (delta < this._minElapsedMS) {
-                      return;
-                  }
-                  this._lastFrame = currentTime - (delta % this._minElapsedMS);
-              }
-              this.deltaMS = elapsedMS;
-              this.deltaTime = this.deltaMS * settings.TARGET_FPMS;
-              // Cache a local reference, in-case ticker is destroyed
-              // during the emit, we can still check for head.next
-              var head = this._head;
-              // Invoke listeners added to internal emitter
-              var listener = head.next;
-              while (listener) {
-                  listener = listener.emit(this.deltaTime);
-              }
-              if (!head.next) {
-                  this._cancelIfNeeded();
-              }
-          }
-          else {
-              this.deltaTime = this.deltaMS = this.elapsedMS = 0;
-          }
-          this.lastTime = currentTime;
-      };
-      Object.defineProperty(Ticker.prototype, "FPS", {
-          /**
-           * The frames per second at which this ticker is running.
-           * The default is approximately 60 in most modern browsers.
-           * **Note:** This does not factor in the value of
-           * {@link PIXI.Ticker#speed}, which is specific
-           * to scaling {@link PIXI.Ticker#deltaTime}.
-           * @member {number}
-           * @readonly
-           */
-          get: function () {
-              return 1000 / this.elapsedMS;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Ticker.prototype, "minFPS", {
-          /**
-           * Manages the maximum amount of milliseconds allowed to
-           * elapse between invoking {@link PIXI.Ticker#update}.
-           * This value is used to cap {@link PIXI.Ticker#deltaTime},
-           * but does not effect the measured value of {@link PIXI.Ticker#FPS}.
-           * When setting this property it is clamped to a value between
-           * `0` and `PIXI.settings.TARGET_FPMS * 1000`.
-           * @member {number}
-           * @default 10
-           */
-          get: function () {
-              return 1000 / this._maxElapsedMS;
-          },
-          set: function (fps) {
-              // Minimum must be below the maxFPS
-              var minFPS = Math.min(this.maxFPS, fps);
-              // Must be at least 0, but below 1 / settings.TARGET_FPMS
-              var minFPMS = Math.min(Math.max(0, minFPS) / 1000, settings.TARGET_FPMS);
-              this._maxElapsedMS = 1 / minFPMS;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Ticker.prototype, "maxFPS", {
-          /**
-           * Manages the minimum amount of milliseconds required to
-           * elapse between invoking {@link PIXI.Ticker#update}.
-           * This will effect the measured value of {@link PIXI.Ticker#FPS}.
-           * If it is set to `0`, then there is no limit; PixiJS will render as many frames as it can.
-           * Otherwise it will be at least `minFPS`
-           * @member {number}
-           * @default 0
-           */
-          get: function () {
-              if (this._minElapsedMS) {
-                  return Math.round(1000 / this._minElapsedMS);
-              }
-              return 0;
-          },
-          set: function (fps) {
-              if (fps === 0) {
-                  this._minElapsedMS = 0;
-              }
-              else {
-                  // Max must be at least the minFPS
-                  var maxFPS = Math.max(this.minFPS, fps);
-                  this._minElapsedMS = 1 / (maxFPS / 1000);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Ticker, "shared", {
-          /**
-           * The shared ticker instance used by {@link PIXI.AnimatedSprite} and by
-           * {@link PIXI.VideoResource} to update animation frames / video textures.
-           *
-           * It may also be used by {@link PIXI.Application} if created with the `sharedTicker` option property set to true.
-           *
-           * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
-           * Please follow the examples for usage, including how to opt-out of auto-starting the shared ticker.
-           * @example
-           * let ticker = PIXI.Ticker.shared;
-           * // Set this to prevent starting this ticker when listeners are added.
-           * // By default this is true only for the PIXI.Ticker.shared instance.
-           * ticker.autoStart = false;
-           * // FYI, call this to ensure the ticker is stopped. It should be stopped
-           * // if you have not attempted to render anything yet.
-           * ticker.stop();
-           * // Call this when you are ready for a running shared ticker.
-           * ticker.start();
-           * @example
-           * // You may use the shared ticker to render...
-           * let renderer = PIXI.autoDetectRenderer();
-           * let stage = new PIXI.Container();
-           * document.body.appendChild(renderer.view);
-           * ticker.add(function (time) {
-           *     renderer.render(stage);
-           * });
-           * @example
-           * // Or you can just update it manually.
-           * ticker.autoStart = false;
-           * ticker.stop();
-           * function animate(time) {
-           *     ticker.update(time);
-           *     renderer.render(stage);
-           *     requestAnimationFrame(animate);
-           * }
-           * animate(performance.now());
-           * @member {PIXI.Ticker}
-           * @static
-           */
-          get: function () {
-              if (!Ticker._shared) {
-                  var shared = Ticker._shared = new Ticker();
-                  shared.autoStart = true;
-                  shared._protected = true;
-              }
-              return Ticker._shared;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Ticker, "system", {
-          /**
-           * The system ticker instance used by {@link PIXI.InteractionManager} and by
-           * {@link PIXI.BasePrepare} for core timing functionality that shouldn't usually need to be paused,
-           * unlike the `shared` ticker which drives visual animations and rendering which may want to be paused.
-           *
-           * The property {@link PIXI.Ticker#autoStart} is set to `true` for this instance.
-           * @member {PIXI.Ticker}
-           * @static
-           */
-          get: function () {
-              if (!Ticker._system) {
-                  var system = Ticker._system = new Ticker();
-                  system.autoStart = true;
-                  system._protected = true;
-              }
-              return Ticker._system;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return Ticker;
-  }());
-
-  /**
-   * Middleware for for Application Ticker.
-   * @example
-   * import {TickerPlugin} from '@pixi/ticker';
-   * import {Application} from '@pixi/app';
-   * import {extensions} from '@pixi/extensions';
-   * extensions.add(TickerPlugin);
-   * @class
-   * @memberof PIXI
-   */
-  var TickerPlugin = /** @class */ (function () {
-      function TickerPlugin() {
-      }
-      /**
-       * Initialize the plugin with scope of application instance
-       * @static
-       * @private
-       * @param {object} [options] - See application options
-       */
-      TickerPlugin.init = function (options) {
-          var _this = this;
-          // Set default
-          options = Object.assign({
-              autoStart: true,
-              sharedTicker: false,
-          }, options);
-          // Create ticker setter
-          Object.defineProperty(this, 'ticker', {
-              set: function (ticker) {
-                  if (this._ticker) {
-                      this._ticker.remove(this.render, this);
-                  }
-                  this._ticker = ticker;
-                  if (ticker) {
-                      ticker.add(this.render, this, exports.UPDATE_PRIORITY.LOW);
-                  }
-              },
-              get: function () {
-                  return this._ticker;
-              },
-          });
-          /**
-           * Convenience method for stopping the render.
-           * @method
-           * @memberof PIXI.Application
-           * @instance
-           */
-          this.stop = function () {
-              _this._ticker.stop();
-          };
-          /**
-           * Convenience method for starting the render.
-           * @method
-           * @memberof PIXI.Application
-           * @instance
-           */
-          this.start = function () {
-              _this._ticker.start();
-          };
-          /**
-           * Internal reference to the ticker.
-           * @type {PIXI.Ticker}
-           * @name _ticker
-           * @memberof PIXI.Application#
-           * @private
-           */
-          this._ticker = null;
-          /**
-           * Ticker for doing render updates.
-           * @type {PIXI.Ticker}
-           * @name ticker
-           * @memberof PIXI.Application#
-           * @default PIXI.Ticker.shared
-           */
-          this.ticker = options.sharedTicker ? Ticker.shared : new Ticker();
-          // Start the rendering
-          if (options.autoStart) {
-              this.start();
-          }
-      };
-      /**
-       * Clean up the ticker, scoped to application.
-       * @static
-       * @private
-       */
-      TickerPlugin.destroy = function () {
-          if (this._ticker) {
-              var oldTicker = this._ticker;
-              this.ticker = null;
-              oldTicker.destroy();
-          }
-      };
-      /** @ignore */
-      TickerPlugin.extension = exports.ExtensionType.Application;
-      return TickerPlugin;
-  }());
-
-  /*!
-   * @pixi/core - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/core is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * The maximum support for using WebGL. If a device does not
-   * support WebGL version, for instance WebGL 2, it will still
-   * attempt to fallback support to WebGL 1. If you want to
-   * explicitly remove feature support to target a more stable
-   * baseline, prefer a lower environment.
-   *
-   * Due to {@link https://bugs.chromium.org/p/chromium/issues/detail?id=934823|bug in chromium}
-   * we disable webgl2 by default for all non-apple mobile devices.
-   * @static
-   * @name PREFER_ENV
-   * @memberof PIXI.settings
-   * @type {number}
-   * @default PIXI.ENV.WEBGL2
-   */
-  settings.PREFER_ENV = isMobile.any ? exports.ENV.WEBGL : exports.ENV.WEBGL2;
-  /**
-   * If set to `true`, *only* Textures and BaseTexture objects stored
-   * in the caches ({@link PIXI.utils.TextureCache TextureCache} and
-   * {@link PIXI.utils.BaseTextureCache BaseTextureCache}) can be
-   * used when calling {@link PIXI.Texture.from Texture.from} or
-   * {@link PIXI.BaseTexture.from BaseTexture.from}.
-   * Otherwise, these `from` calls throw an exception. Using this property
-   * can be useful if you want to enforce preloading all assets with
-   * {@link PIXI.Loader Loader}.
-   * @static
-   * @name STRICT_TEXTURE_CACHE
-   * @memberof PIXI.settings
-   * @type {boolean}
-   * @default false
-   */
-  settings.STRICT_TEXTURE_CACHE = false;
-
-  /**
-   * Collection of installed resource types, class must extend {@link PIXI.Resource}.
-   * @example
-   * class CustomResource extends PIXI.Resource {
-   *   // MUST have source, options constructor signature
-   *   // for auto-detected resources to be created.
-   *   constructor(source, options) {
-   *     super();
-   *   }
-   *   upload(renderer, baseTexture, glTexture) {
-   *     // upload with GL
-   *     return true;
-   *   }
-   *   // used to auto-detect resource
-   *   static test(source, extension) {
-   *     return extension === 'xyz'|| source instanceof SomeClass;
-   *   }
-   * }
-   * // Install the new resource type
-   * PIXI.INSTALLED.push(CustomResource);
-   * @memberof PIXI
-   * @type {Array<PIXI.IResourcePlugin>}
-   * @static
-   * @readonly
-   */
-  var INSTALLED = [];
-  /**
-   * Create a resource element from a single source element. This
-   * auto-detects which type of resource to create. All resources that
-   * are auto-detectable must have a static `test` method and a constructor
-   * with the arguments `(source, options?)`. Currently, the supported
-   * resources for auto-detection include:
-   *  - {@link PIXI.ImageResource}
-   *  - {@link PIXI.CanvasResource}
-   *  - {@link PIXI.VideoResource}
-   *  - {@link PIXI.SVGResource}
-   *  - {@link PIXI.BufferResource}
-   * @static
-   * @memberof PIXI
-   * @function autoDetectResource
-   * @param {string|*} source - Resource source, this can be the URL to the resource,
-   *        a typed-array (for BufferResource), HTMLVideoElement, SVG data-uri
-   *        or any other resource that can be auto-detected. If not resource is
-   *        detected, it's assumed to be an ImageResource.
-   * @param {object} [options] - Pass-through options to use for Resource
-   * @param {number} [options.width] - Width of BufferResource or SVG rasterization
-   * @param {number} [options.height] - Height of BufferResource or SVG rasterization
-   * @param {boolean} [options.autoLoad=true] - Image, SVG and Video flag to start loading
-   * @param {number} [options.scale=1] - SVG source scale. Overridden by width, height
-   * @param {boolean} [options.createBitmap=PIXI.settings.CREATE_IMAGE_BITMAP] - Image option to create Bitmap object
-   * @param {boolean} [options.crossorigin=true] - Image and Video option to set crossOrigin
-   * @param {boolean} [options.autoPlay=true] - Video option to start playing video immediately
-   * @param {number} [options.updateFPS=0] - Video option to update how many times a second the
-   *        texture should be updated from the video. Leave at 0 to update at every render
-   * @returns {PIXI.Resource} The created resource.
-   */
-  function autoDetectResource(source, options) {
-      if (!source) {
-          return null;
-      }
-      var extension = '';
-      if (typeof source === 'string') {
-          // search for file extension: period, 3-4 chars, then ?, # or EOL
-          var result = (/\.(\w{3,4})(?:$|\?|#)/i).exec(source);
-          if (result) {
-              extension = result[1].toLowerCase();
-          }
-      }
-      for (var i = INSTALLED.length - 1; i >= 0; --i) {
-          var ResourcePlugin = INSTALLED[i];
-          if (ResourcePlugin.test && ResourcePlugin.test(source, extension)) {
-              return new ResourcePlugin(source, options);
-          }
-      }
-      throw new Error('Unrecognized source type to auto-detect Resource');
-  }
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$i = function(d, b) {
-      extendStatics$i = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$i(d, b);
-  };
-
-  function __extends$i(d, b) {
-      extendStatics$i(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var __assign = function() {
-      __assign = Object.assign || function __assign(t) {
-          var arguments$1 = arguments;
-
-          for (var s, i = 1, n = arguments.length; i < n; i++) {
-              s = arguments$1[i];
-              for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p)) { t[p] = s[p]; } }
-          }
-          return t;
-      };
-      return __assign.apply(this, arguments);
-  };
-
-  function __rest(s, e) {
-      var t = {};
-      for (var p in s) { if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-          { t[p] = s[p]; } }
-      if (s != null && typeof Object.getOwnPropertySymbols === "function")
-          { for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                  { t[p[i]] = s[p[i]]; }
-          } }
-      return t;
-  }
-
-  /**
-   * Base resource class for textures that manages validation and uploading, depending on its type.
-   *
-   * Uploading of a base texture to the GPU is required.
-   * @memberof PIXI
-   */
-  var Resource = /** @class */ (function () {
-      /**
-       * @param width - Width of the resource
-       * @param height - Height of the resource
-       */
-      function Resource(width, height) {
-          if (width === void 0) { width = 0; }
-          if (height === void 0) { height = 0; }
-          this._width = width;
-          this._height = height;
-          this.destroyed = false;
-          this.internal = false;
-          this.onResize = new Runner('setRealSize');
-          this.onUpdate = new Runner('update');
-          this.onError = new Runner('onError');
-      }
-      /**
-       * Bind to a parent BaseTexture
-       * @param baseTexture - Parent texture
-       */
-      Resource.prototype.bind = function (baseTexture) {
-          this.onResize.add(baseTexture);
-          this.onUpdate.add(baseTexture);
-          this.onError.add(baseTexture);
-          // Call a resize immediate if we already
-          // have the width and height of the resource
-          if (this._width || this._height) {
-              this.onResize.emit(this._width, this._height);
-          }
-      };
-      /**
-       * Unbind to a parent BaseTexture
-       * @param baseTexture - Parent texture
-       */
-      Resource.prototype.unbind = function (baseTexture) {
-          this.onResize.remove(baseTexture);
-          this.onUpdate.remove(baseTexture);
-          this.onError.remove(baseTexture);
-      };
-      /**
-       * Trigger a resize event
-       * @param width - X dimension
-       * @param height - Y dimension
-       */
-      Resource.prototype.resize = function (width, height) {
-          if (width !== this._width || height !== this._height) {
-              this._width = width;
-              this._height = height;
-              this.onResize.emit(width, height);
-          }
-      };
-      Object.defineProperty(Resource.prototype, "valid", {
-          /**
-           * Has been validated
-           * @readonly
-           */
-          get: function () {
-              return !!this._width && !!this._height;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Has been updated trigger event. */
-      Resource.prototype.update = function () {
-          if (!this.destroyed) {
-              this.onUpdate.emit();
-          }
-      };
-      /**
-       * This can be overridden to start preloading a resource
-       * or do any other prepare step.
-       * @protected
-       * @returns Handle the validate event
-       */
-      Resource.prototype.load = function () {
-          return Promise.resolve(this);
-      };
-      Object.defineProperty(Resource.prototype, "width", {
-          /**
-           * The width of the resource.
-           * @readonly
-           */
-          get: function () {
-              return this._width;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Resource.prototype, "height", {
-          /**
-           * The height of the resource.
-           * @readonly
-           */
-          get: function () {
-              return this._height;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Set the style, optional to override
-       * @param _renderer - yeah, renderer!
-       * @param _baseTexture - the texture
-       * @param _glTexture - texture instance for this webgl context
-       * @returns - `true` is success
-       */
-      Resource.prototype.style = function (_renderer, _baseTexture, _glTexture) {
-          return false;
-      };
-      /** Clean up anything, this happens when destroying is ready. */
-      Resource.prototype.dispose = function () {
-          // override
-      };
-      /**
-       * Call when destroying resource, unbind any BaseTexture object
-       * before calling this method, as reference counts are maintained
-       * internally.
-       */
-      Resource.prototype.destroy = function () {
-          if (!this.destroyed) {
-              this.destroyed = true;
-              this.dispose();
-              this.onError.removeAll();
-              this.onError = null;
-              this.onResize.removeAll();
-              this.onResize = null;
-              this.onUpdate.removeAll();
-              this.onUpdate = null;
-          }
-      };
-      /**
-       * Abstract, used to auto-detect resource type.
-       * @param {*} _source - The source object
-       * @param {string} _extension - The extension of source, if set
-       */
-      Resource.test = function (_source, _extension) {
-          return false;
-      };
-      return Resource;
-  }());
-
-  /**
-   * @interface SharedArrayBuffer
-   */
-  /**
-   * Buffer resource with data of typed array.
-   * @memberof PIXI
-   */
-  var BufferResource = /** @class */ (function (_super) {
-      __extends$i(BufferResource, _super);
-      /**
-       * @param source - Source buffer
-       * @param options - Options
-       * @param {number} options.width - Width of the texture
-       * @param {number} options.height - Height of the texture
-       */
-      function BufferResource(source, options) {
-          var _this = this;
-          var _a = options || {}, width = _a.width, height = _a.height;
-          if (!width || !height) {
-              throw new Error('BufferResource width or height invalid');
-          }
-          _this = _super.call(this, width, height) || this;
-          _this.data = source;
-          return _this;
-      }
-      /**
-       * Upload the texture to the GPU.
-       * @param renderer - Upload to the renderer
-       * @param baseTexture - Reference to parent texture
-       * @param glTexture - glTexture
-       * @returns - true is success
-       */
-      BufferResource.prototype.upload = function (renderer, baseTexture, glTexture) {
-          var gl = renderer.gl;
-          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === exports.ALPHA_MODES.UNPACK);
-          var width = baseTexture.realWidth;
-          var height = baseTexture.realHeight;
-          if (glTexture.width === width && glTexture.height === height) {
-              gl.texSubImage2D(baseTexture.target, 0, 0, 0, width, height, baseTexture.format, glTexture.type, this.data);
-          }
-          else {
-              glTexture.width = width;
-              glTexture.height = height;
-              gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, width, height, 0, baseTexture.format, glTexture.type, this.data);
-          }
-          return true;
-      };
-      /** Destroy and don't use after this. */
-      BufferResource.prototype.dispose = function () {
-          this.data = null;
-      };
-      /**
-       * Used to auto-detect the type of resource.
-       * @param {*} source - The source object
-       * @returns {boolean} `true` if <canvas>
-       */
-      BufferResource.test = function (source) {
-          return source instanceof Float32Array
-              || source instanceof Uint8Array
-              || source instanceof Uint32Array;
-      };
-      return BufferResource;
-  }(Resource));
-
-  var defaultBufferOptions = {
-      scaleMode: exports.SCALE_MODES.NEAREST,
-      format: exports.FORMATS.RGBA,
-      alphaMode: exports.ALPHA_MODES.NPM,
-  };
-  /**
-   * A Texture stores the information that represents an image.
-   * All textures have a base texture, which contains information about the source.
-   * Therefore you can have many textures all using a single BaseTexture
-   * @memberof PIXI
-   * @typeParam R - The BaseTexture's Resource type.
-   * @typeParam RO - The options for constructing resource.
-   */
-  var BaseTexture = /** @class */ (function (_super) {
-      __extends$i(BaseTexture, _super);
-      /**
-       * @param {PIXI.Resource|string|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} [resource=null] -
-       *        The current resource to use, for things that aren't Resource objects, will be converted
-       *        into a Resource.
-       * @param options - Collection of options
-       * @param {PIXI.MIPMAP_MODES} [options.mipmap=PIXI.settings.MIPMAP_TEXTURES] - If mipmapping is enabled for texture
-       * @param {number} [options.anisotropicLevel=PIXI.settings.ANISOTROPIC_LEVEL] - Anisotropic filtering level of texture
-       * @param {PIXI.WRAP_MODES} [options.wrapMode=PIXI.settings.WRAP_MODE] - Wrap mode for textures
-       * @param {PIXI.SCALE_MODES} [options.scaleMode=PIXI.settings.SCALE_MODE] - Default scale mode, linear, nearest
-       * @param {PIXI.FORMATS} [options.format=PIXI.FORMATS.RGBA] - GL format type
-       * @param {PIXI.TYPES} [options.type=PIXI.TYPES.UNSIGNED_BYTE] - GL data type
-       * @param {PIXI.TARGETS} [options.target=PIXI.TARGETS.TEXTURE_2D] - GL texture target
-       * @param {PIXI.ALPHA_MODES} [options.alphaMode=PIXI.ALPHA_MODES.UNPACK] - Pre multiply the image alpha
-       * @param {number} [options.width=0] - Width of the texture
-       * @param {number} [options.height=0] - Height of the texture
-       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] - Resolution of the base texture
-       * @param {object} [options.resourceOptions] - Optional resource options,
-       *        see {@link PIXI.autoDetectResource autoDetectResource}
-       */
-      function BaseTexture(resource, options) {
-          if (resource === void 0) { resource = null; }
-          if (options === void 0) { options = null; }
-          var _this = _super.call(this) || this;
-          options = options || {};
-          var alphaMode = options.alphaMode, mipmap = options.mipmap, anisotropicLevel = options.anisotropicLevel, scaleMode = options.scaleMode, width = options.width, height = options.height, wrapMode = options.wrapMode, format = options.format, type = options.type, target = options.target, resolution = options.resolution, resourceOptions = options.resourceOptions;
-          // Convert the resource to a Resource object
-          if (resource && !(resource instanceof Resource)) {
-              resource = autoDetectResource(resource, resourceOptions);
-              resource.internal = true;
-          }
-          _this.resolution = resolution || settings.RESOLUTION;
-          _this.width = Math.round((width || 0) * _this.resolution) / _this.resolution;
-          _this.height = Math.round((height || 0) * _this.resolution) / _this.resolution;
-          _this._mipmap = mipmap !== undefined ? mipmap : settings.MIPMAP_TEXTURES;
-          _this.anisotropicLevel = anisotropicLevel !== undefined ? anisotropicLevel : settings.ANISOTROPIC_LEVEL;
-          _this._wrapMode = wrapMode || settings.WRAP_MODE;
-          _this._scaleMode = scaleMode !== undefined ? scaleMode : settings.SCALE_MODE;
-          _this.format = format || exports.FORMATS.RGBA;
-          _this.type = type || exports.TYPES.UNSIGNED_BYTE;
-          _this.target = target || exports.TARGETS.TEXTURE_2D;
-          _this.alphaMode = alphaMode !== undefined ? alphaMode : exports.ALPHA_MODES.UNPACK;
-          _this.uid = uid();
-          _this.touched = 0;
-          _this.isPowerOfTwo = false;
-          _this._refreshPOT();
-          _this._glTextures = {};
-          _this.dirtyId = 0;
-          _this.dirtyStyleId = 0;
-          _this.cacheId = null;
-          _this.valid = width > 0 && height > 0;
-          _this.textureCacheIds = [];
-          _this.destroyed = false;
-          _this.resource = null;
-          _this._batchEnabled = 0;
-          _this._batchLocation = 0;
-          _this.parentTextureArray = null;
-          /**
-           * Fired when a not-immediately-available source finishes loading.
-           * @protected
-           * @event PIXI.BaseTexture#loaded
-           * @param {PIXI.BaseTexture} baseTexture - Resource loaded.
-           */
-          /**
-           * Fired when a not-immediately-available source fails to load.
-           * @protected
-           * @event PIXI.BaseTexture#error
-           * @param {PIXI.BaseTexture} baseTexture - Resource errored.
-           * @param {ErrorEvent} event - Load error event.
-           */
-          /**
-           * Fired when BaseTexture is updated.
-           * @protected
-           * @event PIXI.BaseTexture#loaded
-           * @param {PIXI.BaseTexture} baseTexture - Resource loaded.
-           */
-          /**
-           * Fired when BaseTexture is updated.
-           * @protected
-           * @event PIXI.BaseTexture#update
-           * @param {PIXI.BaseTexture} baseTexture - Instance of texture being updated.
-           */
-          /**
-           * Fired when BaseTexture is destroyed.
-           * @protected
-           * @event PIXI.BaseTexture#dispose
-           * @param {PIXI.BaseTexture} baseTexture - Instance of texture being destroyed.
-           */
-          // Set the resource
-          _this.setResource(resource);
-          return _this;
-      }
-      Object.defineProperty(BaseTexture.prototype, "realWidth", {
-          /**
-           * Pixel width of the source of this texture
-           * @readonly
-           */
-          get: function () {
-              return Math.round(this.width * this.resolution);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BaseTexture.prototype, "realHeight", {
-          /**
-           * Pixel height of the source of this texture
-           * @readonly
-           */
-          get: function () {
-              return Math.round(this.height * this.resolution);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BaseTexture.prototype, "mipmap", {
-          /**
-           * Mipmap mode of the texture, affects downscaled images
-           * @default PIXI.settings.MIPMAP_TEXTURES
-           */
-          get: function () {
-              return this._mipmap;
-          },
-          set: function (value) {
-              if (this._mipmap !== value) {
-                  this._mipmap = value;
-                  this.dirtyStyleId++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BaseTexture.prototype, "scaleMode", {
-          /**
-           * The scale mode to apply when scaling this texture
-           * @default PIXI.settings.SCALE_MODE
-           */
-          get: function () {
-              return this._scaleMode;
-          },
-          set: function (value) {
-              if (this._scaleMode !== value) {
-                  this._scaleMode = value;
-                  this.dirtyStyleId++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BaseTexture.prototype, "wrapMode", {
-          /**
-           * How the texture wraps
-           * @default PIXI.settings.WRAP_MODE
-           */
-          get: function () {
-              return this._wrapMode;
-          },
-          set: function (value) {
-              if (this._wrapMode !== value) {
-                  this._wrapMode = value;
-                  this.dirtyStyleId++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Changes style options of BaseTexture
-       * @param scaleMode - Pixi scalemode
-       * @param mipmap - enable mipmaps
-       * @returns - this
-       */
-      BaseTexture.prototype.setStyle = function (scaleMode, mipmap) {
-          var dirty;
-          if (scaleMode !== undefined && scaleMode !== this.scaleMode) {
-              this.scaleMode = scaleMode;
-              dirty = true;
-          }
-          if (mipmap !== undefined && mipmap !== this.mipmap) {
-              this.mipmap = mipmap;
-              dirty = true;
-          }
-          if (dirty) {
-              this.dirtyStyleId++;
-          }
-          return this;
-      };
-      /**
-       * Changes w/h/resolution. Texture becomes valid if width and height are greater than zero.
-       * @param desiredWidth - Desired visual width
-       * @param desiredHeight - Desired visual height
-       * @param resolution - Optionally set resolution
-       * @returns - this
-       */
-      BaseTexture.prototype.setSize = function (desiredWidth, desiredHeight, resolution) {
-          resolution = resolution || this.resolution;
-          return this.setRealSize(desiredWidth * resolution, desiredHeight * resolution, resolution);
-      };
-      /**
-       * Sets real size of baseTexture, preserves current resolution.
-       * @param realWidth - Full rendered width
-       * @param realHeight - Full rendered height
-       * @param resolution - Optionally set resolution
-       * @returns - this
-       */
-      BaseTexture.prototype.setRealSize = function (realWidth, realHeight, resolution) {
-          this.resolution = resolution || this.resolution;
-          this.width = Math.round(realWidth) / this.resolution;
-          this.height = Math.round(realHeight) / this.resolution;
-          this._refreshPOT();
-          this.update();
-          return this;
-      };
-      /**
-       * Refresh check for isPowerOfTwo texture based on size
-       * @private
-       */
-      BaseTexture.prototype._refreshPOT = function () {
-          this.isPowerOfTwo = isPow2(this.realWidth) && isPow2(this.realHeight);
-      };
-      /**
-       * Changes resolution
-       * @param resolution - res
-       * @returns - this
-       */
-      BaseTexture.prototype.setResolution = function (resolution) {
-          var oldResolution = this.resolution;
-          if (oldResolution === resolution) {
-              return this;
-          }
-          this.resolution = resolution;
-          if (this.valid) {
-              this.width = Math.round(this.width * oldResolution) / resolution;
-              this.height = Math.round(this.height * oldResolution) / resolution;
-              this.emit('update', this);
-          }
-          this._refreshPOT();
-          return this;
-      };
-      /**
-       * Sets the resource if it wasn't set. Throws error if resource already present
-       * @param resource - that is managing this BaseTexture
-       * @returns - this
-       */
-      BaseTexture.prototype.setResource = function (resource) {
-          if (this.resource === resource) {
-              return this;
-          }
-          if (this.resource) {
-              throw new Error('Resource can be set only once');
-          }
-          resource.bind(this);
-          this.resource = resource;
-          return this;
-      };
-      /** Invalidates the object. Texture becomes valid if width and height are greater than zero. */
-      BaseTexture.prototype.update = function () {
-          if (!this.valid) {
-              if (this.width > 0 && this.height > 0) {
-                  this.valid = true;
-                  this.emit('loaded', this);
-                  this.emit('update', this);
-              }
-          }
-          else {
-              this.dirtyId++;
-              this.dirtyStyleId++;
-              this.emit('update', this);
-          }
-      };
-      /**
-       * Handle errors with resources.
-       * @private
-       * @param event - Error event emitted.
-       */
-      BaseTexture.prototype.onError = function (event) {
-          this.emit('error', this, event);
-      };
-      /**
-       * Destroys this base texture.
-       * The method stops if resource doesn't want this texture to be destroyed.
-       * Removes texture from all caches.
-       */
-      BaseTexture.prototype.destroy = function () {
-          // remove and destroy the resource
-          if (this.resource) {
-              this.resource.unbind(this);
-              // only destroy resourced created internally
-              if (this.resource.internal) {
-                  this.resource.destroy();
-              }
-              this.resource = null;
-          }
-          if (this.cacheId) {
-              delete BaseTextureCache[this.cacheId];
-              delete TextureCache[this.cacheId];
-              this.cacheId = null;
-          }
-          // finally let the WebGL renderer know..
-          this.dispose();
-          BaseTexture.removeFromCache(this);
-          this.textureCacheIds = null;
-          this.destroyed = true;
-      };
-      /**
-       * Frees the texture from WebGL memory without destroying this texture object.
-       * This means you can still use the texture later which will upload it to GPU
-       * memory again.
-       * @fires PIXI.BaseTexture#dispose
-       */
-      BaseTexture.prototype.dispose = function () {
-          this.emit('dispose', this);
-      };
-      /** Utility function for BaseTexture|Texture cast. */
-      BaseTexture.prototype.castToBaseTexture = function () {
-          return this;
-      };
-      /**
-       * Helper function that creates a base texture based on the source you provide.
-       * The source can be - image url, image element, canvas element. If the
-       * source is an image url or an image element and not in the base texture
-       * cache, it will be created and loaded.
-       * @static
-       * @param {string|string[]|HTMLImageElement|HTMLCanvasElement|SVGElement|HTMLVideoElement} source - The
-       *        source to create base texture from.
-       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
-       * @param {string} [options.pixiIdPrefix=pixiid] - If a source has no id, this is the prefix of the generated id
-       * @param {boolean} [strict] - Enforce strict-mode, see {@link PIXI.settings.STRICT_TEXTURE_CACHE}.
-       * @returns {PIXI.BaseTexture} The new base texture.
-       */
-      BaseTexture.from = function (source, options, strict) {
-          if (strict === void 0) { strict = settings.STRICT_TEXTURE_CACHE; }
-          var isFrame = typeof source === 'string';
-          var cacheId = null;
-          if (isFrame) {
-              cacheId = source;
-          }
-          else {
-              if (!source._pixiId) {
-                  var prefix = (options && options.pixiIdPrefix) || 'pixiid';
-                  source._pixiId = prefix + "_" + uid();
-              }
-              cacheId = source._pixiId;
-          }
-          var baseTexture = BaseTextureCache[cacheId];
-          // Strict-mode rejects invalid cacheIds
-          if (isFrame && strict && !baseTexture) {
-              throw new Error("The cacheId \"" + cacheId + "\" does not exist in BaseTextureCache.");
-          }
-          if (!baseTexture) {
-              baseTexture = new BaseTexture(source, options);
-              baseTexture.cacheId = cacheId;
-              BaseTexture.addToCache(baseTexture, cacheId);
-          }
-          return baseTexture;
-      };
-      /**
-       * Create a new BaseTexture with a BufferResource from a Float32Array.
-       * RGBA values are floats from 0 to 1.
-       * @param {Float32Array|Uint8Array} buffer - The optional array to use, if no data
-       *        is provided, a new Float32Array is created.
-       * @param width - Width of the resource
-       * @param height - Height of the resource
-       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
-       *        Default properties are different from the constructor's defaults.
-       * @param {PIXI.FORMATS} [options.format=PIXI.FORMATS.RGBA] - GL format type
-       * @param {PIXI.ALPHA_MODES} [options.alphaMode=PIXI.ALPHA_MODES.NPM] - Image alpha, not premultiplied by default
-       * @param {PIXI.SCALE_MODES} [options.scaleMode=PIXI.SCALE_MODES.NEAREST] - Scale mode, pixelating by default
-       * @returns - The resulting new BaseTexture
-       */
-      BaseTexture.fromBuffer = function (buffer, width, height, options) {
-          buffer = buffer || new Float32Array(width * height * 4);
-          var resource = new BufferResource(buffer, { width: width, height: height });
-          var type = buffer instanceof Float32Array ? exports.TYPES.FLOAT : exports.TYPES.UNSIGNED_BYTE;
-          return new BaseTexture(resource, Object.assign({}, defaultBufferOptions, options || { width: width, height: height, type: type }));
-      };
-      /**
-       * Adds a BaseTexture to the global BaseTextureCache. This cache is shared across the whole PIXI object.
-       * @param {PIXI.BaseTexture} baseTexture - The BaseTexture to add to the cache.
-       * @param {string} id - The id that the BaseTexture will be stored against.
-       */
-      BaseTexture.addToCache = function (baseTexture, id) {
-          if (id) {
-              if (baseTexture.textureCacheIds.indexOf(id) === -1) {
-                  baseTexture.textureCacheIds.push(id);
-              }
-              if (BaseTextureCache[id]) {
-                  // eslint-disable-next-line no-console
-                  console.warn("BaseTexture added to the cache with an id [" + id + "] that already had an entry");
-              }
-              BaseTextureCache[id] = baseTexture;
-          }
-      };
-      /**
-       * Remove a BaseTexture from the global BaseTextureCache.
-       * @param {string|PIXI.BaseTexture} baseTexture - id of a BaseTexture to be removed, or a BaseTexture instance itself.
-       * @returns {PIXI.BaseTexture|null} The BaseTexture that was removed.
-       */
-      BaseTexture.removeFromCache = function (baseTexture) {
-          if (typeof baseTexture === 'string') {
-              var baseTextureFromCache = BaseTextureCache[baseTexture];
-              if (baseTextureFromCache) {
-                  var index = baseTextureFromCache.textureCacheIds.indexOf(baseTexture);
-                  if (index > -1) {
-                      baseTextureFromCache.textureCacheIds.splice(index, 1);
-                  }
-                  delete BaseTextureCache[baseTexture];
-                  return baseTextureFromCache;
-              }
-          }
-          else if (baseTexture && baseTexture.textureCacheIds) {
-              for (var i = 0; i < baseTexture.textureCacheIds.length; ++i) {
-                  delete BaseTextureCache[baseTexture.textureCacheIds[i]];
-              }
-              baseTexture.textureCacheIds.length = 0;
-              return baseTexture;
-          }
-          return null;
-      };
-      /** Global number of the texture batch, used by multi-texture renderers. */
-      BaseTexture._globalBatch = 0;
-      return BaseTexture;
-  }(eventemitter3));
-
-  /**
-   * Resource that can manage several resource (items) inside.
-   * All resources need to have the same pixel size.
-   * Parent class for CubeResource and ArrayResource
-   * @memberof PIXI
-   */
-  var AbstractMultiResource = /** @class */ (function (_super) {
-      __extends$i(AbstractMultiResource, _super);
-      /**
-       * @param length
-       * @param options - Options to for Resource constructor
-       * @param {number} [options.width] - Width of the resource
-       * @param {number} [options.height] - Height of the resource
-       */
-      function AbstractMultiResource(length, options) {
-          var _this = this;
-          var _a = options || {}, width = _a.width, height = _a.height;
-          _this = _super.call(this, width, height) || this;
-          _this.items = [];
-          _this.itemDirtyIds = [];
-          for (var i = 0; i < length; i++) {
-              var partTexture = new BaseTexture();
-              _this.items.push(partTexture);
-              // -2 - first run of texture array upload
-              // -1 - texture item was allocated
-              // >=0 - texture item uploaded , in sync with items[i].dirtyId
-              _this.itemDirtyIds.push(-2);
-          }
-          _this.length = length;
-          _this._load = null;
-          _this.baseTexture = null;
-          return _this;
-      }
-      /**
-       * Used from ArrayResource and CubeResource constructors.
-       * @param resources - Can be resources, image elements, canvas, etc. ,
-       *  length should be same as constructor length
-       * @param options - Detect options for resources
-       */
-      AbstractMultiResource.prototype.initFromArray = function (resources, options) {
-          for (var i = 0; i < this.length; i++) {
-              if (!resources[i]) {
-                  continue;
-              }
-              if (resources[i].castToBaseTexture) {
-                  this.addBaseTextureAt(resources[i].castToBaseTexture(), i);
-              }
-              else if (resources[i] instanceof Resource) {
-                  this.addResourceAt(resources[i], i);
-              }
-              else {
-                  this.addResourceAt(autoDetectResource(resources[i], options), i);
-              }
-          }
-      };
-      /** Destroy this BaseImageResource. */
-      AbstractMultiResource.prototype.dispose = function () {
-          for (var i = 0, len = this.length; i < len; i++) {
-              this.items[i].destroy();
-          }
-          this.items = null;
-          this.itemDirtyIds = null;
-          this._load = null;
-      };
-      /**
-       * Set a resource by ID
-       * @param resource
-       * @param index - Zero-based index of resource to set
-       * @returns - Instance for chaining
-       */
-      AbstractMultiResource.prototype.addResourceAt = function (resource, index) {
-          if (!this.items[index]) {
-              throw new Error("Index " + index + " is out of bounds");
-          }
-          // Inherit the first resource dimensions
-          if (resource.valid && !this.valid) {
-              this.resize(resource.width, resource.height);
-          }
-          this.items[index].setResource(resource);
-          return this;
-      };
-      /**
-       * Set the parent base texture.
-       * @param baseTexture
-       */
-      AbstractMultiResource.prototype.bind = function (baseTexture) {
-          if (this.baseTexture !== null) {
-              throw new Error('Only one base texture per TextureArray is allowed');
-          }
-          _super.prototype.bind.call(this, baseTexture);
-          for (var i = 0; i < this.length; i++) {
-              this.items[i].parentTextureArray = baseTexture;
-              this.items[i].on('update', baseTexture.update, baseTexture);
-          }
-      };
-      /**
-       * Unset the parent base texture.
-       * @param baseTexture
-       */
-      AbstractMultiResource.prototype.unbind = function (baseTexture) {
-          _super.prototype.unbind.call(this, baseTexture);
-          for (var i = 0; i < this.length; i++) {
-              this.items[i].parentTextureArray = null;
-              this.items[i].off('update', baseTexture.update, baseTexture);
-          }
-      };
-      /**
-       * Load all the resources simultaneously
-       * @returns - When load is resolved
-       */
-      AbstractMultiResource.prototype.load = function () {
-          var _this = this;
-          if (this._load) {
-              return this._load;
-          }
-          var resources = this.items.map(function (item) { return item.resource; }).filter(function (item) { return item; });
-          // TODO: also implement load part-by-part strategy
-          var promises = resources.map(function (item) { return item.load(); });
-          this._load = Promise.all(promises)
-              .then(function () {
-              var _a = _this.items[0], realWidth = _a.realWidth, realHeight = _a.realHeight;
-              _this.resize(realWidth, realHeight);
-              return Promise.resolve(_this);
-          });
-          return this._load;
-      };
-      return AbstractMultiResource;
-  }(Resource));
-
-  /**
-   * A resource that contains a number of sources.
-   * @memberof PIXI
-   */
-  var ArrayResource = /** @class */ (function (_super) {
-      __extends$i(ArrayResource, _super);
-      /**
-       * @param source - Number of items in array or the collection
-       *        of image URLs to use. Can also be resources, image elements, canvas, etc.
-       * @param options - Options to apply to {@link PIXI.autoDetectResource}
-       * @param {number} [options.width] - Width of the resource
-       * @param {number} [options.height] - Height of the resource
-       */
-      function ArrayResource(source, options) {
-          var _this = this;
-          var _a = options || {}, width = _a.width, height = _a.height;
-          var urls;
-          var length;
-          if (Array.isArray(source)) {
-              urls = source;
-              length = source.length;
-          }
-          else {
-              length = source;
-          }
-          _this = _super.call(this, length, { width: width, height: height }) || this;
-          if (urls) {
-              _this.initFromArray(urls, options);
-          }
-          return _this;
-      }
-      /**
-       * Set a baseTexture by ID,
-       * ArrayResource just takes resource from it, nothing more
-       * @param baseTexture
-       * @param index - Zero-based index of resource to set
-       * @returns - Instance for chaining
-       */
-      ArrayResource.prototype.addBaseTextureAt = function (baseTexture, index) {
-          if (baseTexture.resource) {
-              this.addResourceAt(baseTexture.resource, index);
-          }
-          else {
-              throw new Error('ArrayResource does not support RenderTexture');
-          }
-          return this;
-      };
-      /**
-       * Add binding
-       * @param baseTexture
-       */
-      ArrayResource.prototype.bind = function (baseTexture) {
-          _super.prototype.bind.call(this, baseTexture);
-          baseTexture.target = exports.TARGETS.TEXTURE_2D_ARRAY;
-      };
-      /**
-       * Upload the resources to the GPU.
-       * @param renderer
-       * @param texture
-       * @param glTexture
-       * @returns - whether texture was uploaded
-       */
-      ArrayResource.prototype.upload = function (renderer, texture, glTexture) {
-          var _a = this, length = _a.length, itemDirtyIds = _a.itemDirtyIds, items = _a.items;
-          var gl = renderer.gl;
-          if (glTexture.dirtyId < 0) {
-              gl.texImage3D(gl.TEXTURE_2D_ARRAY, 0, glTexture.internalFormat, this._width, this._height, length, 0, texture.format, glTexture.type, null);
-          }
-          for (var i = 0; i < length; i++) {
-              var item = items[i];
-              if (itemDirtyIds[i] < item.dirtyId) {
-                  itemDirtyIds[i] = item.dirtyId;
-                  if (item.valid) {
-                      gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, 0, 0, // xoffset
-                      0, // yoffset
-                      i, // zoffset
-                      item.resource.width, item.resource.height, 1, texture.format, glTexture.type, item.resource.source);
-                  }
-              }
-          }
-          return true;
-      };
-      return ArrayResource;
-  }(AbstractMultiResource));
-
-  /**
-   * Base for all the image/canvas resources.
-   * @memberof PIXI
-   */
-  var BaseImageResource = /** @class */ (function (_super) {
-      __extends$i(BaseImageResource, _super);
-      /**
-       * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|SVGElement} source
-       */
-      function BaseImageResource(source) {
-          var _this = this;
-          var sourceAny = source;
-          var width = sourceAny.naturalWidth || sourceAny.videoWidth || sourceAny.width;
-          var height = sourceAny.naturalHeight || sourceAny.videoHeight || sourceAny.height;
-          _this = _super.call(this, width, height) || this;
-          _this.source = source;
-          _this.noSubImage = false;
-          return _this;
-      }
-      /**
-       * Set cross origin based detecting the url and the crossorigin
-       * @param element - Element to apply crossOrigin
-       * @param url - URL to check
-       * @param crossorigin - Cross origin value to use
-       */
-      BaseImageResource.crossOrigin = function (element, url, crossorigin) {
-          if (crossorigin === undefined && url.indexOf('data:') !== 0) {
-              element.crossOrigin = determineCrossOrigin(url);
-          }
-          else if (crossorigin !== false) {
-              element.crossOrigin = typeof crossorigin === 'string' ? crossorigin : 'anonymous';
-          }
-      };
-      /**
-       * Upload the texture to the GPU.
-       * @param renderer - Upload to the renderer
-       * @param baseTexture - Reference to parent texture
-       * @param glTexture
-       * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|SVGElement} [source] - (optional)
-       * @returns - true is success
-       */
-      BaseImageResource.prototype.upload = function (renderer, baseTexture, glTexture, source) {
-          var gl = renderer.gl;
-          var width = baseTexture.realWidth;
-          var height = baseTexture.realHeight;
-          source = source || this.source;
-          if (source instanceof HTMLImageElement) {
-              if (!source.complete || source.naturalWidth === 0) {
-                  return false;
-              }
-          }
-          else if (source instanceof HTMLVideoElement) {
-              if (source.readyState <= 1) {
-                  return false;
-              }
-          }
-          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === exports.ALPHA_MODES.UNPACK);
-          if (!this.noSubImage
-              && baseTexture.target === gl.TEXTURE_2D
-              && glTexture.width === width
-              && glTexture.height === height) {
-              gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, baseTexture.format, glTexture.type, source);
-          }
-          else {
-              glTexture.width = width;
-              glTexture.height = height;
-              gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, baseTexture.format, glTexture.type, source);
-          }
-          return true;
-      };
-      /**
-       * Checks if source width/height was changed, resize can cause extra baseTexture update.
-       * Triggers one update in any case.
-       */
-      BaseImageResource.prototype.update = function () {
-          if (this.destroyed) {
-              return;
-          }
-          var source = this.source;
-          var width = source.naturalWidth || source.videoWidth || source.width;
-          var height = source.naturalHeight || source.videoHeight || source.height;
-          this.resize(width, height);
-          _super.prototype.update.call(this);
-      };
-      /** Destroy this {@link BaseImageResource} */
-      BaseImageResource.prototype.dispose = function () {
-          this.source = null;
-      };
-      return BaseImageResource;
-  }(Resource));
-
-  /**
-   * @interface OffscreenCanvas
-   */
-  /**
-   * Resource type for HTMLCanvasElement.
-   * @memberof PIXI
-   */
-  var CanvasResource = /** @class */ (function (_super) {
-      __extends$i(CanvasResource, _super);
-      /**
-       * @param source - Canvas element to use
-       */
-      // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-      function CanvasResource(source) {
-          return _super.call(this, source) || this;
-      }
-      /**
-       * Used to auto-detect the type of resource.
-       * @param {*} source - The source object
-       * @returns {boolean} `true` if source is HTMLCanvasElement or OffscreenCanvas
-       */
-      CanvasResource.test = function (source) {
-          var OffscreenCanvas = globalThis.OffscreenCanvas;
-          // Check for browsers that don't yet support OffscreenCanvas
-          if (OffscreenCanvas && source instanceof OffscreenCanvas) {
-              return true;
-          }
-          return globalThis.HTMLCanvasElement && source instanceof HTMLCanvasElement;
-      };
-      return CanvasResource;
-  }(BaseImageResource));
-
-  /**
-   * Resource for a CubeTexture which contains six resources.
-   * @memberof PIXI
-   */
-  var CubeResource = /** @class */ (function (_super) {
-      __extends$i(CubeResource, _super);
-      /**
-       * @param {Array<string|PIXI.Resource>} [source] - Collection of URLs or resources
-       *        to use as the sides of the cube.
-       * @param options - ImageResource options
-       * @param {number} [options.width] - Width of resource
-       * @param {number} [options.height] - Height of resource
-       * @param {number} [options.autoLoad=true] - Whether to auto-load resources
-       * @param {number} [options.linkBaseTexture=true] - In case BaseTextures are supplied,
-       *   whether to copy them or use
-       */
-      function CubeResource(source, options) {
-          var _this = this;
-          var _a = options || {}, width = _a.width, height = _a.height, autoLoad = _a.autoLoad, linkBaseTexture = _a.linkBaseTexture;
-          if (source && source.length !== CubeResource.SIDES) {
-              throw new Error("Invalid length. Got " + source.length + ", expected 6");
-          }
-          _this = _super.call(this, 6, { width: width, height: height }) || this;
-          for (var i = 0; i < CubeResource.SIDES; i++) {
-              _this.items[i].target = exports.TARGETS.TEXTURE_CUBE_MAP_POSITIVE_X + i;
-          }
-          _this.linkBaseTexture = linkBaseTexture !== false;
-          if (source) {
-              _this.initFromArray(source, options);
-          }
-          if (autoLoad !== false) {
-              _this.load();
-          }
-          return _this;
-      }
-      /**
-       * Add binding.
-       * @param baseTexture - parent base texture
-       */
-      CubeResource.prototype.bind = function (baseTexture) {
-          _super.prototype.bind.call(this, baseTexture);
-          baseTexture.target = exports.TARGETS.TEXTURE_CUBE_MAP;
-      };
-      CubeResource.prototype.addBaseTextureAt = function (baseTexture, index, linkBaseTexture) {
-          if (!this.items[index]) {
-              throw new Error("Index " + index + " is out of bounds");
-          }
-          if (!this.linkBaseTexture
-              || baseTexture.parentTextureArray
-              || Object.keys(baseTexture._glTextures).length > 0) {
-              // copy mode
-              if (baseTexture.resource) {
-                  this.addResourceAt(baseTexture.resource, index);
-              }
-              else {
-                  throw new Error("CubeResource does not support copying of renderTexture.");
-              }
-          }
-          else {
-              // link mode, the difficult one!
-              baseTexture.target = exports.TARGETS.TEXTURE_CUBE_MAP_POSITIVE_X + index;
-              baseTexture.parentTextureArray = this.baseTexture;
-              this.items[index] = baseTexture;
-          }
-          if (baseTexture.valid && !this.valid) {
-              this.resize(baseTexture.realWidth, baseTexture.realHeight);
-          }
-          this.items[index] = baseTexture;
-          return this;
-      };
-      /**
-       * Upload the resource
-       * @param renderer
-       * @param _baseTexture
-       * @param glTexture
-       * @returns {boolean} true is success
-       */
-      CubeResource.prototype.upload = function (renderer, _baseTexture, glTexture) {
-          var dirty = this.itemDirtyIds;
-          for (var i = 0; i < CubeResource.SIDES; i++) {
-              var side = this.items[i];
-              if (dirty[i] < side.dirtyId || glTexture.dirtyId < _baseTexture.dirtyId) {
-                  if (side.valid && side.resource) {
-                      side.resource.upload(renderer, side, glTexture);
-                      dirty[i] = side.dirtyId;
-                  }
-                  else if (dirty[i] < -1) {
-                      // either item is not valid yet, either its a renderTexture
-                      // allocate the memory
-                      renderer.gl.texImage2D(side.target, 0, glTexture.internalFormat, _baseTexture.realWidth, _baseTexture.realHeight, 0, _baseTexture.format, glTexture.type, null);
-                      dirty[i] = -1;
-                  }
-              }
-          }
-          return true;
-      };
-      /**
-       * Used to auto-detect the type of resource.
-       * @param {*} source - The source object
-       * @returns {boolean} `true` if source is an array of 6 elements
-       */
-      CubeResource.test = function (source) {
-          return Array.isArray(source) && source.length === CubeResource.SIDES;
-      };
-      /** Number of texture sides to store for CubeResources. */
-      CubeResource.SIDES = 6;
-      return CubeResource;
-  }(AbstractMultiResource));
-
-  /**
-   * Resource type for HTMLImageElement.
-   * @memberof PIXI
-   */
-  var ImageResource = /** @class */ (function (_super) {
-      __extends$i(ImageResource, _super);
-      /**
-       * @param source - image source or URL
-       * @param options
-       * @param {boolean} [options.autoLoad=true] - start loading process
-       * @param {boolean} [options.createBitmap=PIXI.settings.CREATE_IMAGE_BITMAP] - whether its required to create
-       *        a bitmap before upload
-       * @param {boolean} [options.crossorigin=true] - Load image using cross origin
-       * @param {PIXI.ALPHA_MODES} [options.alphaMode=PIXI.ALPHA_MODES.UNPACK] - Premultiply image alpha in bitmap
-       */
-      function ImageResource(source, options) {
-          var _this = this;
-          options = options || {};
-          if (!(source instanceof HTMLImageElement)) {
-              var imageElement = new Image();
-              BaseImageResource.crossOrigin(imageElement, source, options.crossorigin);
-              imageElement.src = source;
-              source = imageElement;
-          }
-          _this = _super.call(this, source) || this;
-          // FireFox 68, and possibly other versions, seems like setting the HTMLImageElement#width and #height
-          // to non-zero values before its loading completes if images are in a cache.
-          // Because of this, need to set the `_width` and the `_height` to zero to avoid uploading incomplete images.
-          // Please refer to the issue #5968 (https://github.com/pixijs/pixi.js/issues/5968).
-          if (!source.complete && !!_this._width && !!_this._height) {
-              _this._width = 0;
-              _this._height = 0;
-          }
-          _this.url = source.src;
-          _this._process = null;
-          _this.preserveBitmap = false;
-          _this.createBitmap = (options.createBitmap !== undefined
-              ? options.createBitmap : settings.CREATE_IMAGE_BITMAP) && !!globalThis.createImageBitmap;
-          _this.alphaMode = typeof options.alphaMode === 'number' ? options.alphaMode : null;
-          _this.bitmap = null;
-          _this._load = null;
-          if (options.autoLoad !== false) {
-              _this.load();
-          }
-          return _this;
-      }
-      /**
-       * Returns a promise when image will be loaded and processed.
-       * @param createBitmap - whether process image into bitmap
-       */
-      ImageResource.prototype.load = function (createBitmap) {
-          var _this = this;
-          if (this._load) {
-              return this._load;
-          }
-          if (createBitmap !== undefined) {
-              this.createBitmap = createBitmap;
-          }
-          this._load = new Promise(function (resolve, reject) {
-              var source = _this.source;
-              _this.url = source.src;
-              var completed = function () {
-                  if (_this.destroyed) {
-                      return;
-                  }
-                  source.onload = null;
-                  source.onerror = null;
-                  _this.resize(source.width, source.height);
-                  _this._load = null;
-                  if (_this.createBitmap) {
-                      resolve(_this.process());
-                  }
-                  else {
-                      resolve(_this);
-                  }
-              };
-              if (source.complete && source.src) {
-                  completed();
-              }
-              else {
-                  source.onload = completed;
-                  source.onerror = function (event) {
-                      // Avoids Promise freezing when resource broken
-                      reject(event);
-                      _this.onError.emit(event);
-                  };
-              }
-          });
-          return this._load;
-      };
-      /**
-       * Called when we need to convert image into BitmapImage.
-       * Can be called multiple times, real promise is cached inside.
-       * @returns - Cached promise to fill that bitmap
-       */
-      ImageResource.prototype.process = function () {
-          var _this = this;
-          var source = this.source;
-          if (this._process !== null) {
-              return this._process;
-          }
-          if (this.bitmap !== null || !globalThis.createImageBitmap) {
-              return Promise.resolve(this);
-          }
-          var createImageBitmap = globalThis.createImageBitmap;
-          var cors = !source.crossOrigin || source.crossOrigin === 'anonymous';
-          this._process = fetch(source.src, {
-              mode: cors ? 'cors' : 'no-cors'
-          })
-              .then(function (r) { return r.blob(); })
-              .then(function (blob) { return createImageBitmap(blob, 0, 0, source.width, source.height, {
-              premultiplyAlpha: _this.alphaMode === null || _this.alphaMode === exports.ALPHA_MODES.UNPACK
-                  ? 'premultiply' : 'none',
-          }); })
-              .then(function (bitmap) {
-              if (_this.destroyed) {
-                  return Promise.reject();
-              }
-              _this.bitmap = bitmap;
-              _this.update();
-              _this._process = null;
-              return Promise.resolve(_this);
-          });
-          return this._process;
-      };
-      /**
-       * Upload the image resource to GPU.
-       * @param renderer - Renderer to upload to
-       * @param baseTexture - BaseTexture for this resource
-       * @param glTexture - GLTexture to use
-       * @returns {boolean} true is success
-       */
-      ImageResource.prototype.upload = function (renderer, baseTexture, glTexture) {
-          if (typeof this.alphaMode === 'number') {
-              // bitmap stores unpack premultiply flag, we dont have to notify texImage2D about it
-              baseTexture.alphaMode = this.alphaMode;
-          }
-          if (!this.createBitmap) {
-              return _super.prototype.upload.call(this, renderer, baseTexture, glTexture);
-          }
-          if (!this.bitmap) {
-              // yeah, ignore the output
-              this.process();
-              if (!this.bitmap) {
-                  return false;
-              }
-          }
-          _super.prototype.upload.call(this, renderer, baseTexture, glTexture, this.bitmap);
-          if (!this.preserveBitmap) {
-              // checks if there are other renderers that possibly need this bitmap
-              var flag = true;
-              var glTextures = baseTexture._glTextures;
-              for (var key in glTextures) {
-                  var otherTex = glTextures[key];
-                  if (otherTex !== glTexture && otherTex.dirtyId !== baseTexture.dirtyId) {
-                      flag = false;
-                      break;
-                  }
-              }
-              if (flag) {
-                  if (this.bitmap.close) {
-                      this.bitmap.close();
-                  }
-                  this.bitmap = null;
-              }
-          }
-          return true;
-      };
-      /** Destroys this resource. */
-      ImageResource.prototype.dispose = function () {
-          this.source.onload = null;
-          this.source.onerror = null;
-          _super.prototype.dispose.call(this);
-          if (this.bitmap) {
-              this.bitmap.close();
-              this.bitmap = null;
-          }
-          this._process = null;
-          this._load = null;
-      };
-      /**
-       * Used to auto-detect the type of resource.
-       * @param {*} source - The source object
-       * @returns {boolean} `true` if source is string or HTMLImageElement
-       */
-      ImageResource.test = function (source) {
-          return typeof source === 'string' || source instanceof HTMLImageElement;
-      };
-      return ImageResource;
-  }(BaseImageResource));
-
-  /**
-   * Resource type for SVG elements and graphics.
-   * @memberof PIXI
-   */
-  var SVGResource = /** @class */ (function (_super) {
-      __extends$i(SVGResource, _super);
-      /**
-       * @param sourceBase64 - Base64 encoded SVG element or URL for SVG file.
-       * @param {object} [options] - Options to use
-       * @param {number} [options.scale=1] - Scale to apply to SVG. Overridden by...
-       * @param {number} [options.width] - Rasterize SVG this wide. Aspect ratio preserved if height not specified.
-       * @param {number} [options.height] - Rasterize SVG this high. Aspect ratio preserved if width not specified.
-       * @param {boolean} [options.autoLoad=true] - Start loading right away.
-       */
-      function SVGResource(sourceBase64, options) {
-          var _this = this;
-          options = options || {};
-          _this = _super.call(this, settings.ADAPTER.createCanvas()) || this;
-          _this._width = 0;
-          _this._height = 0;
-          _this.svg = sourceBase64;
-          _this.scale = options.scale || 1;
-          _this._overrideWidth = options.width;
-          _this._overrideHeight = options.height;
-          _this._resolve = null;
-          _this._crossorigin = options.crossorigin;
-          _this._load = null;
-          if (options.autoLoad !== false) {
-              _this.load();
-          }
-          return _this;
-      }
-      SVGResource.prototype.load = function () {
-          var _this = this;
-          if (this._load) {
-              return this._load;
-          }
-          this._load = new Promise(function (resolve) {
-              // Save this until after load is finished
-              _this._resolve = function () {
-                  _this.resize(_this.source.width, _this.source.height);
-                  resolve(_this);
-              };
-              // Convert SVG inline string to data-uri
-              if (SVGResource.SVG_XML.test(_this.svg.trim())) {
-                  if (!btoa) {
-                      throw new Error('Your browser doesn\'t support base64 conversions.');
-                  }
-                  _this.svg = "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(_this.svg)));
-              }
-              _this._loadSvg();
-          });
-          return this._load;
-      };
-      /** Loads an SVG image from `imageUrl` or `data URL`. */
-      SVGResource.prototype._loadSvg = function () {
-          var _this = this;
-          var tempImage = new Image();
-          BaseImageResource.crossOrigin(tempImage, this.svg, this._crossorigin);
-          tempImage.src = this.svg;
-          tempImage.onerror = function (event) {
-              if (!_this._resolve) {
-                  return;
-              }
-              tempImage.onerror = null;
-              _this.onError.emit(event);
-          };
-          tempImage.onload = function () {
-              if (!_this._resolve) {
-                  return;
-              }
-              var svgWidth = tempImage.width;
-              var svgHeight = tempImage.height;
-              if (!svgWidth || !svgHeight) {
-                  throw new Error('The SVG image must have width and height defined (in pixels), canvas API needs them.');
-              }
-              // Set render size
-              var width = svgWidth * _this.scale;
-              var height = svgHeight * _this.scale;
-              if (_this._overrideWidth || _this._overrideHeight) {
-                  width = _this._overrideWidth || _this._overrideHeight / svgHeight * svgWidth;
-                  height = _this._overrideHeight || _this._overrideWidth / svgWidth * svgHeight;
-              }
-              width = Math.round(width);
-              height = Math.round(height);
-              // Create a canvas element
-              var canvas = _this.source;
-              canvas.width = width;
-              canvas.height = height;
-              canvas._pixiId = "canvas_" + uid();
-              // Draw the Svg to the canvas
-              canvas
-                  .getContext('2d')
-                  .drawImage(tempImage, 0, 0, svgWidth, svgHeight, 0, 0, width, height);
-              _this._resolve();
-              _this._resolve = null;
-          };
-      };
-      /**
-       * Get size from an svg string using a regular expression.
-       * @param svgString - a serialized svg element
-       * @returns - image extension
-       */
-      SVGResource.getSize = function (svgString) {
-          var sizeMatch = SVGResource.SVG_SIZE.exec(svgString);
-          var size = {};
-          if (sizeMatch) {
-              size[sizeMatch[1]] = Math.round(parseFloat(sizeMatch[3]));
-              size[sizeMatch[5]] = Math.round(parseFloat(sizeMatch[7]));
-          }
-          return size;
-      };
-      /** Destroys this texture. */
-      SVGResource.prototype.dispose = function () {
-          _super.prototype.dispose.call(this);
-          this._resolve = null;
-          this._crossorigin = null;
-      };
-      /**
-       * Used to auto-detect the type of resource.
-       * @param {*} source - The source object
-       * @param {string} extension - The extension of source, if set
-       * @returns {boolean} - If the source is a SVG source or data file
-       */
-      SVGResource.test = function (source, extension) {
-          // url file extension is SVG
-          return extension === 'svg'
-              // source is SVG data-uri
-              || (typeof source === 'string' && source.startsWith('data:image/svg+xml'))
-              // source is SVG inline
-              || (typeof source === 'string' && SVGResource.SVG_XML.test(source));
-      };
-      /**
-       * Regular expression for SVG XML document.
-       * @example &lt;?xml version="1.0" encoding="utf-8" ?&gt;&lt;!-- image/svg --&gt;&lt;svg
-       * @readonly
-       */
-      SVGResource.SVG_XML = /^(<\?xml[^?]+\?>)?\s*(<!--[^(-->)]*-->)?\s*\<svg/m;
-      /**
-       * Regular expression for SVG size.
-       * @example &lt;svg width="100" height="100"&gt;&lt;/svg&gt;
-       * @readonly
-       */
-      SVGResource.SVG_SIZE = /<svg[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*(?:\s(width|height)=('|")(\d*(?:\.\d+)?)(?:px)?('|"))[^>]*>/i; // eslint-disable-line max-len
-      return SVGResource;
-  }(BaseImageResource));
-
-  /**
-   * Resource type for {@code HTMLVideoElement}.
-   * @memberof PIXI
-   */
-  var VideoResource = /** @class */ (function (_super) {
-      __extends$i(VideoResource, _super);
-      /**
-       * @param {HTMLVideoElement|object|string|Array<string|object>} source - Video element to use.
-       * @param {object} [options] - Options to use
-       * @param {boolean} [options.autoLoad=true] - Start loading the video immediately
-       * @param {boolean} [options.autoPlay=true] - Start playing video immediately
-       * @param {number} [options.updateFPS=0] - How many times a second to update the texture from the video.
-       * Leave at 0 to update at every render.
-       * @param {boolean} [options.crossorigin=true] - Load image using cross origin
-       */
-      function VideoResource(source, options) {
-          var _this = this;
-          options = options || {};
-          if (!(source instanceof HTMLVideoElement)) {
-              var videoElement = document.createElement('video');
-              // workaround for https://github.com/pixijs/pixi.js/issues/5996
-              videoElement.setAttribute('preload', 'auto');
-              videoElement.setAttribute('webkit-playsinline', '');
-              videoElement.setAttribute('playsinline', '');
-              if (typeof source === 'string') {
-                  source = [source];
-              }
-              var firstSrc = source[0].src || source[0];
-              BaseImageResource.crossOrigin(videoElement, firstSrc, options.crossorigin);
-              // array of objects or strings
-              for (var i = 0; i < source.length; ++i) {
-                  var sourceElement = document.createElement('source');
-                  var _a = source[i], src = _a.src, mime = _a.mime;
-                  src = src || source[i];
-                  var baseSrc = src.split('?').shift().toLowerCase();
-                  var ext = baseSrc.slice(baseSrc.lastIndexOf('.') + 1);
-                  mime = mime || VideoResource.MIME_TYPES[ext] || "video/" + ext;
-                  sourceElement.src = src;
-                  sourceElement.type = mime;
-                  videoElement.appendChild(sourceElement);
-              }
-              // Override the source
-              source = videoElement;
-          }
-          _this = _super.call(this, source) || this;
-          _this.noSubImage = true;
-          _this._autoUpdate = true;
-          _this._isConnectedToTicker = false;
-          _this._updateFPS = options.updateFPS || 0;
-          _this._msToNextUpdate = 0;
-          _this.autoPlay = options.autoPlay !== false;
-          _this._load = null;
-          _this._resolve = null;
-          // Bind for listeners
-          _this._onCanPlay = _this._onCanPlay.bind(_this);
-          _this._onError = _this._onError.bind(_this);
-          if (options.autoLoad !== false) {
-              _this.load();
-          }
-          return _this;
-      }
-      /**
-       * Trigger updating of the texture.
-       * @param _deltaTime - time delta since last tick
-       */
-      VideoResource.prototype.update = function (_deltaTime) {
-          if (!this.destroyed) {
-              // account for if video has had its playbackRate changed
-              var elapsedMS = Ticker.shared.elapsedMS * this.source.playbackRate;
-              this._msToNextUpdate = Math.floor(this._msToNextUpdate - elapsedMS);
-              if (!this._updateFPS || this._msToNextUpdate <= 0) {
-                  _super.prototype.update.call(this);
-                  this._msToNextUpdate = this._updateFPS ? Math.floor(1000 / this._updateFPS) : 0;
-              }
-          }
-      };
-      /**
-       * Start preloading the video resource.
-       * @returns {Promise<void>} Handle the validate event
-       */
-      VideoResource.prototype.load = function () {
-          var _this = this;
-          if (this._load) {
-              return this._load;
-          }
-          var source = this.source;
-          if ((source.readyState === source.HAVE_ENOUGH_DATA || source.readyState === source.HAVE_FUTURE_DATA)
-              && source.width && source.height) {
-              source.complete = true;
-          }
-          source.addEventListener('play', this._onPlayStart.bind(this));
-          source.addEventListener('pause', this._onPlayStop.bind(this));
-          if (!this._isSourceReady()) {
-              source.addEventListener('canplay', this._onCanPlay);
-              source.addEventListener('canplaythrough', this._onCanPlay);
-              source.addEventListener('error', this._onError, true);
-          }
-          else {
-              this._onCanPlay();
-          }
-          this._load = new Promise(function (resolve) {
-              if (_this.valid) {
-                  resolve(_this);
-              }
-              else {
-                  _this._resolve = resolve;
-                  source.load();
-              }
-          });
-          return this._load;
-      };
-      /**
-       * Handle video error events.
-       * @param event
-       */
-      VideoResource.prototype._onError = function (event) {
-          this.source.removeEventListener('error', this._onError, true);
-          this.onError.emit(event);
-      };
-      /**
-       * Returns true if the underlying source is playing.
-       * @returns - True if playing.
-       */
-      VideoResource.prototype._isSourcePlaying = function () {
-          var source = this.source;
-          return (!source.paused && !source.ended && this._isSourceReady());
-      };
-      /**
-       * Returns true if the underlying source is ready for playing.
-       * @returns - True if ready.
-       */
-      VideoResource.prototype._isSourceReady = function () {
-          var source = this.source;
-          return source.readyState > 2;
-      };
-      /** Runs the update loop when the video is ready to play. */
-      VideoResource.prototype._onPlayStart = function () {
-          // Just in case the video has not received its can play even yet..
-          if (!this.valid) {
-              this._onCanPlay();
-          }
-          if (this.autoUpdate && !this._isConnectedToTicker) {
-              Ticker.shared.add(this.update, this);
-              this._isConnectedToTicker = true;
-          }
-      };
-      /** Fired when a pause event is triggered, stops the update loop. */
-      VideoResource.prototype._onPlayStop = function () {
-          if (this._isConnectedToTicker) {
-              Ticker.shared.remove(this.update, this);
-              this._isConnectedToTicker = false;
-          }
-      };
-      /** Fired when the video is loaded and ready to play. */
-      VideoResource.prototype._onCanPlay = function () {
-          var source = this.source;
-          source.removeEventListener('canplay', this._onCanPlay);
-          source.removeEventListener('canplaythrough', this._onCanPlay);
-          var valid = this.valid;
-          this.resize(source.videoWidth, source.videoHeight);
-          // prevent multiple loaded dispatches..
-          if (!valid && this._resolve) {
-              this._resolve(this);
-              this._resolve = null;
-          }
-          if (this._isSourcePlaying()) {
-              this._onPlayStart();
-          }
-          else if (this.autoPlay) {
-              source.play();
-          }
-      };
-      /** Destroys this texture. */
-      VideoResource.prototype.dispose = function () {
-          if (this._isConnectedToTicker) {
-              Ticker.shared.remove(this.update, this);
-              this._isConnectedToTicker = false;
-          }
-          var source = this.source;
-          if (source) {
-              source.removeEventListener('error', this._onError, true);
-              source.pause();
-              source.src = '';
-              source.load();
-          }
-          _super.prototype.dispose.call(this);
-      };
-      Object.defineProperty(VideoResource.prototype, "autoUpdate", {
-          /** Should the base texture automatically update itself, set to true by default. */
-          get: function () {
-              return this._autoUpdate;
-          },
-          set: function (value) {
-              if (value !== this._autoUpdate) {
-                  this._autoUpdate = value;
-                  if (!this._autoUpdate && this._isConnectedToTicker) {
-                      Ticker.shared.remove(this.update, this);
-                      this._isConnectedToTicker = false;
-                  }
-                  else if (this._autoUpdate && !this._isConnectedToTicker && this._isSourcePlaying()) {
-                      Ticker.shared.add(this.update, this);
-                      this._isConnectedToTicker = true;
-                  }
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(VideoResource.prototype, "updateFPS", {
-          /**
-           * How many times a second to update the texture from the video. Leave at 0 to update at every render.
-           * A lower fps can help performance, as updating the texture at 60fps on a 30ps video may not be efficient.
-           */
-          get: function () {
-              return this._updateFPS;
-          },
-          set: function (value) {
-              if (value !== this._updateFPS) {
-                  this._updateFPS = value;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Used to auto-detect the type of resource.
-       * @param {*} source - The source object
-       * @param {string} extension - The extension of source, if set
-       * @returns {boolean} `true` if video source
-       */
-      VideoResource.test = function (source, extension) {
-          return (globalThis.HTMLVideoElement && source instanceof HTMLVideoElement)
-              || VideoResource.TYPES.indexOf(extension) > -1;
-      };
-      /**
-       * List of common video file extensions supported by VideoResource.
-       * @readonly
-       */
-      VideoResource.TYPES = ['mp4', 'm4v', 'webm', 'ogg', 'ogv', 'h264', 'avi', 'mov'];
-      /**
-       * Map of video MIME types that can't be directly derived from file extensions.
-       * @readonly
-       */
-      VideoResource.MIME_TYPES = {
-          ogv: 'video/ogg',
-          mov: 'video/quicktime',
-          m4v: 'video/mp4',
-      };
-      return VideoResource;
-  }(BaseImageResource));
-
-  /**
-   * Resource type for ImageBitmap.
-   * @memberof PIXI
-   */
-  var ImageBitmapResource = /** @class */ (function (_super) {
-      __extends$i(ImageBitmapResource, _super);
-      /**
-       * @param source - Image element to use
-       */
-      // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-      function ImageBitmapResource(source) {
-          return _super.call(this, source) || this;
-      }
-      /**
-       * Used to auto-detect the type of resource.
-       * @param {*} source - The source object
-       * @returns {boolean} `true` if source is an ImageBitmap
-       */
-      ImageBitmapResource.test = function (source) {
-          return !!globalThis.createImageBitmap && typeof ImageBitmap !== 'undefined' && source instanceof ImageBitmap;
-      };
-      return ImageBitmapResource;
-  }(BaseImageResource));
-
-  INSTALLED.push(ImageResource, ImageBitmapResource, CanvasResource, VideoResource, SVGResource, BufferResource, CubeResource, ArrayResource);
-
-  var _resources = {
-      __proto__: null,
-      Resource: Resource,
-      BaseImageResource: BaseImageResource,
-      INSTALLED: INSTALLED,
-      autoDetectResource: autoDetectResource,
-      AbstractMultiResource: AbstractMultiResource,
-      ArrayResource: ArrayResource,
-      BufferResource: BufferResource,
-      CanvasResource: CanvasResource,
-      CubeResource: CubeResource,
-      ImageResource: ImageResource,
-      SVGResource: SVGResource,
-      VideoResource: VideoResource,
-      ImageBitmapResource: ImageBitmapResource
-  };
-
-  /**
-   * Resource type for DepthTexture.
-   * @memberof PIXI
-   */
-  var DepthResource = /** @class */ (function (_super) {
-      __extends$i(DepthResource, _super);
-      function DepthResource() {
-          return _super !== null && _super.apply(this, arguments) || this;
-      }
-      /**
-       * Upload the texture to the GPU.
-       * @param renderer - Upload to the renderer
-       * @param baseTexture - Reference to parent texture
-       * @param glTexture - glTexture
-       * @returns - true is success
-       */
-      DepthResource.prototype.upload = function (renderer, baseTexture, glTexture) {
-          var gl = renderer.gl;
-          gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, baseTexture.alphaMode === exports.ALPHA_MODES.UNPACK);
-          var width = baseTexture.realWidth;
-          var height = baseTexture.realHeight;
-          if (glTexture.width === width && glTexture.height === height) {
-              gl.texSubImage2D(baseTexture.target, 0, 0, 0, width, height, baseTexture.format, glTexture.type, this.data);
-          }
-          else {
-              glTexture.width = width;
-              glTexture.height = height;
-              gl.texImage2D(baseTexture.target, 0, glTexture.internalFormat, width, height, 0, baseTexture.format, glTexture.type, this.data);
-          }
-          return true;
-      };
-      return DepthResource;
-  }(BufferResource));
-
-  /**
-   * A framebuffer can be used to render contents off of the screen. {@link PIXI.BaseRenderTexture} uses
-   * one internally to render into itself. You can attach a depth or stencil buffer to a framebuffer.
-   *
-   * On WebGL 2 machines, shaders can output to multiple textures simultaneously with GLSL 300 ES.
-   * @memberof PIXI
-   */
-  var Framebuffer = /** @class */ (function () {
-      /**
-       * @param width - Width of the frame buffer
-       * @param height - Height of the frame buffer
-       */
-      function Framebuffer(width, height) {
-          this.width = Math.round(width || 100);
-          this.height = Math.round(height || 100);
-          this.stencil = false;
-          this.depth = false;
-          this.dirtyId = 0;
-          this.dirtyFormat = 0;
-          this.dirtySize = 0;
-          this.depthTexture = null;
-          this.colorTextures = [];
-          this.glFramebuffers = {};
-          this.disposeRunner = new Runner('disposeFramebuffer');
-          this.multisample = exports.MSAA_QUALITY.NONE;
-      }
-      Object.defineProperty(Framebuffer.prototype, "colorTexture", {
-          /**
-           * Reference to the colorTexture.
-           * @readonly
-           */
-          get: function () {
-              return this.colorTextures[0];
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Add texture to the colorTexture array.
-       * @param index - Index of the array to add the texture to
-       * @param texture - Texture to add to the array
-       */
-      Framebuffer.prototype.addColorTexture = function (index, texture) {
-          if (index === void 0) { index = 0; }
-          // TODO add some validation to the texture - same width / height etc?
-          this.colorTextures[index] = texture || new BaseTexture(null, {
-              scaleMode: exports.SCALE_MODES.NEAREST,
-              resolution: 1,
-              mipmap: exports.MIPMAP_MODES.OFF,
-              width: this.width,
-              height: this.height,
-          });
-          this.dirtyId++;
-          this.dirtyFormat++;
-          return this;
-      };
-      /**
-       * Add a depth texture to the frame buffer.
-       * @param texture - Texture to add.
-       */
-      Framebuffer.prototype.addDepthTexture = function (texture) {
-          /* eslint-disable max-len */
-          this.depthTexture = texture || new BaseTexture(new DepthResource(null, { width: this.width, height: this.height }), {
-              scaleMode: exports.SCALE_MODES.NEAREST,
-              resolution: 1,
-              width: this.width,
-              height: this.height,
-              mipmap: exports.MIPMAP_MODES.OFF,
-              format: exports.FORMATS.DEPTH_COMPONENT,
-              type: exports.TYPES.UNSIGNED_SHORT,
-          });
-          this.dirtyId++;
-          this.dirtyFormat++;
-          return this;
-      };
-      /** Enable depth on the frame buffer. */
-      Framebuffer.prototype.enableDepth = function () {
-          this.depth = true;
-          this.dirtyId++;
-          this.dirtyFormat++;
-          return this;
-      };
-      /** Enable stencil on the frame buffer. */
-      Framebuffer.prototype.enableStencil = function () {
-          this.stencil = true;
-          this.dirtyId++;
-          this.dirtyFormat++;
-          return this;
-      };
-      /**
-       * Resize the frame buffer
-       * @param width - Width of the frame buffer to resize to
-       * @param height - Height of the frame buffer to resize to
-       */
-      Framebuffer.prototype.resize = function (width, height) {
-          width = Math.round(width);
-          height = Math.round(height);
-          if (width === this.width && height === this.height)
-              { return; }
-          this.width = width;
-          this.height = height;
-          this.dirtyId++;
-          this.dirtySize++;
-          for (var i = 0; i < this.colorTextures.length; i++) {
-              var texture = this.colorTextures[i];
-              var resolution = texture.resolution;
-              // take into account the fact the texture may have a different resolution..
-              texture.setSize(width / resolution, height / resolution);
-          }
-          if (this.depthTexture) {
-              var resolution = this.depthTexture.resolution;
-              this.depthTexture.setSize(width / resolution, height / resolution);
-          }
-      };
-      /** Disposes WebGL resources that are connected to this geometry. */
-      Framebuffer.prototype.dispose = function () {
-          this.disposeRunner.emit(this, false);
-      };
-      /** Destroys and removes the depth texture added to this framebuffer. */
-      Framebuffer.prototype.destroyDepthTexture = function () {
-          if (this.depthTexture) {
-              this.depthTexture.destroy();
-              this.depthTexture = null;
-              ++this.dirtyId;
-              ++this.dirtyFormat;
-          }
-      };
-      return Framebuffer;
-  }());
-
-  /**
-   * A BaseRenderTexture is a special texture that allows any PixiJS display object to be rendered to it.
-   *
-   * __Hint__: All DisplayObjects (i.e. Sprites) that render to a BaseRenderTexture should be preloaded
-   * otherwise black rectangles will be drawn instead.
-   *
-   * A BaseRenderTexture takes a snapshot of any Display Object given to its render method. The position
-   * and rotation of the given Display Objects is ignored. For example:
-   *
-   * ```js
-   * let renderer = PIXI.autoDetectRenderer();
-   * let baseRenderTexture = new PIXI.BaseRenderTexture({ width: 800, height: 600 });
-   * let renderTexture = new PIXI.RenderTexture(baseRenderTexture);
-   * let sprite = PIXI.Sprite.from("spinObj_01.png");
-   *
-   * sprite.position.x = 800/2;
-   * sprite.position.y = 600/2;
-   * sprite.anchor.x = 0.5;
-   * sprite.anchor.y = 0.5;
-   *
-   * renderer.render(sprite, {renderTexture});
-   * ```
-   *
-   * The Sprite in this case will be rendered using its local transform. To render this sprite at 0,0
-   * you can clear the transform
-   *
-   * ```js
-   *
-   * sprite.setTransform()
-   *
-   * let baseRenderTexture = new PIXI.BaseRenderTexture({ width: 100, height: 100 });
-   * let renderTexture = new PIXI.RenderTexture(baseRenderTexture);
-   *
-   * renderer.render(sprite, {renderTexture});  // Renders to center of RenderTexture
-   * ```
-   * @memberof PIXI
-   */
-  var BaseRenderTexture = /** @class */ (function (_super) {
-      __extends$i(BaseRenderTexture, _super);
-      /**
-       * @param options
-       * @param {number} [options.width=100] - The width of the base render texture.
-       * @param {number} [options.height=100] - The height of the base render texture.
-       * @param {PIXI.SCALE_MODES} [options.scaleMode=PIXI.settings.SCALE_MODE] - See {@link PIXI.SCALE_MODES}
-       *   for possible values.
-       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] - The resolution / device pixel ratio
-       *   of the texture being generated.
-       * @param {PIXI.MSAA_QUALITY} [options.multisample=PIXI.MSAA_QUALITY.NONE] - The number of samples of the frame buffer.
-       */
-      function BaseRenderTexture(options) {
-          if (options === void 0) { options = {}; }
-          var _this = this;
-          if (typeof options === 'number') {
-              /* eslint-disable prefer-rest-params */
-              // Backward compatibility of signature
-              var width = arguments[0];
-              var height = arguments[1];
-              var scaleMode = arguments[2];
-              var resolution = arguments[3];
-              options = { width: width, height: height, scaleMode: scaleMode, resolution: resolution };
-              /* eslint-enable prefer-rest-params */
-          }
-          options.width = options.width || 100;
-          options.height = options.height || 100;
-          options.multisample = options.multisample !== undefined ? options.multisample : exports.MSAA_QUALITY.NONE;
-          _this = _super.call(this, null, options) || this;
-          // Set defaults
-          _this.mipmap = exports.MIPMAP_MODES.OFF;
-          _this.valid = true;
-          _this.clearColor = [0, 0, 0, 0];
-          _this.framebuffer = new Framebuffer(_this.realWidth, _this.realHeight)
-              .addColorTexture(0, _this);
-          _this.framebuffer.multisample = options.multisample;
-          // TODO - could this be added the systems?
-          _this.maskStack = [];
-          _this.filterStack = [{}];
-          return _this;
-      }
-      /**
-       * Resizes the BaseRenderTexture.
-       * @param desiredWidth - The desired width to resize to.
-       * @param desiredHeight - The desired height to resize to.
-       */
-      BaseRenderTexture.prototype.resize = function (desiredWidth, desiredHeight) {
-          this.framebuffer.resize(desiredWidth * this.resolution, desiredHeight * this.resolution);
-          this.setRealSize(this.framebuffer.width, this.framebuffer.height);
-      };
-      /**
-       * Frees the texture and framebuffer from WebGL memory without destroying this texture object.
-       * This means you can still use the texture later which will upload it to GPU
-       * memory again.
-       * @fires PIXI.BaseTexture#dispose
-       */
-      BaseRenderTexture.prototype.dispose = function () {
-          this.framebuffer.dispose();
-          _super.prototype.dispose.call(this);
-      };
-      /** Destroys this texture. */
-      BaseRenderTexture.prototype.destroy = function () {
-          _super.prototype.destroy.call(this);
-          this.framebuffer.destroyDepthTexture();
-          this.framebuffer = null;
-      };
-      return BaseRenderTexture;
-  }(BaseTexture));
-
-  /**
-   * Stores a texture's frame in UV coordinates, in
-   * which everything lies in the rectangle `[(0,0), (1,0),
-   * (1,1), (0,1)]`.
-   *
-   * | Corner       | Coordinates |
-   * |--------------|-------------|
-   * | Top-Left     | `(x0,y0)`   |
-   * | Top-Right    | `(x1,y1)`   |
-   * | Bottom-Right | `(x2,y2)`   |
-   * | Bottom-Left  | `(x3,y3)`   |
-   * @protected
-   * @memberof PIXI
-   */
-  var TextureUvs = /** @class */ (function () {
-      function TextureUvs() {
-          this.x0 = 0;
-          this.y0 = 0;
-          this.x1 = 1;
-          this.y1 = 0;
-          this.x2 = 1;
-          this.y2 = 1;
-          this.x3 = 0;
-          this.y3 = 1;
-          this.uvsFloat32 = new Float32Array(8);
-      }
-      /**
-       * Sets the texture Uvs based on the given frame information.
-       * @protected
-       * @param frame - The frame of the texture
-       * @param baseFrame - The base frame of the texture
-       * @param rotate - Rotation of frame, see {@link PIXI.groupD8}
-       */
-      TextureUvs.prototype.set = function (frame, baseFrame, rotate) {
-          var tw = baseFrame.width;
-          var th = baseFrame.height;
-          if (rotate) {
-              // width and height div 2 div baseFrame size
-              var w2 = frame.width / 2 / tw;
-              var h2 = frame.height / 2 / th;
-              // coordinates of center
-              var cX = (frame.x / tw) + w2;
-              var cY = (frame.y / th) + h2;
-              rotate = groupD8.add(rotate, groupD8.NW); // NW is top-left corner
-              this.x0 = cX + (w2 * groupD8.uX(rotate));
-              this.y0 = cY + (h2 * groupD8.uY(rotate));
-              rotate = groupD8.add(rotate, 2); // rotate 90 degrees clockwise
-              this.x1 = cX + (w2 * groupD8.uX(rotate));
-              this.y1 = cY + (h2 * groupD8.uY(rotate));
-              rotate = groupD8.add(rotate, 2);
-              this.x2 = cX + (w2 * groupD8.uX(rotate));
-              this.y2 = cY + (h2 * groupD8.uY(rotate));
-              rotate = groupD8.add(rotate, 2);
-              this.x3 = cX + (w2 * groupD8.uX(rotate));
-              this.y3 = cY + (h2 * groupD8.uY(rotate));
-          }
-          else {
-              this.x0 = frame.x / tw;
-              this.y0 = frame.y / th;
-              this.x1 = (frame.x + frame.width) / tw;
-              this.y1 = frame.y / th;
-              this.x2 = (frame.x + frame.width) / tw;
-              this.y2 = (frame.y + frame.height) / th;
-              this.x3 = frame.x / tw;
-              this.y3 = (frame.y + frame.height) / th;
-          }
-          this.uvsFloat32[0] = this.x0;
-          this.uvsFloat32[1] = this.y0;
-          this.uvsFloat32[2] = this.x1;
-          this.uvsFloat32[3] = this.y1;
-          this.uvsFloat32[4] = this.x2;
-          this.uvsFloat32[5] = this.y2;
-          this.uvsFloat32[6] = this.x3;
-          this.uvsFloat32[7] = this.y3;
-      };
-      TextureUvs.prototype.toString = function () {
-          return "[@pixi/core:TextureUvs "
-              + ("x0=" + this.x0 + " y0=" + this.y0 + " ")
-              + ("x1=" + this.x1 + " y1=" + this.y1 + " x2=" + this.x2 + " ")
-              + ("y2=" + this.y2 + " x3=" + this.x3 + " y3=" + this.y3)
-              + "]";
-      };
-      return TextureUvs;
-  }());
-
-  var DEFAULT_UVS = new TextureUvs();
-  /**
-   * Used to remove listeners from WHITE and EMPTY Textures
-   * @ignore
-   */
-  function removeAllHandlers(tex) {
-      tex.destroy = function _emptyDestroy() { };
-      tex.on = function _emptyOn() { };
-      tex.once = function _emptyOnce() { };
-      tex.emit = function _emptyEmit() { };
-  }
-  /**
-   * A texture stores the information that represents an image or part of an image.
-   *
-   * It cannot be added to the display list directly; instead use it as the texture for a Sprite.
-   * If no frame is provided for a texture, then the whole image is used.
-   *
-   * You can directly create a texture from an image and then reuse it multiple times like this :
-   *
-   * ```js
-   * let texture = PIXI.Texture.from('assets/image.png');
-   * let sprite1 = new PIXI.Sprite(texture);
-   * let sprite2 = new PIXI.Sprite(texture);
-   * ```
-   *
-   * If you didnt pass the texture frame to constructor, it enables `noFrame` mode:
-   * it subscribes on baseTexture events, it automatically resizes at the same time as baseTexture.
-   *
-   * Textures made from SVGs, loaded or not, cannot be used before the file finishes processing.
-   * You can check for this by checking the sprite's _textureID property.
-   * ```js
-   * var texture = PIXI.Texture.from('assets/image.svg');
-   * var sprite1 = new PIXI.Sprite(texture);
-   * //sprite1._textureID should not be undefined if the texture has finished processing the SVG file
-   * ```
-   * You can use a ticker or rAF to ensure your sprites load the finished textures after processing. See issue #3068.
-   * @memberof PIXI
-   * @typeParam R - The BaseTexture's Resource type.
-   */
-  var Texture = /** @class */ (function (_super) {
-      __extends$i(Texture, _super);
-      /**
-       * @param baseTexture - The base texture source to create the texture from
-       * @param frame - The rectangle frame of the texture to show
-       * @param orig - The area of original texture
-       * @param trim - Trimmed rectangle of original texture
-       * @param rotate - indicates how the texture was rotated by texture packer. See {@link PIXI.groupD8}
-       * @param anchor - Default anchor point used for sprite placement / rotation
-       */
-      function Texture(baseTexture, frame, orig, trim, rotate, anchor) {
-          var _this = _super.call(this) || this;
-          _this.noFrame = false;
-          if (!frame) {
-              _this.noFrame = true;
-              frame = new Rectangle(0, 0, 1, 1);
-          }
-          if (baseTexture instanceof Texture) {
-              baseTexture = baseTexture.baseTexture;
-          }
-          _this.baseTexture = baseTexture;
-          _this._frame = frame;
-          _this.trim = trim;
-          _this.valid = false;
-          _this._uvs = DEFAULT_UVS;
-          _this.uvMatrix = null;
-          _this.orig = orig || frame; // new Rectangle(0, 0, 1, 1);
-          _this._rotate = Number(rotate || 0);
-          if (rotate === true) {
-              // this is old texturepacker legacy, some games/libraries are passing "true" for rotated textures
-              _this._rotate = 2;
-          }
-          else if (_this._rotate % 2 !== 0) {
-              throw new Error('attempt to use diamond-shaped UVs. If you are sure, set rotation manually');
-          }
-          _this.defaultAnchor = anchor ? new Point(anchor.x, anchor.y) : new Point(0, 0);
-          _this._updateID = 0;
-          _this.textureCacheIds = [];
-          if (!baseTexture.valid) {
-              baseTexture.once('loaded', _this.onBaseTextureUpdated, _this);
-          }
-          else if (_this.noFrame) {
-              // if there is no frame we should monitor for any base texture changes..
-              if (baseTexture.valid) {
-                  _this.onBaseTextureUpdated(baseTexture);
-              }
-          }
-          else {
-              _this.frame = frame;
-          }
-          if (_this.noFrame) {
-              baseTexture.on('update', _this.onBaseTextureUpdated, _this);
-          }
-          return _this;
-      }
-      /**
-       * Updates this texture on the gpu.
-       *
-       * Calls the TextureResource update.
-       *
-       * If you adjusted `frame` manually, please call `updateUvs()` instead.
-       */
-      Texture.prototype.update = function () {
-          if (this.baseTexture.resource) {
-              this.baseTexture.resource.update();
-          }
-      };
-      /**
-       * Called when the base texture is updated
-       * @protected
-       * @param baseTexture - The base texture.
-       */
-      Texture.prototype.onBaseTextureUpdated = function (baseTexture) {
-          if (this.noFrame) {
-              if (!this.baseTexture.valid) {
-                  return;
-              }
-              this._frame.width = baseTexture.width;
-              this._frame.height = baseTexture.height;
-              this.valid = true;
-              this.updateUvs();
-          }
-          else {
-              // TODO this code looks confusing.. boo to abusing getters and setters!
-              // if user gave us frame that has bigger size than resized texture it can be a problem
-              this.frame = this._frame;
-          }
-          this.emit('update', this);
-      };
-      /**
-       * Destroys this texture
-       * @param [destroyBase=false] - Whether to destroy the base texture as well
-       */
-      Texture.prototype.destroy = function (destroyBase) {
-          if (this.baseTexture) {
-              if (destroyBase) {
-                  var resource = this.baseTexture.resource;
-                  // delete the texture if it exists in the texture cache..
-                  // this only needs to be removed if the base texture is actually destroyed too..
-                  if (resource && resource.url && TextureCache[resource.url]) {
-                      Texture.removeFromCache(resource.url);
-                  }
-                  this.baseTexture.destroy();
-              }
-              this.baseTexture.off('loaded', this.onBaseTextureUpdated, this);
-              this.baseTexture.off('update', this.onBaseTextureUpdated, this);
-              this.baseTexture = null;
-          }
-          this._frame = null;
-          this._uvs = null;
-          this.trim = null;
-          this.orig = null;
-          this.valid = false;
-          Texture.removeFromCache(this);
-          this.textureCacheIds = null;
-      };
-      /**
-       * Creates a new texture object that acts the same as this one.
-       * @returns - The new texture
-       */
-      Texture.prototype.clone = function () {
-          var clonedFrame = this._frame.clone();
-          var clonedOrig = this._frame === this.orig ? clonedFrame : this.orig.clone();
-          var clonedTexture = new Texture(this.baseTexture, !this.noFrame && clonedFrame, clonedOrig, this.trim && this.trim.clone(), this.rotate, this.defaultAnchor);
-          if (this.noFrame) {
-              clonedTexture._frame = clonedFrame;
-          }
-          return clonedTexture;
-      };
-      /**
-       * Updates the internal WebGL UV cache. Use it after you change `frame` or `trim` of the texture.
-       * Call it after changing the frame
-       */
-      Texture.prototype.updateUvs = function () {
-          if (this._uvs === DEFAULT_UVS) {
-              this._uvs = new TextureUvs();
-          }
-          this._uvs.set(this._frame, this.baseTexture, this.rotate);
-          this._updateID++;
-      };
-      /**
-       * Helper function that creates a new Texture based on the source you provide.
-       * The source can be - frame id, image url, video url, canvas element, video element, base texture
-       * @param {string|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|PIXI.BaseTexture} source -
-       *        Source or array of sources to create texture from
-       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
-       * @param {string} [options.pixiIdPrefix=pixiid] - If a source has no id, this is the prefix of the generated id
-       * @param {boolean} [strict] - Enforce strict-mode, see {@link PIXI.settings.STRICT_TEXTURE_CACHE}.
-       * @returns {PIXI.Texture} The newly created texture
-       */
-      Texture.from = function (source, options, strict) {
-          if (options === void 0) { options = {}; }
-          if (strict === void 0) { strict = settings.STRICT_TEXTURE_CACHE; }
-          var isFrame = typeof source === 'string';
-          var cacheId = null;
-          if (isFrame) {
-              cacheId = source;
-          }
-          else if (source instanceof BaseTexture) {
-              if (!source.cacheId) {
-                  var prefix = (options && options.pixiIdPrefix) || 'pixiid';
-                  source.cacheId = prefix + "-" + uid();
-                  BaseTexture.addToCache(source, source.cacheId);
-              }
-              cacheId = source.cacheId;
-          }
-          else {
-              if (!source._pixiId) {
-                  var prefix = (options && options.pixiIdPrefix) || 'pixiid';
-                  source._pixiId = prefix + "_" + uid();
-              }
-              cacheId = source._pixiId;
-          }
-          var texture = TextureCache[cacheId];
-          // Strict-mode rejects invalid cacheIds
-          if (isFrame && strict && !texture) {
-              throw new Error("The cacheId \"" + cacheId + "\" does not exist in TextureCache.");
-          }
-          if (!texture && !(source instanceof BaseTexture)) {
-              if (!options.resolution) {
-                  options.resolution = getResolutionOfUrl(source);
-              }
-              texture = new Texture(new BaseTexture(source, options));
-              texture.baseTexture.cacheId = cacheId;
-              BaseTexture.addToCache(texture.baseTexture, cacheId);
-              Texture.addToCache(texture, cacheId);
-          }
-          else if (!texture && (source instanceof BaseTexture)) {
-              texture = new Texture(source);
-              Texture.addToCache(texture, cacheId);
-          }
-          // lets assume its a base texture!
-          return texture;
-      };
-      /**
-       * Useful for loading textures via URLs. Use instead of `Texture.from` because
-       * it does a better job of handling failed URLs more effectively. This also ignores
-       * `PIXI.settings.STRICT_TEXTURE_CACHE`. Works for Videos, SVGs, Images.
-       * @param url - The remote URL or array of URLs to load.
-       * @param options - Optional options to include
-       * @returns - A Promise that resolves to a Texture.
-       */
-      Texture.fromURL = function (url, options) {
-          var resourceOptions = Object.assign({ autoLoad: false }, options === null || options === void 0 ? void 0 : options.resourceOptions);
-          var texture = Texture.from(url, Object.assign({ resourceOptions: resourceOptions }, options), false);
-          var resource = texture.baseTexture.resource;
-          // The texture was already loaded
-          if (texture.baseTexture.valid) {
-              return Promise.resolve(texture);
-          }
-          // Manually load the texture, this should allow users to handle load errors
-          return resource.load().then(function () { return Promise.resolve(texture); });
-      };
-      /**
-       * Create a new Texture with a BufferResource from a Float32Array.
-       * RGBA values are floats from 0 to 1.
-       * @param {Float32Array|Uint8Array} buffer - The optional array to use, if no data
-       *        is provided, a new Float32Array is created.
-       * @param width - Width of the resource
-       * @param height - Height of the resource
-       * @param options - See {@link PIXI.BaseTexture}'s constructor for options.
-       * @returns - The resulting new BaseTexture
-       */
-      Texture.fromBuffer = function (buffer, width, height, options) {
-          return new Texture(BaseTexture.fromBuffer(buffer, width, height, options));
-      };
-      /**
-       * Create a texture from a source and add to the cache.
-       * @param {HTMLImageElement|HTMLCanvasElement|string} source - The input source.
-       * @param imageUrl - File name of texture, for cache and resolving resolution.
-       * @param name - Human readable name for the texture cache. If no name is
-       *        specified, only `imageUrl` will be used as the cache ID.
-       * @param options
-       * @returns - Output texture
-       */
-      Texture.fromLoader = function (source, imageUrl, name, options) {
-          var baseTexture = new BaseTexture(source, Object.assign({
-              scaleMode: settings.SCALE_MODE,
-              resolution: getResolutionOfUrl(imageUrl),
-          }, options));
-          var resource = baseTexture.resource;
-          if (resource instanceof ImageResource) {
-              resource.url = imageUrl;
-          }
-          var texture = new Texture(baseTexture);
-          // No name, use imageUrl instead
-          if (!name) {
-              name = imageUrl;
-          }
-          // lets also add the frame to pixi's global cache for 'fromLoader' function
-          BaseTexture.addToCache(texture.baseTexture, name);
-          Texture.addToCache(texture, name);
-          // also add references by url if they are different.
-          if (name !== imageUrl) {
-              BaseTexture.addToCache(texture.baseTexture, imageUrl);
-              Texture.addToCache(texture, imageUrl);
-          }
-          // Generally images are valid right away
-          if (texture.baseTexture.valid) {
-              return Promise.resolve(texture);
-          }
-          // SVG assets need to be parsed async, let's wait
-          return new Promise(function (resolve) {
-              texture.baseTexture.once('loaded', function () { return resolve(texture); });
-          });
-      };
-      /**
-       * Adds a Texture to the global TextureCache. This cache is shared across the whole PIXI object.
-       * @param texture - The Texture to add to the cache.
-       * @param id - The id that the Texture will be stored against.
-       */
-      Texture.addToCache = function (texture, id) {
-          if (id) {
-              if (texture.textureCacheIds.indexOf(id) === -1) {
-                  texture.textureCacheIds.push(id);
-              }
-              if (TextureCache[id]) {
-                  // eslint-disable-next-line no-console
-                  console.warn("Texture added to the cache with an id [" + id + "] that already had an entry");
-              }
-              TextureCache[id] = texture;
-          }
-      };
-      /**
-       * Remove a Texture from the global TextureCache.
-       * @param texture - id of a Texture to be removed, or a Texture instance itself
-       * @returns - The Texture that was removed
-       */
-      Texture.removeFromCache = function (texture) {
-          if (typeof texture === 'string') {
-              var textureFromCache = TextureCache[texture];
-              if (textureFromCache) {
-                  var index = textureFromCache.textureCacheIds.indexOf(texture);
-                  if (index > -1) {
-                      textureFromCache.textureCacheIds.splice(index, 1);
-                  }
-                  delete TextureCache[texture];
-                  return textureFromCache;
-              }
-          }
-          else if (texture && texture.textureCacheIds) {
-              for (var i = 0; i < texture.textureCacheIds.length; ++i) {
-                  // Check that texture matches the one being passed in before deleting it from the cache.
-                  if (TextureCache[texture.textureCacheIds[i]] === texture) {
-                      delete TextureCache[texture.textureCacheIds[i]];
-                  }
-              }
-              texture.textureCacheIds.length = 0;
-              return texture;
-          }
-          return null;
-      };
-      Object.defineProperty(Texture.prototype, "resolution", {
-          /**
-           * Returns resolution of baseTexture
-           * @readonly
-           */
-          get: function () {
-              return this.baseTexture.resolution;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Texture.prototype, "frame", {
-          /**
-           * The frame specifies the region of the base texture that this texture uses.
-           * Please call `updateUvs()` after you change coordinates of `frame` manually.
-           */
-          get: function () {
-              return this._frame;
-          },
-          set: function (frame) {
-              this._frame = frame;
-              this.noFrame = false;
-              var x = frame.x, y = frame.y, width = frame.width, height = frame.height;
-              var xNotFit = x + width > this.baseTexture.width;
-              var yNotFit = y + height > this.baseTexture.height;
-              if (xNotFit || yNotFit) {
-                  var relationship = xNotFit && yNotFit ? 'and' : 'or';
-                  var errorX = "X: " + x + " + " + width + " = " + (x + width) + " > " + this.baseTexture.width;
-                  var errorY = "Y: " + y + " + " + height + " = " + (y + height) + " > " + this.baseTexture.height;
-                  throw new Error('Texture Error: frame does not fit inside the base Texture dimensions: '
-                      + (errorX + " " + relationship + " " + errorY));
-              }
-              this.valid = width && height && this.baseTexture.valid;
-              if (!this.trim && !this.rotate) {
-                  this.orig = frame;
-              }
-              if (this.valid) {
-                  this.updateUvs();
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Texture.prototype, "rotate", {
-          /**
-           * Indicates whether the texture is rotated inside the atlas
-           * set to 2 to compensate for texture packer rotation
-           * set to 6 to compensate for spine packer rotation
-           * can be used to rotate or mirror sprites
-           * See {@link PIXI.groupD8} for explanation
-           */
-          get: function () {
-              return this._rotate;
-          },
-          set: function (rotate) {
-              this._rotate = rotate;
-              if (this.valid) {
-                  this.updateUvs();
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Texture.prototype, "width", {
-          /** The width of the Texture in pixels. */
-          get: function () {
-              return this.orig.width;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Texture.prototype, "height", {
-          /** The height of the Texture in pixels. */
-          get: function () {
-              return this.orig.height;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Utility function for BaseTexture|Texture cast. */
-      Texture.prototype.castToBaseTexture = function () {
-          return this.baseTexture;
-      };
-      Object.defineProperty(Texture, "EMPTY", {
-          /** An empty texture, used often to not have to create multiple empty textures. Can not be destroyed. */
-          get: function () {
-              if (!Texture._EMPTY) {
-                  Texture._EMPTY = new Texture(new BaseTexture());
-                  removeAllHandlers(Texture._EMPTY);
-                  removeAllHandlers(Texture._EMPTY.baseTexture);
-              }
-              return Texture._EMPTY;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Texture, "WHITE", {
-          /** A white texture of 16x16 size, used for graphics and other things Can not be destroyed. */
-          get: function () {
-              if (!Texture._WHITE) {
-                  var canvas = settings.ADAPTER.createCanvas(16, 16);
-                  var context = canvas.getContext('2d');
-                  canvas.width = 16;
-                  canvas.height = 16;
-                  context.fillStyle = 'white';
-                  context.fillRect(0, 0, 16, 16);
-                  Texture._WHITE = new Texture(BaseTexture.from(canvas));
-                  removeAllHandlers(Texture._WHITE);
-                  removeAllHandlers(Texture._WHITE.baseTexture);
-              }
-              return Texture._WHITE;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return Texture;
-  }(eventemitter3));
-
-  /**
-   * A RenderTexture is a special texture that allows any PixiJS display object to be rendered to it.
-   *
-   * __Hint__: All DisplayObjects (i.e. Sprites) that render to a RenderTexture should be preloaded
-   * otherwise black rectangles will be drawn instead.
-   *
-   * __Hint-2__: The actual memory allocation will happen on first render.
-   * You shouldn't create renderTextures each frame just to delete them after, try to reuse them.
-   *
-   * A RenderTexture takes a snapshot of any Display Object given to its render method. For example:
-   *
-   * ```js
-   * let renderer = PIXI.autoDetectRenderer();
-   * let renderTexture = PIXI.RenderTexture.create({ width: 800, height: 600 });
-   * let sprite = PIXI.Sprite.from("spinObj_01.png");
-   *
-   * sprite.position.x = 800/2;
-   * sprite.position.y = 600/2;
-   * sprite.anchor.x = 0.5;
-   * sprite.anchor.y = 0.5;
-   *
-   * renderer.render(sprite, {renderTexture});
-   * ```
-   * Note that you should not create a new renderer, but reuse the same one as the rest of the application.
-   *
-   * The Sprite in this case will be rendered using its local transform. To render this sprite at 0,0
-   * you can clear the transform
-   *
-   * ```js
-   *
-   * sprite.setTransform()
-   *
-   * let renderTexture = new PIXI.RenderTexture.create({ width: 100, height: 100 });
-   *
-   * renderer.render(sprite, {renderTexture});  // Renders to center of RenderTexture
-   * ```
-   * @memberof PIXI
-   */
-  var RenderTexture = /** @class */ (function (_super) {
-      __extends$i(RenderTexture, _super);
-      /**
-       * @param baseRenderTexture - The base texture object that this texture uses.
-       * @param frame - The rectangle frame of the texture to show.
-       */
-      function RenderTexture(baseRenderTexture, frame) {
-          var _this = _super.call(this, baseRenderTexture, frame) || this;
-          _this.valid = true;
-          _this.filterFrame = null;
-          _this.filterPoolKey = null;
-          _this.updateUvs();
-          return _this;
-      }
-      Object.defineProperty(RenderTexture.prototype, "framebuffer", {
-          /**
-           * Shortcut to `this.baseTexture.framebuffer`, saves baseTexture cast.
-           * @readonly
-           */
-          get: function () {
-              return this.baseTexture.framebuffer;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(RenderTexture.prototype, "multisample", {
-          /**
-           * Shortcut to `this.framebuffer.multisample`.
-           * @default PIXI.MSAA_QUALITY.NONE
-           */
-          get: function () {
-              return this.framebuffer.multisample;
-          },
-          set: function (value) {
-              this.framebuffer.multisample = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Resizes the RenderTexture.
-       * @param desiredWidth - The desired width to resize to.
-       * @param desiredHeight - The desired height to resize to.
-       * @param resizeBaseTexture - Should the baseTexture.width and height values be resized as well?
-       */
-      RenderTexture.prototype.resize = function (desiredWidth, desiredHeight, resizeBaseTexture) {
-          if (resizeBaseTexture === void 0) { resizeBaseTexture = true; }
-          var resolution = this.baseTexture.resolution;
-          var width = Math.round(desiredWidth * resolution) / resolution;
-          var height = Math.round(desiredHeight * resolution) / resolution;
-          // TODO - could be not required..
-          this.valid = (width > 0 && height > 0);
-          this._frame.width = this.orig.width = width;
-          this._frame.height = this.orig.height = height;
-          if (resizeBaseTexture) {
-              this.baseTexture.resize(width, height);
-          }
-          this.updateUvs();
-      };
-      /**
-       * Changes the resolution of baseTexture, but does not change framebuffer size.
-       * @param resolution - The new resolution to apply to RenderTexture
-       */
-      RenderTexture.prototype.setResolution = function (resolution) {
-          var baseTexture = this.baseTexture;
-          if (baseTexture.resolution === resolution) {
-              return;
-          }
-          baseTexture.setResolution(resolution);
-          this.resize(baseTexture.width, baseTexture.height, false);
-      };
-      RenderTexture.create = function (options) {
-          var arguments$1 = arguments;
-
-          var rest = [];
-          for (var _i = 1; _i < arguments.length; _i++) {
-              rest[_i - 1] = arguments$1[_i];
-          }
-          // @deprecated fallback, old-style: create(width, height, scaleMode, resolution)
-          if (typeof options === 'number') {
-              deprecation('6.0.0', 'Arguments (width, height, scaleMode, resolution) have been deprecated.');
-              /* eslint-disable prefer-rest-params */
-              options = {
-                  width: options,
-                  height: rest[0],
-                  scaleMode: rest[1],
-                  resolution: rest[2],
-              };
-              /* eslint-enable prefer-rest-params */
-          }
-          return new RenderTexture(new BaseRenderTexture(options));
-      };
-      return RenderTexture;
-  }(Texture));
-
-  /**
-   * Texture pool, used by FilterSystem and plugins.
-   *
-   * Stores collection of temporary pow2 or screen-sized renderTextures
-   *
-   * If you use custom RenderTexturePool for your filters, you can use methods
-   * `getFilterTexture` and `returnFilterTexture` same as in
-   * @memberof PIXI
-   */
-  var RenderTexturePool = /** @class */ (function () {
-      /**
-       * @param textureOptions - options that will be passed to BaseRenderTexture constructor
-       * @param {PIXI.SCALE_MODES} [textureOptions.scaleMode] - See {@link PIXI.SCALE_MODES} for possible values.
-       */
-      function RenderTexturePool(textureOptions) {
-          this.texturePool = {};
-          this.textureOptions = textureOptions || {};
-          this.enableFullScreen = false;
-          this._pixelsWidth = 0;
-          this._pixelsHeight = 0;
-      }
-      /**
-       * Creates texture with params that were specified in pool constructor.
-       * @param realWidth - Width of texture in pixels.
-       * @param realHeight - Height of texture in pixels.
-       * @param multisample - Number of samples of the framebuffer.
-       */
-      RenderTexturePool.prototype.createTexture = function (realWidth, realHeight, multisample) {
-          if (multisample === void 0) { multisample = exports.MSAA_QUALITY.NONE; }
-          var baseRenderTexture = new BaseRenderTexture(Object.assign({
-              width: realWidth,
-              height: realHeight,
-              resolution: 1,
-              multisample: multisample,
-          }, this.textureOptions));
-          return new RenderTexture(baseRenderTexture);
-      };
-      /**
-       * Gets a Power-of-Two render texture or fullScreen texture
-       * @param minWidth - The minimum width of the render texture.
-       * @param minHeight - The minimum height of the render texture.
-       * @param resolution - The resolution of the render texture.
-       * @param multisample - Number of samples of the render texture.
-       * @returns The new render texture.
-       */
-      RenderTexturePool.prototype.getOptimalTexture = function (minWidth, minHeight, resolution, multisample) {
-          if (resolution === void 0) { resolution = 1; }
-          if (multisample === void 0) { multisample = exports.MSAA_QUALITY.NONE; }
-          var key;
-          minWidth = Math.ceil((minWidth * resolution) - 1e-6);
-          minHeight = Math.ceil((minHeight * resolution) - 1e-6);
-          if (!this.enableFullScreen || minWidth !== this._pixelsWidth || minHeight !== this._pixelsHeight) {
-              minWidth = nextPow2(minWidth);
-              minHeight = nextPow2(minHeight);
-              key = (((minWidth & 0xFFFF) << 16) | (minHeight & 0xFFFF)) >>> 0;
-              if (multisample > 1) {
-                  key += multisample * 0x100000000;
-              }
-          }
-          else {
-              key = multisample > 1 ? -multisample : -1;
-          }
-          if (!this.texturePool[key]) {
-              this.texturePool[key] = [];
-          }
-          var renderTexture = this.texturePool[key].pop();
-          if (!renderTexture) {
-              renderTexture = this.createTexture(minWidth, minHeight, multisample);
-          }
-          renderTexture.filterPoolKey = key;
-          renderTexture.setResolution(resolution);
-          return renderTexture;
-      };
-      /**
-       * Gets extra texture of the same size as input renderTexture
-       *
-       * `getFilterTexture(input, 0.5)` or `getFilterTexture(0.5, input)`
-       * @param input - renderTexture from which size and resolution will be copied
-       * @param resolution - override resolution of the renderTexture
-       *  It overrides, it does not multiply
-       * @param multisample - number of samples of the renderTexture
-       */
-      RenderTexturePool.prototype.getFilterTexture = function (input, resolution, multisample) {
-          var filterTexture = this.getOptimalTexture(input.width, input.height, resolution || input.resolution, multisample || exports.MSAA_QUALITY.NONE);
-          filterTexture.filterFrame = input.filterFrame;
-          return filterTexture;
-      };
-      /**
-       * Place a render texture back into the pool.
-       * @param renderTexture - The renderTexture to free
-       */
-      RenderTexturePool.prototype.returnTexture = function (renderTexture) {
-          var key = renderTexture.filterPoolKey;
-          renderTexture.filterFrame = null;
-          this.texturePool[key].push(renderTexture);
-      };
-      /**
-       * Alias for returnTexture, to be compliant with FilterSystem interface.
-       * @param renderTexture - The renderTexture to free
-       */
-      RenderTexturePool.prototype.returnFilterTexture = function (renderTexture) {
-          this.returnTexture(renderTexture);
-      };
-      /**
-       * Clears the pool.
-       * @param destroyTextures - Destroy all stored textures.
-       */
-      RenderTexturePool.prototype.clear = function (destroyTextures) {
-          destroyTextures = destroyTextures !== false;
-          if (destroyTextures) {
-              for (var i in this.texturePool) {
-                  var textures = this.texturePool[i];
-                  if (textures) {
-                      for (var j = 0; j < textures.length; j++) {
-                          textures[j].destroy(true);
-                      }
-                  }
-              }
-          }
-          this.texturePool = {};
-      };
-      /**
-       * If screen size was changed, drops all screen-sized textures,
-       * sets new screen size, sets `enableFullScreen` to true
-       *
-       * Size is measured in pixels, `renderer.view` can be passed here, not `renderer.screen`
-       * @param size - Initial size of screen.
-       */
-      RenderTexturePool.prototype.setScreenSize = function (size) {
-          if (size.width === this._pixelsWidth
-              && size.height === this._pixelsHeight) {
-              return;
-          }
-          this.enableFullScreen = size.width > 0 && size.height > 0;
-          for (var i in this.texturePool) {
-              if (!(Number(i) < 0)) {
-                  continue;
-              }
-              var textures = this.texturePool[i];
-              if (textures) {
-                  for (var j = 0; j < textures.length; j++) {
-                      textures[j].destroy(true);
-                  }
-              }
-              this.texturePool[i] = [];
-          }
-          this._pixelsWidth = size.width;
-          this._pixelsHeight = size.height;
-      };
-      /**
-       * Key that is used to store fullscreen renderTextures in a pool
-       * @constant
-       */
-      RenderTexturePool.SCREEN_KEY = -1;
-      return RenderTexturePool;
-  }());
-
-  /* eslint-disable max-len */
-  /**
-   * Holds the information for a single attribute structure required to render geometry.
-   *
-   * This does not contain the actual data, but instead has a buffer id that maps to a {@link PIXI.Buffer}
-   * This can include anything from positions, uvs, normals, colors etc.
-   * @memberof PIXI
-   */
-  var Attribute = /** @class */ (function () {
-      /**
-       * @param buffer - the id of the buffer that this attribute will look for
-       * @param size - the size of the attribute. If you have 2 floats per vertex (eg position x and y) this would be 2.
-       * @param normalized - should the data be normalized.
-       * @param {PIXI.TYPES} [type=PIXI.TYPES.FLOAT] - what type of number is the attribute. Check {@link PIXI.TYPES} to see the ones available
-       * @param [stride=0] - How far apart, in bytes, the start of each value is. (used for interleaving data)
-       * @param [start=0] - How far into the array to start reading values (used for interleaving data)
-       * @param [instance=false] - Whether the geometry is instanced.
-       */
-      function Attribute(buffer, size, normalized, type, stride, start, instance) {
-          if (size === void 0) { size = 0; }
-          if (normalized === void 0) { normalized = false; }
-          if (type === void 0) { type = exports.TYPES.FLOAT; }
-          this.buffer = buffer;
-          this.size = size;
-          this.normalized = normalized;
-          this.type = type;
-          this.stride = stride;
-          this.start = start;
-          this.instance = instance;
-      }
-      /** Destroys the Attribute. */
-      Attribute.prototype.destroy = function () {
-          this.buffer = null;
-      };
-      /**
-       * Helper function that creates an Attribute based on the information provided
-       * @param buffer - the id of the buffer that this attribute will look for
-       * @param [size=0] - the size of the attribute. If you have 2 floats per vertex (eg position x and y) this would be 2
-       * @param [normalized=false] - should the data be normalized.
-       * @param [type=PIXI.TYPES.FLOAT] - what type of number is the attribute. Check {@link PIXI.TYPES} to see the ones available
-       * @param [stride=0] - How far apart, in bytes, the start of each value is. (used for interleaving data)
-       * @returns - A new {@link PIXI.Attribute} based on the information provided
-       */
-      Attribute.from = function (buffer, size, normalized, type, stride) {
-          return new Attribute(buffer, size, normalized, type, stride);
-      };
-      return Attribute;
-  }());
-
-  var UID$4 = 0;
-  /**
-   * A wrapper for data so that it can be used and uploaded by WebGL
-   * @memberof PIXI
-   */
-  var Buffer = /** @class */ (function () {
-      /**
-       * @param {PIXI.IArrayBuffer} data - the data to store in the buffer.
-       * @param _static - `true` for static buffer
-       * @param index - `true` for index buffer
-       */
-      function Buffer(data, _static, index) {
-          if (_static === void 0) { _static = true; }
-          if (index === void 0) { index = false; }
-          this.data = (data || new Float32Array(1));
-          this._glBuffers = {};
-          this._updateID = 0;
-          this.index = index;
-          this.static = _static;
-          this.id = UID$4++;
-          this.disposeRunner = new Runner('disposeBuffer');
-      }
-      // TODO could explore flagging only a partial upload?
-      /**
-       * Flags this buffer as requiring an upload to the GPU.
-       * @param {PIXI.IArrayBuffer|number[]} [data] - the data to update in the buffer.
-       */
-      Buffer.prototype.update = function (data) {
-          if (data instanceof Array) {
-              data = new Float32Array(data);
-          }
-          this.data = data || this.data;
-          this._updateID++;
-      };
-      /** Disposes WebGL resources that are connected to this geometry. */
-      Buffer.prototype.dispose = function () {
-          this.disposeRunner.emit(this, false);
-      };
-      /** Destroys the buffer. */
-      Buffer.prototype.destroy = function () {
-          this.dispose();
-          this.data = null;
-      };
-      Object.defineProperty(Buffer.prototype, "index", {
-          get: function () {
-              return this.type === exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
-          },
-          /**
-           * Flags whether this is an index buffer.
-           *
-           * Index buffers are of type `ELEMENT_ARRAY_BUFFER`. Note that setting this property to false will make
-           * the buffer of type `ARRAY_BUFFER`.
-           *
-           * For backwards compatibility.
-           */
-          set: function (value) {
-              this.type = value ? exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER : exports.BUFFER_TYPE.ARRAY_BUFFER;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Helper function that creates a buffer based on an array or TypedArray
-       * @param {ArrayBufferView | number[]} data - the TypedArray that the buffer will store. If this is a regular Array it will be converted to a Float32Array.
-       * @returns - A new Buffer based on the data provided.
-       */
-      Buffer.from = function (data) {
-          if (data instanceof Array) {
-              data = new Float32Array(data);
-          }
-          return new Buffer(data);
-      };
-      return Buffer;
-  }());
-
-  /* eslint-disable object-shorthand */
-  var map$1 = {
-      Float32Array: Float32Array,
-      Uint32Array: Uint32Array,
-      Int32Array: Int32Array,
-      Uint8Array: Uint8Array,
-  };
-  function interleaveTypedArrays(arrays, sizes) {
-      var outSize = 0;
-      var stride = 0;
-      var views = {};
-      for (var i = 0; i < arrays.length; i++) {
-          stride += sizes[i];
-          outSize += arrays[i].length;
-      }
-      var buffer = new ArrayBuffer(outSize * 4);
-      var out = null;
-      var littleOffset = 0;
-      for (var i = 0; i < arrays.length; i++) {
-          var size = sizes[i];
-          var array = arrays[i];
-          var type = getBufferType(array);
-          if (!views[type]) {
-              views[type] = new map$1[type](buffer);
-          }
-          out = views[type];
-          for (var j = 0; j < array.length; j++) {
-              var indexStart = ((j / size | 0) * stride) + littleOffset;
-              var index = j % size;
-              out[indexStart + index] = array[j];
-          }
-          littleOffset += size;
-      }
-      return new Float32Array(buffer);
-  }
-
-  var byteSizeMap$1 = { 5126: 4, 5123: 2, 5121: 1 };
-  var UID$3 = 0;
-  /* eslint-disable object-shorthand */
-  var map = {
-      Float32Array: Float32Array,
-      Uint32Array: Uint32Array,
-      Int32Array: Int32Array,
-      Uint8Array: Uint8Array,
-      Uint16Array: Uint16Array,
-  };
-  /* eslint-disable max-len */
-  /**
-   * The Geometry represents a model. It consists of two components:
-   * - GeometryStyle - The structure of the model such as the attributes layout
-   * - GeometryData - the data of the model - this consists of buffers.
-   * This can include anything from positions, uvs, normals, colors etc.
-   *
-   * Geometry can be defined without passing in a style or data if required (thats how I prefer!)
-   *
-   * ```js
-   * let geometry = new PIXI.Geometry();
-   *
-   * geometry.addAttribute('positions', [0, 0, 100, 0, 100, 100, 0, 100], 2);
-   * geometry.addAttribute('uvs', [0,0,1,0,1,1,0,1],2)
-   * geometry.addIndex([0,1,2,1,3,2])
-   * ```
-   * @memberof PIXI
-   */
-  var Geometry = /** @class */ (function () {
-      /**
-       * @param buffers - An array of buffers. optional.
-       * @param attributes - Of the geometry, optional structure of the attributes layout
-       */
-      function Geometry(buffers, attributes) {
-          if (buffers === void 0) { buffers = []; }
-          if (attributes === void 0) { attributes = {}; }
-          this.buffers = buffers;
-          this.indexBuffer = null;
-          this.attributes = attributes;
-          this.glVertexArrayObjects = {};
-          this.id = UID$3++;
-          this.instanced = false;
-          this.instanceCount = 1;
-          this.disposeRunner = new Runner('disposeGeometry');
-          this.refCount = 0;
-      }
-      /**
-       *
-       * Adds an attribute to the geometry
-       * Note: `stride` and `start` should be `undefined` if you dont know them, not 0!
-       * @param id - the name of the attribute (matching up to a shader)
-       * @param {PIXI.Buffer|number[]} buffer - the buffer that holds the data of the attribute . You can also provide an Array and a buffer will be created from it.
-       * @param size - the size of the attribute. If you have 2 floats per vertex (eg position x and y) this would be 2
-       * @param normalized - should the data be normalized.
-       * @param [type=PIXI.TYPES.FLOAT] - what type of number is the attribute. Check {PIXI.TYPES} to see the ones available
-       * @param [stride=0] - How far apart, in bytes, the start of each value is. (used for interleaving data)
-       * @param [start=0] - How far into the array to start reading values (used for interleaving data)
-       * @param instance - Instancing flag
-       * @returns - Returns self, useful for chaining.
-       */
-      Geometry.prototype.addAttribute = function (id, buffer, size, normalized, type, stride, start, instance) {
-          if (size === void 0) { size = 0; }
-          if (normalized === void 0) { normalized = false; }
-          if (instance === void 0) { instance = false; }
-          if (!buffer) {
-              throw new Error('You must pass a buffer when creating an attribute');
-          }
-          // check if this is a buffer!
-          if (!(buffer instanceof Buffer)) {
-              // its an array!
-              if (buffer instanceof Array) {
-                  buffer = new Float32Array(buffer);
-              }
-              buffer = new Buffer(buffer);
-          }
-          var ids = id.split('|');
-          if (ids.length > 1) {
-              for (var i = 0; i < ids.length; i++) {
-                  this.addAttribute(ids[i], buffer, size, normalized, type);
-              }
-              return this;
-          }
-          var bufferIndex = this.buffers.indexOf(buffer);
-          if (bufferIndex === -1) {
-              this.buffers.push(buffer);
-              bufferIndex = this.buffers.length - 1;
-          }
-          this.attributes[id] = new Attribute(bufferIndex, size, normalized, type, stride, start, instance);
-          // assuming that if there is instanced data then this will be drawn with instancing!
-          this.instanced = this.instanced || instance;
-          return this;
-      };
-      /**
-       * Returns the requested attribute.
-       * @param id - The name of the attribute required
-       * @returns - The attribute requested.
-       */
-      Geometry.prototype.getAttribute = function (id) {
-          return this.attributes[id];
-      };
-      /**
-       * Returns the requested buffer.
-       * @param id - The name of the buffer required.
-       * @returns - The buffer requested.
-       */
-      Geometry.prototype.getBuffer = function (id) {
-          return this.buffers[this.getAttribute(id).buffer];
-      };
-      /**
-       *
-       * Adds an index buffer to the geometry
-       * The index buffer contains integers, three for each triangle in the geometry, which reference the various attribute buffers (position, colour, UV coordinates, other UV coordinates, normal, …). There is only ONE index buffer.
-       * @param {PIXI.Buffer|number[]} [buffer] - The buffer that holds the data of the index buffer. You can also provide an Array and a buffer will be created from it.
-       * @returns - Returns self, useful for chaining.
-       */
-      Geometry.prototype.addIndex = function (buffer) {
-          if (!(buffer instanceof Buffer)) {
-              // its an array!
-              if (buffer instanceof Array) {
-                  buffer = new Uint16Array(buffer);
-              }
-              buffer = new Buffer(buffer);
-          }
-          buffer.type = exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
-          this.indexBuffer = buffer;
-          if (this.buffers.indexOf(buffer) === -1) {
-              this.buffers.push(buffer);
-          }
-          return this;
-      };
-      /**
-       * Returns the index buffer
-       * @returns - The index buffer.
-       */
-      Geometry.prototype.getIndex = function () {
-          return this.indexBuffer;
-      };
-      /**
-       * This function modifies the structure so that all current attributes become interleaved into a single buffer
-       * This can be useful if your model remains static as it offers a little performance boost
-       * @returns - Returns self, useful for chaining.
-       */
-      Geometry.prototype.interleave = function () {
-          // a simple check to see if buffers are already interleaved..
-          if (this.buffers.length === 1 || (this.buffers.length === 2 && this.indexBuffer))
-              { return this; }
-          // assume already that no buffers are interleaved
-          var arrays = [];
-          var sizes = [];
-          var interleavedBuffer = new Buffer();
-          var i;
-          for (i in this.attributes) {
-              var attribute = this.attributes[i];
-              var buffer = this.buffers[attribute.buffer];
-              arrays.push(buffer.data);
-              sizes.push((attribute.size * byteSizeMap$1[attribute.type]) / 4);
-              attribute.buffer = 0;
-          }
-          interleavedBuffer.data = interleaveTypedArrays(arrays, sizes);
-          for (i = 0; i < this.buffers.length; i++) {
-              if (this.buffers[i] !== this.indexBuffer) {
-                  this.buffers[i].destroy();
-              }
-          }
-          this.buffers = [interleavedBuffer];
-          if (this.indexBuffer) {
-              this.buffers.push(this.indexBuffer);
-          }
-          return this;
-      };
-      /** Get the size of the geometries, in vertices. */
-      Geometry.prototype.getSize = function () {
-          for (var i in this.attributes) {
-              var attribute = this.attributes[i];
-              var buffer = this.buffers[attribute.buffer];
-              return buffer.data.length / ((attribute.stride / 4) || attribute.size);
-          }
-          return 0;
-      };
-      /** Disposes WebGL resources that are connected to this geometry. */
-      Geometry.prototype.dispose = function () {
-          this.disposeRunner.emit(this, false);
-      };
-      /** Destroys the geometry. */
-      Geometry.prototype.destroy = function () {
-          this.dispose();
-          this.buffers = null;
-          this.indexBuffer = null;
-          this.attributes = null;
-      };
-      /**
-       * Returns a clone of the geometry.
-       * @returns - A new clone of this geometry.
-       */
-      Geometry.prototype.clone = function () {
-          var geometry = new Geometry();
-          for (var i = 0; i < this.buffers.length; i++) {
-              geometry.buffers[i] = new Buffer(this.buffers[i].data.slice(0));
-          }
-          for (var i in this.attributes) {
-              var attrib = this.attributes[i];
-              geometry.attributes[i] = new Attribute(attrib.buffer, attrib.size, attrib.normalized, attrib.type, attrib.stride, attrib.start, attrib.instance);
-          }
-          if (this.indexBuffer) {
-              geometry.indexBuffer = geometry.buffers[this.buffers.indexOf(this.indexBuffer)];
-              geometry.indexBuffer.type = exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
-          }
-          return geometry;
-      };
-      /**
-       * Merges an array of geometries into a new single one.
-       *
-       * Geometry attribute styles must match for this operation to work.
-       * @param geometries - array of geometries to merge
-       * @returns - Shiny new geometry!
-       */
-      Geometry.merge = function (geometries) {
-          // todo add a geometry check!
-          // also a size check.. cant be too big!]
-          var geometryOut = new Geometry();
-          var arrays = [];
-          var sizes = [];
-          var offsets = [];
-          var geometry;
-          // pass one.. get sizes..
-          for (var i = 0; i < geometries.length; i++) {
-              geometry = geometries[i];
-              for (var j = 0; j < geometry.buffers.length; j++) {
-                  sizes[j] = sizes[j] || 0;
-                  sizes[j] += geometry.buffers[j].data.length;
-                  offsets[j] = 0;
-              }
-          }
-          // build the correct size arrays..
-          for (var i = 0; i < geometry.buffers.length; i++) {
-              // TODO types!
-              arrays[i] = new map[getBufferType(geometry.buffers[i].data)](sizes[i]);
-              geometryOut.buffers[i] = new Buffer(arrays[i]);
-          }
-          // pass to set data..
-          for (var i = 0; i < geometries.length; i++) {
-              geometry = geometries[i];
-              for (var j = 0; j < geometry.buffers.length; j++) {
-                  arrays[j].set(geometry.buffers[j].data, offsets[j]);
-                  offsets[j] += geometry.buffers[j].data.length;
-              }
-          }
-          geometryOut.attributes = geometry.attributes;
-          if (geometry.indexBuffer) {
-              geometryOut.indexBuffer = geometryOut.buffers[geometry.buffers.indexOf(geometry.indexBuffer)];
-              geometryOut.indexBuffer.type = exports.BUFFER_TYPE.ELEMENT_ARRAY_BUFFER;
-              var offset = 0;
-              var stride = 0;
-              var offset2 = 0;
-              var bufferIndexToCount = 0;
-              // get a buffer
-              for (var i = 0; i < geometry.buffers.length; i++) {
-                  if (geometry.buffers[i] !== geometry.indexBuffer) {
-                      bufferIndexToCount = i;
-                      break;
-                  }
-              }
-              // figure out the stride of one buffer..
-              for (var i in geometry.attributes) {
-                  var attribute = geometry.attributes[i];
-                  if ((attribute.buffer | 0) === bufferIndexToCount) {
-                      stride += ((attribute.size * byteSizeMap$1[attribute.type]) / 4);
-                  }
-              }
-              // time to off set all indexes..
-              for (var i = 0; i < geometries.length; i++) {
-                  var indexBufferData = geometries[i].indexBuffer.data;
-                  for (var j = 0; j < indexBufferData.length; j++) {
-                      geometryOut.indexBuffer.data[j + offset2] += offset;
-                  }
-                  offset += geometries[i].buffers[bufferIndexToCount].data.length / (stride);
-                  offset2 += indexBufferData.length;
-              }
-          }
-          return geometryOut;
-      };
-      return Geometry;
-  }());
-
-  /**
-   * Helper class to create a quad
-   * @memberof PIXI
-   */
-  var Quad = /** @class */ (function (_super) {
-      __extends$i(Quad, _super);
-      function Quad() {
-          var _this = _super.call(this) || this;
-          _this.addAttribute('aVertexPosition', new Float32Array([
-              0, 0,
-              1, 0,
-              1, 1,
-              0, 1 ]))
-              .addIndex([0, 1, 3, 2]);
-          return _this;
-      }
-      return Quad;
-  }(Geometry));
-
-  /**
-   * Helper class to create a quad with uvs like in v4
-   * @memberof PIXI
-   */
-  var QuadUv = /** @class */ (function (_super) {
-      __extends$i(QuadUv, _super);
-      function QuadUv() {
-          var _this = _super.call(this) || this;
-          _this.vertices = new Float32Array([
-              -1, -1,
-              1, -1,
-              1, 1,
-              -1, 1 ]);
-          _this.uvs = new Float32Array([
-              0, 0,
-              1, 0,
-              1, 1,
-              0, 1 ]);
-          _this.vertexBuffer = new Buffer(_this.vertices);
-          _this.uvBuffer = new Buffer(_this.uvs);
-          _this.addAttribute('aVertexPosition', _this.vertexBuffer)
-              .addAttribute('aTextureCoord', _this.uvBuffer)
-              .addIndex([0, 1, 2, 0, 2, 3]);
-          return _this;
-      }
-      /**
-       * Maps two Rectangle to the quad.
-       * @param targetTextureFrame - The first rectangle
-       * @param destinationFrame - The second rectangle
-       * @returns - Returns itself.
-       */
-      QuadUv.prototype.map = function (targetTextureFrame, destinationFrame) {
-          var x = 0; // destinationFrame.x / targetTextureFrame.width;
-          var y = 0; // destinationFrame.y / targetTextureFrame.height;
-          this.uvs[0] = x;
-          this.uvs[1] = y;
-          this.uvs[2] = x + (destinationFrame.width / targetTextureFrame.width);
-          this.uvs[3] = y;
-          this.uvs[4] = x + (destinationFrame.width / targetTextureFrame.width);
-          this.uvs[5] = y + (destinationFrame.height / targetTextureFrame.height);
-          this.uvs[6] = x;
-          this.uvs[7] = y + (destinationFrame.height / targetTextureFrame.height);
-          x = destinationFrame.x;
-          y = destinationFrame.y;
-          this.vertices[0] = x;
-          this.vertices[1] = y;
-          this.vertices[2] = x + destinationFrame.width;
-          this.vertices[3] = y;
-          this.vertices[4] = x + destinationFrame.width;
-          this.vertices[5] = y + destinationFrame.height;
-          this.vertices[6] = x;
-          this.vertices[7] = y + destinationFrame.height;
-          this.invalidate();
-          return this;
-      };
-      /**
-       * Legacy upload method, just marks buffers dirty.
-       * @returns - Returns itself.
-       */
-      QuadUv.prototype.invalidate = function () {
-          this.vertexBuffer._updateID++;
-          this.uvBuffer._updateID++;
-          return this;
-      };
-      return QuadUv;
-  }(Geometry));
-
-  var UID$2 = 0;
-  /**
-   * Uniform group holds uniform map and some ID's for work
-   *
-   * `UniformGroup` has two modes:
-   *
-   * 1: Normal mode
-   * Normal mode will upload the uniforms with individual function calls as required
-   *
-   * 2: Uniform buffer mode
-   * This mode will treat the uniforms as a uniform buffer. You can pass in either a buffer that you manually handle, or
-   * or a generic object that PixiJS will automatically map to a buffer for you.
-   * For maximum benefits, make Ubo UniformGroups static, and only update them each frame.
-   *
-   * Rules of UBOs:
-   * - UBOs only work with WebGL2, so make sure you have a fallback!
-   * - Only floats are supported (including vec[2,3,4], mat[2,3,4])
-   * - Samplers cannot be used in ubo's (a GPU limitation)
-   * - You must ensure that the object you pass in exactly matches in the shader ubo structure.
-   * Otherwise, weirdness will ensue!
-   * - The name of the ubo object added to the group must match exactly the name of the ubo in the shader.
-   *
-   * ```
-   * // ubo in shader:
-   * uniform myCoolData { // declaring a ubo..
-   * mat4 uCoolMatrix;
-   * float uFloatyMcFloatFace
-   *
-   *
-   * // a new uniform buffer object..
-   * const myCoolData = new UniformBufferGroup({
-   *   uCoolMatrix: new Matrix(),
-   *   uFloatyMcFloatFace: 23,
-   * }}
-   *
-   * // build a shader...
-   * const shader = Shader.from(srcVert, srcFrag, {
-   *   myCoolData // name matches the ubo name in the shader. will be processed accordingly.
-   * })
-   *
-   *  ```
-   * @memberof PIXI
-   */
-  var UniformGroup = /** @class */ (function () {
-      /**
-       * @param {object | Buffer} [uniforms] - Custom uniforms to use to augment the built-in ones. Or a pixi buffer.
-       * @param isStatic - Uniforms wont be changed after creation.
-       * @param isUbo - If true, will treat this uniform group as a uniform buffer object.
-       */
-      function UniformGroup(uniforms, isStatic, isUbo) {
-          this.group = true;
-          // lets generate this when the shader ?
-          this.syncUniforms = {};
-          this.dirtyId = 0;
-          this.id = UID$2++;
-          this.static = !!isStatic;
-          this.ubo = !!isUbo;
-          if (uniforms instanceof Buffer) {
-              this.buffer = uniforms;
-              this.buffer.type = exports.BUFFER_TYPE.UNIFORM_BUFFER;
-              this.autoManage = false;
-              this.ubo = true;
-          }
-          else {
-              this.uniforms = uniforms;
-              if (this.ubo) {
-                  this.buffer = new Buffer(new Float32Array(1));
-                  this.buffer.type = exports.BUFFER_TYPE.UNIFORM_BUFFER;
-                  this.autoManage = true;
-              }
-          }
-      }
-      UniformGroup.prototype.update = function () {
-          this.dirtyId++;
-          if (!this.autoManage && this.buffer) {
-              this.buffer.update();
-          }
-      };
-      UniformGroup.prototype.add = function (name, uniforms, _static) {
-          if (!this.ubo) {
-              this.uniforms[name] = new UniformGroup(uniforms, _static);
-          }
-          else {
-              // eslint-disable-next-line max-len
-              throw new Error('[UniformGroup] uniform groups in ubo mode cannot be modified, or have uniform groups nested in them');
-          }
-      };
-      UniformGroup.from = function (uniforms, _static, _ubo) {
-          return new UniformGroup(uniforms, _static, _ubo);
-      };
-      /**
-       * A short hand function for creating a static UBO UniformGroup.
-       * @param uniforms - the ubo item
-       * @param _static - should this be updated each time it is used? defaults to true here!
-       */
-      UniformGroup.uboFrom = function (uniforms, _static) {
-          return new UniformGroup(uniforms, _static !== null && _static !== void 0 ? _static : true, true);
-      };
-      return UniformGroup;
-  }());
-
-  /**
-   * System plugin to the renderer to manage filter states.
-   * @ignore
-   */
-  var FilterState = /** @class */ (function () {
-      function FilterState() {
-          this.renderTexture = null;
-          this.target = null;
-          this.legacy = false;
-          this.resolution = 1;
-          this.multisample = exports.MSAA_QUALITY.NONE;
-          // next three fields are created only for root
-          // re-assigned for everything else
-          this.sourceFrame = new Rectangle();
-          this.destinationFrame = new Rectangle();
-          this.bindingSourceFrame = new Rectangle();
-          this.bindingDestinationFrame = new Rectangle();
-          this.filters = [];
-          this.transform = null;
-      }
-      /** Clears the state */
-      FilterState.prototype.clear = function () {
-          this.target = null;
-          this.filters = null;
-          this.renderTexture = null;
-      };
-      return FilterState;
-  }());
-
-  var tempPoints = [new Point(), new Point(), new Point(), new Point()];
-  var tempMatrix$2 = new Matrix();
-  /**
-   * System plugin to the renderer to manage filters.
-   *
-   * ## Pipeline
-   *
-   * The FilterSystem executes the filtering pipeline by rendering the display-object into a texture, applying its
-   * [filters]{@link PIXI.Filter} in series, and the last filter outputs into the final render-target.
-   *
-   * The filter-frame is the rectangle in world space being filtered, and those contents are mapped into
-   * `(0, 0, filterFrame.width, filterFrame.height)` into the filter render-texture. The filter-frame is also called
-   * the source-frame, as it is used to bind the filter render-textures. The last filter outputs to the `filterFrame`
-   * in the final render-target.
-   *
-   * ## Usage
-   *
-   * {@link PIXI.Container#renderAdvanced} is an example of how to use the filter system. It is a 3 step process:
-   *
-   * **push**: Use {@link PIXI.FilterSystem#push} to push the set of filters to be applied on a filter-target.
-   * **render**: Render the contents to be filtered using the renderer. The filter-system will only capture the contents
-   *      inside the bounds of the filter-target. NOTE: Using {@link PIXI.Renderer#render} is
-   *      illegal during an existing render cycle, and it may reset the filter system.
-   * **pop**: Use {@link PIXI.FilterSystem#pop} to pop & execute the filters you initially pushed. It will apply them
-   *      serially and output to the bounds of the filter-target.
-   * @memberof PIXI
-   */
-  var FilterSystem = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this System works for.
-       */
-      function FilterSystem(renderer) {
-          this.renderer = renderer;
-          this.defaultFilterStack = [{}];
-          this.texturePool = new RenderTexturePool();
-          this.texturePool.setScreenSize(renderer.view);
-          this.statePool = [];
-          this.quad = new Quad();
-          this.quadUv = new QuadUv();
-          this.tempRect = new Rectangle();
-          this.activeState = {};
-          this.globalUniforms = new UniformGroup({
-              outputFrame: new Rectangle(),
-              inputSize: new Float32Array(4),
-              inputPixel: new Float32Array(4),
-              inputClamp: new Float32Array(4),
-              resolution: 1,
-              // legacy variables
-              filterArea: new Float32Array(4),
-              filterClamp: new Float32Array(4),
-          }, true);
-          this.forceClear = false;
-          this.useMaxPadding = false;
-      }
-      /**
-       * Pushes a set of filters to be applied later to the system. This will redirect further rendering into an
-       * input render-texture for the rest of the filtering pipeline.
-       * @param {PIXI.DisplayObject} target - The target of the filter to render.
-       * @param filters - The filters to apply.
-       */
-      FilterSystem.prototype.push = function (target, filters) {
-          var _a, _b;
-          var renderer = this.renderer;
-          var filterStack = this.defaultFilterStack;
-          var state = this.statePool.pop() || new FilterState();
-          var renderTextureSystem = this.renderer.renderTexture;
-          var resolution = filters[0].resolution;
-          var multisample = filters[0].multisample;
-          var padding = filters[0].padding;
-          var autoFit = filters[0].autoFit;
-          // We don't know whether it's a legacy filter until it was bound for the first time,
-          // therefore we have to assume that it is if legacy is undefined.
-          var legacy = (_a = filters[0].legacy) !== null && _a !== void 0 ? _a : true;
-          for (var i = 1; i < filters.length; i++) {
-              var filter = filters[i];
-              // let's use the lowest resolution
-              resolution = Math.min(resolution, filter.resolution);
-              // let's use the lowest number of samples
-              multisample = Math.min(multisample, filter.multisample);
-              // figure out the padding required for filters
-              padding = this.useMaxPadding
-                  // old behavior: use largest amount of padding!
-                  ? Math.max(padding, filter.padding)
-                  // new behavior: sum the padding
-                  : padding + filter.padding;
-              // only auto fit if all filters are autofit
-              autoFit = autoFit && filter.autoFit;
-              legacy = legacy || ((_b = filter.legacy) !== null && _b !== void 0 ? _b : true);
-          }
-          if (filterStack.length === 1) {
-              this.defaultFilterStack[0].renderTexture = renderTextureSystem.current;
-          }
-          filterStack.push(state);
-          state.resolution = resolution;
-          state.multisample = multisample;
-          state.legacy = legacy;
-          state.target = target;
-          state.sourceFrame.copyFrom(target.filterArea || target.getBounds(true));
-          state.sourceFrame.pad(padding);
-          var sourceFrameProjected = this.tempRect.copyFrom(renderTextureSystem.sourceFrame);
-          // Project source frame into world space (if projection is applied)
-          if (renderer.projection.transform) {
-              this.transformAABB(tempMatrix$2.copyFrom(renderer.projection.transform).invert(), sourceFrameProjected);
-          }
-          if (autoFit) {
-              state.sourceFrame.fit(sourceFrameProjected);
-              if (state.sourceFrame.width <= 0 || state.sourceFrame.height <= 0) {
-                  state.sourceFrame.width = 0;
-                  state.sourceFrame.height = 0;
-              }
-          }
-          else if (!state.sourceFrame.intersects(sourceFrameProjected)) {
-              state.sourceFrame.width = 0;
-              state.sourceFrame.height = 0;
-          }
-          // Round sourceFrame in screen space based on render-texture.
-          this.roundFrame(state.sourceFrame, renderTextureSystem.current ? renderTextureSystem.current.resolution : renderer.resolution, renderTextureSystem.sourceFrame, renderTextureSystem.destinationFrame, renderer.projection.transform);
-          state.renderTexture = this.getOptimalFilterTexture(state.sourceFrame.width, state.sourceFrame.height, resolution, multisample);
-          state.filters = filters;
-          state.destinationFrame.width = state.renderTexture.width;
-          state.destinationFrame.height = state.renderTexture.height;
-          var destinationFrame = this.tempRect;
-          destinationFrame.x = 0;
-          destinationFrame.y = 0;
-          destinationFrame.width = state.sourceFrame.width;
-          destinationFrame.height = state.sourceFrame.height;
-          state.renderTexture.filterFrame = state.sourceFrame;
-          state.bindingSourceFrame.copyFrom(renderTextureSystem.sourceFrame);
-          state.bindingDestinationFrame.copyFrom(renderTextureSystem.destinationFrame);
-          state.transform = renderer.projection.transform;
-          renderer.projection.transform = null;
-          renderTextureSystem.bind(state.renderTexture, state.sourceFrame, destinationFrame);
-          renderer.framebuffer.clear(0, 0, 0, 0);
-      };
-      /** Pops off the filter and applies it. */
-      FilterSystem.prototype.pop = function () {
-          var filterStack = this.defaultFilterStack;
-          var state = filterStack.pop();
-          var filters = state.filters;
-          this.activeState = state;
-          var globalUniforms = this.globalUniforms.uniforms;
-          globalUniforms.outputFrame = state.sourceFrame;
-          globalUniforms.resolution = state.resolution;
-          var inputSize = globalUniforms.inputSize;
-          var inputPixel = globalUniforms.inputPixel;
-          var inputClamp = globalUniforms.inputClamp;
-          inputSize[0] = state.destinationFrame.width;
-          inputSize[1] = state.destinationFrame.height;
-          inputSize[2] = 1.0 / inputSize[0];
-          inputSize[3] = 1.0 / inputSize[1];
-          inputPixel[0] = Math.round(inputSize[0] * state.resolution);
-          inputPixel[1] = Math.round(inputSize[1] * state.resolution);
-          inputPixel[2] = 1.0 / inputPixel[0];
-          inputPixel[3] = 1.0 / inputPixel[1];
-          inputClamp[0] = 0.5 * inputPixel[2];
-          inputClamp[1] = 0.5 * inputPixel[3];
-          inputClamp[2] = (state.sourceFrame.width * inputSize[2]) - (0.5 * inputPixel[2]);
-          inputClamp[3] = (state.sourceFrame.height * inputSize[3]) - (0.5 * inputPixel[3]);
-          // only update the rect if its legacy..
-          if (state.legacy) {
-              var filterArea = globalUniforms.filterArea;
-              filterArea[0] = state.destinationFrame.width;
-              filterArea[1] = state.destinationFrame.height;
-              filterArea[2] = state.sourceFrame.x;
-              filterArea[3] = state.sourceFrame.y;
-              globalUniforms.filterClamp = globalUniforms.inputClamp;
-          }
-          this.globalUniforms.update();
-          var lastState = filterStack[filterStack.length - 1];
-          this.renderer.framebuffer.blit();
-          if (filters.length === 1) {
-              filters[0].apply(this, state.renderTexture, lastState.renderTexture, exports.CLEAR_MODES.BLEND, state);
-              this.returnFilterTexture(state.renderTexture);
-          }
-          else {
-              var flip = state.renderTexture;
-              var flop = this.getOptimalFilterTexture(flip.width, flip.height, state.resolution);
-              flop.filterFrame = flip.filterFrame;
-              var i = 0;
-              for (i = 0; i < filters.length - 1; ++i) {
-                  if (i === 1 && state.multisample > 1) {
-                      flop = this.getOptimalFilterTexture(flip.width, flip.height, state.resolution);
-                      flop.filterFrame = flip.filterFrame;
-                  }
-                  filters[i].apply(this, flip, flop, exports.CLEAR_MODES.CLEAR, state);
-                  var t = flip;
-                  flip = flop;
-                  flop = t;
-              }
-              filters[i].apply(this, flip, lastState.renderTexture, exports.CLEAR_MODES.BLEND, state);
-              if (i > 1 && state.multisample > 1) {
-                  this.returnFilterTexture(state.renderTexture);
-              }
-              this.returnFilterTexture(flip);
-              this.returnFilterTexture(flop);
-          }
-          // lastState.renderTexture is blitted when lastState is popped
-          state.clear();
-          this.statePool.push(state);
-      };
-      /**
-       * Binds a renderTexture with corresponding `filterFrame`, clears it if mode corresponds.
-       * @param filterTexture - renderTexture to bind, should belong to filter pool or filter stack
-       * @param clearMode - clearMode, by default its CLEAR/YES. See {@link PIXI.CLEAR_MODES}
-       */
-      FilterSystem.prototype.bindAndClear = function (filterTexture, clearMode) {
-          if (clearMode === void 0) { clearMode = exports.CLEAR_MODES.CLEAR; }
-          var _a = this.renderer, renderTextureSystem = _a.renderTexture, stateSystem = _a.state;
-          if (filterTexture === this.defaultFilterStack[this.defaultFilterStack.length - 1].renderTexture) {
-              // Restore projection transform if rendering into the output render-target.
-              this.renderer.projection.transform = this.activeState.transform;
-          }
-          else {
-              // Prevent projection within filtering pipeline.
-              this.renderer.projection.transform = null;
-          }
-          if (filterTexture && filterTexture.filterFrame) {
-              var destinationFrame = this.tempRect;
-              destinationFrame.x = 0;
-              destinationFrame.y = 0;
-              destinationFrame.width = filterTexture.filterFrame.width;
-              destinationFrame.height = filterTexture.filterFrame.height;
-              renderTextureSystem.bind(filterTexture, filterTexture.filterFrame, destinationFrame);
-          }
-          else if (filterTexture !== this.defaultFilterStack[this.defaultFilterStack.length - 1].renderTexture) {
-              renderTextureSystem.bind(filterTexture);
-          }
-          else {
-              // Restore binding for output render-target.
-              this.renderer.renderTexture.bind(filterTexture, this.activeState.bindingSourceFrame, this.activeState.bindingDestinationFrame);
-          }
-          // Clear the texture in BLIT mode if blending is disabled or the forceClear flag is set. The blending
-          // is stored in the 0th bit of the state.
-          var autoClear = (stateSystem.stateId & 1) || this.forceClear;
-          if (clearMode === exports.CLEAR_MODES.CLEAR
-              || (clearMode === exports.CLEAR_MODES.BLIT && autoClear)) {
-              // Use framebuffer.clear because we want to clear the whole filter texture, not just the filtering
-              // area over which the shaders are run. This is because filters may sampling outside of it (e.g. blur)
-              // instead of clamping their arithmetic.
-              this.renderer.framebuffer.clear(0, 0, 0, 0);
-          }
-      };
-      /**
-       * Draws a filter using the default rendering process.
-       *
-       * This should be called only by {@link Filter#apply}.
-       * @param filter - The filter to draw.
-       * @param input - The input render target.
-       * @param output - The target to output to.
-       * @param clearMode - Should the output be cleared before rendering to it
-       */
-      FilterSystem.prototype.applyFilter = function (filter, input, output, clearMode) {
-          var renderer = this.renderer;
-          // Set state before binding, so bindAndClear gets the blend mode.
-          renderer.state.set(filter.state);
-          this.bindAndClear(output, clearMode);
-          // set the uniforms..
-          filter.uniforms.uSampler = input;
-          filter.uniforms.filterGlobals = this.globalUniforms;
-          // TODO make it so that the order of this does not matter..
-          // because it does at the moment cos of global uniforms.
-          // they need to get resynced
-          renderer.shader.bind(filter);
-          // check to see if the filter is a legacy one..
-          filter.legacy = !!filter.program.attributeData.aTextureCoord;
-          if (filter.legacy) {
-              this.quadUv.map(input._frame, input.filterFrame);
-              renderer.geometry.bind(this.quadUv);
-              renderer.geometry.draw(exports.DRAW_MODES.TRIANGLES);
-          }
-          else {
-              renderer.geometry.bind(this.quad);
-              renderer.geometry.draw(exports.DRAW_MODES.TRIANGLE_STRIP);
-          }
-      };
-      /**
-       * Multiply _input normalized coordinates_ to this matrix to get _sprite texture normalized coordinates_.
-       *
-       * Use `outputMatrix * vTextureCoord` in the shader.
-       * @param outputMatrix - The matrix to output to.
-       * @param {PIXI.Sprite} sprite - The sprite to map to.
-       * @returns The mapped matrix.
-       */
-      FilterSystem.prototype.calculateSpriteMatrix = function (outputMatrix, sprite) {
-          var _a = this.activeState, sourceFrame = _a.sourceFrame, destinationFrame = _a.destinationFrame;
-          var orig = sprite._texture.orig;
-          var mappedMatrix = outputMatrix.set(destinationFrame.width, 0, 0, destinationFrame.height, sourceFrame.x, sourceFrame.y);
-          var worldTransform = sprite.worldTransform.copyTo(Matrix.TEMP_MATRIX);
-          worldTransform.invert();
-          mappedMatrix.prepend(worldTransform);
-          mappedMatrix.scale(1.0 / orig.width, 1.0 / orig.height);
-          mappedMatrix.translate(sprite.anchor.x, sprite.anchor.y);
-          return mappedMatrix;
-      };
-      /** Destroys this Filter System. */
-      FilterSystem.prototype.destroy = function () {
-          this.renderer = null;
-          // Those textures has to be destroyed by RenderTextureSystem or FramebufferSystem
-          this.texturePool.clear(false);
-      };
-      /**
-       * Gets a Power-of-Two render texture or fullScreen texture
-       * @param minWidth - The minimum width of the render texture in real pixels.
-       * @param minHeight - The minimum height of the render texture in real pixels.
-       * @param resolution - The resolution of the render texture.
-       * @param multisample - Number of samples of the render texture.
-       * @returns - The new render texture.
-       */
-      FilterSystem.prototype.getOptimalFilterTexture = function (minWidth, minHeight, resolution, multisample) {
-          if (resolution === void 0) { resolution = 1; }
-          if (multisample === void 0) { multisample = exports.MSAA_QUALITY.NONE; }
-          return this.texturePool.getOptimalTexture(minWidth, minHeight, resolution, multisample);
-      };
-      /**
-       * Gets extra render texture to use inside current filter
-       * To be compliant with older filters, you can use params in any order
-       * @param input - renderTexture from which size and resolution will be copied
-       * @param resolution - override resolution of the renderTexture
-       * @param multisample - number of samples of the renderTexture
-       */
-      FilterSystem.prototype.getFilterTexture = function (input, resolution, multisample) {
-          if (typeof input === 'number') {
-              var swap = input;
-              input = resolution;
-              resolution = swap;
-          }
-          input = input || this.activeState.renderTexture;
-          var filterTexture = this.texturePool.getOptimalTexture(input.width, input.height, resolution || input.resolution, multisample || exports.MSAA_QUALITY.NONE);
-          filterTexture.filterFrame = input.filterFrame;
-          return filterTexture;
-      };
-      /**
-       * Frees a render texture back into the pool.
-       * @param renderTexture - The renderTarget to free
-       */
-      FilterSystem.prototype.returnFilterTexture = function (renderTexture) {
-          this.texturePool.returnTexture(renderTexture);
-      };
-      /** Empties the texture pool. */
-      FilterSystem.prototype.emptyPool = function () {
-          this.texturePool.clear(true);
-      };
-      /** Calls `texturePool.resize()`, affects fullScreen renderTextures. */
-      FilterSystem.prototype.resize = function () {
-          this.texturePool.setScreenSize(this.renderer.view);
-      };
-      /**
-       * @param matrix - first param
-       * @param rect - second param
-       */
-      FilterSystem.prototype.transformAABB = function (matrix, rect) {
-          var lt = tempPoints[0];
-          var lb = tempPoints[1];
-          var rt = tempPoints[2];
-          var rb = tempPoints[3];
-          lt.set(rect.left, rect.top);
-          lb.set(rect.left, rect.bottom);
-          rt.set(rect.right, rect.top);
-          rb.set(rect.right, rect.bottom);
-          matrix.apply(lt, lt);
-          matrix.apply(lb, lb);
-          matrix.apply(rt, rt);
-          matrix.apply(rb, rb);
-          var x0 = Math.min(lt.x, lb.x, rt.x, rb.x);
-          var y0 = Math.min(lt.y, lb.y, rt.y, rb.y);
-          var x1 = Math.max(lt.x, lb.x, rt.x, rb.x);
-          var y1 = Math.max(lt.y, lb.y, rt.y, rb.y);
-          rect.x = x0;
-          rect.y = y0;
-          rect.width = x1 - x0;
-          rect.height = y1 - y0;
-      };
-      FilterSystem.prototype.roundFrame = function (frame, resolution, bindingSourceFrame, bindingDestinationFrame, transform) {
-          if (frame.width <= 0 || frame.height <= 0 || bindingSourceFrame.width <= 0 || bindingSourceFrame.height <= 0) {
-              return;
-          }
-          if (transform) {
-              var a = transform.a, b = transform.b, c = transform.c, d = transform.d;
-              // Skip if skew/rotation present in matrix, except for multiple of 90° rotation. If rotation
-              // is a multiple of 90°, then either pair of (b,c) or (a,d) will be (0,0).
-              if ((Math.abs(b) > 1e-4 || Math.abs(c) > 1e-4)
-                  && (Math.abs(a) > 1e-4 || Math.abs(d) > 1e-4)) {
-                  return;
-              }
-          }
-          transform = transform ? tempMatrix$2.copyFrom(transform) : tempMatrix$2.identity();
-          // Get forward transform from world space to screen space
-          transform
-              .translate(-bindingSourceFrame.x, -bindingSourceFrame.y)
-              .scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height)
-              .translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
-          // Convert frame to screen space
-          this.transformAABB(transform, frame);
-          // Round frame in screen space
-          frame.ceil(resolution);
-          // Project back into world space.
-          this.transformAABB(transform.invert(), frame);
-      };
-      return FilterSystem;
-  }());
-
-  /**
-   * Base for a common object renderer that can be used as a
-   * system renderer plugin.
-   * @memberof PIXI
-   */
-  var ObjectRenderer = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this manager works for.
-       */
-      function ObjectRenderer(renderer) {
-          this.renderer = renderer;
-      }
-      /** Stub method that should be used to empty the current batch by rendering objects now. */
-      ObjectRenderer.prototype.flush = function () {
-          // flush!
-      };
-      /** Generic destruction method that frees all resources. This should be called by subclasses. */
-      ObjectRenderer.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      /**
-       * Stub method that initializes any state required before
-       * rendering starts. It is different from the `prerender`
-       * signal, which occurs every frame, in that it is called
-       * whenever an object requests _this_ renderer specifically.
-       */
-      ObjectRenderer.prototype.start = function () {
-          // set the shader..
-      };
-      /** Stops the renderer. It should free up any state and become dormant. */
-      ObjectRenderer.prototype.stop = function () {
-          this.flush();
-      };
-      /**
-       * Keeps the object to render. It doesn't have to be
-       * rendered immediately.
-       * @param {PIXI.DisplayObject} _object - The object to render.
-       */
-      ObjectRenderer.prototype.render = function (_object) {
-          // render the object
-      };
-      return ObjectRenderer;
-  }());
-
-  /**
-   * System plugin to the renderer to manage batching.
-   * @memberof PIXI
-   */
-  var BatchSystem = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this System works for.
-       */
-      function BatchSystem(renderer) {
-          this.renderer = renderer;
-          this.emptyRenderer = new ObjectRenderer(renderer);
-          this.currentRenderer = this.emptyRenderer;
-      }
-      /**
-       * Changes the current renderer to the one given in parameter
-       * @param objectRenderer - The object renderer to use.
-       */
-      BatchSystem.prototype.setObjectRenderer = function (objectRenderer) {
-          if (this.currentRenderer === objectRenderer) {
-              return;
-          }
-          this.currentRenderer.stop();
-          this.currentRenderer = objectRenderer;
-          this.currentRenderer.start();
-      };
-      /**
-       * This should be called if you wish to do some custom rendering
-       * It will basically render anything that may be batched up such as sprites
-       */
-      BatchSystem.prototype.flush = function () {
-          this.setObjectRenderer(this.emptyRenderer);
-      };
-      /** Reset the system to an empty renderer */
-      BatchSystem.prototype.reset = function () {
-          this.setObjectRenderer(this.emptyRenderer);
-      };
-      /**
-       * Handy function for batch renderers: copies bound textures in first maxTextures locations to array
-       * sets actual _batchLocation for them
-       * @param arr - arr copy destination
-       * @param maxTextures - number of copied elements
-       */
-      BatchSystem.prototype.copyBoundTextures = function (arr, maxTextures) {
-          var boundTextures = this.renderer.texture.boundTextures;
-          for (var i = maxTextures - 1; i >= 0; --i) {
-              arr[i] = boundTextures[i] || null;
-              if (arr[i]) {
-                  arr[i]._batchLocation = i;
-              }
-          }
-      };
-      /**
-       * Assigns batch locations to textures in array based on boundTextures state.
-       * All textures in texArray should have `_batchEnabled = _batchId`,
-       * and their count should be less than `maxTextures`.
-       * @param texArray - textures to bound
-       * @param boundTextures - current state of bound textures
-       * @param batchId - marker for _batchEnabled param of textures in texArray
-       * @param maxTextures - number of texture locations to manipulate
-       */
-      BatchSystem.prototype.boundArray = function (texArray, boundTextures, batchId, maxTextures) {
-          var elements = texArray.elements, ids = texArray.ids, count = texArray.count;
-          var j = 0;
-          for (var i = 0; i < count; i++) {
-              var tex = elements[i];
-              var loc = tex._batchLocation;
-              if (loc >= 0 && loc < maxTextures
-                  && boundTextures[loc] === tex) {
-                  ids[i] = loc;
-                  continue;
-              }
-              while (j < maxTextures) {
-                  var bound = boundTextures[j];
-                  if (bound && bound._batchEnabled === batchId
-                      && bound._batchLocation === j) {
-                      j++;
-                      continue;
-                  }
-                  ids[i] = j;
-                  tex._batchLocation = j;
-                  boundTextures[j] = tex;
-                  break;
-              }
-          }
-      };
-      /**
-       * @ignore
-       */
-      BatchSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return BatchSystem;
-  }());
-
-  var CONTEXT_UID_COUNTER = 0;
-  /**
-   * System plugin to the renderer to manage the context.
-   * @memberof PIXI
-   */
-  var ContextSystem = /** @class */ (function () {
-      /** @param renderer - The renderer this System works for. */
-      function ContextSystem(renderer) {
-          this.renderer = renderer;
-          this.webGLVersion = 1;
-          this.extensions = {};
-          this.supports = {
-              uint32Indices: false,
-          };
-          // Bind functions
-          this.handleContextLost = this.handleContextLost.bind(this);
-          this.handleContextRestored = this.handleContextRestored.bind(this);
-          renderer.view.addEventListener('webglcontextlost', this.handleContextLost, false);
-          renderer.view.addEventListener('webglcontextrestored', this.handleContextRestored, false);
-      }
-      Object.defineProperty(ContextSystem.prototype, "isLost", {
-          /**
-           * `true` if the context is lost
-           * @readonly
-           */
-          get: function () {
-              return (!this.gl || this.gl.isContextLost());
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Handles the context change event.
-       * @param {WebGLRenderingContext} gl - New WebGL context.
-       */
-      ContextSystem.prototype.contextChange = function (gl) {
-          this.gl = gl;
-          this.renderer.gl = gl;
-          this.renderer.CONTEXT_UID = CONTEXT_UID_COUNTER++;
-      };
-      /**
-       * Initializes the context.
-       * @protected
-       * @param {WebGLRenderingContext} gl - WebGL context
-       */
-      ContextSystem.prototype.initFromContext = function (gl) {
-          this.gl = gl;
-          this.validateContext(gl);
-          this.renderer.gl = gl;
-          this.renderer.CONTEXT_UID = CONTEXT_UID_COUNTER++;
-          this.renderer.runners.contextChange.emit(gl);
-      };
-      /**
-       * Initialize from context options
-       * @protected
-       * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/getContext
-       * @param {object} options - context attributes
-       */
-      ContextSystem.prototype.initFromOptions = function (options) {
-          var gl = this.createContext(this.renderer.view, options);
-          this.initFromContext(gl);
-      };
-      /**
-       * Helper class to create a WebGL Context
-       * @param canvas - the canvas element that we will get the context from
-       * @param options - An options object that gets passed in to the canvas element containing the
-       *    context attributes
-       * @see https://developer.mozilla.org/en/docs/Web/API/HTMLCanvasElement/getContext
-       * @returns {WebGLRenderingContext} the WebGL context
-       */
-      ContextSystem.prototype.createContext = function (canvas, options) {
-          var gl;
-          if (settings.PREFER_ENV >= exports.ENV.WEBGL2) {
-              gl = canvas.getContext('webgl2', options);
-          }
-          if (gl) {
-              this.webGLVersion = 2;
-          }
-          else {
-              this.webGLVersion = 1;
-              gl = canvas.getContext('webgl', options) || canvas.getContext('experimental-webgl', options);
-              if (!gl) {
-                  // fail, not able to get a context
-                  throw new Error('This browser does not support WebGL. Try using the canvas renderer');
-              }
-          }
-          this.gl = gl;
-          this.getExtensions();
-          return this.gl;
-      };
-      /** Auto-populate the {@link PIXI.ContextSystem.extensions extensions}. */
-      ContextSystem.prototype.getExtensions = function () {
-          // time to set up default extensions that Pixi uses.
-          var gl = this.gl;
-          var common = {
-              loseContext: gl.getExtension('WEBGL_lose_context'),
-              anisotropicFiltering: gl.getExtension('EXT_texture_filter_anisotropic'),
-              floatTextureLinear: gl.getExtension('OES_texture_float_linear'),
-              s3tc: gl.getExtension('WEBGL_compressed_texture_s3tc'),
-              s3tc_sRGB: gl.getExtension('WEBGL_compressed_texture_s3tc_srgb'),
-              etc: gl.getExtension('WEBGL_compressed_texture_etc'),
-              etc1: gl.getExtension('WEBGL_compressed_texture_etc1'),
-              pvrtc: gl.getExtension('WEBGL_compressed_texture_pvrtc')
-                  || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc'),
-              atc: gl.getExtension('WEBGL_compressed_texture_atc'),
-              astc: gl.getExtension('WEBGL_compressed_texture_astc')
-          };
-          if (this.webGLVersion === 1) {
-              Object.assign(this.extensions, common, {
-                  drawBuffers: gl.getExtension('WEBGL_draw_buffers'),
-                  depthTexture: gl.getExtension('WEBGL_depth_texture'),
-                  vertexArrayObject: gl.getExtension('OES_vertex_array_object')
-                      || gl.getExtension('MOZ_OES_vertex_array_object')
-                      || gl.getExtension('WEBKIT_OES_vertex_array_object'),
-                  uint32ElementIndex: gl.getExtension('OES_element_index_uint'),
-                  // Floats and half-floats
-                  floatTexture: gl.getExtension('OES_texture_float'),
-                  floatTextureLinear: gl.getExtension('OES_texture_float_linear'),
-                  textureHalfFloat: gl.getExtension('OES_texture_half_float'),
-                  textureHalfFloatLinear: gl.getExtension('OES_texture_half_float_linear'),
-              });
-          }
-          else if (this.webGLVersion === 2) {
-              Object.assign(this.extensions, common, {
-                  // Floats and half-floats
-                  colorBufferFloat: gl.getExtension('EXT_color_buffer_float')
-              });
-          }
-      };
-      /**
-       * Handles a lost webgl context
-       * @param {WebGLContextEvent} event - The context lost event.
-       */
-      ContextSystem.prototype.handleContextLost = function (event) {
-          var _this = this;
-          // Prevent default to be able to restore the context
-          event.preventDefault();
-          // Restore the context after this event has exited
-          setTimeout(function () {
-              if (_this.gl.isContextLost() && _this.extensions.loseContext) {
-                  _this.extensions.loseContext.restoreContext();
-              }
-          }, 0);
-      };
-      /** Handles a restored webgl context. */
-      ContextSystem.prototype.handleContextRestored = function () {
-          this.renderer.runners.contextChange.emit(this.gl);
-      };
-      ContextSystem.prototype.destroy = function () {
-          var view = this.renderer.view;
-          this.renderer = null;
-          // remove listeners
-          view.removeEventListener('webglcontextlost', this.handleContextLost);
-          view.removeEventListener('webglcontextrestored', this.handleContextRestored);
-          this.gl.useProgram(null);
-          if (this.extensions.loseContext) {
-              this.extensions.loseContext.loseContext();
-          }
-      };
-      /** Handle the post-render runner event. */
-      ContextSystem.prototype.postrender = function () {
-          if (this.renderer.renderingToScreen) {
-              this.gl.flush();
-          }
-      };
-      /**
-       * Validate context.
-       * @param {WebGLRenderingContext} gl - Render context.
-       */
-      ContextSystem.prototype.validateContext = function (gl) {
-          var attributes = gl.getContextAttributes();
-          var isWebGl2 = 'WebGL2RenderingContext' in globalThis && gl instanceof globalThis.WebGL2RenderingContext;
-          if (isWebGl2) {
-              this.webGLVersion = 2;
-          }
-          // this is going to be fairly simple for now.. but at least we have room to grow!
-          if (attributes && !attributes.stencil) {
-              /* eslint-disable max-len, no-console */
-              console.warn('Provided WebGL context does not have a stencil buffer, masks may not render correctly');
-              /* eslint-enable max-len, no-console */
-          }
-          var hasuint32 = isWebGl2 || !!gl.getExtension('OES_element_index_uint');
-          this.supports.uint32Indices = hasuint32;
-          if (!hasuint32) {
-              /* eslint-disable max-len, no-console */
-              console.warn('Provided WebGL context does not support 32 index buffer, complex graphics may not render correctly');
-              /* eslint-enable max-len, no-console */
-          }
-      };
-      return ContextSystem;
-  }());
-
-  /**
-   * Internal framebuffer for WebGL context.
-   * @memberof PIXI
-   */
-  var GLFramebuffer = /** @class */ (function () {
-      function GLFramebuffer(framebuffer) {
-          this.framebuffer = framebuffer;
-          this.stencil = null;
-          this.dirtyId = -1;
-          this.dirtyFormat = -1;
-          this.dirtySize = -1;
-          this.multisample = exports.MSAA_QUALITY.NONE;
-          this.msaaBuffer = null;
-          this.blitFramebuffer = null;
-          this.mipLevel = 0;
-      }
-      return GLFramebuffer;
-  }());
-
-  var tempRectangle = new Rectangle();
-  /**
-   * System plugin to the renderer to manage framebuffers.
-   * @memberof PIXI
-   */
-  var FramebufferSystem = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this System works for.
-       */
-      function FramebufferSystem(renderer) {
-          this.renderer = renderer;
-          this.managedFramebuffers = [];
-          this.unknownFramebuffer = new Framebuffer(10, 10);
-          this.msaaSamples = null;
-      }
-      /** Sets up the renderer context and necessary buffers. */
-      FramebufferSystem.prototype.contextChange = function () {
-          this.disposeAll(true);
-          var gl = this.gl = this.renderer.gl;
-          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
-          this.current = this.unknownFramebuffer;
-          this.viewport = new Rectangle();
-          this.hasMRT = true;
-          this.writeDepthTexture = true;
-          // webgl2
-          if (this.renderer.context.webGLVersion === 1) {
-              // webgl 1!
-              var nativeDrawBuffersExtension_1 = this.renderer.context.extensions.drawBuffers;
-              var nativeDepthTextureExtension = this.renderer.context.extensions.depthTexture;
-              if (settings.PREFER_ENV === exports.ENV.WEBGL_LEGACY) {
-                  nativeDrawBuffersExtension_1 = null;
-                  nativeDepthTextureExtension = null;
-              }
-              if (nativeDrawBuffersExtension_1) {
-                  gl.drawBuffers = function (activeTextures) {
-                      return nativeDrawBuffersExtension_1.drawBuffersWEBGL(activeTextures);
-                  };
-              }
-              else {
-                  this.hasMRT = false;
-                  gl.drawBuffers = function () {
-                      // empty
-                  };
-              }
-              if (!nativeDepthTextureExtension) {
-                  this.writeDepthTexture = false;
-              }
-          }
-          else {
-              // WebGL2
-              // cache possible MSAA samples
-              this.msaaSamples = gl.getInternalformatParameter(gl.RENDERBUFFER, gl.RGBA8, gl.SAMPLES);
-          }
-      };
-      /**
-       * Bind a framebuffer.
-       * @param framebuffer
-       * @param frame - frame, default is framebuffer size
-       * @param mipLevel - optional mip level to set on the framebuffer - defaults to 0
-       */
-      FramebufferSystem.prototype.bind = function (framebuffer, frame, mipLevel) {
-          if (mipLevel === void 0) { mipLevel = 0; }
-          var gl = this.gl;
-          if (framebuffer) {
-              // TODO caching layer!
-              var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID] || this.initFramebuffer(framebuffer);
-              if (this.current !== framebuffer) {
-                  this.current = framebuffer;
-                  gl.bindFramebuffer(gl.FRAMEBUFFER, fbo.framebuffer);
-              }
-              // make sure all textures are unbound..
-              if (fbo.mipLevel !== mipLevel) {
-                  framebuffer.dirtyId++;
-                  framebuffer.dirtyFormat++;
-                  fbo.mipLevel = mipLevel;
-              }
-              // now check for updates...
-              if (fbo.dirtyId !== framebuffer.dirtyId) {
-                  fbo.dirtyId = framebuffer.dirtyId;
-                  if (fbo.dirtyFormat !== framebuffer.dirtyFormat) {
-                      fbo.dirtyFormat = framebuffer.dirtyFormat;
-                      fbo.dirtySize = framebuffer.dirtySize;
-                      this.updateFramebuffer(framebuffer, mipLevel);
-                  }
-                  else if (fbo.dirtySize !== framebuffer.dirtySize) {
-                      fbo.dirtySize = framebuffer.dirtySize;
-                      this.resizeFramebuffer(framebuffer);
-                  }
-              }
-              for (var i = 0; i < framebuffer.colorTextures.length; i++) {
-                  var tex = framebuffer.colorTextures[i];
-                  this.renderer.texture.unbind(tex.parentTextureArray || tex);
-              }
-              if (framebuffer.depthTexture) {
-                  this.renderer.texture.unbind(framebuffer.depthTexture);
-              }
-              if (frame) {
-                  var mipWidth = (frame.width >> mipLevel);
-                  var mipHeight = (frame.height >> mipLevel);
-                  var scale = mipWidth / frame.width;
-                  this.setViewport(frame.x * scale, frame.y * scale, mipWidth, mipHeight);
-              }
-              else {
-                  var mipWidth = (framebuffer.width >> mipLevel);
-                  var mipHeight = (framebuffer.height >> mipLevel);
-                  this.setViewport(0, 0, mipWidth, mipHeight);
-              }
-          }
-          else {
-              if (this.current) {
-                  this.current = null;
-                  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-              }
-              if (frame) {
-                  this.setViewport(frame.x, frame.y, frame.width, frame.height);
-              }
-              else {
-                  this.setViewport(0, 0, this.renderer.width, this.renderer.height);
-              }
-          }
-      };
-      /**
-       * Set the WebGLRenderingContext's viewport.
-       * @param x - X position of viewport
-       * @param y - Y position of viewport
-       * @param width - Width of viewport
-       * @param height - Height of viewport
-       */
-      FramebufferSystem.prototype.setViewport = function (x, y, width, height) {
-          var v = this.viewport;
-          x = Math.round(x);
-          y = Math.round(y);
-          width = Math.round(width);
-          height = Math.round(height);
-          if (v.width !== width || v.height !== height || v.x !== x || v.y !== y) {
-              v.x = x;
-              v.y = y;
-              v.width = width;
-              v.height = height;
-              this.gl.viewport(x, y, width, height);
-          }
-      };
-      Object.defineProperty(FramebufferSystem.prototype, "size", {
-          /**
-           * Get the size of the current width and height. Returns object with `width` and `height` values.
-           * @readonly
-           */
-          get: function () {
-              if (this.current) {
-                  // TODO store temp
-                  return { x: 0, y: 0, width: this.current.width, height: this.current.height };
-              }
-              return { x: 0, y: 0, width: this.renderer.width, height: this.renderer.height };
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Clear the color of the context
-       * @param r - Red value from 0 to 1
-       * @param g - Green value from 0 to 1
-       * @param b - Blue value from 0 to 1
-       * @param a - Alpha value from 0 to 1
-       * @param {PIXI.BUFFER_BITS} [mask=BUFFER_BITS.COLOR | BUFFER_BITS.DEPTH] - Bitwise OR of masks
-       *  that indicate the buffers to be cleared, by default COLOR and DEPTH buffers.
-       */
-      FramebufferSystem.prototype.clear = function (r, g, b, a, mask) {
-          if (mask === void 0) { mask = exports.BUFFER_BITS.COLOR | exports.BUFFER_BITS.DEPTH; }
-          var gl = this.gl;
-          // TODO clear color can be set only one right?
-          gl.clearColor(r, g, b, a);
-          gl.clear(mask);
-      };
-      /**
-       * Initialize framebuffer for this context
-       * @protected
-       * @param framebuffer
-       * @returns - created GLFramebuffer
-       */
-      FramebufferSystem.prototype.initFramebuffer = function (framebuffer) {
-          var gl = this.gl;
-          var fbo = new GLFramebuffer(gl.createFramebuffer());
-          fbo.multisample = this.detectSamples(framebuffer.multisample);
-          framebuffer.glFramebuffers[this.CONTEXT_UID] = fbo;
-          this.managedFramebuffers.push(framebuffer);
-          framebuffer.disposeRunner.add(this);
-          return fbo;
-      };
-      /**
-       * Resize the framebuffer
-       * @param framebuffer
-       * @protected
-       */
-      FramebufferSystem.prototype.resizeFramebuffer = function (framebuffer) {
-          var gl = this.gl;
-          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
-          if (fbo.msaaBuffer) {
-              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.msaaBuffer);
-              gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.RGBA8, framebuffer.width, framebuffer.height);
-          }
-          if (fbo.stencil) {
-              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.stencil);
-              if (fbo.msaaBuffer) {
-                  gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, framebuffer.width, framebuffer.height);
-              }
-              else {
-                  gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, framebuffer.width, framebuffer.height);
-              }
-          }
-          var colorTextures = framebuffer.colorTextures;
-          var count = colorTextures.length;
-          if (!gl.drawBuffers) {
-              count = Math.min(count, 1);
-          }
-          for (var i = 0; i < count; i++) {
-              var texture = colorTextures[i];
-              var parentTexture = texture.parentTextureArray || texture;
-              this.renderer.texture.bind(parentTexture, 0);
-          }
-          if (framebuffer.depthTexture && this.writeDepthTexture) {
-              this.renderer.texture.bind(framebuffer.depthTexture, 0);
-          }
-      };
-      /**
-       * Update the framebuffer
-       * @param framebuffer
-       * @param mipLevel
-       * @protected
-       */
-      FramebufferSystem.prototype.updateFramebuffer = function (framebuffer, mipLevel) {
-          var gl = this.gl;
-          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
-          // bind the color texture
-          var colorTextures = framebuffer.colorTextures;
-          var count = colorTextures.length;
-          if (!gl.drawBuffers) {
-              count = Math.min(count, 1);
-          }
-          if (fbo.multisample > 1 && this.canMultisampleFramebuffer(framebuffer)) {
-              fbo.msaaBuffer = fbo.msaaBuffer || gl.createRenderbuffer();
-              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.msaaBuffer);
-              gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.RGBA8, framebuffer.width, framebuffer.height);
-              gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, fbo.msaaBuffer);
-          }
-          else if (fbo.msaaBuffer) {
-              gl.deleteRenderbuffer(fbo.msaaBuffer);
-              fbo.msaaBuffer = null;
-              if (fbo.blitFramebuffer) {
-                  fbo.blitFramebuffer.dispose();
-                  fbo.blitFramebuffer = null;
-              }
-          }
-          var activeTextures = [];
-          for (var i = 0; i < count; i++) {
-              var texture = colorTextures[i];
-              var parentTexture = texture.parentTextureArray || texture;
-              this.renderer.texture.bind(parentTexture, 0);
-              if (i === 0 && fbo.msaaBuffer) {
-                  continue;
-              }
-              gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, texture.target, parentTexture._glTextures[this.CONTEXT_UID].texture, mipLevel);
-              activeTextures.push(gl.COLOR_ATTACHMENT0 + i);
-          }
-          if (activeTextures.length > 1) {
-              gl.drawBuffers(activeTextures);
-          }
-          if (framebuffer.depthTexture) {
-              var writeDepthTexture = this.writeDepthTexture;
-              if (writeDepthTexture) {
-                  var depthTexture = framebuffer.depthTexture;
-                  this.renderer.texture.bind(depthTexture, 0);
-                  gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, depthTexture._glTextures[this.CONTEXT_UID].texture, mipLevel);
-              }
-          }
-          if ((framebuffer.stencil || framebuffer.depth) && !(framebuffer.depthTexture && this.writeDepthTexture)) {
-              fbo.stencil = fbo.stencil || gl.createRenderbuffer();
-              gl.bindRenderbuffer(gl.RENDERBUFFER, fbo.stencil);
-              if (fbo.msaaBuffer) {
-                  gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, framebuffer.width, framebuffer.height);
-              }
-              else {
-                  gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, framebuffer.width, framebuffer.height);
-              }
-              gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, fbo.stencil);
-          }
-          else if (fbo.stencil) {
-              gl.deleteRenderbuffer(fbo.stencil);
-              fbo.stencil = null;
-          }
-      };
-      /**
-       * Returns true if the frame buffer can be multisampled.
-       * @param framebuffer
-       */
-      FramebufferSystem.prototype.canMultisampleFramebuffer = function (framebuffer) {
-          return this.renderer.context.webGLVersion !== 1
-              && framebuffer.colorTextures.length <= 1 && !framebuffer.depthTexture;
-      };
-      /**
-       * Detects number of samples that is not more than a param but as close to it as possible
-       * @param samples - number of samples
-       * @returns - recommended number of samples
-       */
-      FramebufferSystem.prototype.detectSamples = function (samples) {
-          var msaaSamples = this.msaaSamples;
-          var res = exports.MSAA_QUALITY.NONE;
-          if (samples <= 1 || msaaSamples === null) {
-              return res;
-          }
-          for (var i = 0; i < msaaSamples.length; i++) {
-              if (msaaSamples[i] <= samples) {
-                  res = msaaSamples[i];
-                  break;
-              }
-          }
-          if (res === 1) {
-              res = exports.MSAA_QUALITY.NONE;
-          }
-          return res;
-      };
-      /**
-       * Only works with WebGL2
-       *
-       * blits framebuffer to another of the same or bigger size
-       * after that target framebuffer is bound
-       *
-       * Fails with WebGL warning if blits multisample framebuffer to different size
-       * @param framebuffer - by default it blits "into itself", from renderBuffer to texture.
-       * @param sourcePixels - source rectangle in pixels
-       * @param destPixels - dest rectangle in pixels, assumed to be the same as sourcePixels
-       */
-      FramebufferSystem.prototype.blit = function (framebuffer, sourcePixels, destPixels) {
-          var _a = this, current = _a.current, renderer = _a.renderer, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
-          if (renderer.context.webGLVersion !== 2) {
-              return;
-          }
-          if (!current) {
-              return;
-          }
-          var fbo = current.glFramebuffers[CONTEXT_UID];
-          if (!fbo) {
-              return;
-          }
-          if (!framebuffer) {
-              if (!fbo.msaaBuffer) {
-                  return;
-              }
-              var colorTexture = current.colorTextures[0];
-              if (!colorTexture) {
-                  return;
-              }
-              if (!fbo.blitFramebuffer) {
-                  fbo.blitFramebuffer = new Framebuffer(current.width, current.height);
-                  fbo.blitFramebuffer.addColorTexture(0, colorTexture);
-              }
-              framebuffer = fbo.blitFramebuffer;
-              if (framebuffer.colorTextures[0] !== colorTexture) {
-                  framebuffer.colorTextures[0] = colorTexture;
-                  framebuffer.dirtyId++;
-                  framebuffer.dirtyFormat++;
-              }
-              if (framebuffer.width !== current.width || framebuffer.height !== current.height) {
-                  framebuffer.width = current.width;
-                  framebuffer.height = current.height;
-                  framebuffer.dirtyId++;
-                  framebuffer.dirtySize++;
-              }
-          }
-          if (!sourcePixels) {
-              sourcePixels = tempRectangle;
-              sourcePixels.width = current.width;
-              sourcePixels.height = current.height;
-          }
-          if (!destPixels) {
-              destPixels = sourcePixels;
-          }
-          var sameSize = sourcePixels.width === destPixels.width && sourcePixels.height === destPixels.height;
-          this.bind(framebuffer);
-          gl.bindFramebuffer(gl.READ_FRAMEBUFFER, fbo.framebuffer);
-          gl.blitFramebuffer(sourcePixels.left, sourcePixels.top, sourcePixels.right, sourcePixels.bottom, destPixels.left, destPixels.top, destPixels.right, destPixels.bottom, gl.COLOR_BUFFER_BIT, sameSize ? gl.NEAREST : gl.LINEAR);
-      };
-      /**
-       * Disposes framebuffer.
-       * @param framebuffer - framebuffer that has to be disposed of
-       * @param contextLost - If context was lost, we suppress all delete function calls
-       */
-      FramebufferSystem.prototype.disposeFramebuffer = function (framebuffer, contextLost) {
-          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
-          var gl = this.gl;
-          if (!fbo) {
-              return;
-          }
-          delete framebuffer.glFramebuffers[this.CONTEXT_UID];
-          var index = this.managedFramebuffers.indexOf(framebuffer);
-          if (index >= 0) {
-              this.managedFramebuffers.splice(index, 1);
-          }
-          framebuffer.disposeRunner.remove(this);
-          if (!contextLost) {
-              gl.deleteFramebuffer(fbo.framebuffer);
-              if (fbo.msaaBuffer) {
-                  gl.deleteRenderbuffer(fbo.msaaBuffer);
-              }
-              if (fbo.stencil) {
-                  gl.deleteRenderbuffer(fbo.stencil);
-              }
-          }
-          if (fbo.blitFramebuffer) {
-              fbo.blitFramebuffer.dispose();
-          }
-      };
-      /**
-       * Disposes all framebuffers, but not textures bound to them.
-       * @param [contextLost=false] - If context was lost, we suppress all delete function calls
-       */
-      FramebufferSystem.prototype.disposeAll = function (contextLost) {
-          var list = this.managedFramebuffers;
-          this.managedFramebuffers = [];
-          for (var i = 0; i < list.length; i++) {
-              this.disposeFramebuffer(list[i], contextLost);
-          }
-      };
-      /**
-       * Forcing creation of stencil buffer for current framebuffer, if it wasn't done before.
-       * Used by MaskSystem, when its time to use stencil mask for Graphics element.
-       *
-       * Its an alternative for public lazy `framebuffer.enableStencil`, in case we need stencil without rebind.
-       * @private
-       */
-      FramebufferSystem.prototype.forceStencil = function () {
-          var framebuffer = this.current;
-          if (!framebuffer) {
-              return;
-          }
-          var fbo = framebuffer.glFramebuffers[this.CONTEXT_UID];
-          if (!fbo || fbo.stencil) {
-              return;
-          }
-          framebuffer.stencil = true;
-          var w = framebuffer.width;
-          var h = framebuffer.height;
-          var gl = this.gl;
-          var stencil = gl.createRenderbuffer();
-          gl.bindRenderbuffer(gl.RENDERBUFFER, stencil);
-          if (fbo.msaaBuffer) {
-              gl.renderbufferStorageMultisample(gl.RENDERBUFFER, fbo.multisample, gl.DEPTH24_STENCIL8, w, h);
-          }
-          else {
-              gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, w, h);
-          }
-          fbo.stencil = stencil;
-          gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, stencil);
-      };
-      /** Resets framebuffer stored state, binds screen framebuffer. Should be called before renderTexture reset(). */
-      FramebufferSystem.prototype.reset = function () {
-          this.current = this.unknownFramebuffer;
-          this.viewport = new Rectangle();
-      };
-      FramebufferSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return FramebufferSystem;
-  }());
-
-  var byteSizeMap = { 5126: 4, 5123: 2, 5121: 1 };
-  /**
-   * System plugin to the renderer to manage geometry.
-   * @memberof PIXI
-   */
-  var GeometrySystem = /** @class */ (function () {
-      /** @param renderer - The renderer this System works for. */
-      function GeometrySystem(renderer) {
-          this.renderer = renderer;
-          this._activeGeometry = null;
-          this._activeVao = null;
-          this.hasVao = true;
-          this.hasInstance = true;
-          this.canUseUInt32ElementIndex = false;
-          this.managedGeometries = {};
-      }
-      /** Sets up the renderer context and necessary buffers. */
-      GeometrySystem.prototype.contextChange = function () {
-          this.disposeAll(true);
-          var gl = this.gl = this.renderer.gl;
-          var context = this.renderer.context;
-          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
-          // webgl2
-          if (context.webGLVersion !== 2) {
-              // webgl 1!
-              var nativeVaoExtension_1 = this.renderer.context.extensions.vertexArrayObject;
-              if (settings.PREFER_ENV === exports.ENV.WEBGL_LEGACY) {
-                  nativeVaoExtension_1 = null;
-              }
-              if (nativeVaoExtension_1) {
-                  gl.createVertexArray = function () {
-                      return nativeVaoExtension_1.createVertexArrayOES();
-                  };
-                  gl.bindVertexArray = function (vao) {
-                      return nativeVaoExtension_1.bindVertexArrayOES(vao);
-                  };
-                  gl.deleteVertexArray = function (vao) {
-                      return nativeVaoExtension_1.deleteVertexArrayOES(vao);
-                  };
-              }
-              else {
-                  this.hasVao = false;
-                  gl.createVertexArray = function () {
-                      return null;
-                  };
-                  gl.bindVertexArray = function () {
-                      return null;
-                  };
-                  gl.deleteVertexArray = function () {
-                      return null;
-                  };
-              }
-          }
-          if (context.webGLVersion !== 2) {
-              var instanceExt_1 = gl.getExtension('ANGLE_instanced_arrays');
-              if (instanceExt_1) {
-                  gl.vertexAttribDivisor = function (a, b) {
-                      return instanceExt_1.vertexAttribDivisorANGLE(a, b);
-                  };
-                  gl.drawElementsInstanced = function (a, b, c, d, e) {
-                      return instanceExt_1.drawElementsInstancedANGLE(a, b, c, d, e);
-                  };
-                  gl.drawArraysInstanced = function (a, b, c, d) {
-                      return instanceExt_1.drawArraysInstancedANGLE(a, b, c, d);
-                  };
-              }
-              else {
-                  this.hasInstance = false;
-              }
-          }
-          this.canUseUInt32ElementIndex = context.webGLVersion === 2 || !!context.extensions.uint32ElementIndex;
-      };
-      /**
-       * Binds geometry so that is can be drawn. Creating a Vao if required
-       * @param geometry - Instance of geometry to bind.
-       * @param shader - Instance of shader to use vao for.
-       */
-      GeometrySystem.prototype.bind = function (geometry, shader) {
-          shader = shader || this.renderer.shader.shader;
-          var gl = this.gl;
-          // not sure the best way to address this..
-          // currently different shaders require different VAOs for the same geometry
-          // Still mulling over the best way to solve this one..
-          // will likely need to modify the shader attribute locations at run time!
-          var vaos = geometry.glVertexArrayObjects[this.CONTEXT_UID];
-          var incRefCount = false;
-          if (!vaos) {
-              this.managedGeometries[geometry.id] = geometry;
-              geometry.disposeRunner.add(this);
-              geometry.glVertexArrayObjects[this.CONTEXT_UID] = vaos = {};
-              incRefCount = true;
-          }
-          var vao = vaos[shader.program.id] || this.initGeometryVao(geometry, shader, incRefCount);
-          this._activeGeometry = geometry;
-          if (this._activeVao !== vao) {
-              this._activeVao = vao;
-              if (this.hasVao) {
-                  gl.bindVertexArray(vao);
-              }
-              else {
-                  this.activateVao(geometry, shader.program);
-              }
-          }
-          // TODO - optimise later!
-          // don't need to loop through if nothing changed!
-          // maybe look to add an 'autoupdate' to geometry?
-          this.updateBuffers();
-      };
-      /** Reset and unbind any active VAO and geometry. */
-      GeometrySystem.prototype.reset = function () {
-          this.unbind();
-      };
-      /** Update buffers of the currently bound geometry. */
-      GeometrySystem.prototype.updateBuffers = function () {
-          var geometry = this._activeGeometry;
-          var bufferSystem = this.renderer.buffer;
-          for (var i = 0; i < geometry.buffers.length; i++) {
-              var buffer = geometry.buffers[i];
-              bufferSystem.update(buffer);
-          }
-      };
-      /**
-       * Check compatibility between a geometry and a program
-       * @param geometry - Geometry instance.
-       * @param program - Program instance.
-       */
-      GeometrySystem.prototype.checkCompatibility = function (geometry, program) {
-          // geometry must have at least all the attributes that the shader requires.
-          var geometryAttributes = geometry.attributes;
-          var shaderAttributes = program.attributeData;
-          for (var j in shaderAttributes) {
-              if (!geometryAttributes[j]) {
-                  throw new Error("shader and geometry incompatible, geometry missing the \"" + j + "\" attribute");
-              }
-          }
-      };
-      /**
-       * Takes a geometry and program and generates a unique signature for them.
-       * @param geometry - To get signature from.
-       * @param program - To test geometry against.
-       * @returns - Unique signature of the geometry and program
-       */
-      GeometrySystem.prototype.getSignature = function (geometry, program) {
-          var attribs = geometry.attributes;
-          var shaderAttributes = program.attributeData;
-          var strings = ['g', geometry.id];
-          for (var i in attribs) {
-              if (shaderAttributes[i]) {
-                  strings.push(i, shaderAttributes[i].location);
-              }
-          }
-          return strings.join('-');
-      };
-      /**
-       * Creates or gets Vao with the same structure as the geometry and stores it on the geometry.
-       * If vao is created, it is bound automatically. We use a shader to infer what and how to set up the
-       * attribute locations.
-       * @param geometry - Instance of geometry to to generate Vao for.
-       * @param shader - Instance of the shader.
-       * @param incRefCount - Increment refCount of all geometry buffers.
-       */
-      GeometrySystem.prototype.initGeometryVao = function (geometry, shader, incRefCount) {
-          if (incRefCount === void 0) { incRefCount = true; }
-          var gl = this.gl;
-          var CONTEXT_UID = this.CONTEXT_UID;
-          var bufferSystem = this.renderer.buffer;
-          var program = shader.program;
-          if (!program.glPrograms[CONTEXT_UID]) {
-              this.renderer.shader.generateProgram(shader);
-          }
-          this.checkCompatibility(geometry, program);
-          var signature = this.getSignature(geometry, program);
-          var vaoObjectHash = geometry.glVertexArrayObjects[this.CONTEXT_UID];
-          var vao = vaoObjectHash[signature];
-          if (vao) {
-              // this will give us easy access to the vao
-              vaoObjectHash[program.id] = vao;
-              return vao;
-          }
-          var buffers = geometry.buffers;
-          var attributes = geometry.attributes;
-          var tempStride = {};
-          var tempStart = {};
-          for (var j in buffers) {
-              tempStride[j] = 0;
-              tempStart[j] = 0;
-          }
-          for (var j in attributes) {
-              if (!attributes[j].size && program.attributeData[j]) {
-                  attributes[j].size = program.attributeData[j].size;
-              }
-              else if (!attributes[j].size) {
-                  console.warn("PIXI Geometry attribute '" + j + "' size cannot be determined (likely the bound shader does not have the attribute)"); // eslint-disable-line
-              }
-              tempStride[attributes[j].buffer] += attributes[j].size * byteSizeMap[attributes[j].type];
-          }
-          for (var j in attributes) {
-              var attribute = attributes[j];
-              var attribSize = attribute.size;
-              if (attribute.stride === undefined) {
-                  if (tempStride[attribute.buffer] === attribSize * byteSizeMap[attribute.type]) {
-                      attribute.stride = 0;
-                  }
-                  else {
-                      attribute.stride = tempStride[attribute.buffer];
-                  }
-              }
-              if (attribute.start === undefined) {
-                  attribute.start = tempStart[attribute.buffer];
-                  tempStart[attribute.buffer] += attribSize * byteSizeMap[attribute.type];
-              }
-          }
-          vao = gl.createVertexArray();
-          gl.bindVertexArray(vao);
-          // first update - and create the buffers!
-          // only create a gl buffer if it actually gets
-          for (var i = 0; i < buffers.length; i++) {
-              var buffer = buffers[i];
-              bufferSystem.bind(buffer);
-              if (incRefCount) {
-                  buffer._glBuffers[CONTEXT_UID].refCount++;
-              }
-          }
-          // TODO - maybe make this a data object?
-          // lets wait to see if we need to first!
-          this.activateVao(geometry, program);
-          this._activeVao = vao;
-          // add it to the cache!
-          vaoObjectHash[program.id] = vao;
-          vaoObjectHash[signature] = vao;
-          return vao;
-      };
-      /**
-       * Disposes geometry.
-       * @param geometry - Geometry with buffers. Only VAO will be disposed
-       * @param [contextLost=false] - If context was lost, we suppress deleteVertexArray
-       */
-      GeometrySystem.prototype.disposeGeometry = function (geometry, contextLost) {
-          var _a;
-          if (!this.managedGeometries[geometry.id]) {
-              return;
-          }
-          delete this.managedGeometries[geometry.id];
-          var vaos = geometry.glVertexArrayObjects[this.CONTEXT_UID];
-          var gl = this.gl;
-          var buffers = geometry.buffers;
-          var bufferSystem = (_a = this.renderer) === null || _a === void 0 ? void 0 : _a.buffer;
-          geometry.disposeRunner.remove(this);
-          if (!vaos) {
-              return;
-          }
-          // bufferSystem may have already been destroyed..
-          // if this is the case, there is no need to destroy the geometry buffers...
-          // they already have been!
-          if (bufferSystem) {
-              for (var i = 0; i < buffers.length; i++) {
-                  var buf = buffers[i]._glBuffers[this.CONTEXT_UID];
-                  // my be null as context may have changed right before the dispose is called
-                  if (buf) {
-                      buf.refCount--;
-                      if (buf.refCount === 0 && !contextLost) {
-                          bufferSystem.dispose(buffers[i], contextLost);
-                      }
-                  }
-              }
-          }
-          if (!contextLost) {
-              for (var vaoId in vaos) {
-                  // delete only signatures, everything else are copies
-                  if (vaoId[0] === 'g') {
-                      var vao = vaos[vaoId];
-                      if (this._activeVao === vao) {
-                          this.unbind();
-                      }
-                      gl.deleteVertexArray(vao);
-                  }
-              }
-          }
-          delete geometry.glVertexArrayObjects[this.CONTEXT_UID];
-      };
-      /**
-       * Dispose all WebGL resources of all managed geometries.
-       * @param [contextLost=false] - If context was lost, we suppress `gl.delete` calls
-       */
-      GeometrySystem.prototype.disposeAll = function (contextLost) {
-          var all = Object.keys(this.managedGeometries);
-          for (var i = 0; i < all.length; i++) {
-              this.disposeGeometry(this.managedGeometries[all[i]], contextLost);
-          }
-      };
-      /**
-       * Activate vertex array object.
-       * @param geometry - Geometry instance.
-       * @param program - Shader program instance.
-       */
-      GeometrySystem.prototype.activateVao = function (geometry, program) {
-          var gl = this.gl;
-          var CONTEXT_UID = this.CONTEXT_UID;
-          var bufferSystem = this.renderer.buffer;
-          var buffers = geometry.buffers;
-          var attributes = geometry.attributes;
-          if (geometry.indexBuffer) {
-              // first update the index buffer if we have one..
-              bufferSystem.bind(geometry.indexBuffer);
-          }
-          var lastBuffer = null;
-          // add a new one!
-          for (var j in attributes) {
-              var attribute = attributes[j];
-              var buffer = buffers[attribute.buffer];
-              var glBuffer = buffer._glBuffers[CONTEXT_UID];
-              if (program.attributeData[j]) {
-                  if (lastBuffer !== glBuffer) {
-                      bufferSystem.bind(buffer);
-                      lastBuffer = glBuffer;
-                  }
-                  var location = program.attributeData[j].location;
-                  // TODO introduce state again
-                  // we can optimise this for older devices that have no VAOs
-                  gl.enableVertexAttribArray(location);
-                  gl.vertexAttribPointer(location, attribute.size, attribute.type || gl.FLOAT, attribute.normalized, attribute.stride, attribute.start);
-                  if (attribute.instance) {
-                      // TODO calculate instance count based of this...
-                      if (this.hasInstance) {
-                          gl.vertexAttribDivisor(location, 1);
-                      }
-                      else {
-                          throw new Error('geometry error, GPU Instancing is not supported on this device');
-                      }
-                  }
-              }
-          }
-      };
-      /**
-       * Draws the currently bound geometry.
-       * @param type - The type primitive to render.
-       * @param size - The number of elements to be rendered. If not specified, all vertices after the
-       *  starting vertex will be drawn.
-       * @param start - The starting vertex in the geometry to start drawing from. If not specified,
-       *  drawing will start from the first vertex.
-       * @param instanceCount - The number of instances of the set of elements to execute. If not specified,
-       *  all instances will be drawn.
-       */
-      GeometrySystem.prototype.draw = function (type, size, start, instanceCount) {
-          var gl = this.gl;
-          var geometry = this._activeGeometry;
-          // TODO.. this should not change so maybe cache the function?
-          if (geometry.indexBuffer) {
-              var byteSize = geometry.indexBuffer.data.BYTES_PER_ELEMENT;
-              var glType = byteSize === 2 ? gl.UNSIGNED_SHORT : gl.UNSIGNED_INT;
-              if (byteSize === 2 || (byteSize === 4 && this.canUseUInt32ElementIndex)) {
-                  if (geometry.instanced) {
-                      /* eslint-disable max-len */
-                      gl.drawElementsInstanced(type, size || geometry.indexBuffer.data.length, glType, (start || 0) * byteSize, instanceCount || 1);
-                      /* eslint-enable max-len */
-                  }
-                  else {
-                      /* eslint-disable max-len */
-                      gl.drawElements(type, size || geometry.indexBuffer.data.length, glType, (start || 0) * byteSize);
-                      /* eslint-enable max-len */
-                  }
-              }
-              else {
-                  console.warn('unsupported index buffer type: uint32');
-              }
-          }
-          else if (geometry.instanced) {
-              // TODO need a better way to calculate size..
-              gl.drawArraysInstanced(type, start, size || geometry.getSize(), instanceCount || 1);
-          }
-          else {
-              gl.drawArrays(type, start, size || geometry.getSize());
-          }
-          return this;
-      };
-      /** Unbind/reset everything. */
-      GeometrySystem.prototype.unbind = function () {
-          this.gl.bindVertexArray(null);
-          this._activeVao = null;
-          this._activeGeometry = null;
-      };
-      GeometrySystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return GeometrySystem;
-  }());
-
-  /**
-   * Component for masked elements.
-   *
-   * Holds mask mode and temporary data about current mask.
-   * @memberof PIXI
-   */
-  var MaskData = /** @class */ (function () {
-      /**
-       * Create MaskData
-       * @param {PIXI.DisplayObject} [maskObject=null] - object that describes the mask
-       */
-      function MaskData(maskObject) {
-          if (maskObject === void 0) { maskObject = null; }
-          this.type = exports.MASK_TYPES.NONE;
-          this.autoDetect = true;
-          this.maskObject = maskObject || null;
-          this.pooled = false;
-          this.isMaskData = true;
-          this.resolution = null;
-          this.multisample = settings.FILTER_MULTISAMPLE;
-          this.enabled = true;
-          this.colorMask = 0xf;
-          this._filters = null;
-          this._stencilCounter = 0;
-          this._scissorCounter = 0;
-          this._scissorRect = null;
-          this._scissorRectLocal = null;
-          this._colorMask = 0xf;
-          this._target = null;
-      }
-      Object.defineProperty(MaskData.prototype, "filter", {
-          /**
-           * The sprite mask filter.
-           * If set to `null`, the default sprite mask filter is used.
-           * @default null
-           */
-          get: function () {
-              return this._filters ? this._filters[0] : null;
-          },
-          set: function (value) {
-              if (value) {
-                  if (this._filters) {
-                      this._filters[0] = value;
-                  }
-                  else {
-                      this._filters = [value];
-                  }
-              }
-              else {
-                  this._filters = null;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Resets the mask data after popMask(). */
-      MaskData.prototype.reset = function () {
-          if (this.pooled) {
-              this.maskObject = null;
-              this.type = exports.MASK_TYPES.NONE;
-              this.autoDetect = true;
-          }
-          this._target = null;
-          this._scissorRectLocal = null;
-      };
-      /**
-       * Copies counters from maskData above, called from pushMask().
-       * @param maskAbove
-       */
-      MaskData.prototype.copyCountersOrReset = function (maskAbove) {
-          if (maskAbove) {
-              this._stencilCounter = maskAbove._stencilCounter;
-              this._scissorCounter = maskAbove._scissorCounter;
-              this._scissorRect = maskAbove._scissorRect;
-          }
-          else {
-              this._stencilCounter = 0;
-              this._scissorCounter = 0;
-              this._scissorRect = null;
-          }
-      };
-      return MaskData;
-  }());
-
-  /**
-   * @private
-   * @param {WebGLRenderingContext} gl - The current WebGL context {WebGLProgram}
-   * @param {number} type - the type, can be either VERTEX_SHADER or FRAGMENT_SHADER
-   * @param {string} src - The vertex shader source as an array of strings.
-   * @returns {WebGLShader} the shader
-   */
-  function compileShader(gl, type, src) {
-      var shader = gl.createShader(type);
-      gl.shaderSource(shader, src);
-      gl.compileShader(shader);
-      return shader;
-  }
-
-  /**
-   * will log a shader error highlighting the lines with the error
-   * also will add numbers along the side.
-   * @param gl - the WebGLContext
-   * @param shader - the shader to log errors for
-   */
-  function logPrettyShaderError(gl, shader) {
-      var shaderSrc = gl.getShaderSource(shader)
-          .split('\n')
-          .map(function (line, index) { return index + ": " + line; });
-      var shaderLog = gl.getShaderInfoLog(shader);
-      var splitShader = shaderLog.split('\n');
-      var dedupe = {};
-      var lineNumbers = splitShader.map(function (line) { return parseFloat(line.replace(/^ERROR\: 0\:([\d]+)\:.*$/, '$1')); })
-          .filter(function (n) {
-          if (n && !dedupe[n]) {
-              dedupe[n] = true;
-              return true;
-          }
-          return false;
-      });
-      var logArgs = [''];
-      lineNumbers.forEach(function (number) {
-          shaderSrc[number - 1] = "%c" + shaderSrc[number - 1] + "%c";
-          logArgs.push('background: #FF0000; color:#FFFFFF; font-size: 10px', 'font-size: 10px');
-      });
-      var fragmentSourceToLog = shaderSrc
-          .join('\n');
-      logArgs[0] = fragmentSourceToLog;
-      console.error(shaderLog);
-      // eslint-disable-next-line no-console
-      console.groupCollapsed('click to view full shader code');
-      console.warn.apply(console, logArgs);
-      // eslint-disable-next-line no-console
-      console.groupEnd();
-  }
-  /**
-   *
-   * logs out any program errors
-   * @param gl - The current WebGL context
-   * @param program - the WebGL program to display errors for
-   * @param vertexShader  - the fragment WebGL shader program
-   * @param fragmentShader - the vertex WebGL shader program
-   */
-  function logProgramError(gl, program, vertexShader, fragmentShader) {
-      // if linking fails, then log and cleanup
-      if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-          if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
-              logPrettyShaderError(gl, vertexShader);
-          }
-          if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
-              logPrettyShaderError(gl, fragmentShader);
-          }
-          console.error('PixiJS Error: Could not initialize shader.');
-          // if there is a program info log, log it
-          if (gl.getProgramInfoLog(program) !== '') {
-              console.warn('PixiJS Warning: gl.getProgramInfoLog()', gl.getProgramInfoLog(program));
-          }
-      }
-  }
-
-  function booleanArray(size) {
-      var array = new Array(size);
-      for (var i = 0; i < array.length; i++) {
-          array[i] = false;
-      }
-      return array;
-  }
-  /**
-   * @method defaultValue
-   * @memberof PIXI.glCore.shader
-   * @param {string} type - Type of value
-   * @param {number} size
-   * @private
-   */
-  function defaultValue(type, size) {
-      switch (type) {
-          case 'float':
-              return 0;
-          case 'vec2':
-              return new Float32Array(2 * size);
-          case 'vec3':
-              return new Float32Array(3 * size);
-          case 'vec4':
-              return new Float32Array(4 * size);
-          case 'int':
-          case 'uint':
-          case 'sampler2D':
-          case 'sampler2DArray':
-              return 0;
-          case 'ivec2':
-              return new Int32Array(2 * size);
-          case 'ivec3':
-              return new Int32Array(3 * size);
-          case 'ivec4':
-              return new Int32Array(4 * size);
-          case 'uvec2':
-              return new Uint32Array(2 * size);
-          case 'uvec3':
-              return new Uint32Array(3 * size);
-          case 'uvec4':
-              return new Uint32Array(4 * size);
-          case 'bool':
-              return false;
-          case 'bvec2':
-              return booleanArray(2 * size);
-          case 'bvec3':
-              return booleanArray(3 * size);
-          case 'bvec4':
-              return booleanArray(4 * size);
-          case 'mat2':
-              return new Float32Array([1, 0,
-                  0, 1]);
-          case 'mat3':
-              return new Float32Array([1, 0, 0,
-                  0, 1, 0,
-                  0, 0, 1]);
-          case 'mat4':
-              return new Float32Array([1, 0, 0, 0,
-                  0, 1, 0, 0,
-                  0, 0, 1, 0,
-                  0, 0, 0, 1]);
-      }
-      return null;
-  }
-
-  var unknownContext = {};
-  var context = unknownContext;
-  /**
-   * returns a little WebGL context to use for program inspection.
-   * @static
-   * @private
-   * @returns {WebGLRenderingContext} a gl context to test with
-   */
-  function getTestContext() {
-      if (context === unknownContext || (context && context.isContextLost())) {
-          var canvas = settings.ADAPTER.createCanvas();
-          var gl = void 0;
-          if (settings.PREFER_ENV >= exports.ENV.WEBGL2) {
-              gl = canvas.getContext('webgl2', {});
-          }
-          if (!gl) {
-              gl = (canvas.getContext('webgl', {})
-                  || canvas.getContext('experimental-webgl', {}));
-              if (!gl) {
-                  // fail, not able to get a context
-                  gl = null;
-              }
-              else {
-                  // for shader testing..
-                  gl.getExtension('WEBGL_draw_buffers');
-              }
-          }
-          context = gl;
-      }
-      return context;
-  }
-
-  var maxFragmentPrecision;
-  function getMaxFragmentPrecision() {
-      if (!maxFragmentPrecision) {
-          maxFragmentPrecision = exports.PRECISION.MEDIUM;
-          var gl = getTestContext();
-          if (gl) {
-              if (gl.getShaderPrecisionFormat) {
-                  var shaderFragment = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT);
-                  maxFragmentPrecision = shaderFragment.precision ? exports.PRECISION.HIGH : exports.PRECISION.MEDIUM;
-              }
-          }
-      }
-      return maxFragmentPrecision;
-  }
-
-  /**
-   * Sets the float precision on the shader, ensuring the device supports the request precision.
-   * If the precision is already present, it just ensures that the device is able to handle it.
-   * @private
-   * @param {string} src - The shader source
-   * @param {PIXI.PRECISION} requestedPrecision - The request float precision of the shader.
-   * @param {PIXI.PRECISION} maxSupportedPrecision - The maximum precision the shader supports.
-   * @returns {string} modified shader source
-   */
-  function setPrecision(src, requestedPrecision, maxSupportedPrecision) {
-      if (src.substring(0, 9) !== 'precision') {
-          // no precision supplied, so PixiJS will add the requested level.
-          var precision = requestedPrecision;
-          // If highp is requested but not supported, downgrade precision to a level all devices support.
-          if (requestedPrecision === exports.PRECISION.HIGH && maxSupportedPrecision !== exports.PRECISION.HIGH) {
-              precision = exports.PRECISION.MEDIUM;
-          }
-          return "precision " + precision + " float;\n" + src;
-      }
-      else if (maxSupportedPrecision !== exports.PRECISION.HIGH && src.substring(0, 15) === 'precision highp') {
-          // precision was supplied, but at a level this device does not support, so downgrading to mediump.
-          return src.replace('precision highp', 'precision mediump');
-      }
-      return src;
-  }
-
-  var GLSL_TO_SIZE = {
-      float: 1,
-      vec2: 2,
-      vec3: 3,
-      vec4: 4,
-      int: 1,
-      ivec2: 2,
-      ivec3: 3,
-      ivec4: 4,
-      uint: 1,
-      uvec2: 2,
-      uvec3: 3,
-      uvec4: 4,
-      bool: 1,
-      bvec2: 2,
-      bvec3: 3,
-      bvec4: 4,
-      mat2: 4,
-      mat3: 9,
-      mat4: 16,
-      sampler2D: 1,
-  };
-  /**
-   * @private
-   * @method mapSize
-   * @memberof PIXI.glCore.shader
-   * @param {string} type
-   */
-  function mapSize(type) {
-      return GLSL_TO_SIZE[type];
-  }
-
-  var GL_TABLE = null;
-  var GL_TO_GLSL_TYPES = {
-      FLOAT: 'float',
-      FLOAT_VEC2: 'vec2',
-      FLOAT_VEC3: 'vec3',
-      FLOAT_VEC4: 'vec4',
-      INT: 'int',
-      INT_VEC2: 'ivec2',
-      INT_VEC3: 'ivec3',
-      INT_VEC4: 'ivec4',
-      UNSIGNED_INT: 'uint',
-      UNSIGNED_INT_VEC2: 'uvec2',
-      UNSIGNED_INT_VEC3: 'uvec3',
-      UNSIGNED_INT_VEC4: 'uvec4',
-      BOOL: 'bool',
-      BOOL_VEC2: 'bvec2',
-      BOOL_VEC3: 'bvec3',
-      BOOL_VEC4: 'bvec4',
-      FLOAT_MAT2: 'mat2',
-      FLOAT_MAT3: 'mat3',
-      FLOAT_MAT4: 'mat4',
-      SAMPLER_2D: 'sampler2D',
-      INT_SAMPLER_2D: 'sampler2D',
-      UNSIGNED_INT_SAMPLER_2D: 'sampler2D',
-      SAMPLER_CUBE: 'samplerCube',
-      INT_SAMPLER_CUBE: 'samplerCube',
-      UNSIGNED_INT_SAMPLER_CUBE: 'samplerCube',
-      SAMPLER_2D_ARRAY: 'sampler2DArray',
-      INT_SAMPLER_2D_ARRAY: 'sampler2DArray',
-      UNSIGNED_INT_SAMPLER_2D_ARRAY: 'sampler2DArray',
-  };
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  function mapType(gl, type) {
-      if (!GL_TABLE) {
-          var typeNames = Object.keys(GL_TO_GLSL_TYPES);
-          GL_TABLE = {};
-          for (var i = 0; i < typeNames.length; ++i) {
-              var tn = typeNames[i];
-              GL_TABLE[gl[tn]] = GL_TO_GLSL_TYPES[tn];
-          }
-      }
-      return GL_TABLE[type];
-  }
-
-  /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-  // Parsers, each one of these will take a look at the type of shader property and uniform.
-  // if they pass the test function then the code function is called that returns a the shader upload code for that uniform.
-  // Shader upload code is automagically generated with these parsers.
-  // If no parser is valid then the default upload functions are used.
-  // exposing Parsers means that custom upload logic can be added to pixi's shaders.
-  // A good example would be a pixi rectangle can be directly set on a uniform.
-  // If the shader sees it it knows how to upload the rectangle structure as a vec4
-  // format is as follows:
-  //
-  // {
-  //     test: (data, uniform) => {} <--- test is this code should be used for this uniform
-  //     code: (name, uniform) => {} <--- returns the string of the piece of code that uploads the uniform
-  //     codeUbo: (name, uniform) => {} <--- returns the string of the piece of code that uploads the
-  //                                         uniform to a uniform buffer
-  // }
-  var uniformParsers = [
-      // a float cache layer
-      {
-          test: function (data) {
-              return data.type === 'float' && data.size === 1 && !data.isArray;
-          },
-          code: function (name) {
-              return "\n            if(uv[\"" + name + "\"] !== ud[\"" + name + "\"].value)\n            {\n                ud[\"" + name + "\"].value = uv[\"" + name + "\"]\n                gl.uniform1f(ud[\"" + name + "\"].location, uv[\"" + name + "\"])\n            }\n            ";
-          },
-      },
-      // handling samplers
-      {
-          test: function (data, uniform) {
-              // eslint-disable-next-line max-len,no-eq-null,eqeqeq
-              return (data.type === 'sampler2D' || data.type === 'samplerCube' || data.type === 'sampler2DArray') && data.size === 1 && !data.isArray && (uniform == null || uniform.castToBaseTexture !== undefined);
-          },
-          code: function (name) { return "t = syncData.textureCount++;\n\n            renderer.texture.bind(uv[\"" + name + "\"], t);\n\n            if(ud[\"" + name + "\"].value !== t)\n            {\n                ud[\"" + name + "\"].value = t;\n                gl.uniform1i(ud[\"" + name + "\"].location, t);\n; // eslint-disable-line max-len\n            }"; },
-      },
-      // uploading pixi matrix object to mat3
-      {
-          test: function (data, uniform) {
-              return data.type === 'mat3' && data.size === 1 && !data.isArray && uniform.a !== undefined;
-          },
-          code: function (name) {
-              // TODO and some smart caching dirty ids here!
-              return "\n            gl.uniformMatrix3fv(ud[\"" + name + "\"].location, false, uv[\"" + name + "\"].toArray(true));\n            ";
-          },
-          codeUbo: function (name) {
-              return "\n                var " + name + "_matrix = uv." + name + ".toArray(true);\n\n                data[offset] = " + name + "_matrix[0];\n                data[offset+1] = " + name + "_matrix[1];\n                data[offset+2] = " + name + "_matrix[2];\n        \n                data[offset + 4] = " + name + "_matrix[3];\n                data[offset + 5] = " + name + "_matrix[4];\n                data[offset + 6] = " + name + "_matrix[5];\n        \n                data[offset + 8] = " + name + "_matrix[6];\n                data[offset + 9] = " + name + "_matrix[7];\n                data[offset + 10] = " + name + "_matrix[8];\n            ";
-          },
-      },
-      // uploading a pixi point as a vec2 with caching layer
-      {
-          test: function (data, uniform) {
-              return data.type === 'vec2' && data.size === 1 && !data.isArray && uniform.x !== undefined;
-          },
-          code: function (name) {
-              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v.x || cv[1] !== v.y)\n                {\n                    cv[0] = v.x;\n                    cv[1] = v.y;\n                    gl.uniform2f(ud[\"" + name + "\"].location, v.x, v.y);\n                }";
-          },
-          codeUbo: function (name) {
-              return "\n                v = uv." + name + ";\n\n                data[offset] = v.x;\n                data[offset+1] = v.y;\n            ";
-          }
-      },
-      // caching layer for a vec2
-      {
-          test: function (data) {
-              return data.type === 'vec2' && data.size === 1 && !data.isArray;
-          },
-          code: function (name) {
-              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v[0] || cv[1] !== v[1])\n                {\n                    cv[0] = v[0];\n                    cv[1] = v[1];\n                    gl.uniform2f(ud[\"" + name + "\"].location, v[0], v[1]);\n                }\n            ";
-          },
-      },
-      // upload a pixi rectangle as a vec4 with caching layer
-      {
-          test: function (data, uniform) {
-              return data.type === 'vec4' && data.size === 1 && !data.isArray && uniform.width !== undefined;
-          },
-          code: function (name) {
-              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v.x || cv[1] !== v.y || cv[2] !== v.width || cv[3] !== v.height)\n                {\n                    cv[0] = v.x;\n                    cv[1] = v.y;\n                    cv[2] = v.width;\n                    cv[3] = v.height;\n                    gl.uniform4f(ud[\"" + name + "\"].location, v.x, v.y, v.width, v.height)\n                }";
-          },
-          codeUbo: function (name) {
-              return "\n                    v = uv." + name + ";\n\n                    data[offset] = v.x;\n                    data[offset+1] = v.y;\n                    data[offset+2] = v.width;\n                    data[offset+3] = v.height;\n                ";
-          }
-      },
-      // a caching layer for vec4 uploading
-      {
-          test: function (data) {
-              return data.type === 'vec4' && data.size === 1 && !data.isArray;
-          },
-          code: function (name) {
-              return "\n                cv = ud[\"" + name + "\"].value;\n                v = uv[\"" + name + "\"];\n\n                if(cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n                {\n                    cv[0] = v[0];\n                    cv[1] = v[1];\n                    cv[2] = v[2];\n                    cv[3] = v[3];\n\n                    gl.uniform4f(ud[\"" + name + "\"].location, v[0], v[1], v[2], v[3])\n                }";
-          },
-      } ];
-
-  // cu = Cached value's uniform data field
-  // cv = Cached value
-  // v = value to upload
-  // ud = uniformData
-  // uv = uniformValue
-  // l = location
-  var GLSL_TO_SINGLE_SETTERS_CACHED = {
-      float: "\n    if (cv !== v)\n    {\n        cu.value = v;\n        gl.uniform1f(location, v);\n    }",
-      vec2: "\n    if (cv[0] !== v[0] || cv[1] !== v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2f(location, v[0], v[1])\n    }",
-      vec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3f(location, v[0], v[1], v[2])\n    }",
-      vec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4f(location, v[0], v[1], v[2], v[3]);\n    }",
-      int: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
-      ivec2: "\n    if (cv[0] !== v[0] || cv[1] !== v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2i(location, v[0], v[1]);\n    }",
-      ivec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3i(location, v[0], v[1], v[2]);\n    }",
-      ivec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4i(location, v[0], v[1], v[2], v[3]);\n    }",
-      uint: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1ui(location, v);\n    }",
-      uvec2: "\n    if (cv[0] !== v[0] || cv[1] !== v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2ui(location, v[0], v[1]);\n    }",
-      uvec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3ui(location, v[0], v[1], v[2]);\n    }",
-      uvec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4ui(location, v[0], v[1], v[2], v[3]);\n    }",
-      bool: "\n    if (cv !== v)\n    {\n        cu.value = v;\n        gl.uniform1i(location, v);\n    }",
-      bvec2: "\n    if (cv[0] != v[0] || cv[1] != v[1])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n\n        gl.uniform2i(location, v[0], v[1]);\n    }",
-      bvec3: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n\n        gl.uniform3i(location, v[0], v[1], v[2]);\n    }",
-      bvec4: "\n    if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3])\n    {\n        cv[0] = v[0];\n        cv[1] = v[1];\n        cv[2] = v[2];\n        cv[3] = v[3];\n\n        gl.uniform4i(location, v[0], v[1], v[2], v[3]);\n    }",
-      mat2: 'gl.uniformMatrix2fv(location, false, v)',
-      mat3: 'gl.uniformMatrix3fv(location, false, v)',
-      mat4: 'gl.uniformMatrix4fv(location, false, v)',
-      sampler2D: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
-      samplerCube: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
-      sampler2DArray: "\n    if (cv !== v)\n    {\n        cu.value = v;\n\n        gl.uniform1i(location, v);\n    }",
-  };
-  var GLSL_TO_ARRAY_SETTERS = {
-      float: "gl.uniform1fv(location, v)",
-      vec2: "gl.uniform2fv(location, v)",
-      vec3: "gl.uniform3fv(location, v)",
-      vec4: 'gl.uniform4fv(location, v)',
-      mat4: 'gl.uniformMatrix4fv(location, false, v)',
-      mat3: 'gl.uniformMatrix3fv(location, false, v)',
-      mat2: 'gl.uniformMatrix2fv(location, false, v)',
-      int: 'gl.uniform1iv(location, v)',
-      ivec2: 'gl.uniform2iv(location, v)',
-      ivec3: 'gl.uniform3iv(location, v)',
-      ivec4: 'gl.uniform4iv(location, v)',
-      uint: 'gl.uniform1uiv(location, v)',
-      uvec2: 'gl.uniform2uiv(location, v)',
-      uvec3: 'gl.uniform3uiv(location, v)',
-      uvec4: 'gl.uniform4uiv(location, v)',
-      bool: 'gl.uniform1iv(location, v)',
-      bvec2: 'gl.uniform2iv(location, v)',
-      bvec3: 'gl.uniform3iv(location, v)',
-      bvec4: 'gl.uniform4iv(location, v)',
-      sampler2D: 'gl.uniform1iv(location, v)',
-      samplerCube: 'gl.uniform1iv(location, v)',
-      sampler2DArray: 'gl.uniform1iv(location, v)',
-  };
-  function generateUniformsSync(group, uniformData) {
-      var _a;
-      var funcFragments = ["\n        var v = null;\n        var cv = null;\n        var cu = null;\n        var t = 0;\n        var gl = renderer.gl;\n    "];
-      for (var i in group.uniforms) {
-          var data = uniformData[i];
-          if (!data) {
-              if ((_a = group.uniforms[i]) === null || _a === void 0 ? void 0 : _a.group) {
-                  if (group.uniforms[i].ubo) {
-                      funcFragments.push("\n                        renderer.shader.syncUniformBufferGroup(uv." + i + ", '" + i + "');\n                    ");
-                  }
-                  else {
-                      funcFragments.push("\n                        renderer.shader.syncUniformGroup(uv." + i + ", syncData);\n                    ");
-                  }
-              }
-              continue;
-          }
-          var uniform = group.uniforms[i];
-          var parsed = false;
-          for (var j = 0; j < uniformParsers.length; j++) {
-              if (uniformParsers[j].test(data, uniform)) {
-                  funcFragments.push(uniformParsers[j].code(i, uniform));
-                  parsed = true;
-                  break;
-              }
-          }
-          if (!parsed) {
-              var templateType = data.size === 1 && !data.isArray ? GLSL_TO_SINGLE_SETTERS_CACHED : GLSL_TO_ARRAY_SETTERS;
-              var template = templateType[data.type].replace('location', "ud[\"" + i + "\"].location");
-              funcFragments.push("\n            cu = ud[\"" + i + "\"];\n            cv = cu.value;\n            v = uv[\"" + i + "\"];\n            " + template + ";");
-          }
-      }
-      /*
-       * the introduction of syncData is to solve an issue where textures in uniform groups are not set correctly
-       * the texture count was always starting from 0 in each group. This needs to increment each time a texture is used
-       * no matter which group is being used
-       *
-       */
-      // eslint-disable-next-line no-new-func
-      return new Function('ud', 'uv', 'renderer', 'syncData', funcFragments.join('\n'));
-  }
-
-  var fragTemplate$1 = [
-      'precision mediump float;',
-      'void main(void){',
-      'float test = 0.1;',
-      '%forloop%',
-      'gl_FragColor = vec4(0.0);',
-      '}' ].join('\n');
-  function generateIfTestSrc(maxIfs) {
-      var src = '';
-      for (var i = 0; i < maxIfs; ++i) {
-          if (i > 0) {
-              src += '\nelse ';
-          }
-          if (i < maxIfs - 1) {
-              src += "if(test == " + i + ".0){}";
-          }
-      }
-      return src;
-  }
-  function checkMaxIfStatementsInShader(maxIfs, gl) {
-      if (maxIfs === 0) {
-          throw new Error('Invalid value of `0` passed to `checkMaxIfStatementsInShader`');
-      }
-      var shader = gl.createShader(gl.FRAGMENT_SHADER);
-      while (true) // eslint-disable-line no-constant-condition
-       {
-          var fragmentSrc = fragTemplate$1.replace(/%forloop%/gi, generateIfTestSrc(maxIfs));
-          gl.shaderSource(shader, fragmentSrc);
-          gl.compileShader(shader);
-          if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-              maxIfs = (maxIfs / 2) | 0;
-          }
-          else {
-              // valid!
-              break;
-          }
-      }
-      return maxIfs;
-  }
-
-  // Cache the result to prevent running this over and over
-  var unsafeEval;
-  /**
-   * Not all platforms allow to generate function code (e.g., `new Function`).
-   * this provides the platform-level detection.
-   * @private
-   * @returns {boolean} `true` if `new Function` is supported.
-   */
-  function unsafeEvalSupported() {
-      if (typeof unsafeEval === 'boolean') {
-          return unsafeEval;
-      }
-      try {
-          /* eslint-disable no-new-func */
-          var func = new Function('param1', 'param2', 'param3', 'return param1[param2] === param3;');
-          /* eslint-enable no-new-func */
-          unsafeEval = func({ a: 'b' }, 'a', 'b') === true;
-      }
-      catch (e) {
-          unsafeEval = false;
-      }
-      return unsafeEval;
-  }
-
-  var defaultFragment$2 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n   gl_FragColor *= texture2D(uSampler, vTextureCoord);\n}";
-
-  var defaultVertex$3 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void){\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}\n";
-
-  var UID$1 = 0;
-  var nameCache = {};
-  /**
-   * Helper class to create a shader program.
-   * @memberof PIXI
-   */
-  var Program = /** @class */ (function () {
-      /**
-       * @param vertexSrc - The source of the vertex shader.
-       * @param fragmentSrc - The source of the fragment shader.
-       * @param name - Name for shader
-       */
-      function Program(vertexSrc, fragmentSrc, name) {
-          if (name === void 0) { name = 'pixi-shader'; }
-          this.id = UID$1++;
-          this.vertexSrc = vertexSrc || Program.defaultVertexSrc;
-          this.fragmentSrc = fragmentSrc || Program.defaultFragmentSrc;
-          this.vertexSrc = this.vertexSrc.trim();
-          this.fragmentSrc = this.fragmentSrc.trim();
-          if (this.vertexSrc.substring(0, 8) !== '#version') {
-              name = name.replace(/\s+/g, '-');
-              if (nameCache[name]) {
-                  nameCache[name]++;
-                  name += "-" + nameCache[name];
-              }
-              else {
-                  nameCache[name] = 1;
-              }
-              this.vertexSrc = "#define SHADER_NAME " + name + "\n" + this.vertexSrc;
-              this.fragmentSrc = "#define SHADER_NAME " + name + "\n" + this.fragmentSrc;
-              this.vertexSrc = setPrecision(this.vertexSrc, settings.PRECISION_VERTEX, exports.PRECISION.HIGH);
-              this.fragmentSrc = setPrecision(this.fragmentSrc, settings.PRECISION_FRAGMENT, getMaxFragmentPrecision());
-          }
-          // currently this does not extract structs only default types
-          // this is where we store shader references..
-          this.glPrograms = {};
-          this.syncUniforms = null;
-      }
-      Object.defineProperty(Program, "defaultVertexSrc", {
-          /**
-           * The default vertex shader source.
-           * @constant
-           */
-          get: function () {
-              return defaultVertex$3;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Program, "defaultFragmentSrc", {
-          /**
-           * The default fragment shader source.
-           * @constant
-           */
-          get: function () {
-              return defaultFragment$2;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * A short hand function to create a program based of a vertex and fragment shader.
-       *
-       * This method will also check to see if there is a cached program.
-       * @param vertexSrc - The source of the vertex shader.
-       * @param fragmentSrc - The source of the fragment shader.
-       * @param name - Name for shader
-       * @returns A shiny new PixiJS shader program!
-       */
-      Program.from = function (vertexSrc, fragmentSrc, name) {
-          var key = vertexSrc + fragmentSrc;
-          var program = ProgramCache[key];
-          if (!program) {
-              ProgramCache[key] = program = new Program(vertexSrc, fragmentSrc, name);
-          }
-          return program;
-      };
-      return Program;
-  }());
-
-  /**
-   * A helper class for shaders.
-   * @memberof PIXI
-   */
-  var Shader = /** @class */ (function () {
-      /**
-       * @param program - The program the shader will use.
-       * @param uniforms - Custom uniforms to use to augment the built-in ones.
-       */
-      function Shader(program, uniforms) {
-          /**
-           * Used internally to bind uniform buffer objects.
-           * @ignore
-           */
-          this.uniformBindCount = 0;
-          this.program = program;
-          // lets see whats been passed in
-          // uniforms should be converted to a uniform group
-          if (uniforms) {
-              if (uniforms instanceof UniformGroup) {
-                  this.uniformGroup = uniforms;
-              }
-              else {
-                  this.uniformGroup = new UniformGroup(uniforms);
-              }
-          }
-          else {
-              this.uniformGroup = new UniformGroup({});
-          }
-          this.disposeRunner = new Runner('disposeShader');
-      }
-      // TODO move to shader system..
-      Shader.prototype.checkUniformExists = function (name, group) {
-          if (group.uniforms[name]) {
-              return true;
-          }
-          for (var i in group.uniforms) {
-              var uniform = group.uniforms[i];
-              if (uniform.group) {
-                  if (this.checkUniformExists(name, uniform)) {
-                      return true;
-                  }
-              }
-          }
-          return false;
-      };
-      Shader.prototype.destroy = function () {
-          // usage count on programs?
-          // remove if not used!
-          this.uniformGroup = null;
-          this.disposeRunner.emit(this);
-          this.disposeRunner.destroy();
-      };
-      Object.defineProperty(Shader.prototype, "uniforms", {
-          /**
-           * Shader uniform values, shortcut for `uniformGroup.uniforms`.
-           * @readonly
-           */
-          get: function () {
-              return this.uniformGroup.uniforms;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * A short hand function to create a shader based of a vertex and fragment shader.
-       * @param vertexSrc - The source of the vertex shader.
-       * @param fragmentSrc - The source of the fragment shader.
-       * @param uniforms - Custom uniforms to use to augment the built-in ones.
-       * @returns A shiny new PixiJS shader!
-       */
-      Shader.from = function (vertexSrc, fragmentSrc, uniforms) {
-          var program = Program.from(vertexSrc, fragmentSrc);
-          return new Shader(program, uniforms);
-      };
-      return Shader;
-  }());
-
-  /* eslint-disable max-len */
-  var BLEND$1 = 0;
-  var OFFSET$1 = 1;
-  var CULLING$1 = 2;
-  var DEPTH_TEST$1 = 3;
-  var WINDING$1 = 4;
-  var DEPTH_MASK$1 = 5;
-  /**
-   * This is a WebGL state, and is is passed to {@link PIXI.StateSystem}.
-   *
-   * Each mesh rendered may require WebGL to be in a different state.
-   * For example you may want different blend mode or to enable polygon offsets
-   * @memberof PIXI
-   */
-  var State = /** @class */ (function () {
-      function State() {
-          this.data = 0;
-          this.blendMode = exports.BLEND_MODES.NORMAL;
-          this.polygonOffset = 0;
-          this.blend = true;
-          this.depthMask = true;
-          //  this.depthTest = true;
-      }
-      Object.defineProperty(State.prototype, "blend", {
-          /**
-           * Activates blending of the computed fragment color values.
-           * @default true
-           */
-          get: function () {
-              return !!(this.data & (1 << BLEND$1));
-          },
-          set: function (value) {
-              if (!!(this.data & (1 << BLEND$1)) !== value) {
-                  this.data ^= (1 << BLEND$1);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(State.prototype, "offsets", {
-          /**
-           * Activates adding an offset to depth values of polygon's fragments
-           * @default false
-           */
-          get: function () {
-              return !!(this.data & (1 << OFFSET$1));
-          },
-          set: function (value) {
-              if (!!(this.data & (1 << OFFSET$1)) !== value) {
-                  this.data ^= (1 << OFFSET$1);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(State.prototype, "culling", {
-          /**
-           * Activates culling of polygons.
-           * @default false
-           */
-          get: function () {
-              return !!(this.data & (1 << CULLING$1));
-          },
-          set: function (value) {
-              if (!!(this.data & (1 << CULLING$1)) !== value) {
-                  this.data ^= (1 << CULLING$1);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(State.prototype, "depthTest", {
-          /**
-           * Activates depth comparisons and updates to the depth buffer.
-           * @default false
-           */
-          get: function () {
-              return !!(this.data & (1 << DEPTH_TEST$1));
-          },
-          set: function (value) {
-              if (!!(this.data & (1 << DEPTH_TEST$1)) !== value) {
-                  this.data ^= (1 << DEPTH_TEST$1);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(State.prototype, "depthMask", {
-          /**
-           * Enables or disables writing to the depth buffer.
-           * @default true
-           */
-          get: function () {
-              return !!(this.data & (1 << DEPTH_MASK$1));
-          },
-          set: function (value) {
-              if (!!(this.data & (1 << DEPTH_MASK$1)) !== value) {
-                  this.data ^= (1 << DEPTH_MASK$1);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(State.prototype, "clockwiseFrontFace", {
-          /**
-           * Specifies whether or not front or back-facing polygons can be culled.
-           * @default false
-           */
-          get: function () {
-              return !!(this.data & (1 << WINDING$1));
-          },
-          set: function (value) {
-              if (!!(this.data & (1 << WINDING$1)) !== value) {
-                  this.data ^= (1 << WINDING$1);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(State.prototype, "blendMode", {
-          /**
-           * The blend mode to be applied when this state is set. Apply a value of `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.
-           * Setting this mode to anything other than NO_BLEND will automatically switch blending on.
-           * @default PIXI.BLEND_MODES.NORMAL
-           */
-          get: function () {
-              return this._blendMode;
-          },
-          set: function (value) {
-              this.blend = (value !== exports.BLEND_MODES.NONE);
-              this._blendMode = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(State.prototype, "polygonOffset", {
-          /**
-           * The polygon offset. Setting this property to anything other than 0 will automatically enable polygon offset fill.
-           * @default 0
-           */
-          get: function () {
-              return this._polygonOffset;
-          },
-          set: function (value) {
-              this.offsets = !!value;
-              this._polygonOffset = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      State.prototype.toString = function () {
-          return "[@pixi/core:State "
-              + ("blendMode=" + this.blendMode + " ")
-              + ("clockwiseFrontFace=" + this.clockwiseFrontFace + " ")
-              + ("culling=" + this.culling + " ")
-              + ("depthMask=" + this.depthMask + " ")
-              + ("polygonOffset=" + this.polygonOffset)
-              + "]";
-      };
-      State.for2d = function () {
-          var state = new State();
-          state.depthTest = false;
-          state.blend = true;
-          return state;
-      };
-      return State;
-  }());
-
-  var defaultFragment$1 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n   gl_FragColor = texture2D(uSampler, vTextureCoord);\n}\n";
-
-  var defaultVertex$2 = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";
-
-  /**
-   * A filter is a special shader that applies post-processing effects to an input texture and writes into an output
-   * render-target.
-   *
-   * {@link http://pixijs.io/examples/#/filters/blur-filter.js Example} of the
-   * {@link PIXI.filters.BlurFilter BlurFilter}.
-   *
-   * ### Usage
-   * Filters can be applied to any DisplayObject or Container.
-   * PixiJS' `FilterSystem` renders the container into temporary Framebuffer,
-   * then filter renders it to the screen.
-   * Multiple filters can be added to the `filters` array property and stacked on each other.
-   *
-   * ```
-   * const filter = new PIXI.Filter(myShaderVert, myShaderFrag, { myUniform: 0.5 });
-   * const container = new PIXI.Container();
-   * container.filters = [filter];
-   * ```
-   *
-   * ### Previous Version Differences
-   *
-   * In PixiJS **v3**, a filter was always applied to _whole screen_.
-   *
-   * In PixiJS **v4**, a filter can be applied _only part of the screen_.
-   * Developers had to create a set of uniforms to deal with coordinates.
-   *
-   * In PixiJS **v5** combines _both approaches_.
-   * Developers can use normal coordinates of v3 and then allow filter to use partial Framebuffers,
-   * bringing those extra uniforms into account.
-   *
-   * Also be aware that we have changed default vertex shader, please consult
-   * {@link https://github.com/pixijs/pixi.js/wiki/v5-Creating-filters Wiki}.
-   *
-   * ### Frames
-   *
-   * The following table summarizes the coordinate spaces used in the filtering pipeline:
-   *
-   * <table>
-   * <thead>
-   *   <tr>
-   *     <th>Coordinate Space</th>
-   *     <th>Description</th>
-   *   </tr>
-   * </thead>
-   * <tbody>
-   *   <tr>
-   *     <td>Texture Coordinates</td>
-   *     <td>
-   *         The texture (or UV) coordinates in the input base-texture's space. These are normalized into the (0,1) range along
-   *         both axes.
-   *     </td>
-   *   </tr>
-   *   <tr>
-   *     <td>World Space</td>
-   *     <td>
-   *         A point in the same space as the world bounds of any display-object (i.e. in the scene graph's space).
-   *     </td>
-   *   </tr>
-   *   <tr>
-   *     <td>Physical Pixels</td>
-   *     <td>
-   *         This is base-texture's space with the origin on the top-left. You can calculate these by multiplying the texture
-   *         coordinates by the dimensions of the texture.
-   *     </td>
-   *   </tr>
-   * </tbody>
-   * </table>
-   *
-   * ### Built-in Uniforms
-   *
-   * PixiJS viewport uses screen (CSS) coordinates, `(0, 0, renderer.screen.width, renderer.screen.height)`,
-   * and `projectionMatrix` uniform maps it to the gl viewport.
-   *
-   * **uSampler**
-   *
-   * The most important uniform is the input texture that container was rendered into.
-   * _Important note: as with all Framebuffers in PixiJS, both input and output are
-   * premultiplied by alpha._
-   *
-   * By default, input normalized coordinates are passed to fragment shader with `vTextureCoord`.
-   * Use it to sample the input.
-   *
-   * ```
-   * const fragment = `
-   * varying vec2 vTextureCoord;
-   * uniform sampler2D uSampler;
-   * void main(void)
-   * {
-   *    gl_FragColor = texture2D(uSampler, vTextureCoord);
-   * }
-   * `;
-   *
-   * const myFilter = new PIXI.Filter(null, fragment);
-   * ```
-   *
-   * This filter is just one uniform less than {@link PIXI.filters.AlphaFilter AlphaFilter}.
-   *
-   * **outputFrame**
-   *
-   * The `outputFrame` holds the rectangle where filter is applied in screen (CSS) coordinates.
-   * It's the same as `renderer.screen` for a fullscreen filter.
-   * Only a part of  `outputFrame.zw` size of temporary Framebuffer is used,
-   * `(0, 0, outputFrame.width, outputFrame.height)`,
-   *
-   * Filters uses this quad to normalized (0-1) space, its passed into `aVertexPosition` attribute.
-   * To calculate vertex position in screen space using normalized (0-1) space:
-   *
-   * ```
-   * vec4 filterVertexPosition( void )
-   * {
-   *     vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;
-   *     return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);
-   * }
-   * ```
-   *
-   * **inputSize**
-   *
-   * Temporary framebuffer is different, it can be either the size of screen, either power-of-two.
-   * The `inputSize.xy` are size of temporary framebuffer that holds input.
-   * The `inputSize.zw` is inverted, it's a shortcut to evade division inside the shader.
-   *
-   * Set `inputSize.xy = outputFrame.zw` for a fullscreen filter.
-   *
-   * To calculate input normalized coordinate, you have to map it to filter normalized space.
-   * Multiply by `outputFrame.zw` to get input coordinate.
-   * Divide by `inputSize.xy` to get input normalized coordinate.
-   *
-   * ```
-   * vec2 filterTextureCoord( void )
-   * {
-   *     return aVertexPosition * (outputFrame.zw * inputSize.zw); // same as /inputSize.xy
-   * }
-   * ```
-   * **resolution**
-   *
-   * The `resolution` is the ratio of screen (CSS) pixels to real pixels.
-   *
-   * **inputPixel**
-   *
-   * `inputPixel.xy` is the size of framebuffer in real pixels, same as `inputSize.xy * resolution`
-   * `inputPixel.zw` is inverted `inputPixel.xy`.
-   *
-   * It's handy for filters that use neighbour pixels, like {@link PIXI.filters.FXAAFilter FXAAFilter}.
-   *
-   * **inputClamp**
-   *
-   * If you try to get info from outside of used part of Framebuffer - you'll get undefined behaviour.
-   * For displacements, coordinates has to be clamped.
-   *
-   * The `inputClamp.xy` is left-top pixel center, you may ignore it, because we use left-top part of Framebuffer
-   * `inputClamp.zw` is bottom-right pixel center.
-   *
-   * ```
-   * vec4 color = texture2D(uSampler, clamp(modifiedTextureCoord, inputClamp.xy, inputClamp.zw))
-   * ```
-   * OR
-   * ```
-   * vec4 color = texture2D(uSampler, min(modifigedTextureCoord, inputClamp.zw))
-   * ```
-   *
-   * ### Additional Information
-   *
-   * Complete documentation on Filter usage is located in the
-   * {@link https://github.com/pixijs/pixi.js/wiki/v5-Creating-filters Wiki}.
-   *
-   * Since PixiJS only had a handful of built-in filters, additional filters can be downloaded
-   * {@link https://github.com/pixijs/pixi-filters here} from the PixiJS Filters repository.
-   * @memberof PIXI
-   */
-  var Filter = /** @class */ (function (_super) {
-      __extends$i(Filter, _super);
-      /**
-       * @param vertexSrc - The source of the vertex shader.
-       * @param fragmentSrc - The source of the fragment shader.
-       * @param uniforms - Custom uniforms to use to augment the built-in ones.
-       */
-      function Filter(vertexSrc, fragmentSrc, uniforms) {
-          var _this = this;
-          var program = Program.from(vertexSrc || Filter.defaultVertexSrc, fragmentSrc || Filter.defaultFragmentSrc);
-          _this = _super.call(this, program, uniforms) || this;
-          _this.padding = 0;
-          _this.resolution = settings.FILTER_RESOLUTION;
-          _this.multisample = settings.FILTER_MULTISAMPLE;
-          _this.enabled = true;
-          _this.autoFit = true;
-          _this.state = new State();
-          return _this;
-      }
-      /**
-       * Applies the filter
-       * @param {PIXI.FilterSystem} filterManager - The renderer to retrieve the filter from
-       * @param {PIXI.RenderTexture} input - The input render target.
-       * @param {PIXI.RenderTexture} output - The target to output to.
-       * @param {PIXI.CLEAR_MODES} [clearMode] - Should the output be cleared before rendering to it.
-       * @param {object} [_currentState] - It's current state of filter.
-       *        There are some useful properties in the currentState :
-       *        target, filters, sourceFrame, destinationFrame, renderTarget, resolution
-       */
-      Filter.prototype.apply = function (filterManager, input, output, clearMode, _currentState) {
-          // do as you please!
-          filterManager.applyFilter(this, input, output, clearMode);
-          // or just do a regular render..
-      };
-      Object.defineProperty(Filter.prototype, "blendMode", {
-          /**
-           * Sets the blend mode of the filter.
-           * @default PIXI.BLEND_MODES.NORMAL
-           */
-          get: function () {
-              return this.state.blendMode;
-          },
-          set: function (value) {
-              this.state.blendMode = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Filter.prototype, "resolution", {
-          /**
-           * The resolution of the filter. Setting this to be lower will lower the quality but
-           * increase the performance of the filter.
-           */
-          get: function () {
-              return this._resolution;
-          },
-          set: function (value) {
-              this._resolution = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Filter, "defaultVertexSrc", {
-          /**
-           * The default vertex shader source
-           * @constant
-           */
-          get: function () {
-              return defaultVertex$2;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Filter, "defaultFragmentSrc", {
-          /**
-           * The default fragment shader source
-           * @constant
-           */
-          get: function () {
-              return defaultFragment$1;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return Filter;
-  }(Shader));
-
-  var vertex$4 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 otherMatrix;\n\nvarying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;\n}\n";
-
-  var fragment$7 = "varying vec2 vMaskCoord;\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform sampler2D mask;\nuniform float alpha;\nuniform float npmAlpha;\nuniform vec4 maskClamp;\n\nvoid main(void)\n{\n    float clip = step(3.5,\n        step(maskClamp.x, vMaskCoord.x) +\n        step(maskClamp.y, vMaskCoord.y) +\n        step(vMaskCoord.x, maskClamp.z) +\n        step(vMaskCoord.y, maskClamp.w));\n\n    vec4 original = texture2D(uSampler, vTextureCoord);\n    vec4 masky = texture2D(mask, vMaskCoord);\n    float alphaMul = 1.0 - npmAlpha * (1.0 - masky.a);\n\n    original *= (alphaMul * masky.r * alpha * clip);\n\n    gl_FragColor = original;\n}\n";
-
-  var tempMat$1 = new Matrix();
-  /**
-   * Class controls uv mapping from Texture normal space to BaseTexture normal space.
-   *
-   * Takes `trim` and `rotate` into account. May contain clamp settings for Meshes and TilingSprite.
-   *
-   * Can be used in Texture `uvMatrix` field, or separately, you can use different clamp settings on the same texture.
-   * If you want to add support for texture region of certain feature or filter, that's what you're looking for.
-   *
-   * Takes track of Texture changes through `_lastTextureID` private field.
-   * Use `update()` method call to track it from outside.
-   * @see PIXI.Texture
-   * @see PIXI.Mesh
-   * @see PIXI.TilingSprite
-   * @memberof PIXI
-   */
-  var TextureMatrix = /** @class */ (function () {
-      /**
-       * @param texture - observed texture
-       * @param clampMargin - Changes frame clamping, 0.5 by default. Use -0.5 for extra border.
-       */
-      function TextureMatrix(texture, clampMargin) {
-          this._texture = texture;
-          this.mapCoord = new Matrix();
-          this.uClampFrame = new Float32Array(4);
-          this.uClampOffset = new Float32Array(2);
-          this._textureID = -1;
-          this._updateID = 0;
-          this.clampOffset = 0;
-          this.clampMargin = (typeof clampMargin === 'undefined') ? 0.5 : clampMargin;
-          this.isSimple = false;
-      }
-      Object.defineProperty(TextureMatrix.prototype, "texture", {
-          /** Texture property. */
-          get: function () {
-              return this._texture;
-          },
-          set: function (value) {
-              this._texture = value;
-              this._textureID = -1;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Multiplies uvs array to transform
-       * @param uvs - mesh uvs
-       * @param [out=uvs] - output
-       * @returns - output
-       */
-      TextureMatrix.prototype.multiplyUvs = function (uvs, out) {
-          if (out === undefined) {
-              out = uvs;
-          }
-          var mat = this.mapCoord;
-          for (var i = 0; i < uvs.length; i += 2) {
-              var x = uvs[i];
-              var y = uvs[i + 1];
-              out[i] = (x * mat.a) + (y * mat.c) + mat.tx;
-              out[i + 1] = (x * mat.b) + (y * mat.d) + mat.ty;
-          }
-          return out;
-      };
-      /**
-       * Updates matrices if texture was changed.
-       * @param [forceUpdate=false] - if true, matrices will be updated any case
-       * @returns - Whether or not it was updated
-       */
-      TextureMatrix.prototype.update = function (forceUpdate) {
-          var tex = this._texture;
-          if (!tex || !tex.valid) {
-              return false;
-          }
-          if (!forceUpdate
-              && this._textureID === tex._updateID) {
-              return false;
-          }
-          this._textureID = tex._updateID;
-          this._updateID++;
-          var uvs = tex._uvs;
-          this.mapCoord.set(uvs.x1 - uvs.x0, uvs.y1 - uvs.y0, uvs.x3 - uvs.x0, uvs.y3 - uvs.y0, uvs.x0, uvs.y0);
-          var orig = tex.orig;
-          var trim = tex.trim;
-          if (trim) {
-              tempMat$1.set(orig.width / trim.width, 0, 0, orig.height / trim.height, -trim.x / trim.width, -trim.y / trim.height);
-              this.mapCoord.append(tempMat$1);
-          }
-          var texBase = tex.baseTexture;
-          var frame = this.uClampFrame;
-          var margin = this.clampMargin / texBase.resolution;
-          var offset = this.clampOffset;
-          frame[0] = (tex._frame.x + margin + offset) / texBase.width;
-          frame[1] = (tex._frame.y + margin + offset) / texBase.height;
-          frame[2] = (tex._frame.x + tex._frame.width - margin + offset) / texBase.width;
-          frame[3] = (tex._frame.y + tex._frame.height - margin + offset) / texBase.height;
-          this.uClampOffset[0] = offset / texBase.realWidth;
-          this.uClampOffset[1] = offset / texBase.realHeight;
-          this.isSimple = tex._frame.width === texBase.width
-              && tex._frame.height === texBase.height
-              && tex.rotate === 0;
-          return true;
-      };
-      return TextureMatrix;
-  }());
-
-  /**
-   * This handles a Sprite acting as a mask, as opposed to a Graphic.
-   *
-   * WebGL only.
-   * @memberof PIXI
-   */
-  var SpriteMaskFilter = /** @class */ (function (_super) {
-      __extends$i(SpriteMaskFilter, _super);
-      /** @ignore */
-      function SpriteMaskFilter(vertexSrc, fragmentSrc, uniforms) {
-          var _this = this;
-          var sprite = null;
-          if (typeof vertexSrc !== 'string' && fragmentSrc === undefined && uniforms === undefined) {
-              sprite = vertexSrc;
-              vertexSrc = undefined;
-              fragmentSrc = undefined;
-              uniforms = undefined;
-          }
-          _this = _super.call(this, vertexSrc || vertex$4, fragmentSrc || fragment$7, uniforms) || this;
-          _this.maskSprite = sprite;
-          _this.maskMatrix = new Matrix();
-          return _this;
-      }
-      Object.defineProperty(SpriteMaskFilter.prototype, "maskSprite", {
-          /**
-           * Sprite mask
-           * @type {PIXI.DisplayObject}
-           */
-          get: function () {
-              return this._maskSprite;
-          },
-          set: function (value) {
-              this._maskSprite = value;
-              if (this._maskSprite) {
-                  this._maskSprite.renderable = false;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Applies the filter
-       * @param filterManager - The renderer to retrieve the filter from
-       * @param input - The input render target.
-       * @param output - The target to output to.
-       * @param clearMode - Should the output be cleared before rendering to it.
-       */
-      SpriteMaskFilter.prototype.apply = function (filterManager, input, output, clearMode) {
-          var maskSprite = this._maskSprite;
-          var tex = maskSprite._texture;
-          if (!tex.valid) {
-              return;
-          }
-          if (!tex.uvMatrix) {
-              // margin = 0.0, let it bleed a bit, shader code becomes easier
-              // assuming that atlas textures were made with 1-pixel padding
-              tex.uvMatrix = new TextureMatrix(tex, 0.0);
-          }
-          tex.uvMatrix.update();
-          this.uniforms.npmAlpha = tex.baseTexture.alphaMode ? 0.0 : 1.0;
-          this.uniforms.mask = tex;
-          // get _normalized sprite texture coords_ and convert them to _normalized atlas texture coords_ with `prepend`
-          this.uniforms.otherMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, maskSprite)
-              .prepend(tex.uvMatrix.mapCoord);
-          this.uniforms.alpha = maskSprite.worldAlpha;
-          this.uniforms.maskClamp = tex.uvMatrix.uClampFrame;
-          filterManager.applyFilter(this, input, output, clearMode);
-      };
-      return SpriteMaskFilter;
-  }(Filter));
-
-  /**
-   * System plugin to the renderer to manage masks.
-   *
-   * There are three built-in types of masking:
-   * **Scissor Masking**: Scissor masking discards pixels that are outside of a rectangle called the scissor box. It is
-   *  the most performant as the scissor test is inexpensive. However, it can only be used when the mask is rectangular.
-   * **Stencil Masking**: Stencil masking discards pixels that don't overlap with the pixels rendered into the stencil
-   *  buffer. It is the next fastest option as it does not require rendering into a separate framebuffer. However, it does
-   *  cause the mask to be rendered **twice** for each masking operation; hence, minimize the rendering cost of your masks.
-   * **Sprite Mask Filtering**: Sprite mask filtering discards pixels based on the red channel of the sprite-mask's
-   *  texture. (Generally, the masking texture is grayscale). Using advanced techniques, you might be able to embed this
-   *  type of masking in a custom shader - and hence, bypassing the masking system fully for performance wins.
-   *
-   * The best type of masking is auto-detected when you `push` one. To use scissor masking, you must pass in a `Graphics`
-   * object with just a rectangle drawn.
-   *
-   * ## Mask Stacks
-   *
-   * In the scene graph, masks can be applied recursively, i.e. a mask can be applied during a masking operation. The mask
-   * stack stores the currently applied masks in order. Each {@link PIXI.BaseRenderTexture} holds its own mask stack, i.e.
-   * when you switch render-textures, the old masks only applied when you switch back to rendering to the old render-target.
-   * @memberof PIXI
-   */
-  var MaskSystem = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this System works for.
-       */
-      function MaskSystem(renderer) {
-          this.renderer = renderer;
-          this.enableScissor = true;
-          this.alphaMaskPool = [];
-          this.maskDataPool = [];
-          this.maskStack = [];
-          this.alphaMaskIndex = 0;
-      }
-      /**
-       * Changes the mask stack that is used by this System.
-       * @param maskStack - The mask stack
-       */
-      MaskSystem.prototype.setMaskStack = function (maskStack) {
-          this.maskStack = maskStack;
-          this.renderer.scissor.setMaskStack(maskStack);
-          this.renderer.stencil.setMaskStack(maskStack);
-      };
-      /**
-       * Enables the mask and appends it to the current mask stack.
-       *
-       * NOTE: The batch renderer should be flushed beforehand to prevent pending renders from being masked.
-       * @param {PIXI.DisplayObject} target - Display Object to push the mask to
-       * @param {PIXI.MaskData|PIXI.Sprite|PIXI.Graphics|PIXI.DisplayObject} maskDataOrTarget - The masking data.
-       */
-      MaskSystem.prototype.push = function (target, maskDataOrTarget) {
-          var maskData = maskDataOrTarget;
-          if (!maskData.isMaskData) {
-              var d = this.maskDataPool.pop() || new MaskData();
-              d.pooled = true;
-              d.maskObject = maskDataOrTarget;
-              maskData = d;
-          }
-          var maskAbove = this.maskStack.length !== 0 ? this.maskStack[this.maskStack.length - 1] : null;
-          maskData.copyCountersOrReset(maskAbove);
-          maskData._colorMask = maskAbove ? maskAbove._colorMask : 0xf;
-          if (maskData.autoDetect) {
-              this.detect(maskData);
-          }
-          maskData._target = target;
-          if (maskData.type !== exports.MASK_TYPES.SPRITE) {
-              this.maskStack.push(maskData);
-          }
-          if (maskData.enabled) {
-              switch (maskData.type) {
-                  case exports.MASK_TYPES.SCISSOR:
-                      this.renderer.scissor.push(maskData);
-                      break;
-                  case exports.MASK_TYPES.STENCIL:
-                      this.renderer.stencil.push(maskData);
-                      break;
-                  case exports.MASK_TYPES.SPRITE:
-                      maskData.copyCountersOrReset(null);
-                      this.pushSpriteMask(maskData);
-                      break;
-                  case exports.MASK_TYPES.COLOR:
-                      this.pushColorMask(maskData);
-                      break;
-              }
-          }
-          if (maskData.type === exports.MASK_TYPES.SPRITE) {
-              this.maskStack.push(maskData);
-          }
-      };
-      /**
-       * Removes the last mask from the mask stack and doesn't return it.
-       *
-       * NOTE: The batch renderer should be flushed beforehand to render the masked contents before the mask is removed.
-       * @param {PIXI.IMaskTarget} target - Display Object to pop the mask from
-       */
-      MaskSystem.prototype.pop = function (target) {
-          var maskData = this.maskStack.pop();
-          if (!maskData || maskData._target !== target) {
-              // TODO: add an assert when we have it
-              return;
-          }
-          if (maskData.enabled) {
-              switch (maskData.type) {
-                  case exports.MASK_TYPES.SCISSOR:
-                      this.renderer.scissor.pop(maskData);
-                      break;
-                  case exports.MASK_TYPES.STENCIL:
-                      this.renderer.stencil.pop(maskData.maskObject);
-                      break;
-                  case exports.MASK_TYPES.SPRITE:
-                      this.popSpriteMask(maskData);
-                      break;
-                  case exports.MASK_TYPES.COLOR:
-                      this.popColorMask(maskData);
-                      break;
-              }
-          }
-          maskData.reset();
-          if (maskData.pooled) {
-              this.maskDataPool.push(maskData);
-          }
-          if (this.maskStack.length !== 0) {
-              var maskCurrent = this.maskStack[this.maskStack.length - 1];
-              if (maskCurrent.type === exports.MASK_TYPES.SPRITE && maskCurrent._filters) {
-                  maskCurrent._filters[0].maskSprite = maskCurrent.maskObject;
-              }
-          }
-      };
-      /**
-       * Sets type of MaskData based on its maskObject.
-       * @param maskData
-       */
-      MaskSystem.prototype.detect = function (maskData) {
-          var maskObject = maskData.maskObject;
-          if (!maskObject) {
-              maskData.type = exports.MASK_TYPES.COLOR;
-          }
-          else if (maskObject.isSprite) {
-              maskData.type = exports.MASK_TYPES.SPRITE;
-          }
-          else if (this.enableScissor && this.renderer.scissor.testScissor(maskData)) {
-              maskData.type = exports.MASK_TYPES.SCISSOR;
-          }
-          else {
-              maskData.type = exports.MASK_TYPES.STENCIL;
-          }
-      };
-      /**
-       * Applies the Mask and adds it to the current filter stack.
-       * @param maskData - Sprite to be used as the mask.
-       */
-      MaskSystem.prototype.pushSpriteMask = function (maskData) {
-          var _a, _b;
-          var maskObject = maskData.maskObject;
-          var target = maskData._target;
-          var alphaMaskFilter = maskData._filters;
-          if (!alphaMaskFilter) {
-              alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex];
-              if (!alphaMaskFilter) {
-                  alphaMaskFilter = this.alphaMaskPool[this.alphaMaskIndex] = [new SpriteMaskFilter()];
-              }
-          }
-          var renderer = this.renderer;
-          var renderTextureSystem = renderer.renderTexture;
-          var resolution;
-          var multisample;
-          if (renderTextureSystem.current) {
-              var renderTexture = renderTextureSystem.current;
-              resolution = maskData.resolution || renderTexture.resolution;
-              multisample = (_a = maskData.multisample) !== null && _a !== void 0 ? _a : renderTexture.multisample;
-          }
-          else {
-              resolution = maskData.resolution || renderer.resolution;
-              multisample = (_b = maskData.multisample) !== null && _b !== void 0 ? _b : renderer.multisample;
-          }
-          alphaMaskFilter[0].resolution = resolution;
-          alphaMaskFilter[0].multisample = multisample;
-          alphaMaskFilter[0].maskSprite = maskObject;
-          var stashFilterArea = target.filterArea;
-          target.filterArea = maskObject.getBounds(true);
-          renderer.filter.push(target, alphaMaskFilter);
-          target.filterArea = stashFilterArea;
-          if (!maskData._filters) {
-              this.alphaMaskIndex++;
-          }
-      };
-      /**
-       * Removes the last filter from the filter stack and doesn't return it.
-       * @param maskData - Sprite to be used as the mask.
-       */
-      MaskSystem.prototype.popSpriteMask = function (maskData) {
-          this.renderer.filter.pop();
-          if (maskData._filters) {
-              maskData._filters[0].maskSprite = null;
-          }
-          else {
-              this.alphaMaskIndex--;
-              this.alphaMaskPool[this.alphaMaskIndex][0].maskSprite = null;
-          }
-      };
-      /**
-       * Pushes the color mask.
-       * @param maskData - The mask data
-       */
-      MaskSystem.prototype.pushColorMask = function (maskData) {
-          var currColorMask = maskData._colorMask;
-          var nextColorMask = maskData._colorMask = currColorMask & maskData.colorMask;
-          if (nextColorMask !== currColorMask) {
-              this.renderer.gl.colorMask((nextColorMask & 0x1) !== 0, (nextColorMask & 0x2) !== 0, (nextColorMask & 0x4) !== 0, (nextColorMask & 0x8) !== 0);
-          }
-      };
-      /**
-       * Pops the color mask.
-       * @param maskData - The mask data
-       */
-      MaskSystem.prototype.popColorMask = function (maskData) {
-          var currColorMask = maskData._colorMask;
-          var nextColorMask = this.maskStack.length > 0
-              ? this.maskStack[this.maskStack.length - 1]._colorMask : 0xf;
-          if (nextColorMask !== currColorMask) {
-              this.renderer.gl.colorMask((nextColorMask & 0x1) !== 0, (nextColorMask & 0x2) !== 0, (nextColorMask & 0x4) !== 0, (nextColorMask & 0x8) !== 0);
-          }
-      };
-      MaskSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return MaskSystem;
-  }());
-
-  /**
-   * System plugin to the renderer to manage specific types of masking operations.
-   * @memberof PIXI
-   */
-  var AbstractMaskSystem = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this System works for.
-       */
-      function AbstractMaskSystem(renderer) {
-          this.renderer = renderer;
-          this.maskStack = [];
-          this.glConst = 0;
-      }
-      /** Gets count of masks of certain type. */
-      AbstractMaskSystem.prototype.getStackLength = function () {
-          return this.maskStack.length;
-      };
-      /**
-       * Changes the mask stack that is used by this System.
-       * @param {PIXI.MaskData[]} maskStack - The mask stack
-       */
-      AbstractMaskSystem.prototype.setMaskStack = function (maskStack) {
-          var gl = this.renderer.gl;
-          var curStackLen = this.getStackLength();
-          this.maskStack = maskStack;
-          var newStackLen = this.getStackLength();
-          if (newStackLen !== curStackLen) {
-              if (newStackLen === 0) {
-                  gl.disable(this.glConst);
-              }
-              else {
-                  gl.enable(this.glConst);
-                  this._useCurrent();
-              }
-          }
-      };
-      /**
-       * Setup renderer to use the current mask data.
-       * @private
-       */
-      AbstractMaskSystem.prototype._useCurrent = function () {
-          // OVERWRITE;
-      };
-      /** Destroys the mask stack. */
-      AbstractMaskSystem.prototype.destroy = function () {
-          this.renderer = null;
-          this.maskStack = null;
-      };
-      return AbstractMaskSystem;
-  }());
-
-  var tempMatrix$1 = new Matrix();
-  var rectPool = [];
-  /**
-   * System plugin to the renderer to manage scissor masking.
-   *
-   * Scissor masking discards pixels outside of a rectangle called the scissor box. The scissor box is in the framebuffer
-   * viewport's space; however, the mask's rectangle is projected from world-space to viewport space automatically
-   * by this system.
-   * @memberof PIXI
-   */
-  var ScissorSystem = /** @class */ (function (_super) {
-      __extends$i(ScissorSystem, _super);
-      /**
-       * @param {PIXI.Renderer} renderer - The renderer this System works for.
-       */
-      function ScissorSystem(renderer) {
-          var _this = _super.call(this, renderer) || this;
-          _this.glConst = settings.ADAPTER.getWebGLRenderingContext().SCISSOR_TEST;
-          return _this;
-      }
-      ScissorSystem.prototype.getStackLength = function () {
-          var maskData = this.maskStack[this.maskStack.length - 1];
-          if (maskData) {
-              return maskData._scissorCounter;
-          }
-          return 0;
-      };
-      /**
-       * evaluates _boundsTransformed, _scissorRect for MaskData
-       * @param maskData
-       */
-      ScissorSystem.prototype.calcScissorRect = function (maskData) {
-          var _a;
-          if (maskData._scissorRectLocal) {
-              return;
-          }
-          var prevData = maskData._scissorRect;
-          var maskObject = maskData.maskObject;
-          var renderer = this.renderer;
-          var renderTextureSystem = renderer.renderTexture;
-          var rect = maskObject.getBounds(true, (_a = rectPool.pop()) !== null && _a !== void 0 ? _a : new Rectangle());
-          this.roundFrameToPixels(rect, renderTextureSystem.current ? renderTextureSystem.current.resolution : renderer.resolution, renderTextureSystem.sourceFrame, renderTextureSystem.destinationFrame, renderer.projection.transform);
-          if (prevData) {
-              rect.fit(prevData);
-          }
-          maskData._scissorRectLocal = rect;
-      };
-      ScissorSystem.isMatrixRotated = function (matrix) {
-          if (!matrix) {
-              return false;
-          }
-          var a = matrix.a, b = matrix.b, c = matrix.c, d = matrix.d;
-          // Skip if skew/rotation present in matrix, except for multiple of 90° rotation. If rotation
-          // is a multiple of 90°, then either pair of (b,c) or (a,d) will be (0,0).
-          return ((Math.abs(b) > 1e-4 || Math.abs(c) > 1e-4)
-              && (Math.abs(a) > 1e-4 || Math.abs(d) > 1e-4));
-      };
-      /**
-       * Test, whether the object can be scissor mask with current renderer projection.
-       * Calls "calcScissorRect()" if its true.
-       * @param maskData - mask data
-       * @returns whether Whether the object can be scissor mask
-       */
-      ScissorSystem.prototype.testScissor = function (maskData) {
-          var maskObject = maskData.maskObject;
-          if (!maskObject.isFastRect || !maskObject.isFastRect()) {
-              return false;
-          }
-          if (ScissorSystem.isMatrixRotated(maskObject.worldTransform)) {
-              return false;
-          }
-          if (ScissorSystem.isMatrixRotated(this.renderer.projection.transform)) {
-              return false;
-          }
-          this.calcScissorRect(maskData);
-          var rect = maskData._scissorRectLocal;
-          return rect.width > 0 && rect.height > 0;
-      };
-      ScissorSystem.prototype.roundFrameToPixels = function (frame, resolution, bindingSourceFrame, bindingDestinationFrame, transform) {
-          if (ScissorSystem.isMatrixRotated(transform)) {
-              return;
-          }
-          transform = transform ? tempMatrix$1.copyFrom(transform) : tempMatrix$1.identity();
-          // Get forward transform from world space to screen space
-          transform
-              .translate(-bindingSourceFrame.x, -bindingSourceFrame.y)
-              .scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height)
-              .translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
-          // Convert frame to screen space
-          this.renderer.filter.transformAABB(transform, frame);
-          frame.fit(bindingDestinationFrame);
-          frame.x = Math.round(frame.x * resolution);
-          frame.y = Math.round(frame.y * resolution);
-          frame.width = Math.round(frame.width * resolution);
-          frame.height = Math.round(frame.height * resolution);
-      };
-      /**
-       * Applies the Mask and adds it to the current stencil stack.
-       * @author alvin
-       * @param maskData - The mask data.
-       */
-      ScissorSystem.prototype.push = function (maskData) {
-          if (!maskData._scissorRectLocal) {
-              this.calcScissorRect(maskData);
-          }
-          var gl = this.renderer.gl;
-          if (!maskData._scissorRect) {
-              gl.enable(gl.SCISSOR_TEST);
-          }
-          maskData._scissorCounter++;
-          maskData._scissorRect = maskData._scissorRectLocal;
-          this._useCurrent();
-      };
-      /**
-       * This should be called after a mask is popped off the mask stack. It will rebind the scissor box to be latest with the
-       * last mask in the stack.
-       *
-       * This can also be called when you directly modify the scissor box and want to restore PixiJS state.
-       * @param maskData - The mask data.
-       */
-      ScissorSystem.prototype.pop = function (maskData) {
-          var gl = this.renderer.gl;
-          if (maskData) {
-              rectPool.push(maskData._scissorRectLocal);
-          }
-          if (this.getStackLength() > 0) {
-              this._useCurrent();
-          }
-          else {
-              gl.disable(gl.SCISSOR_TEST);
-          }
-      };
-      /**
-       * Setup renderer to use the current scissor data.
-       * @private
-       */
-      ScissorSystem.prototype._useCurrent = function () {
-          var rect = this.maskStack[this.maskStack.length - 1]._scissorRect;
-          var y;
-          if (this.renderer.renderTexture.current) {
-              y = rect.y;
-          }
-          else {
-              // flipY. In future we'll have it over renderTextures as an option
-              y = this.renderer.height - rect.height - rect.y;
-          }
-          this.renderer.gl.scissor(rect.x, y, rect.width, rect.height);
-      };
-      return ScissorSystem;
-  }(AbstractMaskSystem));
-
-  /**
-   * System plugin to the renderer to manage stencils (used for masks).
-   * @memberof PIXI
-   */
-  var StencilSystem = /** @class */ (function (_super) {
-      __extends$i(StencilSystem, _super);
-      /**
-       * @param renderer - The renderer this System works for.
-       */
-      function StencilSystem(renderer) {
-          var _this = _super.call(this, renderer) || this;
-          _this.glConst = settings.ADAPTER.getWebGLRenderingContext().STENCIL_TEST;
-          return _this;
-      }
-      StencilSystem.prototype.getStackLength = function () {
-          var maskData = this.maskStack[this.maskStack.length - 1];
-          if (maskData) {
-              return maskData._stencilCounter;
-          }
-          return 0;
-      };
-      /**
-       * Applies the Mask and adds it to the current stencil stack.
-       * @param maskData - The mask data
-       */
-      StencilSystem.prototype.push = function (maskData) {
-          var maskObject = maskData.maskObject;
-          var gl = this.renderer.gl;
-          var prevMaskCount = maskData._stencilCounter;
-          if (prevMaskCount === 0) {
-              // force use stencil texture in current framebuffer
-              this.renderer.framebuffer.forceStencil();
-              gl.clearStencil(0);
-              gl.clear(gl.STENCIL_BUFFER_BIT);
-              gl.enable(gl.STENCIL_TEST);
-          }
-          maskData._stencilCounter++;
-          var colorMask = maskData._colorMask;
-          if (colorMask !== 0) {
-              maskData._colorMask = 0;
-              gl.colorMask(false, false, false, false);
-          }
-          // Increment the reference stencil value where the new mask overlaps with the old ones.
-          gl.stencilFunc(gl.EQUAL, prevMaskCount, 0xFFFFFFFF);
-          gl.stencilOp(gl.KEEP, gl.KEEP, gl.INCR);
-          maskObject.renderable = true;
-          maskObject.render(this.renderer);
-          this.renderer.batch.flush();
-          maskObject.renderable = false;
-          if (colorMask !== 0) {
-              maskData._colorMask = colorMask;
-              gl.colorMask((colorMask & 1) !== 0, (colorMask & 2) !== 0, (colorMask & 4) !== 0, (colorMask & 8) !== 0);
-          }
-          this._useCurrent();
-      };
-      /**
-       * Pops stencil mask. MaskData is already removed from stack
-       * @param {PIXI.DisplayObject} maskObject - object of popped mask data
-       */
-      StencilSystem.prototype.pop = function (maskObject) {
-          var gl = this.renderer.gl;
-          if (this.getStackLength() === 0) {
-              // the stack is empty!
-              gl.disable(gl.STENCIL_TEST);
-          }
-          else {
-              var maskData = this.maskStack.length !== 0 ? this.maskStack[this.maskStack.length - 1] : null;
-              var colorMask = maskData ? maskData._colorMask : 0xf;
-              if (colorMask !== 0) {
-                  maskData._colorMask = 0;
-                  gl.colorMask(false, false, false, false);
-              }
-              // Decrement the reference stencil value where the popped mask overlaps with the other ones
-              gl.stencilOp(gl.KEEP, gl.KEEP, gl.DECR);
-              maskObject.renderable = true;
-              maskObject.render(this.renderer);
-              this.renderer.batch.flush();
-              maskObject.renderable = false;
-              if (colorMask !== 0) {
-                  maskData._colorMask = colorMask;
-                  gl.colorMask((colorMask & 0x1) !== 0, (colorMask & 0x2) !== 0, (colorMask & 0x4) !== 0, (colorMask & 0x8) !== 0);
-              }
-              this._useCurrent();
-          }
-      };
-      /**
-       * Setup renderer to use the current stencil data.
-       * @private
-       */
-      StencilSystem.prototype._useCurrent = function () {
-          var gl = this.renderer.gl;
-          gl.stencilFunc(gl.EQUAL, this.getStackLength(), 0xFFFFFFFF);
-          gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
-      };
-      return StencilSystem;
-  }(AbstractMaskSystem));
-
-  /**
-   * System plugin to the renderer to manage the projection matrix.
-   *
-   * The `projectionMatrix` is a global uniform provided to all shaders. It is used to transform points in world space to
-   * normalized device coordinates.
-   * @memberof PIXI
-   */
-  var ProjectionSystem = /** @class */ (function () {
-      /** @param renderer - The renderer this System works for. */
-      function ProjectionSystem(renderer) {
-          this.renderer = renderer;
-          this.destinationFrame = null;
-          this.sourceFrame = null;
-          this.defaultFrame = null;
-          this.projectionMatrix = new Matrix();
-          this.transform = null;
-      }
-      /**
-       * Updates the projection-matrix based on the sourceFrame → destinationFrame mapping provided.
-       *
-       * NOTE: It is expected you call `renderer.framebuffer.setViewport(destinationFrame)` after this. This is because
-       * the framebuffer viewport converts shader vertex output in normalized device coordinates to window coordinates.
-       *
-       * NOTE-2: {@link RenderTextureSystem#bind} updates the projection-matrix when you bind a render-texture. It is expected
-       * that you dirty the current bindings when calling this manually.
-       * @param destinationFrame - The rectangle in the render-target to render the contents into. If rendering to the canvas,
-       *  the origin is on the top-left; if rendering to a render-texture, the origin is on the bottom-left.
-       * @param sourceFrame - The rectangle in world space that contains the contents being rendered.
-       * @param resolution - The resolution of the render-target, which is the ratio of
-       *  world-space (or CSS) pixels to physical pixels.
-       * @param root - Whether the render-target is the screen. This is required because rendering to textures
-       *  is y-flipped (i.e. upside down relative to the screen).
-       */
-      ProjectionSystem.prototype.update = function (destinationFrame, sourceFrame, resolution, root) {
-          this.destinationFrame = destinationFrame || this.destinationFrame || this.defaultFrame;
-          this.sourceFrame = sourceFrame || this.sourceFrame || destinationFrame;
-          // Calculate object-space to clip-space projection
-          this.calculateProjection(this.destinationFrame, this.sourceFrame, resolution, root);
-          if (this.transform) {
-              this.projectionMatrix.append(this.transform);
-          }
-          var renderer = this.renderer;
-          renderer.globalUniforms.uniforms.projectionMatrix = this.projectionMatrix;
-          renderer.globalUniforms.update();
-          // this will work for now
-          // but would be sweet to stick and even on the global uniforms..
-          if (renderer.shader.shader) {
-              renderer.shader.syncUniformGroup(renderer.shader.shader.uniforms.globals);
-          }
-      };
-      /**
-       * Calculates the `projectionMatrix` to map points inside `sourceFrame` to inside `destinationFrame`.
-       * @param _destinationFrame - The destination frame in the render-target.
-       * @param sourceFrame - The source frame in world space.
-       * @param _resolution - The render-target's resolution, i.e. ratio of CSS to physical pixels.
-       * @param root - Whether rendering into the screen. Otherwise, if rendering to a framebuffer, the projection
-       *  is y-flipped.
-       */
-      ProjectionSystem.prototype.calculateProjection = function (_destinationFrame, sourceFrame, _resolution, root) {
-          var pm = this.projectionMatrix;
-          var sign = !root ? 1 : -1;
-          pm.identity();
-          pm.a = (1 / sourceFrame.width * 2);
-          pm.d = sign * (1 / sourceFrame.height * 2);
-          pm.tx = -1 - (sourceFrame.x * pm.a);
-          pm.ty = -sign - (sourceFrame.y * pm.d);
-      };
-      /**
-       * Sets the transform of the active render target to the given matrix.
-       * @param _matrix - The transformation matrix
-       */
-      ProjectionSystem.prototype.setTransform = function (_matrix) {
-          // this._activeRenderTarget.transform = matrix;
-      };
-      ProjectionSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return ProjectionSystem;
-  }());
-
-  // Temporary rectangle for assigned sourceFrame or destinationFrame
-  var tempRect = new Rectangle();
-  // Temporary rectangle for renderTexture destinationFrame
-  var tempRect2 = new Rectangle();
-  /* eslint-disable max-len */
-  /**
-   * System plugin to the renderer to manage render textures.
-   *
-   * Should be added after FramebufferSystem
-   *
-   * ### Frames
-   *
-   * The `RenderTextureSystem` holds a sourceFrame → destinationFrame projection. The following table explains the different
-   * coordinate spaces used:
-   *
-   * | Frame                  | Description                                                      | Coordinate System                                       |
-   * | ---------------------- | ---------------------------------------------------------------- | ------------------------------------------------------- |
-   * | sourceFrame            | The rectangle inside of which display-objects are being rendered | **World Space**: The origin on the top-left             |
-   * | destinationFrame       | The rectangle in the render-target (canvas or texture) into which contents should be rendered | If rendering to the canvas, this is in screen space and the origin is on the top-left. If rendering to a render-texture, this is in its base-texture's space with the origin on the bottom-left.  |
-   * | viewportFrame          | The framebuffer viewport corresponding to the destination-frame  | **Window Coordinates**: The origin is always on the bottom-left. |
-   * @memberof PIXI
-   */
-  var RenderTextureSystem = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this System works for.
-       */
-      function RenderTextureSystem(renderer) {
-          this.renderer = renderer;
-          this.clearColor = renderer._backgroundColorRgba;
-          this.defaultMaskStack = [];
-          this.current = null;
-          this.sourceFrame = new Rectangle();
-          this.destinationFrame = new Rectangle();
-          this.viewportFrame = new Rectangle();
-      }
-      /**
-       * Bind the current render texture.
-       * @param renderTexture - RenderTexture to bind, by default its `null` - the screen.
-       * @param sourceFrame - Part of world that is mapped to the renderTexture.
-       * @param destinationFrame - Part of renderTexture, by default it has the same size as sourceFrame.
-       */
-      RenderTextureSystem.prototype.bind = function (renderTexture, sourceFrame, destinationFrame) {
-          if (renderTexture === void 0) { renderTexture = null; }
-          var renderer = this.renderer;
-          this.current = renderTexture;
-          var baseTexture;
-          var framebuffer;
-          var resolution;
-          if (renderTexture) {
-              baseTexture = renderTexture.baseTexture;
-              resolution = baseTexture.resolution;
-              if (!sourceFrame) {
-                  tempRect.width = renderTexture.frame.width;
-                  tempRect.height = renderTexture.frame.height;
-                  sourceFrame = tempRect;
-              }
-              if (!destinationFrame) {
-                  tempRect2.x = renderTexture.frame.x;
-                  tempRect2.y = renderTexture.frame.y;
-                  tempRect2.width = sourceFrame.width;
-                  tempRect2.height = sourceFrame.height;
-                  destinationFrame = tempRect2;
-              }
-              framebuffer = baseTexture.framebuffer;
-          }
-          else {
-              resolution = renderer.resolution;
-              if (!sourceFrame) {
-                  tempRect.width = renderer.screen.width;
-                  tempRect.height = renderer.screen.height;
-                  sourceFrame = tempRect;
-              }
-              if (!destinationFrame) {
-                  destinationFrame = tempRect;
-                  destinationFrame.width = sourceFrame.width;
-                  destinationFrame.height = sourceFrame.height;
-              }
-          }
-          var viewportFrame = this.viewportFrame;
-          viewportFrame.x = destinationFrame.x * resolution;
-          viewportFrame.y = destinationFrame.y * resolution;
-          viewportFrame.width = destinationFrame.width * resolution;
-          viewportFrame.height = destinationFrame.height * resolution;
-          if (!renderTexture) {
-              viewportFrame.y = renderer.view.height - (viewportFrame.y + viewportFrame.height);
-          }
-          viewportFrame.ceil();
-          this.renderer.framebuffer.bind(framebuffer, viewportFrame);
-          this.renderer.projection.update(destinationFrame, sourceFrame, resolution, !framebuffer);
-          if (renderTexture) {
-              this.renderer.mask.setMaskStack(baseTexture.maskStack);
-          }
-          else {
-              this.renderer.mask.setMaskStack(this.defaultMaskStack);
-          }
-          this.sourceFrame.copyFrom(sourceFrame);
-          this.destinationFrame.copyFrom(destinationFrame);
-      };
-      /**
-       * Erases the render texture and fills the drawing area with a colour.
-       * @param clearColor - The color as rgba, default to use the renderer backgroundColor
-       * @param [mask=BUFFER_BITS.COLOR | BUFFER_BITS.DEPTH] - Bitwise OR of masks
-       *  that indicate the buffers to be cleared, by default COLOR and DEPTH buffers.
-       */
-      RenderTextureSystem.prototype.clear = function (clearColor, mask) {
-          if (this.current) {
-              clearColor = clearColor || this.current.baseTexture.clearColor;
-          }
-          else {
-              clearColor = clearColor || this.clearColor;
-          }
-          var destinationFrame = this.destinationFrame;
-          var baseFrame = this.current ? this.current.baseTexture : this.renderer.screen;
-          var clearMask = destinationFrame.width !== baseFrame.width || destinationFrame.height !== baseFrame.height;
-          if (clearMask) {
-              var _a = this.viewportFrame, x = _a.x, y = _a.y, width = _a.width, height = _a.height;
-              x = Math.round(x);
-              y = Math.round(y);
-              width = Math.round(width);
-              height = Math.round(height);
-              // TODO: ScissorSystem should cache whether the scissor test is enabled or not.
-              this.renderer.gl.enable(this.renderer.gl.SCISSOR_TEST);
-              this.renderer.gl.scissor(x, y, width, height);
-          }
-          this.renderer.framebuffer.clear(clearColor[0], clearColor[1], clearColor[2], clearColor[3], mask);
-          if (clearMask) {
-              // Restore the scissor box
-              this.renderer.scissor.pop();
-          }
-      };
-      RenderTextureSystem.prototype.resize = function () {
-          // resize the root only!
-          this.bind(null);
-      };
-      /** Resets render-texture state. */
-      RenderTextureSystem.prototype.reset = function () {
-          this.bind(null);
-      };
-      RenderTextureSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return RenderTextureSystem;
-  }());
-
-  function uboUpdate(_ud, _uv, _renderer, _syncData, buffer) {
-      _renderer.buffer.update(buffer);
-  }
-  // cv = CachedValue
-  // v = value
-  // ud = uniformData
-  // uv = uniformValue
-  // l = location
-  var UBO_TO_SINGLE_SETTERS = {
-      float: "\n        data[offset] = v;\n    ",
-      vec2: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n    ",
-      vec3: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n        data[offset+2] = v[2];\n\n    ",
-      vec4: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n        data[offset+2] = v[2];\n        data[offset+3] = v[3];\n    ",
-      mat2: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n\n        data[offset+4] = v[2];\n        data[offset+5] = v[3];\n    ",
-      mat3: "\n        data[offset] = v[0];\n        data[offset+1] = v[1];\n        data[offset+2] = v[2];\n\n        data[offset + 4] = v[3];\n        data[offset + 5] = v[4];\n        data[offset + 6] = v[5];\n\n        data[offset + 8] = v[6];\n        data[offset + 9] = v[7];\n        data[offset + 10] = v[8];\n    ",
-      mat4: "\n        for(var i = 0; i < 16; i++)\n        {\n            data[offset + i] = v[i];\n        }\n    "
-  };
-  var GLSL_TO_STD40_SIZE = {
-      float: 4,
-      vec2: 8,
-      vec3: 12,
-      vec4: 16,
-      int: 4,
-      ivec2: 8,
-      ivec3: 12,
-      ivec4: 16,
-      uint: 4,
-      uvec2: 8,
-      uvec3: 12,
-      uvec4: 16,
-      bool: 4,
-      bvec2: 8,
-      bvec3: 12,
-      bvec4: 16,
-      mat2: 16 * 2,
-      mat3: 16 * 3,
-      mat4: 16 * 4,
-  };
-  /**
-   * logic originally from here: https://github.com/sketchpunk/FunWithWebGL2/blob/master/lesson_022/Shaders.js
-   * rewrote it, but this was a great starting point to get a solid understanding of whats going on :)
-   * @ignore
-   * @param uniformData
-   */
-  function createUBOElements(uniformData) {
-      var uboElements = uniformData.map(function (data) {
-          return ({
-              data: data,
-              offset: 0,
-              dataLen: 0,
-              dirty: 0
-          });
-      });
-      var size = 0;
-      var chunkSize = 0;
-      var offset = 0;
-      for (var i = 0; i < uboElements.length; i++) {
-          var uboElement = uboElements[i];
-          size = GLSL_TO_STD40_SIZE[uboElement.data.type];
-          if (uboElement.data.size > 1) {
-              size = Math.max(size, 16) * uboElement.data.size;
-          }
-          uboElement.dataLen = size;
-          // add some size offset..
-          // must align to the nearest 16 bytes or internally nearest round size
-          if (chunkSize % size !== 0 && chunkSize < 16) {
-              // diff required to line up..
-              var lineUpValue = (chunkSize % size) % 16;
-              chunkSize += lineUpValue;
-              offset += lineUpValue;
-          }
-          if ((chunkSize + size) > 16) {
-              offset = Math.ceil(offset / 16) * 16;
-              uboElement.offset = offset;
-              offset += size;
-              chunkSize = size;
-          }
-          else {
-              uboElement.offset = offset;
-              chunkSize += size;
-              offset += size;
-          }
-      }
-      offset = Math.ceil(offset / 16) * 16;
-      return { uboElements: uboElements, size: offset };
-  }
-  function getUBOData(uniforms, uniformData) {
-      var usedUniformDatas = [];
-      // build..
-      for (var i in uniforms) {
-          if (uniformData[i]) {
-              usedUniformDatas.push(uniformData[i]);
-          }
-      }
-      // sort them out by index!
-      usedUniformDatas.sort(function (a, b) { return a.index - b.index; });
-      return usedUniformDatas;
-  }
-  function generateUniformBufferSync(group, uniformData) {
-      if (!group.autoManage) {
-          // if the group is nott automatically managed, we don't need to generate a special function for it...
-          return { size: 0, syncFunc: uboUpdate };
-      }
-      var usedUniformDatas = getUBOData(group.uniforms, uniformData);
-      var _a = createUBOElements(usedUniformDatas), uboElements = _a.uboElements, size = _a.size;
-      var funcFragments = ["\n    var v = null;\n    var v2 = null;\n    var cv = null;\n    var t = 0;\n    var gl = renderer.gl\n    var index = 0;\n    var data = buffer.data;\n    "];
-      for (var i = 0; i < uboElements.length; i++) {
-          var uboElement = uboElements[i];
-          var uniform = group.uniforms[uboElement.data.name];
-          var name = uboElement.data.name;
-          var parsed = false;
-          for (var j = 0; j < uniformParsers.length; j++) {
-              var uniformParser = uniformParsers[j];
-              if (uniformParser.codeUbo && uniformParser.test(uboElement.data, uniform)) {
-                  funcFragments.push("offset = " + uboElement.offset / 4 + ";", uniformParsers[j].codeUbo(uboElement.data.name, uniform));
-                  parsed = true;
-                  break;
-              }
-          }
-          if (!parsed) {
-              if (uboElement.data.size > 1) {
-                  var size_1 = mapSize(uboElement.data.type);
-                  var rowSize = Math.max(GLSL_TO_STD40_SIZE[uboElement.data.type] / 16, 1);
-                  var elementSize = size_1 / rowSize;
-                  var remainder = (4 - (elementSize % 4)) % 4;
-                  funcFragments.push("\n                cv = ud." + name + ".value;\n                v = uv." + name + ";\n                offset = " + uboElement.offset / 4 + ";\n\n                t = 0;\n\n                for(var i=0; i < " + uboElement.data.size * rowSize + "; i++)\n                {\n                    for(var j = 0; j < " + elementSize + "; j++)\n                    {\n                        data[offset++] = v[t++];\n                    }\n                    offset += " + remainder + ";\n                }\n\n                ");
-              }
-              else {
-                  var template = UBO_TO_SINGLE_SETTERS[uboElement.data.type];
-                  funcFragments.push("\n                cv = ud." + name + ".value;\n                v = uv." + name + ";\n                offset = " + uboElement.offset / 4 + ";\n                " + template + ";\n                ");
-              }
-          }
-      }
-      funcFragments.push("\n       renderer.buffer.update(buffer);\n    ");
-      return {
-          size: size,
-          // eslint-disable-next-line no-new-func
-          syncFunc: new Function('ud', 'uv', 'renderer', 'syncData', 'buffer', funcFragments.join('\n'))
-      };
-  }
-
-  /**
-   * @private
-   */
-  var IGLUniformData = /** @class */ (function () {
-      function IGLUniformData() {
-      }
-      return IGLUniformData;
-  }());
-  /**
-   * Helper class to create a WebGL Program
-   * @memberof PIXI
-   */
-  var GLProgram = /** @class */ (function () {
-      /**
-       * Makes a new Pixi program.
-       * @param program - webgl program
-       * @param uniformData - uniforms
-       */
-      function GLProgram(program, uniformData) {
-          this.program = program;
-          this.uniformData = uniformData;
-          this.uniformGroups = {};
-          this.uniformDirtyGroups = {};
-          this.uniformBufferBindings = {};
-      }
-      /** Destroys this program. */
-      GLProgram.prototype.destroy = function () {
-          this.uniformData = null;
-          this.uniformGroups = null;
-          this.uniformDirtyGroups = null;
-          this.uniformBufferBindings = null;
-          this.program = null;
-      };
-      return GLProgram;
-  }());
-
-  /**
-   * returns the attribute data from the program
-   * @private
-   * @param {WebGLProgram} [program] - the WebGL program
-   * @param {WebGLRenderingContext} [gl] - the WebGL context
-   * @returns {object} the attribute data for this program
-   */
-  function getAttributeData(program, gl) {
-      var attributes = {};
-      var totalAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
-      for (var i = 0; i < totalAttributes; i++) {
-          var attribData = gl.getActiveAttrib(program, i);
-          if (attribData.name.indexOf('gl_') === 0) {
-              continue;
-          }
-          var type = mapType(gl, attribData.type);
-          var data = {
-              type: type,
-              name: attribData.name,
-              size: mapSize(type),
-              location: gl.getAttribLocation(program, attribData.name),
-          };
-          attributes[attribData.name] = data;
-      }
-      return attributes;
-  }
-
-  /**
-   * returns the uniform data from the program
-   * @private
-   * @param program - the webgl program
-   * @param gl - the WebGL context
-   * @returns {object} the uniform data for this program
-   */
-  function getUniformData(program, gl) {
-      var uniforms = {};
-      var totalUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
-      for (var i = 0; i < totalUniforms; i++) {
-          var uniformData = gl.getActiveUniform(program, i);
-          var name = uniformData.name.replace(/\[.*?\]$/, '');
-          var isArray = !!(uniformData.name.match(/\[.*?\]$/));
-          var type = mapType(gl, uniformData.type);
-          uniforms[name] = {
-              name: name,
-              index: i,
-              type: type,
-              size: uniformData.size,
-              isArray: isArray,
-              value: defaultValue(type, uniformData.size),
-          };
-      }
-      return uniforms;
-  }
-
-  /**
-   * generates a WebGL Program object from a high level Pixi Program.
-   * @param gl - a rendering context on which to generate the program
-   * @param program - the high level Pixi Program.
-   */
-  function generateProgram(gl, program) {
-      var glVertShader = compileShader(gl, gl.VERTEX_SHADER, program.vertexSrc);
-      var glFragShader = compileShader(gl, gl.FRAGMENT_SHADER, program.fragmentSrc);
-      var webGLProgram = gl.createProgram();
-      gl.attachShader(webGLProgram, glVertShader);
-      gl.attachShader(webGLProgram, glFragShader);
-      gl.linkProgram(webGLProgram);
-      if (!gl.getProgramParameter(webGLProgram, gl.LINK_STATUS)) {
-          logProgramError(gl, webGLProgram, glVertShader, glFragShader);
-      }
-      program.attributeData = getAttributeData(webGLProgram, gl);
-      program.uniformData = getUniformData(webGLProgram, gl);
-      // GLSL 1.00: bind attributes sorted by name in ascending order
-      // GLSL 3.00: don't change the attribute locations that where chosen by the compiler
-      //            or assigned by the layout specifier in the shader source code
-      if (!(/^[ \t]*#[ \t]*version[ \t]+300[ \t]+es[ \t]*$/m).test(program.vertexSrc)) {
-          var keys = Object.keys(program.attributeData);
-          keys.sort(function (a, b) { return (a > b) ? 1 : -1; }); // eslint-disable-line no-confusing-arrow
-          for (var i = 0; i < keys.length; i++) {
-              program.attributeData[keys[i]].location = i;
-              gl.bindAttribLocation(webGLProgram, i, keys[i]);
-          }
-          gl.linkProgram(webGLProgram);
-      }
-      gl.deleteShader(glVertShader);
-      gl.deleteShader(glFragShader);
-      var uniformData = {};
-      for (var i in program.uniformData) {
-          var data = program.uniformData[i];
-          uniformData[i] = {
-              location: gl.getUniformLocation(webGLProgram, i),
-              value: defaultValue(data.type, data.size),
-          };
-      }
-      var glProgram = new GLProgram(webGLProgram, uniformData);
-      return glProgram;
-  }
-
-  var UID = 0;
-  // default sync data so we don't create a new one each time!
-  var defaultSyncData = { textureCount: 0, uboCount: 0 };
-  /**
-   * System plugin to the renderer to manage shaders.
-   * @memberof PIXI
-   */
-  var ShaderSystem = /** @class */ (function () {
-      /** @param renderer - The renderer this System works for. */
-      function ShaderSystem(renderer) {
-          this.destroyed = false;
-          this.renderer = renderer;
-          // Validation check that this environment support `new Function`
-          this.systemCheck();
-          this.gl = null;
-          this.shader = null;
-          this.program = null;
-          this.cache = {};
-          this._uboCache = {};
-          this.id = UID++;
-      }
-      /**
-       * Overrideable function by `@pixi/unsafe-eval` to silence
-       * throwing an error if platform doesn't support unsafe-evals.
-       * @private
-       */
-      ShaderSystem.prototype.systemCheck = function () {
-          if (!unsafeEvalSupported()) {
-              throw new Error('Current environment does not allow unsafe-eval, '
-                  + 'please use @pixi/unsafe-eval module to enable support.');
-          }
-      };
-      ShaderSystem.prototype.contextChange = function (gl) {
-          this.gl = gl;
-          this.reset();
-      };
-      /**
-       * Changes the current shader to the one given in parameter.
-       * @param shader - the new shader
-       * @param dontSync - false if the shader should automatically sync its uniforms.
-       * @returns the glProgram that belongs to the shader.
-       */
-      ShaderSystem.prototype.bind = function (shader, dontSync) {
-          shader.disposeRunner.add(this);
-          shader.uniforms.globals = this.renderer.globalUniforms;
-          var program = shader.program;
-          var glProgram = program.glPrograms[this.renderer.CONTEXT_UID] || this.generateProgram(shader);
-          this.shader = shader;
-          // TODO - some current Pixi plugins bypass this.. so it not safe to use yet..
-          if (this.program !== program) {
-              this.program = program;
-              this.gl.useProgram(glProgram.program);
-          }
-          if (!dontSync) {
-              defaultSyncData.textureCount = 0;
-              defaultSyncData.uboCount = 0;
-              this.syncUniformGroup(shader.uniformGroup, defaultSyncData);
-          }
-          return glProgram;
-      };
-      /**
-       * Uploads the uniforms values to the currently bound shader.
-       * @param uniforms - the uniforms values that be applied to the current shader
-       */
-      ShaderSystem.prototype.setUniforms = function (uniforms) {
-          var shader = this.shader.program;
-          var glProgram = shader.glPrograms[this.renderer.CONTEXT_UID];
-          shader.syncUniforms(glProgram.uniformData, uniforms, this.renderer);
-      };
-      /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-      /**
-       * Syncs uniforms on the group
-       * @param group - the uniform group to sync
-       * @param syncData - this is data that is passed to the sync function and any nested sync functions
-       */
-      ShaderSystem.prototype.syncUniformGroup = function (group, syncData) {
-          var glProgram = this.getGlProgram();
-          if (!group.static || group.dirtyId !== glProgram.uniformDirtyGroups[group.id]) {
-              glProgram.uniformDirtyGroups[group.id] = group.dirtyId;
-              this.syncUniforms(group, glProgram, syncData);
-          }
-      };
-      /**
-       * Overrideable by the @pixi/unsafe-eval package to use static syncUniforms instead.
-       * @param group
-       * @param glProgram
-       * @param syncData
-       */
-      ShaderSystem.prototype.syncUniforms = function (group, glProgram, syncData) {
-          var syncFunc = group.syncUniforms[this.shader.program.id] || this.createSyncGroups(group);
-          syncFunc(glProgram.uniformData, group.uniforms, this.renderer, syncData);
-      };
-      ShaderSystem.prototype.createSyncGroups = function (group) {
-          var id = this.getSignature(group, this.shader.program.uniformData, 'u');
-          if (!this.cache[id]) {
-              this.cache[id] = generateUniformsSync(group, this.shader.program.uniformData);
-          }
-          group.syncUniforms[this.shader.program.id] = this.cache[id];
-          return group.syncUniforms[this.shader.program.id];
-      };
-      /**
-       * Syncs uniform buffers
-       * @param group - the uniform buffer group to sync
-       * @param name - the name of the uniform buffer
-       */
-      ShaderSystem.prototype.syncUniformBufferGroup = function (group, name) {
-          var glProgram = this.getGlProgram();
-          if (!group.static || group.dirtyId !== 0 || !glProgram.uniformGroups[group.id]) {
-              group.dirtyId = 0;
-              var syncFunc = glProgram.uniformGroups[group.id]
-                  || this.createSyncBufferGroup(group, glProgram, name);
-              // TODO wrap update in a cache??
-              group.buffer.update();
-              syncFunc(glProgram.uniformData, group.uniforms, this.renderer, defaultSyncData, group.buffer);
-          }
-          this.renderer.buffer.bindBufferBase(group.buffer, glProgram.uniformBufferBindings[name]);
-      };
-      /**
-       * Will create a function that uploads a uniform buffer using the STD140 standard.
-       * The upload function will then be cached for future calls
-       * If a group is manually managed, then a simple upload function is generated
-       * @param group - the uniform buffer group to sync
-       * @param glProgram - the gl program to attach the uniform bindings to
-       * @param name - the name of the uniform buffer (must exist on the shader)
-       */
-      ShaderSystem.prototype.createSyncBufferGroup = function (group, glProgram, name) {
-          var gl = this.renderer.gl;
-          this.renderer.buffer.bind(group.buffer);
-          // bind them...
-          var uniformBlockIndex = this.gl.getUniformBlockIndex(glProgram.program, name);
-          glProgram.uniformBufferBindings[name] = this.shader.uniformBindCount;
-          gl.uniformBlockBinding(glProgram.program, uniformBlockIndex, this.shader.uniformBindCount);
-          this.shader.uniformBindCount++;
-          var id = this.getSignature(group, this.shader.program.uniformData, 'ubo');
-          var uboData = this._uboCache[id];
-          if (!uboData) {
-              uboData = this._uboCache[id] = generateUniformBufferSync(group, this.shader.program.uniformData);
-          }
-          if (group.autoManage) {
-              var data = new Float32Array(uboData.size / 4);
-              group.buffer.update(data);
-          }
-          glProgram.uniformGroups[group.id] = uboData.syncFunc;
-          return glProgram.uniformGroups[group.id];
-      };
-      /**
-       * Takes a uniform group and data and generates a unique signature for them.
-       * @param group - The uniform group to get signature of
-       * @param group.uniforms
-       * @param uniformData - Uniform information generated by the shader
-       * @param preFix
-       * @returns Unique signature of the uniform group
-       */
-      ShaderSystem.prototype.getSignature = function (group, uniformData, preFix) {
-          var uniforms = group.uniforms;
-          var strings = [preFix + "-"];
-          for (var i in uniforms) {
-              strings.push(i);
-              if (uniformData[i]) {
-                  strings.push(uniformData[i].type);
-              }
-          }
-          return strings.join('-');
-      };
-      /**
-       * Returns the underlying GLShade rof the currently bound shader.
-       *
-       * This can be handy for when you to have a little more control over the setting of your uniforms.
-       * @returns The glProgram for the currently bound Shader for this context
-       */
-      ShaderSystem.prototype.getGlProgram = function () {
-          if (this.shader) {
-              return this.shader.program.glPrograms[this.renderer.CONTEXT_UID];
-          }
-          return null;
-      };
-      /**
-       * Generates a glProgram version of the Shader provided.
-       * @param shader - The shader that the glProgram will be based on.
-       * @returns A shiny new glProgram!
-       */
-      ShaderSystem.prototype.generateProgram = function (shader) {
-          var gl = this.gl;
-          var program = shader.program;
-          var glProgram = generateProgram(gl, program);
-          program.glPrograms[this.renderer.CONTEXT_UID] = glProgram;
-          return glProgram;
-      };
-      /** Resets ShaderSystem state, does not affect WebGL state. */
-      ShaderSystem.prototype.reset = function () {
-          this.program = null;
-          this.shader = null;
-      };
-      /**
-       * Disposes shader.
-       * If disposing one equals with current shader, set current as null.
-       * @param shader - Shader object
-       */
-      ShaderSystem.prototype.disposeShader = function (shader) {
-          if (this.shader === shader) {
-              this.shader = null;
-          }
-      };
-      /** Destroys this System and removes all its textures. */
-      ShaderSystem.prototype.destroy = function () {
-          this.renderer = null;
-          // TODO implement destroy method for ShaderSystem
-          this.destroyed = true;
-      };
-      return ShaderSystem;
-  }());
-
-  /**
-   * Maps gl blend combinations to WebGL.
-   * @memberof PIXI
-   * @function mapWebGLBlendModesToPixi
-   * @private
-   * @param {WebGLRenderingContext} gl - The rendering context.
-   * @param {number[][]} [array=[]] - The array to output into.
-   * @returns {number[][]} Mapped modes.
-   */
-  function mapWebGLBlendModesToPixi(gl, array) {
-      if (array === void 0) { array = []; }
-      // TODO - premultiply alpha would be different.
-      // add a boolean for that!
-      array[exports.BLEND_MODES.NORMAL] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.ADD] = [gl.ONE, gl.ONE];
-      array[exports.BLEND_MODES.MULTIPLY] = [gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.SCREEN] = [gl.ONE, gl.ONE_MINUS_SRC_COLOR, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.OVERLAY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.DARKEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.LIGHTEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.COLOR_DODGE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.COLOR_BURN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.HARD_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.SOFT_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.DIFFERENCE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.EXCLUSION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.HUE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.SATURATION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.COLOR] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.LUMINOSITY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.NONE] = [0, 0];
-      // not-premultiplied blend modes
-      array[exports.BLEND_MODES.NORMAL_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.ADD_NPM] = [gl.SRC_ALPHA, gl.ONE, gl.ONE, gl.ONE];
-      array[exports.BLEND_MODES.SCREEN_NPM] = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_COLOR, gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
-      // composite operations
-      array[exports.BLEND_MODES.SRC_IN] = [gl.DST_ALPHA, gl.ZERO];
-      array[exports.BLEND_MODES.SRC_OUT] = [gl.ONE_MINUS_DST_ALPHA, gl.ZERO];
-      array[exports.BLEND_MODES.SRC_ATOP] = [gl.DST_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.DST_OVER] = [gl.ONE_MINUS_DST_ALPHA, gl.ONE];
-      array[exports.BLEND_MODES.DST_IN] = [gl.ZERO, gl.SRC_ALPHA];
-      array[exports.BLEND_MODES.DST_OUT] = [gl.ZERO, gl.ONE_MINUS_SRC_ALPHA];
-      array[exports.BLEND_MODES.DST_ATOP] = [gl.ONE_MINUS_DST_ALPHA, gl.SRC_ALPHA];
-      array[exports.BLEND_MODES.XOR] = [gl.ONE_MINUS_DST_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
-      // SUBTRACT from flash
-      array[exports.BLEND_MODES.SUBTRACT] = [gl.ONE, gl.ONE, gl.ONE, gl.ONE, gl.FUNC_REVERSE_SUBTRACT, gl.FUNC_ADD];
-      return array;
-  }
-
-  var BLEND = 0;
-  var OFFSET = 1;
-  var CULLING = 2;
-  var DEPTH_TEST = 3;
-  var WINDING = 4;
-  var DEPTH_MASK = 5;
-  /**
-   * System plugin to the renderer to manage WebGL state machines.
-   * @memberof PIXI
-   */
-  var StateSystem = /** @class */ (function () {
-      function StateSystem() {
-          this.gl = null;
-          this.stateId = 0;
-          this.polygonOffset = 0;
-          this.blendMode = exports.BLEND_MODES.NONE;
-          this._blendEq = false;
-          // map functions for when we set state..
-          this.map = [];
-          this.map[BLEND] = this.setBlend;
-          this.map[OFFSET] = this.setOffset;
-          this.map[CULLING] = this.setCullFace;
-          this.map[DEPTH_TEST] = this.setDepthTest;
-          this.map[WINDING] = this.setFrontFace;
-          this.map[DEPTH_MASK] = this.setDepthMask;
-          this.checks = [];
-          this.defaultState = new State();
-          this.defaultState.blend = true;
-      }
-      StateSystem.prototype.contextChange = function (gl) {
-          this.gl = gl;
-          this.blendModes = mapWebGLBlendModesToPixi(gl);
-          this.set(this.defaultState);
-          this.reset();
-      };
-      /**
-       * Sets the current state
-       * @param {*} state - The state to set.
-       */
-      StateSystem.prototype.set = function (state) {
-          state = state || this.defaultState;
-          // TODO maybe to an object check? ( this.state === state )?
-          if (this.stateId !== state.data) {
-              var diff = this.stateId ^ state.data;
-              var i = 0;
-              // order from least to most common
-              while (diff) {
-                  if (diff & 1) {
-                      // state change!
-                      this.map[i].call(this, !!(state.data & (1 << i)));
-                  }
-                  diff = diff >> 1;
-                  i++;
-              }
-              this.stateId = state.data;
-          }
-          // based on the above settings we check for specific modes..
-          // for example if blend is active we check and set the blend modes
-          // or of polygon offset is active we check the poly depth.
-          for (var i = 0; i < this.checks.length; i++) {
-              this.checks[i](this, state);
-          }
-      };
-      /**
-       * Sets the state, when previous state is unknown.
-       * @param {*} state - The state to set
-       */
-      StateSystem.prototype.forceState = function (state) {
-          state = state || this.defaultState;
-          for (var i = 0; i < this.map.length; i++) {
-              this.map[i].call(this, !!(state.data & (1 << i)));
-          }
-          for (var i = 0; i < this.checks.length; i++) {
-              this.checks[i](this, state);
-          }
-          this.stateId = state.data;
-      };
-      /**
-       * Sets whether to enable or disable blending.
-       * @param value - Turn on or off WebGl blending.
-       */
-      StateSystem.prototype.setBlend = function (value) {
-          this.updateCheck(StateSystem.checkBlendMode, value);
-          this.gl[value ? 'enable' : 'disable'](this.gl.BLEND);
-      };
-      /**
-       * Sets whether to enable or disable polygon offset fill.
-       * @param value - Turn on or off webgl polygon offset testing.
-       */
-      StateSystem.prototype.setOffset = function (value) {
-          this.updateCheck(StateSystem.checkPolygonOffset, value);
-          this.gl[value ? 'enable' : 'disable'](this.gl.POLYGON_OFFSET_FILL);
-      };
-      /**
-       * Sets whether to enable or disable depth test.
-       * @param value - Turn on or off webgl depth testing.
-       */
-      StateSystem.prototype.setDepthTest = function (value) {
-          this.gl[value ? 'enable' : 'disable'](this.gl.DEPTH_TEST);
-      };
-      /**
-       * Sets whether to enable or disable depth mask.
-       * @param value - Turn on or off webgl depth mask.
-       */
-      StateSystem.prototype.setDepthMask = function (value) {
-          this.gl.depthMask(value);
-      };
-      /**
-       * Sets whether to enable or disable cull face.
-       * @param {boolean} value - Turn on or off webgl cull face.
-       */
-      StateSystem.prototype.setCullFace = function (value) {
-          this.gl[value ? 'enable' : 'disable'](this.gl.CULL_FACE);
-      };
-      /**
-       * Sets the gl front face.
-       * @param {boolean} value - true is clockwise and false is counter-clockwise
-       */
-      StateSystem.prototype.setFrontFace = function (value) {
-          this.gl.frontFace(this.gl[value ? 'CW' : 'CCW']);
-      };
-      /**
-       * Sets the blend mode.
-       * @param {number} value - The blend mode to set to.
-       */
-      StateSystem.prototype.setBlendMode = function (value) {
-          if (value === this.blendMode) {
-              return;
-          }
-          this.blendMode = value;
-          var mode = this.blendModes[value];
-          var gl = this.gl;
-          if (mode.length === 2) {
-              gl.blendFunc(mode[0], mode[1]);
-          }
-          else {
-              gl.blendFuncSeparate(mode[0], mode[1], mode[2], mode[3]);
-          }
-          if (mode.length === 6) {
-              this._blendEq = true;
-              gl.blendEquationSeparate(mode[4], mode[5]);
-          }
-          else if (this._blendEq) {
-              this._blendEq = false;
-              gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD);
-          }
-      };
-      /**
-       * Sets the polygon offset.
-       * @param {number} value - the polygon offset
-       * @param {number} scale - the polygon offset scale
-       */
-      StateSystem.prototype.setPolygonOffset = function (value, scale) {
-          this.gl.polygonOffset(value, scale);
-      };
-      // used
-      /** Resets all the logic and disables the VAOs. */
-      StateSystem.prototype.reset = function () {
-          this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, false);
-          this.forceState(this.defaultState);
-          this._blendEq = true;
-          this.blendMode = -1;
-          this.setBlendMode(0);
-      };
-      /**
-       * Checks to see which updates should be checked based on which settings have been activated.
-       *
-       * For example, if blend is enabled then we should check the blend modes each time the state is changed
-       * or if polygon fill is activated then we need to check if the polygon offset changes.
-       * The idea is that we only check what we have too.
-       * @param func - the checking function to add or remove
-       * @param value - should the check function be added or removed.
-       */
-      StateSystem.prototype.updateCheck = function (func, value) {
-          var index = this.checks.indexOf(func);
-          if (value && index === -1) {
-              this.checks.push(func);
-          }
-          else if (!value && index !== -1) {
-              this.checks.splice(index, 1);
-          }
-      };
-      /**
-       * A private little wrapper function that we call to check the blend mode.
-       * @param system - the System to perform the state check on
-       * @param state - the state that the blendMode will pulled from
-       */
-      StateSystem.checkBlendMode = function (system, state) {
-          system.setBlendMode(state.blendMode);
-      };
-      /**
-       * A private little wrapper function that we call to check the polygon offset.
-       * @param system - the System to perform the state check on
-       * @param state - the state that the blendMode will pulled from
-       */
-      StateSystem.checkPolygonOffset = function (system, state) {
-          system.setPolygonOffset(1, state.polygonOffset);
-      };
-      /**
-       * @ignore
-       */
-      StateSystem.prototype.destroy = function () {
-          this.gl = null;
-      };
-      return StateSystem;
-  }());
-
-  /**
-   * System plugin to the renderer to manage texture garbage collection on the GPU,
-   * ensuring that it does not get clogged up with textures that are no longer being used.
-   * @memberof PIXI
-   */
-  var TextureGCSystem = /** @class */ (function () {
-      /** @param renderer - The renderer this System works for. */
-      function TextureGCSystem(renderer) {
-          this.renderer = renderer;
-          this.count = 0;
-          this.checkCount = 0;
-          this.maxIdle = settings.GC_MAX_IDLE;
-          this.checkCountMax = settings.GC_MAX_CHECK_COUNT;
-          this.mode = settings.GC_MODE;
-      }
-      /**
-       * Checks to see when the last time a texture was used
-       * if the texture has not been used for a specified amount of time it will be removed from the GPU
-       */
-      TextureGCSystem.prototype.postrender = function () {
-          if (!this.renderer.renderingToScreen) {
-              return;
-          }
-          this.count++;
-          if (this.mode === exports.GC_MODES.MANUAL) {
-              return;
-          }
-          this.checkCount++;
-          if (this.checkCount > this.checkCountMax) {
-              this.checkCount = 0;
-              this.run();
-          }
-      };
-      /**
-       * Checks to see when the last time a texture was used
-       * if the texture has not been used for a specified amount of time it will be removed from the GPU
-       */
-      TextureGCSystem.prototype.run = function () {
-          var tm = this.renderer.texture;
-          var managedTextures = tm.managedTextures;
-          var wasRemoved = false;
-          for (var i = 0; i < managedTextures.length; i++) {
-              var texture = managedTextures[i];
-              // only supports non generated textures at the moment!
-              if (!texture.framebuffer && this.count - texture.touched > this.maxIdle) {
-                  tm.destroyTexture(texture, true);
-                  managedTextures[i] = null;
-                  wasRemoved = true;
-              }
-          }
-          if (wasRemoved) {
-              var j = 0;
-              for (var i = 0; i < managedTextures.length; i++) {
-                  if (managedTextures[i] !== null) {
-                      managedTextures[j++] = managedTextures[i];
-                  }
-              }
-              managedTextures.length = j;
-          }
-      };
-      /**
-       * Removes all the textures within the specified displayObject and its children from the GPU
-       * @param {PIXI.DisplayObject} displayObject - the displayObject to remove the textures from.
-       */
-      TextureGCSystem.prototype.unload = function (displayObject) {
-          var tm = this.renderer.texture;
-          var texture = displayObject._texture;
-          // only destroy non generated textures
-          if (texture && !texture.framebuffer) {
-              tm.destroyTexture(texture);
-          }
-          for (var i = displayObject.children.length - 1; i >= 0; i--) {
-              this.unload(displayObject.children[i]);
-          }
-      };
-      TextureGCSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return TextureGCSystem;
-  }());
-
-  /**
-   * Returns a lookup table that maps each type-format pair to a compatible internal format.
-   * @memberof PIXI
-   * @function mapTypeAndFormatToInternalFormat
-   * @private
-   * @param {WebGLRenderingContext} gl - The rendering context.
-   * @returns Lookup table.
-   */
-  function mapTypeAndFormatToInternalFormat(gl) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
-      var table;
-      if ('WebGL2RenderingContext' in globalThis && gl instanceof globalThis.WebGL2RenderingContext) {
-          table = (_a = {},
-              _a[exports.TYPES.UNSIGNED_BYTE] = (_b = {},
-                  _b[exports.FORMATS.RGBA] = gl.RGBA8,
-                  _b[exports.FORMATS.RGB] = gl.RGB8,
-                  _b[exports.FORMATS.RG] = gl.RG8,
-                  _b[exports.FORMATS.RED] = gl.R8,
-                  _b[exports.FORMATS.RGBA_INTEGER] = gl.RGBA8UI,
-                  _b[exports.FORMATS.RGB_INTEGER] = gl.RGB8UI,
-                  _b[exports.FORMATS.RG_INTEGER] = gl.RG8UI,
-                  _b[exports.FORMATS.RED_INTEGER] = gl.R8UI,
-                  _b[exports.FORMATS.ALPHA] = gl.ALPHA,
-                  _b[exports.FORMATS.LUMINANCE] = gl.LUMINANCE,
-                  _b[exports.FORMATS.LUMINANCE_ALPHA] = gl.LUMINANCE_ALPHA,
-                  _b),
-              _a[exports.TYPES.BYTE] = (_c = {},
-                  _c[exports.FORMATS.RGBA] = gl.RGBA8_SNORM,
-                  _c[exports.FORMATS.RGB] = gl.RGB8_SNORM,
-                  _c[exports.FORMATS.RG] = gl.RG8_SNORM,
-                  _c[exports.FORMATS.RED] = gl.R8_SNORM,
-                  _c[exports.FORMATS.RGBA_INTEGER] = gl.RGBA8I,
-                  _c[exports.FORMATS.RGB_INTEGER] = gl.RGB8I,
-                  _c[exports.FORMATS.RG_INTEGER] = gl.RG8I,
-                  _c[exports.FORMATS.RED_INTEGER] = gl.R8I,
-                  _c),
-              _a[exports.TYPES.UNSIGNED_SHORT] = (_d = {},
-                  _d[exports.FORMATS.RGBA_INTEGER] = gl.RGBA16UI,
-                  _d[exports.FORMATS.RGB_INTEGER] = gl.RGB16UI,
-                  _d[exports.FORMATS.RG_INTEGER] = gl.RG16UI,
-                  _d[exports.FORMATS.RED_INTEGER] = gl.R16UI,
-                  _d[exports.FORMATS.DEPTH_COMPONENT] = gl.DEPTH_COMPONENT16,
-                  _d),
-              _a[exports.TYPES.SHORT] = (_e = {},
-                  _e[exports.FORMATS.RGBA_INTEGER] = gl.RGBA16I,
-                  _e[exports.FORMATS.RGB_INTEGER] = gl.RGB16I,
-                  _e[exports.FORMATS.RG_INTEGER] = gl.RG16I,
-                  _e[exports.FORMATS.RED_INTEGER] = gl.R16I,
-                  _e),
-              _a[exports.TYPES.UNSIGNED_INT] = (_f = {},
-                  _f[exports.FORMATS.RGBA_INTEGER] = gl.RGBA32UI,
-                  _f[exports.FORMATS.RGB_INTEGER] = gl.RGB32UI,
-                  _f[exports.FORMATS.RG_INTEGER] = gl.RG32UI,
-                  _f[exports.FORMATS.RED_INTEGER] = gl.R32UI,
-                  _f[exports.FORMATS.DEPTH_COMPONENT] = gl.DEPTH_COMPONENT24,
-                  _f),
-              _a[exports.TYPES.INT] = (_g = {},
-                  _g[exports.FORMATS.RGBA_INTEGER] = gl.RGBA32I,
-                  _g[exports.FORMATS.RGB_INTEGER] = gl.RGB32I,
-                  _g[exports.FORMATS.RG_INTEGER] = gl.RG32I,
-                  _g[exports.FORMATS.RED_INTEGER] = gl.R32I,
-                  _g),
-              _a[exports.TYPES.FLOAT] = (_h = {},
-                  _h[exports.FORMATS.RGBA] = gl.RGBA32F,
-                  _h[exports.FORMATS.RGB] = gl.RGB32F,
-                  _h[exports.FORMATS.RG] = gl.RG32F,
-                  _h[exports.FORMATS.RED] = gl.R32F,
-                  _h[exports.FORMATS.DEPTH_COMPONENT] = gl.DEPTH_COMPONENT32F,
-                  _h),
-              _a[exports.TYPES.HALF_FLOAT] = (_j = {},
-                  _j[exports.FORMATS.RGBA] = gl.RGBA16F,
-                  _j[exports.FORMATS.RGB] = gl.RGB16F,
-                  _j[exports.FORMATS.RG] = gl.RG16F,
-                  _j[exports.FORMATS.RED] = gl.R16F,
-                  _j),
-              _a[exports.TYPES.UNSIGNED_SHORT_5_6_5] = (_k = {},
-                  _k[exports.FORMATS.RGB] = gl.RGB565,
-                  _k),
-              _a[exports.TYPES.UNSIGNED_SHORT_4_4_4_4] = (_l = {},
-                  _l[exports.FORMATS.RGBA] = gl.RGBA4,
-                  _l),
-              _a[exports.TYPES.UNSIGNED_SHORT_5_5_5_1] = (_m = {},
-                  _m[exports.FORMATS.RGBA] = gl.RGB5_A1,
-                  _m),
-              _a[exports.TYPES.UNSIGNED_INT_2_10_10_10_REV] = (_o = {},
-                  _o[exports.FORMATS.RGBA] = gl.RGB10_A2,
-                  _o[exports.FORMATS.RGBA_INTEGER] = gl.RGB10_A2UI,
-                  _o),
-              _a[exports.TYPES.UNSIGNED_INT_10F_11F_11F_REV] = (_p = {},
-                  _p[exports.FORMATS.RGB] = gl.R11F_G11F_B10F,
-                  _p),
-              _a[exports.TYPES.UNSIGNED_INT_5_9_9_9_REV] = (_q = {},
-                  _q[exports.FORMATS.RGB] = gl.RGB9_E5,
-                  _q),
-              _a[exports.TYPES.UNSIGNED_INT_24_8] = (_r = {},
-                  _r[exports.FORMATS.DEPTH_STENCIL] = gl.DEPTH24_STENCIL8,
-                  _r),
-              _a[exports.TYPES.FLOAT_32_UNSIGNED_INT_24_8_REV] = (_s = {},
-                  _s[exports.FORMATS.DEPTH_STENCIL] = gl.DEPTH32F_STENCIL8,
-                  _s),
-              _a);
-      }
-      else {
-          table = (_t = {},
-              _t[exports.TYPES.UNSIGNED_BYTE] = (_u = {},
-                  _u[exports.FORMATS.RGBA] = gl.RGBA,
-                  _u[exports.FORMATS.RGB] = gl.RGB,
-                  _u[exports.FORMATS.ALPHA] = gl.ALPHA,
-                  _u[exports.FORMATS.LUMINANCE] = gl.LUMINANCE,
-                  _u[exports.FORMATS.LUMINANCE_ALPHA] = gl.LUMINANCE_ALPHA,
-                  _u),
-              _t[exports.TYPES.UNSIGNED_SHORT_5_6_5] = (_v = {},
-                  _v[exports.FORMATS.RGB] = gl.RGB,
-                  _v),
-              _t[exports.TYPES.UNSIGNED_SHORT_4_4_4_4] = (_w = {},
-                  _w[exports.FORMATS.RGBA] = gl.RGBA,
-                  _w),
-              _t[exports.TYPES.UNSIGNED_SHORT_5_5_5_1] = (_x = {},
-                  _x[exports.FORMATS.RGBA] = gl.RGBA,
-                  _x),
-              _t);
-      }
-      return table;
-  }
-
-  /**
-   * Internal texture for WebGL context.
-   * @memberof PIXI
-   */
-  var GLTexture = /** @class */ (function () {
-      function GLTexture(texture) {
-          this.texture = texture;
-          this.width = -1;
-          this.height = -1;
-          this.dirtyId = -1;
-          this.dirtyStyleId = -1;
-          this.mipmap = false;
-          this.wrapMode = 33071;
-          this.type = exports.TYPES.UNSIGNED_BYTE;
-          this.internalFormat = exports.FORMATS.RGBA;
-          this.samplerType = 0;
-      }
-      return GLTexture;
-  }());
-
-  /**
-   * System plugin to the renderer to manage textures.
-   * @memberof PIXI
-   */
-  var TextureSystem = /** @class */ (function () {
-      /**
-       * @param renderer - The renderer this system works for.
-       */
-      function TextureSystem(renderer) {
-          this.renderer = renderer;
-          // TODO set to max textures...
-          this.boundTextures = [];
-          this.currentLocation = -1;
-          this.managedTextures = [];
-          this._unknownBoundTextures = false;
-          this.unknownTexture = new BaseTexture();
-          this.hasIntegerTextures = false;
-      }
-      /** Sets up the renderer context and necessary buffers. */
-      TextureSystem.prototype.contextChange = function () {
-          var gl = this.gl = this.renderer.gl;
-          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
-          this.webGLVersion = this.renderer.context.webGLVersion;
-          this.internalFormats = mapTypeAndFormatToInternalFormat(gl);
-          var maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
-          this.boundTextures.length = maxTextures;
-          for (var i = 0; i < maxTextures; i++) {
-              this.boundTextures[i] = null;
-          }
-          // TODO move this.. to a nice make empty textures class..
-          this.emptyTextures = {};
-          var emptyTexture2D = new GLTexture(gl.createTexture());
-          gl.bindTexture(gl.TEXTURE_2D, emptyTexture2D.texture);
-          gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4));
-          this.emptyTextures[gl.TEXTURE_2D] = emptyTexture2D;
-          this.emptyTextures[gl.TEXTURE_CUBE_MAP] = new GLTexture(gl.createTexture());
-          gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.emptyTextures[gl.TEXTURE_CUBE_MAP].texture);
-          for (var i = 0; i < 6; i++) {
-              gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
-          }
-          gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-          gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-          for (var i = 0; i < this.boundTextures.length; i++) {
-              this.bind(null, i);
-          }
-      };
-      /**
-       * Bind a texture to a specific location
-       *
-       * If you want to unbind something, please use `unbind(texture)` instead of `bind(null, textureLocation)`
-       * @param texture - Texture to bind
-       * @param [location=0] - Location to bind at
-       */
-      TextureSystem.prototype.bind = function (texture, location) {
-          if (location === void 0) { location = 0; }
-          var gl = this.gl;
-          texture = texture === null || texture === void 0 ? void 0 : texture.castToBaseTexture();
-          // cannot bind partial texture
-          // TODO: report a warning
-          if (texture && texture.valid && !texture.parentTextureArray) {
-              texture.touched = this.renderer.textureGC.count;
-              var glTexture = texture._glTextures[this.CONTEXT_UID] || this.initTexture(texture);
-              if (this.boundTextures[location] !== texture) {
-                  if (this.currentLocation !== location) {
-                      this.currentLocation = location;
-                      gl.activeTexture(gl.TEXTURE0 + location);
-                  }
-                  gl.bindTexture(texture.target, glTexture.texture);
-              }
-              if (glTexture.dirtyId !== texture.dirtyId) {
-                  if (this.currentLocation !== location) {
-                      this.currentLocation = location;
-                      gl.activeTexture(gl.TEXTURE0 + location);
-                  }
-                  this.updateTexture(texture);
-              }
-              else if (glTexture.dirtyStyleId !== texture.dirtyStyleId) {
-                  this.updateTextureStyle(texture);
-              }
-              this.boundTextures[location] = texture;
-          }
-          else {
-              if (this.currentLocation !== location) {
-                  this.currentLocation = location;
-                  gl.activeTexture(gl.TEXTURE0 + location);
-              }
-              gl.bindTexture(gl.TEXTURE_2D, this.emptyTextures[gl.TEXTURE_2D].texture);
-              this.boundTextures[location] = null;
-          }
-      };
-      /** Resets texture location and bound textures Actual `bind(null, i)` calls will be performed at next `unbind()` call */
-      TextureSystem.prototype.reset = function () {
-          this._unknownBoundTextures = true;
-          this.hasIntegerTextures = false;
-          this.currentLocation = -1;
-          for (var i = 0; i < this.boundTextures.length; i++) {
-              this.boundTextures[i] = this.unknownTexture;
-          }
-      };
-      /**
-       * Unbind a texture.
-       * @param texture - Texture to bind
-       */
-      TextureSystem.prototype.unbind = function (texture) {
-          var _a = this, gl = _a.gl, boundTextures = _a.boundTextures;
-          if (this._unknownBoundTextures) {
-              this._unknownBoundTextures = false;
-              // someone changed webGL state,
-              // we have to be sure that our texture does not appear in multi-texture renderer samplers
-              for (var i = 0; i < boundTextures.length; i++) {
-                  if (boundTextures[i] === this.unknownTexture) {
-                      this.bind(null, i);
-                  }
-              }
-          }
-          for (var i = 0; i < boundTextures.length; i++) {
-              if (boundTextures[i] === texture) {
-                  if (this.currentLocation !== i) {
-                      gl.activeTexture(gl.TEXTURE0 + i);
-                      this.currentLocation = i;
-                  }
-                  gl.bindTexture(texture.target, this.emptyTextures[texture.target].texture);
-                  boundTextures[i] = null;
-              }
-          }
-      };
-      /**
-       * Ensures that current boundTextures all have FLOAT sampler type,
-       * see {@link PIXI.SAMPLER_TYPES} for explanation.
-       * @param maxTextures - number of locations to check
-       */
-      TextureSystem.prototype.ensureSamplerType = function (maxTextures) {
-          var _a = this, boundTextures = _a.boundTextures, hasIntegerTextures = _a.hasIntegerTextures, CONTEXT_UID = _a.CONTEXT_UID;
-          if (!hasIntegerTextures) {
-              return;
-          }
-          for (var i = maxTextures - 1; i >= 0; --i) {
-              var tex = boundTextures[i];
-              if (tex) {
-                  var glTexture = tex._glTextures[CONTEXT_UID];
-                  if (glTexture.samplerType !== exports.SAMPLER_TYPES.FLOAT) {
-                      this.renderer.texture.unbind(tex);
-                  }
-              }
-          }
-      };
-      /**
-       * Initialize a texture
-       * @private
-       * @param texture - Texture to initialize
-       */
-      TextureSystem.prototype.initTexture = function (texture) {
-          var glTexture = new GLTexture(this.gl.createTexture());
-          // guarantee an update..
-          glTexture.dirtyId = -1;
-          texture._glTextures[this.CONTEXT_UID] = glTexture;
-          this.managedTextures.push(texture);
-          texture.on('dispose', this.destroyTexture, this);
-          return glTexture;
-      };
-      TextureSystem.prototype.initTextureType = function (texture, glTexture) {
-          var _a, _b;
-          glTexture.internalFormat = (_b = (_a = this.internalFormats[texture.type]) === null || _a === void 0 ? void 0 : _a[texture.format]) !== null && _b !== void 0 ? _b : texture.format;
-          if (this.webGLVersion === 2 && texture.type === exports.TYPES.HALF_FLOAT) {
-              // TYPES.HALF_FLOAT is WebGL1 HALF_FLOAT_OES
-              // we have to convert it to WebGL HALF_FLOAT
-              glTexture.type = this.gl.HALF_FLOAT;
-          }
-          else {
-              glTexture.type = texture.type;
-          }
-      };
-      /**
-       * Update a texture
-       * @private
-       * @param {PIXI.BaseTexture} texture - Texture to initialize
-       */
-      TextureSystem.prototype.updateTexture = function (texture) {
-          var glTexture = texture._glTextures[this.CONTEXT_UID];
-          if (!glTexture) {
-              return;
-          }
-          var renderer = this.renderer;
-          this.initTextureType(texture, glTexture);
-          if (texture.resource && texture.resource.upload(renderer, texture, glTexture)) {
-              // texture is uploaded, dont do anything!
-              if (glTexture.samplerType !== exports.SAMPLER_TYPES.FLOAT) {
-                  this.hasIntegerTextures = true;
-              }
-          }
-          else {
-              // default, renderTexture-like logic
-              var width = texture.realWidth;
-              var height = texture.realHeight;
-              var gl = renderer.gl;
-              if (glTexture.width !== width
-                  || glTexture.height !== height
-                  || glTexture.dirtyId < 0) {
-                  glTexture.width = width;
-                  glTexture.height = height;
-                  gl.texImage2D(texture.target, 0, glTexture.internalFormat, width, height, 0, texture.format, glTexture.type, null);
-              }
-          }
-          // lets only update what changes..
-          if (texture.dirtyStyleId !== glTexture.dirtyStyleId) {
-              this.updateTextureStyle(texture);
-          }
-          glTexture.dirtyId = texture.dirtyId;
-      };
-      /**
-       * Deletes the texture from WebGL
-       * @private
-       * @param texture - the texture to destroy
-       * @param [skipRemove=false] - Whether to skip removing the texture from the TextureManager.
-       */
-      TextureSystem.prototype.destroyTexture = function (texture, skipRemove) {
-          var gl = this.gl;
-          texture = texture.castToBaseTexture();
-          if (texture._glTextures[this.CONTEXT_UID]) {
-              this.unbind(texture);
-              gl.deleteTexture(texture._glTextures[this.CONTEXT_UID].texture);
-              texture.off('dispose', this.destroyTexture, this);
-              delete texture._glTextures[this.CONTEXT_UID];
-              if (!skipRemove) {
-                  var i = this.managedTextures.indexOf(texture);
-                  if (i !== -1) {
-                      removeItems(this.managedTextures, i, 1);
-                  }
-              }
-          }
-      };
-      /**
-       * Update texture style such as mipmap flag
-       * @private
-       * @param {PIXI.BaseTexture} texture - Texture to update
-       */
-      TextureSystem.prototype.updateTextureStyle = function (texture) {
-          var glTexture = texture._glTextures[this.CONTEXT_UID];
-          if (!glTexture) {
-              return;
-          }
-          if ((texture.mipmap === exports.MIPMAP_MODES.POW2 || this.webGLVersion !== 2) && !texture.isPowerOfTwo) {
-              glTexture.mipmap = false;
-          }
-          else {
-              glTexture.mipmap = texture.mipmap >= 1;
-          }
-          if (this.webGLVersion !== 2 && !texture.isPowerOfTwo) {
-              glTexture.wrapMode = exports.WRAP_MODES.CLAMP;
-          }
-          else {
-              glTexture.wrapMode = texture.wrapMode;
-          }
-          if (texture.resource && texture.resource.style(this.renderer, texture, glTexture)) { ; }
-          else {
-              this.setStyle(texture, glTexture);
-          }
-          glTexture.dirtyStyleId = texture.dirtyStyleId;
-      };
-      /**
-       * Set style for texture
-       * @private
-       * @param texture - Texture to update
-       * @param glTexture
-       */
-      TextureSystem.prototype.setStyle = function (texture, glTexture) {
-          var gl = this.gl;
-          if (glTexture.mipmap && texture.mipmap !== exports.MIPMAP_MODES.ON_MANUAL) {
-              gl.generateMipmap(texture.target);
-          }
-          gl.texParameteri(texture.target, gl.TEXTURE_WRAP_S, glTexture.wrapMode);
-          gl.texParameteri(texture.target, gl.TEXTURE_WRAP_T, glTexture.wrapMode);
-          if (glTexture.mipmap) {
-              /* eslint-disable max-len */
-              gl.texParameteri(texture.target, gl.TEXTURE_MIN_FILTER, texture.scaleMode === exports.SCALE_MODES.LINEAR ? gl.LINEAR_MIPMAP_LINEAR : gl.NEAREST_MIPMAP_NEAREST);
-              /* eslint-disable max-len */
-              var anisotropicExt = this.renderer.context.extensions.anisotropicFiltering;
-              if (anisotropicExt && texture.anisotropicLevel > 0 && texture.scaleMode === exports.SCALE_MODES.LINEAR) {
-                  var level = Math.min(texture.anisotropicLevel, gl.getParameter(anisotropicExt.MAX_TEXTURE_MAX_ANISOTROPY_EXT));
-                  gl.texParameterf(texture.target, anisotropicExt.TEXTURE_MAX_ANISOTROPY_EXT, level);
-              }
-          }
-          else {
-              gl.texParameteri(texture.target, gl.TEXTURE_MIN_FILTER, texture.scaleMode === exports.SCALE_MODES.LINEAR ? gl.LINEAR : gl.NEAREST);
-          }
-          gl.texParameteri(texture.target, gl.TEXTURE_MAG_FILTER, texture.scaleMode === exports.SCALE_MODES.LINEAR ? gl.LINEAR : gl.NEAREST);
-      };
-      TextureSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return TextureSystem;
-  }());
-
-  var _systems = {
-      __proto__: null,
-      FilterSystem: FilterSystem,
-      BatchSystem: BatchSystem,
-      ContextSystem: ContextSystem,
-      FramebufferSystem: FramebufferSystem,
-      GeometrySystem: GeometrySystem,
-      MaskSystem: MaskSystem,
-      ScissorSystem: ScissorSystem,
-      StencilSystem: StencilSystem,
-      ProjectionSystem: ProjectionSystem,
-      RenderTextureSystem: RenderTextureSystem,
-      ShaderSystem: ShaderSystem,
-      StateSystem: StateSystem,
-      TextureGCSystem: TextureGCSystem,
-      TextureSystem: TextureSystem
-  };
-
-  var tempMatrix = new Matrix();
-  /**
-   * The AbstractRenderer is the base for a PixiJS Renderer. It is extended by the {@link PIXI.CanvasRenderer}
-   * and {@link PIXI.Renderer} which can be used for rendering a PixiJS scene.
-   * @abstract
-   * @class
-   * @extends PIXI.utils.EventEmitter
-   * @memberof PIXI
-   */
-  var AbstractRenderer = /** @class */ (function (_super) {
-      __extends$i(AbstractRenderer, _super);
-      /**
-       * @param type - The renderer type.
-       * @param {PIXI.IRendererOptions} [options] - The optional renderer parameters.
-       * @param {boolean} [options.antialias=false] -
-       *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
-       * @param {boolean} [options.autoDensity=false] -
-       *  Whether the CSS dimensions of the renderer's view should be resized automatically.
-       * @param {number} [options.backgroundAlpha=1] -
-       *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
-       * @param {number} [options.backgroundColor=0x000000] -
-       *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
-       * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
-       * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
-       * @param {number} [options.height=600] - The height of the renderer's view.
-       * @param {string} [options.powerPreference] -
-       *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
-       *  can be `'default'`, `'high-performance'` or `'low-power'`.
-       *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
-       *  while setting to `'low-power'` will prioritize power saving over rendering performance.
-       * @param {boolean} [options.premultipliedAlpha=true] -
-       *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
-       * @param {boolean} [options.preserveDrawingBuffer=false] -
-       *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
-       *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
-       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
-       *  The resolution / device pixel ratio of the renderer.
-       * @param {boolean} [options.transparent] -
-       *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
-       *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
-       * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
-       *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
-       *  canvas needs to be opaque, possibly for performance reasons on some older devices.
-       *  If you want to set transparency, please use `backgroundAlpha`. \
-       *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
-       *  set to `true` and `premultipliedAlpha` will be to `false`.
-       * @param {HTMLCanvasElement} [options.view=null] -
-       *  The canvas to use as the view. If omitted, a new canvas will be created.
-       * @param {number} [options.width=800] - The width of the renderer's view.
-       */
-      function AbstractRenderer(type, options) {
-          if (type === void 0) { type = exports.RENDERER_TYPE.UNKNOWN; }
-          var _this = _super.call(this) || this;
-          // Add the default render options
-          options = Object.assign({}, settings.RENDER_OPTIONS, options);
-          /**
-           * The supplied constructor options.
-           * @member {object}
-           * @readonly
-           */
-          _this.options = options;
-          /**
-           * The type of the renderer.
-           * @member {number}
-           * @default PIXI.RENDERER_TYPE.UNKNOWN
-           * @see PIXI.RENDERER_TYPE
-           */
-          _this.type = type;
-          /**
-           * Measurements of the screen. (0, 0, screenWidth, screenHeight).
-           *
-           * Its safe to use as filterArea or hitArea for the whole stage.
-           * @member {PIXI.Rectangle}
-           */
-          _this.screen = new Rectangle(0, 0, options.width, options.height);
-          /**
-           * The canvas element that everything is drawn to.
-           * @member {HTMLCanvasElement}
-           */
-          _this.view = options.view || settings.ADAPTER.createCanvas();
-          /**
-           * The resolution / device pixel ratio of the renderer.
-           * @member {number}
-           * @default PIXI.settings.RESOLUTION
-           */
-          _this.resolution = options.resolution || settings.RESOLUTION;
-          /**
-           * Pass-thru setting for the canvas' context `alpha` property. This is typically
-           * not something you need to fiddle with. If you want transparency, use `backgroundAlpha`.
-           * @member {boolean}
-           */
-          _this.useContextAlpha = options.useContextAlpha;
-          /**
-           * Whether CSS dimensions of canvas view should be resized to screen dimensions automatically.
-           * @member {boolean}
-           */
-          _this.autoDensity = !!options.autoDensity;
-          /**
-           * The value of the preserveDrawingBuffer flag affects whether or not the contents of
-           * the stencil buffer is retained after rendering.
-           * @member {boolean}
-           */
-          _this.preserveDrawingBuffer = options.preserveDrawingBuffer;
-          /**
-           * This sets if the CanvasRenderer will clear the canvas or not before the new render pass.
-           * If the scene is NOT transparent PixiJS will use a canvas sized fillRect operation every
-           * frame to set the canvas background color. If the scene is transparent PixiJS will use clearRect
-           * to clear the canvas every frame. Disable this by setting this to false. For example, if
-           * your game has a canvas filling background image you often don't need this set.
-           * @member {boolean}
-           * @default
-           */
-          _this.clearBeforeRender = options.clearBeforeRender;
-          /**
-           * The background color as a number.
-           * @member {number}
-           * @protected
-           */
-          _this._backgroundColor = 0x000000;
-          /**
-           * The background color as an [R, G, B, A] array.
-           * @member {number[]}
-           * @protected
-           */
-          _this._backgroundColorRgba = [0, 0, 0, 1];
-          /**
-           * The background color as a string.
-           * @member {string}
-           * @protected
-           */
-          _this._backgroundColorString = '#000000';
-          _this.backgroundColor = options.backgroundColor || _this._backgroundColor; // run bg color setter
-          _this.backgroundAlpha = options.backgroundAlpha;
-          // @deprecated
-          if (options.transparent !== undefined) {
-              deprecation('6.0.0', 'Option transparent is deprecated, please use backgroundAlpha instead.');
-              _this.useContextAlpha = options.transparent;
-              _this.backgroundAlpha = options.transparent ? 0 : 1;
-          }
-          /**
-           * The last root object that the renderer tried to render.
-           * @member {PIXI.DisplayObject}
-           * @protected
-           */
-          _this._lastObjectRendered = null;
-          /**
-           * Collection of plugins.
-           * @readonly
-           * @member {object}
-           */
-          _this.plugins = {};
-          return _this;
-      }
-      /**
-       * Initialize the plugins.
-       * @protected
-       * @param {object} staticMap - The dictionary of statically saved plugins.
-       */
-      AbstractRenderer.prototype.initPlugins = function (staticMap) {
-          for (var o in staticMap) {
-              this.plugins[o] = new (staticMap[o])(this);
-          }
-      };
-      Object.defineProperty(AbstractRenderer.prototype, "width", {
-          /**
-           * Same as view.width, actual number of pixels in the canvas by horizontal.
-           * @member {number}
-           * @readonly
-           * @default 800
-           */
-          get: function () {
-              return this.view.width;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(AbstractRenderer.prototype, "height", {
-          /**
-           * Same as view.height, actual number of pixels in the canvas by vertical.
-           * @member {number}
-           * @readonly
-           * @default 600
-           */
-          get: function () {
-              return this.view.height;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Resizes the screen and canvas as close as possible to the specified width and height.
-       * Canvas dimensions are multiplied by resolution and rounded to the nearest integers.
-       * The new canvas dimensions divided by the resolution become the new screen dimensions.
-       * @param desiredScreenWidth - The desired width of the screen.
-       * @param desiredScreenHeight - The desired height of the screen.
-       */
-      AbstractRenderer.prototype.resize = function (desiredScreenWidth, desiredScreenHeight) {
-          this.view.width = Math.round(desiredScreenWidth * this.resolution);
-          this.view.height = Math.round(desiredScreenHeight * this.resolution);
-          var screenWidth = this.view.width / this.resolution;
-          var screenHeight = this.view.height / this.resolution;
-          this.screen.width = screenWidth;
-          this.screen.height = screenHeight;
-          if (this.autoDensity) {
-              this.view.style.width = screenWidth + "px";
-              this.view.style.height = screenHeight + "px";
-          }
-          /**
-           * Fired after view has been resized.
-           * @event PIXI.Renderer#resize
-           * @param {number} screenWidth - The new width of the screen.
-           * @param {number} screenHeight - The new height of the screen.
-           */
-          this.emit('resize', screenWidth, screenHeight);
-      };
-      /**
-       * @ignore
-       */
-      AbstractRenderer.prototype.generateTexture = function (displayObject, options, resolution, region) {
-          if (options === void 0) { options = {}; }
-          // @deprecated parameters spread, use options instead
-          if (typeof options === 'number') {
-              deprecation('6.1.0', 'generateTexture options (scaleMode, resolution, region) are now object options.');
-              options = { scaleMode: options, resolution: resolution, region: region };
-          }
-          var manualRegion = options.region, textureOptions = __rest(options, ["region"]);
-          region = manualRegion || displayObject.getLocalBounds(null, true);
-          // minimum texture size is 1x1, 0x0 will throw an error
-          if (region.width === 0)
-              { region.width = 1; }
-          if (region.height === 0)
-              { region.height = 1; }
-          var renderTexture = RenderTexture.create(__assign({ width: region.width, height: region.height }, textureOptions));
-          tempMatrix.tx = -region.x;
-          tempMatrix.ty = -region.y;
-          this.render(displayObject, {
-              renderTexture: renderTexture,
-              clear: false,
-              transform: tempMatrix,
-              skipUpdateTransform: !!displayObject.parent
-          });
-          return renderTexture;
-      };
-      /**
-       * Removes everything from the renderer and optionally removes the Canvas DOM element.
-       * @param [removeView=false] - Removes the Canvas element from the DOM.
-       */
-      AbstractRenderer.prototype.destroy = function (removeView) {
-          for (var o in this.plugins) {
-              this.plugins[o].destroy();
-              this.plugins[o] = null;
-          }
-          if (removeView && this.view.parentNode) {
-              this.view.parentNode.removeChild(this.view);
-          }
-          var thisAny = this;
-          // null-ing all objects, that's a tradition!
-          thisAny.plugins = null;
-          thisAny.type = exports.RENDERER_TYPE.UNKNOWN;
-          thisAny.view = null;
-          thisAny.screen = null;
-          thisAny._tempDisplayObjectParent = null;
-          thisAny.options = null;
-          this._backgroundColorRgba = null;
-          this._backgroundColorString = null;
-          this._lastObjectRendered = null;
-      };
-      Object.defineProperty(AbstractRenderer.prototype, "backgroundColor", {
-          /**
-           * The background color to fill if not transparent
-           * @member {number}
-           */
-          get: function () {
-              return this._backgroundColor;
-          },
-          set: function (value) {
-              this._backgroundColor = value;
-              this._backgroundColorString = hex2string(value);
-              hex2rgb(value, this._backgroundColorRgba);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(AbstractRenderer.prototype, "backgroundAlpha", {
-          /**
-           * The background color alpha. Setting this to 0 will make the canvas transparent.
-           * @member {number}
-           */
-          get: function () {
-              return this._backgroundColorRgba[3];
-          },
-          set: function (value) {
-              this._backgroundColorRgba[3] = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return AbstractRenderer;
-  }(eventemitter3));
-
-  var GLBuffer = /** @class */ (function () {
-      function GLBuffer(buffer) {
-          this.buffer = buffer || null;
-          this.updateID = -1;
-          this.byteLength = -1;
-          this.refCount = 0;
-      }
-      return GLBuffer;
-  }());
-
-  /**
-   * System plugin to the renderer to manage buffers.
-   *
-   * WebGL uses Buffers as a way to store objects to the GPU.
-   * This system makes working with them a lot easier.
-   *
-   * Buffers are used in three main places in WebGL
-   * - geometry information
-   * - Uniform information (via uniform buffer objects - a WebGL 2 only feature)
-   * - Transform feedback information. (WebGL 2 only feature)
-   *
-   * This system will handle the binding of buffers to the GPU as well as uploading
-   * them. With this system, you never need to work directly with GPU buffers, but instead work with
-   * the PIXI.Buffer class.
-   * @class
-   * @memberof PIXI
-   */
-  var BufferSystem = /** @class */ (function () {
-      /**
-       * @param {PIXI.Renderer} renderer - The renderer this System works for.
-       */
-      function BufferSystem(renderer) {
-          this.renderer = renderer;
-          this.managedBuffers = {};
-          this.boundBufferBases = {};
-      }
-      /**
-       * @ignore
-       */
-      BufferSystem.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      /** Sets up the renderer context and necessary buffers. */
-      BufferSystem.prototype.contextChange = function () {
-          this.disposeAll(true);
-          this.gl = this.renderer.gl;
-          // TODO fill out...
-          this.CONTEXT_UID = this.renderer.CONTEXT_UID;
-      };
-      /**
-       * This binds specified buffer. On first run, it will create the webGL buffers for the context too
-       * @param buffer - the buffer to bind to the renderer
-       */
-      BufferSystem.prototype.bind = function (buffer) {
-          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
-          var glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
-          gl.bindBuffer(buffer.type, glBuffer.buffer);
-      };
-      /**
-       * Binds an uniform buffer to at the given index.
-       *
-       * A cache is used so a buffer will not be bound again if already bound.
-       * @param buffer - the buffer to bind
-       * @param index - the base index to bind it to.
-       */
-      BufferSystem.prototype.bindBufferBase = function (buffer, index) {
-          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
-          if (this.boundBufferBases[index] !== buffer) {
-              var glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
-              this.boundBufferBases[index] = buffer;
-              gl.bindBufferBase(gl.UNIFORM_BUFFER, index, glBuffer.buffer);
-          }
-      };
-      /**
-       * Binds a buffer whilst also binding its range.
-       * This will make the buffer start from the offset supplied rather than 0 when it is read.
-       * @param buffer - the buffer to bind
-       * @param index - the base index to bind at, defaults to 0
-       * @param offset - the offset to bind at (this is blocks of 256). 0 = 0, 1 = 256, 2 = 512 etc
-       */
-      BufferSystem.prototype.bindBufferRange = function (buffer, index, offset) {
-          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
-          offset = offset || 0;
-          var glBuffer = buffer._glBuffers[CONTEXT_UID] || this.createGLBuffer(buffer);
-          gl.bindBufferRange(gl.UNIFORM_BUFFER, index || 0, glBuffer.buffer, offset * 256, 256);
-      };
-      /**
-       * Will ensure the data in the buffer is uploaded to the GPU.
-       * @param {PIXI.Buffer} buffer - the buffer to update
-       */
-      BufferSystem.prototype.update = function (buffer) {
-          var _a = this, gl = _a.gl, CONTEXT_UID = _a.CONTEXT_UID;
-          var glBuffer = buffer._glBuffers[CONTEXT_UID];
-          if (buffer._updateID === glBuffer.updateID) {
-              return;
-          }
-          glBuffer.updateID = buffer._updateID;
-          gl.bindBuffer(buffer.type, glBuffer.buffer);
-          if (glBuffer.byteLength >= buffer.data.byteLength) {
-              // offset is always zero for now!
-              gl.bufferSubData(buffer.type, 0, buffer.data);
-          }
-          else {
-              var drawType = buffer.static ? gl.STATIC_DRAW : gl.DYNAMIC_DRAW;
-              glBuffer.byteLength = buffer.data.byteLength;
-              gl.bufferData(buffer.type, buffer.data, drawType);
-          }
-      };
-      /**
-       * Disposes buffer
-       * @param {PIXI.Buffer} buffer - buffer with data
-       * @param {boolean} [contextLost=false] - If context was lost, we suppress deleteVertexArray
-       */
-      BufferSystem.prototype.dispose = function (buffer, contextLost) {
-          if (!this.managedBuffers[buffer.id]) {
-              return;
-          }
-          delete this.managedBuffers[buffer.id];
-          var glBuffer = buffer._glBuffers[this.CONTEXT_UID];
-          var gl = this.gl;
-          buffer.disposeRunner.remove(this);
-          if (!glBuffer) {
-              return;
-          }
-          if (!contextLost) {
-              gl.deleteBuffer(glBuffer.buffer);
-          }
-          delete buffer._glBuffers[this.CONTEXT_UID];
-      };
-      /**
-       * dispose all WebGL resources of all managed buffers
-       * @param {boolean} [contextLost=false] - If context was lost, we suppress `gl.delete` calls
-       */
-      BufferSystem.prototype.disposeAll = function (contextLost) {
-          var all = Object.keys(this.managedBuffers);
-          for (var i = 0; i < all.length; i++) {
-              this.dispose(this.managedBuffers[all[i]], contextLost);
-          }
-      };
-      /**
-       * creates and attaches a GLBuffer object tied to the current context.
-       * @param buffer
-       * @protected
-       */
-      BufferSystem.prototype.createGLBuffer = function (buffer) {
-          var _a = this, CONTEXT_UID = _a.CONTEXT_UID, gl = _a.gl;
-          buffer._glBuffers[CONTEXT_UID] = new GLBuffer(gl.createBuffer());
-          this.managedBuffers[buffer.id] = buffer;
-          buffer.disposeRunner.add(this);
-          return buffer._glBuffers[CONTEXT_UID];
-      };
-      return BufferSystem;
-  }());
-
-  /**
-   * The Renderer draws the scene and all its content onto a WebGL enabled canvas.
-   *
-   * This renderer should be used for browsers that support WebGL.
-   *
-   * This renderer works by automatically managing WebGLBatchesm, so no need for Sprite Batches or Sprite Clouds.
-   * Don't forget to add the view to your DOM or you will not see anything!
-   *
-   * Renderer is composed of systems that manage specific tasks. The following systems are added by default
-   * whenever you create a renderer:
-   *
-   * | System                               | Description                                                                   |
-   * | ------------------------------------ | ----------------------------------------------------------------------------- |
-   * | {@link PIXI.BatchSystem}             | This manages object renderers that defer rendering until a flush.             |
-   * | {@link PIXI.ContextSystem}           | This manages the WebGL context and extensions.                                |
-   * | {@link PIXI.EventSystem}             | This manages UI events.                                                       |
-   * | {@link PIXI.FilterSystem}            | This manages the filtering pipeline for post-processing effects.              |
-   * | {@link PIXI.FramebufferSystem}       | This manages framebuffers, which are used for offscreen rendering.            |
-   * | {@link PIXI.GeometrySystem}          | This manages geometries & buffers, which are used to draw object meshes.      |
-   * | {@link PIXI.MaskSystem}              | This manages masking operations.                                              |
-   * | {@link PIXI.ProjectionSystem}        | This manages the `projectionMatrix`, used by shaders to get NDC coordinates.  |
-   * | {@link PIXI.RenderTextureSystem}     | This manages render-textures, which are an abstraction over framebuffers.     |
-   * | {@link PIXI.ScissorSystem}           | This handles scissor masking, and is used internally by {@link MaskSystem}    |
-   * | {@link PIXI.ShaderSystem}            | This manages shaders, programs that run on the GPU to calculate 'em pixels.   |
-   * | {@link PIXI.StateSystem}             | This manages the WebGL state variables like blend mode, depth testing, etc.   |
-   * | {@link PIXI.StencilSystem}           | This handles stencil masking, and is used internally by {@link MaskSystem}    |
-   * | {@link PIXI.TextureSystem}           | This manages textures and their resources on the GPU.                         |
-   * | {@link PIXI.TextureGCSystem}         | This will automatically remove textures from the GPU if they are not used.    |
-   *
-   * The breadth of the API surface provided by the renderer is contained within these systems.
-   * @memberof PIXI
-   */
-  var Renderer = /** @class */ (function (_super) {
-      __extends$i(Renderer, _super);
-      /**
-       * @param {PIXI.IRendererOptions} [options] - The optional renderer parameters.
-       * @param {boolean} [options.antialias=false] -
-       *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
-       * @param {boolean} [options.autoDensity=false] -
-       *  Whether the CSS dimensions of the renderer's view should be resized automatically.
-       * @param {number} [options.backgroundAlpha=1] -
-       *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
-       * @param {number} [options.backgroundColor=0x000000] -
-       *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
-       * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
-       * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
-       * @param {number} [options.height=600] - The height of the renderer's view.
-       * @param {string} [options.powerPreference] -
-       *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
-       *  can be `'default'`, `'high-performance'` or `'low-power'`.
-       *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
-       *  while setting to `'low-power'` will prioritize power saving over rendering performance.
-       * @param {boolean} [options.premultipliedAlpha=true] -
-       *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
-       * @param {boolean} [options.preserveDrawingBuffer=false] -
-       *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
-       *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
-       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
-       *  The resolution / device pixel ratio of the renderer.
-       * @param {boolean} [options.transparent] -
-       *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
-       *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
-       * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
-       *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
-       *  canvas needs to be opaque, possibly for performance reasons on some older devices.
-       *  If you want to set transparency, please use `backgroundAlpha`. \
-       *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
-       *  set to `true` and `premultipliedAlpha` will be to `false`.
-       * @param {HTMLCanvasElement} [options.view=null] -
-       *  The canvas to use as the view. If omitted, a new canvas will be created.
-       * @param {number} [options.width=800] - The width of the renderer's view.
-       */
-      function Renderer(options) {
-          var _this = _super.call(this, exports.RENDERER_TYPE.WEBGL, options) || this;
-          // the options will have been modified here in the super constructor with pixi's default settings..
-          options = _this.options;
-          _this.gl = null;
-          _this.CONTEXT_UID = 0;
-          _this.runners = {
-              destroy: new Runner('destroy'),
-              contextChange: new Runner('contextChange'),
-              reset: new Runner('reset'),
-              update: new Runner('update'),
-              postrender: new Runner('postrender'),
-              prerender: new Runner('prerender'),
-              resize: new Runner('resize'),
-          };
-          _this.runners.contextChange.add(_this);
-          _this.globalUniforms = new UniformGroup({
-              projectionMatrix: new Matrix(),
-          }, true);
-          _this.addSystem(MaskSystem, 'mask')
-              .addSystem(ContextSystem, 'context')
-              .addSystem(StateSystem, 'state')
-              .addSystem(ShaderSystem, 'shader')
-              .addSystem(TextureSystem, 'texture')
-              .addSystem(BufferSystem, 'buffer')
-              .addSystem(GeometrySystem, 'geometry')
-              .addSystem(FramebufferSystem, 'framebuffer')
-              .addSystem(ScissorSystem, 'scissor')
-              .addSystem(StencilSystem, 'stencil')
-              .addSystem(ProjectionSystem, 'projection')
-              .addSystem(TextureGCSystem, 'textureGC')
-              .addSystem(FilterSystem, 'filter')
-              .addSystem(RenderTextureSystem, 'renderTexture')
-              .addSystem(BatchSystem, 'batch');
-          _this.initPlugins(Renderer.__plugins);
-          _this.multisample = undefined;
-          /*
-           * The options passed in to create a new WebGL context.
-           */
-          if (options.context) {
-              _this.context.initFromContext(options.context);
-          }
-          else {
-              _this.context.initFromOptions({
-                  alpha: !!_this.useContextAlpha,
-                  antialias: options.antialias,
-                  premultipliedAlpha: _this.useContextAlpha && _this.useContextAlpha !== 'notMultiplied',
-                  stencil: true,
-                  preserveDrawingBuffer: options.preserveDrawingBuffer,
-                  powerPreference: _this.options.powerPreference,
-              });
-          }
-          _this.renderingToScreen = true;
-          sayHello(_this.context.webGLVersion === 2 ? 'WebGL 2' : 'WebGL 1');
-          _this.resize(_this.options.width, _this.options.height);
-          return _this;
-      }
-      /**
-       * Create renderer if WebGL is available. Overrideable
-       * by the **@pixi/canvas-renderer** package to allow fallback.
-       * throws error if WebGL is not available.
-       * @param options
-       * @private
-       */
-      Renderer.create = function (options) {
-          if (isWebGLSupported()) {
-              return new Renderer(options);
-          }
-          throw new Error('WebGL unsupported in this browser, use "pixi.js-legacy" for fallback canvas2d support.');
-      };
-      Renderer.prototype.contextChange = function () {
-          var gl = this.gl;
-          var samples;
-          if (this.context.webGLVersion === 1) {
-              var framebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
-              gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-              samples = gl.getParameter(gl.SAMPLES);
-              gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-          }
-          else {
-              var framebuffer = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
-              gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
-              samples = gl.getParameter(gl.SAMPLES);
-              gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, framebuffer);
-          }
-          if (samples >= exports.MSAA_QUALITY.HIGH) {
-              this.multisample = exports.MSAA_QUALITY.HIGH;
-          }
-          else if (samples >= exports.MSAA_QUALITY.MEDIUM) {
-              this.multisample = exports.MSAA_QUALITY.MEDIUM;
-          }
-          else if (samples >= exports.MSAA_QUALITY.LOW) {
-              this.multisample = exports.MSAA_QUALITY.LOW;
-          }
-          else {
-              this.multisample = exports.MSAA_QUALITY.NONE;
-          }
-      };
-      /**
-       * Add a new system to the renderer.
-       * @param ClassRef - Class reference
-       * @param name - Property name for system, if not specified
-       *        will use a static `name` property on the class itself. This
-       *        name will be assigned as s property on the Renderer so make
-       *        sure it doesn't collide with properties on Renderer.
-       * @returns Return instance of renderer
-       */
-      Renderer.prototype.addSystem = function (ClassRef, name) {
-          var system = new ClassRef(this);
-          if (this[name]) {
-              throw new Error("Whoops! The name \"" + name + "\" is already in use");
-          }
-          this[name] = system;
-          for (var i in this.runners) {
-              this.runners[i].add(system);
-          }
-          /**
-           * Fired after rendering finishes.
-           * @event PIXI.Renderer#postrender
-           */
-          /**
-           * Fired before rendering starts.
-           * @event PIXI.Renderer#prerender
-           */
-          /**
-           * Fired when the WebGL context is set.
-           * @event PIXI.Renderer#context
-           * @param {WebGLRenderingContext} gl - WebGL context.
-           */
-          return this;
-      };
-      /**
-       * @ignore
-       */
-      Renderer.prototype.render = function (displayObject, options) {
-          var renderTexture;
-          var clear;
-          var transform;
-          var skipUpdateTransform;
-          if (options) {
-              if (options instanceof RenderTexture) {
-                  deprecation('6.0.0', 'Renderer#render arguments changed, use options instead.');
-                  /* eslint-disable prefer-rest-params */
-                  renderTexture = options;
-                  clear = arguments[2];
-                  transform = arguments[3];
-                  skipUpdateTransform = arguments[4];
-                  /* eslint-enable prefer-rest-params */
-              }
-              else {
-                  renderTexture = options.renderTexture;
-                  clear = options.clear;
-                  transform = options.transform;
-                  skipUpdateTransform = options.skipUpdateTransform;
-              }
-          }
-          // can be handy to know!
-          this.renderingToScreen = !renderTexture;
-          this.runners.prerender.emit();
-          this.emit('prerender');
-          // apply a transform at a GPU level
-          this.projection.transform = transform;
-          // no point rendering if our context has been blown up!
-          if (this.context.isLost) {
-              return;
-          }
-          if (!renderTexture) {
-              this._lastObjectRendered = displayObject;
-          }
-          if (!skipUpdateTransform) {
-              // update the scene graph
-              var cacheParent = displayObject.enableTempParent();
-              displayObject.updateTransform();
-              displayObject.disableTempParent(cacheParent);
-              // displayObject.hitArea = //TODO add a temp hit area
-          }
-          this.renderTexture.bind(renderTexture);
-          this.batch.currentRenderer.start();
-          if (clear !== undefined ? clear : this.clearBeforeRender) {
-              this.renderTexture.clear();
-          }
-          displayObject.render(this);
-          // apply transform..
-          this.batch.currentRenderer.flush();
-          if (renderTexture) {
-              renderTexture.baseTexture.update();
-          }
-          this.runners.postrender.emit();
-          // reset transform after render
-          this.projection.transform = null;
-          this.emit('postrender');
-      };
-      /**
-       * @override
-       * @ignore
-       */
-      Renderer.prototype.generateTexture = function (displayObject, options, resolution, region) {
-          if (options === void 0) { options = {}; }
-          var renderTexture = _super.prototype.generateTexture.call(this, displayObject, options, resolution, region);
-          this.framebuffer.blit();
-          return renderTexture;
-      };
-      /**
-       * Resizes the WebGL view to the specified width and height.
-       * @param desiredScreenWidth - The desired width of the screen.
-       * @param desiredScreenHeight - The desired height of the screen.
-       */
-      Renderer.prototype.resize = function (desiredScreenWidth, desiredScreenHeight) {
-          _super.prototype.resize.call(this, desiredScreenWidth, desiredScreenHeight);
-          this.runners.resize.emit(this.screen.height, this.screen.width);
-      };
-      /**
-       * Resets the WebGL state so you can render things however you fancy!
-       * @returns Returns itself.
-       */
-      Renderer.prototype.reset = function () {
-          this.runners.reset.emit();
-          return this;
-      };
-      /** Clear the frame buffer. */
-      Renderer.prototype.clear = function () {
-          this.renderTexture.bind();
-          this.renderTexture.clear();
-      };
-      /**
-       * Removes everything from the renderer (event listeners, spritebatch, etc...)
-       * @param [removeView=false] - Removes the Canvas element from the DOM.
-       *  See: https://github.com/pixijs/pixi.js/issues/2233
-       */
-      Renderer.prototype.destroy = function (removeView) {
-          this.runners.destroy.emit();
-          for (var r in this.runners) {
-              this.runners[r].destroy();
-          }
-          // call base destroy
-          _super.prototype.destroy.call(this, removeView);
-          // TODO nullify all the managers..
-          this.gl = null;
-      };
-      Object.defineProperty(Renderer.prototype, "extract", {
-          /**
-           * Please use `plugins.extract` instead.
-           * @member {PIXI.Extract} extract
-           * @deprecated since 6.0.0
-           * @readonly
-           */
-          get: function () {
-              deprecation('6.0.0', 'Renderer#extract has been deprecated, please use Renderer#plugins.extract instead.');
-              return this.plugins.extract;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Use the {@link PIXI.extensions.add} API to register plugins.
-       * @deprecated since 6.5.0
-       * @param pluginName - The name of the plugin.
-       * @param ctor - The constructor function or class for the plugin.
-       */
-      Renderer.registerPlugin = function (pluginName, ctor) {
-          deprecation('6.5.0', 'Renderer.registerPlugin() has been deprecated, please use extensions.add() instead.');
-          extensions.add({
-              name: pluginName,
-              type: exports.ExtensionType.RendererPlugin,
-              ref: ctor,
-          });
-      };
-      /**
-       * Collection of installed plugins. These are included by default in PIXI, but can be excluded
-       * by creating a custom build. Consult the README for more information about creating custom
-       * builds and excluding plugins.
-       * @readonly
-       * @property {PIXI.AccessibilityManager} accessibility Support tabbing interactive elements.
-       * @property {PIXI.Extract} extract Extract image data from renderer.
-       * @property {PIXI.InteractionManager} interaction Handles mouse, touch and pointer events.
-       * @property {PIXI.ParticleRenderer} particle Renderer for ParticleContainer objects.
-       * @property {PIXI.Prepare} prepare Pre-render display objects.
-       * @property {PIXI.BatchRenderer} batch Batching of Sprite, Graphics and Mesh objects.
-       * @property {PIXI.TilingSpriteRenderer} tilingSprite Renderer for TilingSprite objects.
-       */
-      Renderer.__plugins = {};
-      return Renderer;
-  }(AbstractRenderer));
-  // Handle registration of extensions
-  extensions.handleByMap(exports.ExtensionType.RendererPlugin, Renderer.__plugins);
-
-  /**
-   * This helper function will automatically detect which renderer you should be using.
-   * WebGL is the preferred renderer as it is a lot faster. If WebGL is not supported by
-   * the browser then this function will return a canvas renderer.
-   * @memberof PIXI
-   * @function autoDetectRenderer
-   * @param {PIXI.IRendererOptionsAuto} [options] - The optional renderer parameters.
-   * @param {boolean} [options.antialias=false] -
-   *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
-   * @param {boolean} [options.autoDensity=false] -
-   *  Whether the CSS dimensions of the renderer's view should be resized automatically.
-   * @param {number} [options.backgroundAlpha=1] -
-   *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
-   * @param {number} [options.backgroundColor=0x000000] -
-   *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
-   * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
-   * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
-   * @param {boolean} [options.forceCanvas=false] -
-   *  Force using {@link PIXI.CanvasRenderer}, even if WebGL is available. This option only is available when
-   *  using **pixi.js-legacy** or **@pixi/canvas-renderer** packages, otherwise it is ignored.
-   * @param {number} [options.height=600] - The height of the renderer's view.
-   * @param {string} [options.powerPreference] -
-   *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
-   *  can be `'default'`, `'high-performance'` or `'low-power'`.
-   *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
-   *  while setting to `'low-power'` will prioritize power saving over rendering performance.
-   * @param {boolean} [options.premultipliedAlpha=true] -
-   *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
-   * @param {boolean} [options.preserveDrawingBuffer=false] -
-   *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
-   *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
-   * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
-   *  The resolution / device pixel ratio of the renderer.
-   * @param {boolean} [options.transparent] -
-   *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
-   *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
-   * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
-   *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
-   *  canvas needs to be opaque, possibly for performance reasons on some older devices.
-   *  If you want to set transparency, please use `backgroundAlpha`. \
-   *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
-   *  set to `true` and `premultipliedAlpha` will be to `false`.
-   * @param {HTMLCanvasElement} [options.view=null] -
-   *  The canvas to use as the view. If omitted, a new canvas will be created.
-   * @param {number} [options.width=800] - The width of the renderer's view.
-   * @returns {PIXI.Renderer|PIXI.CanvasRenderer}
-   *  Returns {@link PIXI.Renderer} if WebGL is available, otherwise {@link PIXI.CanvasRenderer}.
-   */
-  function autoDetectRenderer(options) {
-      return Renderer.create(options);
-  }
-
-  var $defaultVertex = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n}";
-
-  var $defaultFilterVertex = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";
-
-  /**
-   * Default vertex shader
-   * @memberof PIXI
-   * @member {string} defaultVertex
-   */
-  /**
-   * Default filter vertex shader
-   * @memberof PIXI
-   * @member {string} defaultFilterVertex
-   */
-  // NOTE: This black magic is so that @microsoft/api-extractor does not complain! This explicitly specifies the types
-  // of defaultVertex, defaultFilterVertex.
-  var defaultVertex$1 = $defaultVertex;
-  var defaultFilterVertex = $defaultFilterVertex;
-
-  /**
-   * Use the ISystem interface instead.
-   * @deprecated since 6.1.0
-   * @memberof PIXI
-   */
-  var System = /** @class */ (function () {
-      /**
-       * @param renderer - Reference to Renderer
-       */
-      function System(renderer) {
-          deprecation('6.1.0', 'System class is deprecated, implemement ISystem interface instead.');
-          this.renderer = renderer;
-      }
-      /** Destroy and don't use after this. */
-      System.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      return System;
-  }());
-
-  /**
-   * Used by the batcher to draw batches.
-   * Each one of these contains all information required to draw a bound geometry.
-   * @memberof PIXI
-   */
-  var BatchDrawCall = /** @class */ (function () {
-      function BatchDrawCall() {
-          this.texArray = null;
-          this.blend = 0;
-          this.type = exports.DRAW_MODES.TRIANGLES;
-          this.start = 0;
-          this.size = 0;
-          this.data = null;
-      }
-      return BatchDrawCall;
-  }());
-
-  /**
-   * Used by the batcher to build texture batches.
-   * Holds list of textures and their respective locations.
-   * @memberof PIXI
-   */
-  var BatchTextureArray = /** @class */ (function () {
-      function BatchTextureArray() {
-          this.elements = [];
-          this.ids = [];
-          this.count = 0;
-      }
-      BatchTextureArray.prototype.clear = function () {
-          for (var i = 0; i < this.count; i++) {
-              this.elements[i] = null;
-          }
-          this.count = 0;
-      };
-      return BatchTextureArray;
-  }());
-
-  /**
-   * Flexible wrapper around `ArrayBuffer` that also provides typed array views on demand.
-   * @memberof PIXI
-   */
-  var ViewableBuffer = /** @class */ (function () {
-      function ViewableBuffer(sizeOrBuffer) {
-          if (typeof sizeOrBuffer === 'number') {
-              this.rawBinaryData = new ArrayBuffer(sizeOrBuffer);
-          }
-          else if (sizeOrBuffer instanceof Uint8Array) {
-              this.rawBinaryData = sizeOrBuffer.buffer;
-          }
-          else {
-              this.rawBinaryData = sizeOrBuffer;
-          }
-          this.uint32View = new Uint32Array(this.rawBinaryData);
-          this.float32View = new Float32Array(this.rawBinaryData);
-      }
-      Object.defineProperty(ViewableBuffer.prototype, "int8View", {
-          /** View on the raw binary data as a `Int8Array`. */
-          get: function () {
-              if (!this._int8View) {
-                  this._int8View = new Int8Array(this.rawBinaryData);
-              }
-              return this._int8View;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(ViewableBuffer.prototype, "uint8View", {
-          /** View on the raw binary data as a `Uint8Array`. */
-          get: function () {
-              if (!this._uint8View) {
-                  this._uint8View = new Uint8Array(this.rawBinaryData);
-              }
-              return this._uint8View;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(ViewableBuffer.prototype, "int16View", {
-          /**  View on the raw binary data as a `Int16Array`. */
-          get: function () {
-              if (!this._int16View) {
-                  this._int16View = new Int16Array(this.rawBinaryData);
-              }
-              return this._int16View;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(ViewableBuffer.prototype, "uint16View", {
-          /** View on the raw binary data as a `Uint16Array`. */
-          get: function () {
-              if (!this._uint16View) {
-                  this._uint16View = new Uint16Array(this.rawBinaryData);
-              }
-              return this._uint16View;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(ViewableBuffer.prototype, "int32View", {
-          /** View on the raw binary data as a `Int32Array`. */
-          get: function () {
-              if (!this._int32View) {
-                  this._int32View = new Int32Array(this.rawBinaryData);
-              }
-              return this._int32View;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Returns the view of the given type.
-       * @param type - One of `int8`, `uint8`, `int16`,
-       *    `uint16`, `int32`, `uint32`, and `float32`.
-       * @returns - typed array of given type
-       */
-      ViewableBuffer.prototype.view = function (type) {
-          return this[type + "View"];
-      };
-      /** Destroys all buffer references. Do not use after calling this. */
-      ViewableBuffer.prototype.destroy = function () {
-          this.rawBinaryData = null;
-          this._int8View = null;
-          this._uint8View = null;
-          this._int16View = null;
-          this._uint16View = null;
-          this._int32View = null;
-          this.uint32View = null;
-          this.float32View = null;
-      };
-      ViewableBuffer.sizeOf = function (type) {
-          switch (type) {
-              case 'int8':
-              case 'uint8':
-                  return 1;
-              case 'int16':
-              case 'uint16':
-                  return 2;
-              case 'int32':
-              case 'uint32':
-              case 'float32':
-                  return 4;
-              default:
-                  throw new Error(type + " isn't a valid view type");
-          }
-      };
-      return ViewableBuffer;
-  }());
-
-  /**
-   * Renderer dedicated to drawing and batching sprites.
-   *
-   * This is the default batch renderer. It buffers objects
-   * with texture-based geometries and renders them in
-   * batches. It uploads multiple textures to the GPU to
-   * reduce to the number of draw calls.
-   * @memberof PIXI
-   */
-  var AbstractBatchRenderer = /** @class */ (function (_super) {
-      __extends$i(AbstractBatchRenderer, _super);
-      /**
-       * This will hook onto the renderer's `contextChange`
-       * and `prerender` signals.
-       * @param {PIXI.Renderer} renderer - The renderer this works for.
-       */
-      function AbstractBatchRenderer(renderer) {
-          var _this = _super.call(this, renderer) || this;
-          _this.shaderGenerator = null;
-          _this.geometryClass = null;
-          _this.vertexSize = null;
-          _this.state = State.for2d();
-          _this.size = settings.SPRITE_BATCH_SIZE * 4;
-          _this._vertexCount = 0;
-          _this._indexCount = 0;
-          _this._bufferedElements = [];
-          _this._bufferedTextures = [];
-          _this._bufferSize = 0;
-          _this._shader = null;
-          _this._packedGeometries = [];
-          _this._packedGeometryPoolSize = 2;
-          _this._flushId = 0;
-          _this._aBuffers = {};
-          _this._iBuffers = {};
-          _this.MAX_TEXTURES = 1;
-          _this.renderer.on('prerender', _this.onPrerender, _this);
-          renderer.runners.contextChange.add(_this);
-          _this._dcIndex = 0;
-          _this._aIndex = 0;
-          _this._iIndex = 0;
-          _this._attributeBuffer = null;
-          _this._indexBuffer = null;
-          _this._tempBoundTextures = [];
-          return _this;
-      }
-      /**
-       * Handles the `contextChange` signal.
-       *
-       * It calculates `this.MAX_TEXTURES` and allocating the packed-geometry object pool.
-       */
-      AbstractBatchRenderer.prototype.contextChange = function () {
-          var gl = this.renderer.gl;
-          if (settings.PREFER_ENV === exports.ENV.WEBGL_LEGACY) {
-              this.MAX_TEXTURES = 1;
-          }
-          else {
-              // step 1: first check max textures the GPU can handle.
-              this.MAX_TEXTURES = Math.min(gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS), settings.SPRITE_MAX_TEXTURES);
-              // step 2: check the maximum number of if statements the shader can have too..
-              this.MAX_TEXTURES = checkMaxIfStatementsInShader(this.MAX_TEXTURES, gl);
-          }
-          this._shader = this.shaderGenerator.generateShader(this.MAX_TEXTURES);
-          // we use the second shader as the first one depending on your browser
-          // may omit aTextureId as it is not used by the shader so is optimized out.
-          for (var i = 0; i < this._packedGeometryPoolSize; i++) {
-              /* eslint-disable max-len */
-              this._packedGeometries[i] = new (this.geometryClass)();
-          }
-          this.initFlushBuffers();
-      };
-      /** Makes sure that static and dynamic flush pooled objects have correct dimensions. */
-      AbstractBatchRenderer.prototype.initFlushBuffers = function () {
-          var _drawCallPool = AbstractBatchRenderer._drawCallPool, _textureArrayPool = AbstractBatchRenderer._textureArrayPool;
-          // max draw calls
-          var MAX_SPRITES = this.size / 4;
-          // max texture arrays
-          var MAX_TA = Math.floor(MAX_SPRITES / this.MAX_TEXTURES) + 1;
-          while (_drawCallPool.length < MAX_SPRITES) {
-              _drawCallPool.push(new BatchDrawCall());
-          }
-          while (_textureArrayPool.length < MAX_TA) {
-              _textureArrayPool.push(new BatchTextureArray());
-          }
-          for (var i = 0; i < this.MAX_TEXTURES; i++) {
-              this._tempBoundTextures[i] = null;
-          }
-      };
-      /** Handles the `prerender` signal. It ensures that flushes start from the first geometry object again. */
-      AbstractBatchRenderer.prototype.onPrerender = function () {
-          this._flushId = 0;
-      };
-      /**
-       * Buffers the "batchable" object. It need not be rendered immediately.
-       * @param {PIXI.DisplayObject} element - the element to render when
-       *    using this renderer
-       */
-      AbstractBatchRenderer.prototype.render = function (element) {
-          if (!element._texture.valid) {
-              return;
-          }
-          if (this._vertexCount + (element.vertexData.length / 2) > this.size) {
-              this.flush();
-          }
-          this._vertexCount += element.vertexData.length / 2;
-          this._indexCount += element.indices.length;
-          this._bufferedTextures[this._bufferSize] = element._texture.baseTexture;
-          this._bufferedElements[this._bufferSize++] = element;
-      };
-      AbstractBatchRenderer.prototype.buildTexturesAndDrawCalls = function () {
-          var _a = this, textures = _a._bufferedTextures, MAX_TEXTURES = _a.MAX_TEXTURES;
-          var textureArrays = AbstractBatchRenderer._textureArrayPool;
-          var batch = this.renderer.batch;
-          var boundTextures = this._tempBoundTextures;
-          var touch = this.renderer.textureGC.count;
-          var TICK = ++BaseTexture._globalBatch;
-          var countTexArrays = 0;
-          var texArray = textureArrays[0];
-          var start = 0;
-          batch.copyBoundTextures(boundTextures, MAX_TEXTURES);
-          for (var i = 0; i < this._bufferSize; ++i) {
-              var tex = textures[i];
-              textures[i] = null;
-              if (tex._batchEnabled === TICK) {
-                  continue;
-              }
-              if (texArray.count >= MAX_TEXTURES) {
-                  batch.boundArray(texArray, boundTextures, TICK, MAX_TEXTURES);
-                  this.buildDrawCalls(texArray, start, i);
-                  start = i;
-                  texArray = textureArrays[++countTexArrays];
-                  ++TICK;
-              }
-              tex._batchEnabled = TICK;
-              tex.touched = touch;
-              texArray.elements[texArray.count++] = tex;
-          }
-          if (texArray.count > 0) {
-              batch.boundArray(texArray, boundTextures, TICK, MAX_TEXTURES);
-              this.buildDrawCalls(texArray, start, this._bufferSize);
-              ++countTexArrays;
-              ++TICK;
-          }
-          // Clean-up
-          for (var i = 0; i < boundTextures.length; i++) {
-              boundTextures[i] = null;
-          }
-          BaseTexture._globalBatch = TICK;
-      };
-      /**
-       * Populating drawcalls for rendering
-       * @param texArray
-       * @param start
-       * @param finish
-       */
-      AbstractBatchRenderer.prototype.buildDrawCalls = function (texArray, start, finish) {
-          var _a = this, elements = _a._bufferedElements, _attributeBuffer = _a._attributeBuffer, _indexBuffer = _a._indexBuffer, vertexSize = _a.vertexSize;
-          var drawCalls = AbstractBatchRenderer._drawCallPool;
-          var dcIndex = this._dcIndex;
-          var aIndex = this._aIndex;
-          var iIndex = this._iIndex;
-          var drawCall = drawCalls[dcIndex];
-          drawCall.start = this._iIndex;
-          drawCall.texArray = texArray;
-          for (var i = start; i < finish; ++i) {
-              var sprite = elements[i];
-              var tex = sprite._texture.baseTexture;
-              var spriteBlendMode = premultiplyBlendMode[tex.alphaMode ? 1 : 0][sprite.blendMode];
-              elements[i] = null;
-              if (start < i && drawCall.blend !== spriteBlendMode) {
-                  drawCall.size = iIndex - drawCall.start;
-                  start = i;
-                  drawCall = drawCalls[++dcIndex];
-                  drawCall.texArray = texArray;
-                  drawCall.start = iIndex;
-              }
-              this.packInterleavedGeometry(sprite, _attributeBuffer, _indexBuffer, aIndex, iIndex);
-              aIndex += sprite.vertexData.length / 2 * vertexSize;
-              iIndex += sprite.indices.length;
-              drawCall.blend = spriteBlendMode;
-          }
-          if (start < finish) {
-              drawCall.size = iIndex - drawCall.start;
-              ++dcIndex;
-          }
-          this._dcIndex = dcIndex;
-          this._aIndex = aIndex;
-          this._iIndex = iIndex;
-      };
-      /**
-       * Bind textures for current rendering
-       * @param texArray
-       */
-      AbstractBatchRenderer.prototype.bindAndClearTexArray = function (texArray) {
-          var textureSystem = this.renderer.texture;
-          for (var j = 0; j < texArray.count; j++) {
-              textureSystem.bind(texArray.elements[j], texArray.ids[j]);
-              texArray.elements[j] = null;
-          }
-          texArray.count = 0;
-      };
-      AbstractBatchRenderer.prototype.updateGeometry = function () {
-          var _a = this, packedGeometries = _a._packedGeometries, attributeBuffer = _a._attributeBuffer, indexBuffer = _a._indexBuffer;
-          if (!settings.CAN_UPLOAD_SAME_BUFFER) { /* Usually on iOS devices, where the browser doesn't
-              like uploads to the same buffer in a single frame. */
-              if (this._packedGeometryPoolSize <= this._flushId) {
-                  this._packedGeometryPoolSize++;
-                  packedGeometries[this._flushId] = new (this.geometryClass)();
-              }
-              packedGeometries[this._flushId]._buffer.update(attributeBuffer.rawBinaryData);
-              packedGeometries[this._flushId]._indexBuffer.update(indexBuffer);
-              this.renderer.geometry.bind(packedGeometries[this._flushId]);
-              this.renderer.geometry.updateBuffers();
-              this._flushId++;
-          }
-          else {
-              // lets use the faster option, always use buffer number 0
-              packedGeometries[this._flushId]._buffer.update(attributeBuffer.rawBinaryData);
-              packedGeometries[this._flushId]._indexBuffer.update(indexBuffer);
-              this.renderer.geometry.updateBuffers();
-          }
-      };
-      AbstractBatchRenderer.prototype.drawBatches = function () {
-          var dcCount = this._dcIndex;
-          var _a = this.renderer, gl = _a.gl, stateSystem = _a.state;
-          var drawCalls = AbstractBatchRenderer._drawCallPool;
-          var curTexArray = null;
-          // Upload textures and do the draw calls
-          for (var i = 0; i < dcCount; i++) {
-              var _b = drawCalls[i], texArray = _b.texArray, type = _b.type, size = _b.size, start = _b.start, blend = _b.blend;
-              if (curTexArray !== texArray) {
-                  curTexArray = texArray;
-                  this.bindAndClearTexArray(texArray);
-              }
-              this.state.blendMode = blend;
-              stateSystem.set(this.state);
-              gl.drawElements(type, size, gl.UNSIGNED_SHORT, start * 2);
-          }
-      };
-      /** Renders the content _now_ and empties the current batch. */
-      AbstractBatchRenderer.prototype.flush = function () {
-          if (this._vertexCount === 0) {
-              return;
-          }
-          this._attributeBuffer = this.getAttributeBuffer(this._vertexCount);
-          this._indexBuffer = this.getIndexBuffer(this._indexCount);
-          this._aIndex = 0;
-          this._iIndex = 0;
-          this._dcIndex = 0;
-          this.buildTexturesAndDrawCalls();
-          this.updateGeometry();
-          this.drawBatches();
-          // reset elements buffer for the next flush
-          this._bufferSize = 0;
-          this._vertexCount = 0;
-          this._indexCount = 0;
-      };
-      /** Starts a new sprite batch. */
-      AbstractBatchRenderer.prototype.start = function () {
-          this.renderer.state.set(this.state);
-          this.renderer.texture.ensureSamplerType(this.MAX_TEXTURES);
-          this.renderer.shader.bind(this._shader);
-          if (settings.CAN_UPLOAD_SAME_BUFFER) {
-              // bind buffer #0, we don't need others
-              this.renderer.geometry.bind(this._packedGeometries[this._flushId]);
-          }
-      };
-      /** Stops and flushes the current batch. */
-      AbstractBatchRenderer.prototype.stop = function () {
-          this.flush();
-      };
-      /** Destroys this `AbstractBatchRenderer`. It cannot be used again. */
-      AbstractBatchRenderer.prototype.destroy = function () {
-          for (var i = 0; i < this._packedGeometryPoolSize; i++) {
-              if (this._packedGeometries[i]) {
-                  this._packedGeometries[i].destroy();
-              }
-          }
-          this.renderer.off('prerender', this.onPrerender, this);
-          this._aBuffers = null;
-          this._iBuffers = null;
-          this._packedGeometries = null;
-          this._attributeBuffer = null;
-          this._indexBuffer = null;
-          if (this._shader) {
-              this._shader.destroy();
-              this._shader = null;
-          }
-          _super.prototype.destroy.call(this);
-      };
-      /**
-       * Fetches an attribute buffer from `this._aBuffers` that can hold atleast `size` floats.
-       * @param size - minimum capacity required
-       * @returns - buffer than can hold atleast `size` floats
-       */
-      AbstractBatchRenderer.prototype.getAttributeBuffer = function (size) {
-          // 8 vertices is enough for 2 quads
-          var roundedP2 = nextPow2(Math.ceil(size / 8));
-          var roundedSizeIndex = log2(roundedP2);
-          var roundedSize = roundedP2 * 8;
-          if (this._aBuffers.length <= roundedSizeIndex) {
-              this._iBuffers.length = roundedSizeIndex + 1;
-          }
-          var buffer = this._aBuffers[roundedSize];
-          if (!buffer) {
-              this._aBuffers[roundedSize] = buffer = new ViewableBuffer(roundedSize * this.vertexSize * 4);
-          }
-          return buffer;
-      };
-      /**
-       * Fetches an index buffer from `this._iBuffers` that can
-       * have at least `size` capacity.
-       * @param size - minimum required capacity
-       * @returns - buffer that can fit `size` indices.
-       */
-      AbstractBatchRenderer.prototype.getIndexBuffer = function (size) {
-          // 12 indices is enough for 2 quads
-          var roundedP2 = nextPow2(Math.ceil(size / 12));
-          var roundedSizeIndex = log2(roundedP2);
-          var roundedSize = roundedP2 * 12;
-          if (this._iBuffers.length <= roundedSizeIndex) {
-              this._iBuffers.length = roundedSizeIndex + 1;
-          }
-          var buffer = this._iBuffers[roundedSizeIndex];
-          if (!buffer) {
-              this._iBuffers[roundedSizeIndex] = buffer = new Uint16Array(roundedSize);
-          }
-          return buffer;
-      };
-      /**
-       * Takes the four batching parameters of `element`, interleaves
-       * and pushes them into the batching attribute/index buffers given.
-       *
-       * It uses these properties: `vertexData` `uvs`, `textureId` and
-       * `indicies`. It also uses the "tint" of the base-texture, if
-       * present.
-       * @param {PIXI.DisplayObject} element - element being rendered
-       * @param attributeBuffer - attribute buffer.
-       * @param indexBuffer - index buffer
-       * @param aIndex - number of floats already in the attribute buffer
-       * @param iIndex - number of indices already in `indexBuffer`
-       */
-      AbstractBatchRenderer.prototype.packInterleavedGeometry = function (element, attributeBuffer, indexBuffer, aIndex, iIndex) {
-          var uint32View = attributeBuffer.uint32View, float32View = attributeBuffer.float32View;
-          var packedVertices = aIndex / this.vertexSize;
-          var uvs = element.uvs;
-          var indicies = element.indices;
-          var vertexData = element.vertexData;
-          var textureId = element._texture.baseTexture._batchLocation;
-          var alpha = Math.min(element.worldAlpha, 1.0);
-          var argb = (alpha < 1.0
-              && element._texture.baseTexture.alphaMode)
-              ? premultiplyTint(element._tintRGB, alpha)
-              : element._tintRGB + (alpha * 255 << 24);
-          // lets not worry about tint! for now..
-          for (var i = 0; i < vertexData.length; i += 2) {
-              float32View[aIndex++] = vertexData[i];
-              float32View[aIndex++] = vertexData[i + 1];
-              float32View[aIndex++] = uvs[i];
-              float32View[aIndex++] = uvs[i + 1];
-              uint32View[aIndex++] = argb;
-              float32View[aIndex++] = textureId;
-          }
-          for (var i = 0; i < indicies.length; i++) {
-              indexBuffer[iIndex++] = packedVertices + indicies[i];
-          }
-      };
-      /**
-       * Pool of `BatchDrawCall` objects that `flush` used
-       * to create "batches" of the objects being rendered.
-       *
-       * These are never re-allocated again.
-       * Shared between all batch renderers because it can be only one "flush" working at the moment.
-       * @member {PIXI.BatchDrawCall[]}
-       */
-      AbstractBatchRenderer._drawCallPool = [];
-      /**
-       * Pool of `BatchDrawCall` objects that `flush` used
-       * to create "batches" of the objects being rendered.
-       *
-       * These are never re-allocated again.
-       * Shared between all batch renderers because it can be only one "flush" working at the moment.
-       * @member {PIXI.BatchTextureArray[]}
-       */
-      AbstractBatchRenderer._textureArrayPool = [];
-      return AbstractBatchRenderer;
-  }(ObjectRenderer));
-
-  /**
-   * Helper that generates batching multi-texture shader. Use it with your new BatchRenderer
-   * @memberof PIXI
-   */
-  var BatchShaderGenerator = /** @class */ (function () {
-      /**
-       * @param vertexSrc - Vertex shader
-       * @param fragTemplate - Fragment shader template
-       */
-      function BatchShaderGenerator(vertexSrc, fragTemplate) {
-          this.vertexSrc = vertexSrc;
-          this.fragTemplate = fragTemplate;
-          this.programCache = {};
-          this.defaultGroupCache = {};
-          if (fragTemplate.indexOf('%count%') < 0) {
-              throw new Error('Fragment template must contain "%count%".');
-          }
-          if (fragTemplate.indexOf('%forloop%') < 0) {
-              throw new Error('Fragment template must contain "%forloop%".');
-          }
-      }
-      BatchShaderGenerator.prototype.generateShader = function (maxTextures) {
-          if (!this.programCache[maxTextures]) {
-              var sampleValues = new Int32Array(maxTextures);
-              for (var i = 0; i < maxTextures; i++) {
-                  sampleValues[i] = i;
-              }
-              this.defaultGroupCache[maxTextures] = UniformGroup.from({ uSamplers: sampleValues }, true);
-              var fragmentSrc = this.fragTemplate;
-              fragmentSrc = fragmentSrc.replace(/%count%/gi, "" + maxTextures);
-              fragmentSrc = fragmentSrc.replace(/%forloop%/gi, this.generateSampleSrc(maxTextures));
-              this.programCache[maxTextures] = new Program(this.vertexSrc, fragmentSrc);
-          }
-          var uniforms = {
-              tint: new Float32Array([1, 1, 1, 1]),
-              translationMatrix: new Matrix(),
-              default: this.defaultGroupCache[maxTextures],
-          };
-          return new Shader(this.programCache[maxTextures], uniforms);
-      };
-      BatchShaderGenerator.prototype.generateSampleSrc = function (maxTextures) {
-          var src = '';
-          src += '\n';
-          src += '\n';
-          for (var i = 0; i < maxTextures; i++) {
-              if (i > 0) {
-                  src += '\nelse ';
-              }
-              if (i < maxTextures - 1) {
-                  src += "if(vTextureId < " + i + ".5)";
-              }
-              src += '\n{';
-              src += "\n\tcolor = texture2D(uSamplers[" + i + "], vTextureCoord);";
-              src += '\n}';
-          }
-          src += '\n';
-          src += '\n';
-          return src;
-      };
-      return BatchShaderGenerator;
-  }());
-
-  /**
-   * Geometry used to batch standard PIXI content (e.g. Mesh, Sprite, Graphics objects).
-   * @memberof PIXI
-   */
-  var BatchGeometry = /** @class */ (function (_super) {
-      __extends$i(BatchGeometry, _super);
-      /**
-       * @param {boolean} [_static=false] - Optimization flag, where `false`
-       *        is updated every frame, `true` doesn't change frame-to-frame.
-       */
-      function BatchGeometry(_static) {
-          if (_static === void 0) { _static = false; }
-          var _this = _super.call(this) || this;
-          _this._buffer = new Buffer(null, _static, false);
-          _this._indexBuffer = new Buffer(null, _static, true);
-          _this.addAttribute('aVertexPosition', _this._buffer, 2, false, exports.TYPES.FLOAT)
-              .addAttribute('aTextureCoord', _this._buffer, 2, false, exports.TYPES.FLOAT)
-              .addAttribute('aColor', _this._buffer, 4, true, exports.TYPES.UNSIGNED_BYTE)
-              .addAttribute('aTextureId', _this._buffer, 1, true, exports.TYPES.FLOAT)
-              .addIndex(_this._indexBuffer);
-          return _this;
-      }
-      return BatchGeometry;
-  }(Geometry));
-
-  var defaultVertex = "precision highp float;\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\nattribute float aTextureId;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform vec4 tint;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\n\nvoid main(void){\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vTextureId = aTextureId;\n    vColor = aColor * tint;\n}\n";
-
-  var defaultFragment = "varying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\nuniform sampler2D uSamplers[%count%];\n\nvoid main(void){\n    vec4 color;\n    %forloop%\n    gl_FragColor = color * vColor;\n}\n";
-
-  /** @memberof PIXI */
-  var BatchPluginFactory = /** @class */ (function () {
-      function BatchPluginFactory() {
-      }
-      /**
-       * Create a new BatchRenderer plugin for Renderer. this convenience can provide an easy way
-       * to extend BatchRenderer with all the necessary pieces.
-       * @example
-       * const fragment = `
-       * varying vec2 vTextureCoord;
-       * varying vec4 vColor;
-       * varying float vTextureId;
-       * uniform sampler2D uSamplers[%count%];
-       *
-       * void main(void){
-       *     vec4 color;
-       *     %forloop%
-       *     gl_FragColor = vColor * vec4(color.a - color.rgb, color.a);
-       * }
-       * `;
-       * const InvertBatchRenderer = PIXI.BatchPluginFactory.create({ fragment });
-       * PIXI.extensions.add({
-       *  name: 'invert',
-       *  ref: InvertBatchRenderer,
-       *  type: PIXI.ExtensionType.RendererPlugin,
-       * });
-       * const sprite = new PIXI.Sprite();
-       * sprite.pluginName = 'invert';
-       * @param {object} [options]
-       * @param {string} [options.vertex=PIXI.BatchPluginFactory.defaultVertexSrc] - Vertex shader source
-       * @param {string} [options.fragment=PIXI.BatchPluginFactory.defaultFragmentTemplate] - Fragment shader template
-       * @param {number} [options.vertexSize=6] - Vertex size
-       * @param {object} [options.geometryClass=PIXI.BatchGeometry]
-       * @returns {*} New batch renderer plugin
-       */
-      BatchPluginFactory.create = function (options) {
-          var _a = Object.assign({
-              vertex: defaultVertex,
-              fragment: defaultFragment,
-              geometryClass: BatchGeometry,
-              vertexSize: 6,
-          }, options), vertex = _a.vertex, fragment = _a.fragment, vertexSize = _a.vertexSize, geometryClass = _a.geometryClass;
-          return /** @class */ (function (_super) {
-              __extends$i(BatchPlugin, _super);
-              function BatchPlugin(renderer) {
-                  var _this = _super.call(this, renderer) || this;
-                  _this.shaderGenerator = new BatchShaderGenerator(vertex, fragment);
-                  _this.geometryClass = geometryClass;
-                  _this.vertexSize = vertexSize;
-                  return _this;
-              }
-              return BatchPlugin;
-          }(AbstractBatchRenderer));
-      };
-      Object.defineProperty(BatchPluginFactory, "defaultVertexSrc", {
-          /**
-           * The default vertex shader source
-           * @readonly
-           */
-          get: function () {
-              return defaultVertex;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BatchPluginFactory, "defaultFragmentTemplate", {
-          /**
-           * The default fragment shader source
-           * @readonly
-           */
-          get: function () {
-              return defaultFragment;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return BatchPluginFactory;
-  }());
-  // Setup the default BatchRenderer plugin, this is what
-  // we'll actually export at the root level
-  var BatchRenderer = BatchPluginFactory.create();
-  Object.assign(BatchRenderer, {
-      extension: {
-          name: 'batch',
-          type: exports.ExtensionType.RendererPlugin,
-      },
-  });
-
-  /**
-   * @memberof PIXI
-   * @namespace resources
-   * @see PIXI
-   * @deprecated since 6.0.0
-   */
-  var resources = {};
-  var _loop_1 = function (name) {
-      Object.defineProperty(resources, name, {
-          get: function () {
-              deprecation('6.0.0', "PIXI.systems." + name + " has moved to PIXI." + name);
-              return _resources[name];
-          },
-      });
-  };
-  for (var name in _resources) {
-      _loop_1(name);
-  }
-  /**
-   * @memberof PIXI
-   * @namespace systems
-   * @see PIXI
-   * @deprecated since 6.0.0
-   */
-  var systems = {};
-  var _loop_2 = function (name) {
-      Object.defineProperty(systems, name, {
-          get: function () {
-              deprecation('6.0.0', "PIXI.resources." + name + " has moved to PIXI." + name);
-              return _systems[name];
-          },
-      });
-  };
-  for (var name in _systems) {
-      _loop_2(name);
-  }
-
-  /**
-   * @namespace PIXI
-   */
-  /**
-   * String of the current PIXI version.
-   * @memberof PIXI
-   */
-  var VERSION = '6.5.10';
-
-  /*!
-   * @pixi/accessibility - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/accessibility is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Default property values of accessible objects
-   * used by {@link PIXI.AccessibilityManager}.
-   * @private
-   * @function accessibleTarget
-   * @memberof PIXI
-   * @type {object}
-   * @example
-   *      function MyObject() {}
-   *
-   *      Object.assign(
-   *          MyObject.prototype,
-   *          PIXI.accessibleTarget
-   *      );
-   */
-  var accessibleTarget = {
-      /**
-       *  Flag for if the object is accessible. If true AccessibilityManager will overlay a
-       *   shadow div with attributes set
-       * @member {boolean}
-       * @memberof PIXI.DisplayObject#
-       */
-      accessible: false,
-      /**
-       * Sets the title attribute of the shadow div
-       * If accessibleTitle AND accessibleHint has not been this will default to 'displayObject [tabIndex]'
-       * @member {?string}
-       * @memberof PIXI.DisplayObject#
-       */
-      accessibleTitle: null,
-      /**
-       * Sets the aria-label attribute of the shadow div
-       * @member {string}
-       * @memberof PIXI.DisplayObject#
-       */
-      accessibleHint: null,
-      /**
-       * @member {number}
-       * @memberof PIXI.DisplayObject#
-       * @private
-       * @todo Needs docs.
-       */
-      tabIndex: 0,
-      /**
-       * @member {boolean}
-       * @memberof PIXI.DisplayObject#
-       * @todo Needs docs.
-       */
-      _accessibleActive: false,
-      /**
-       * @member {boolean}
-       * @memberof PIXI.DisplayObject#
-       * @todo Needs docs.
-       */
-      _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 PIXI.DisplayObject#
-       * @default 'button'
-       */
-      accessibleType: 'button',
-      /**
-       * Specify the pointer-events the accessible div will use
-       * Defaults to auto.
-       * @member {string}
-       * @memberof PIXI.DisplayObject#
-       * @default 'auto'
-       */
-      accessiblePointerEvents: 'auto',
-      /**
-       * Setting to false will prevent any children inside this container to
-       * be accessible. Defaults to true.
-       * @member {boolean}
-       * @memberof PIXI.DisplayObject#
-       * @default true
-       */
-      accessibleChildren: true,
-      renderId: -1,
-  };
-
-  // add some extra variables to the container..
-  DisplayObject.mixin(accessibleTarget);
-  var KEY_CODE_TAB = 9;
-  var DIV_TOUCH_SIZE = 100;
-  var DIV_TOUCH_POS_X = 0;
-  var DIV_TOUCH_POS_Y = 0;
-  var DIV_TOUCH_ZINDEX = 2;
-  var DIV_HOOK_SIZE = 1;
-  var DIV_HOOK_POS_X = -1000;
-  var DIV_HOOK_POS_Y = -1000;
-  var DIV_HOOK_ZINDEX = 2;
-  /**
-   * The Accessibility manager 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 DisplayObject 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.plugins.accessibility`
-   * @class
-   * @memberof PIXI
-   */
-  var AccessibilityManager = /** @class */ (function () {
-      /**
-       * @param {PIXI.CanvasRenderer|PIXI.Renderer} renderer - A reference to the current renderer
-       */
-      function AccessibilityManager(renderer) {
-          /** 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; // 2fps
-          this._hookDiv = null;
-          if (isMobile.tablet || isMobile.phone) {
-              this.createTouchHook();
-          }
-          // first we create a div that will sit over the PixiJS element. This is where the div overlays will go.
-          var 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;
-          /**
-           * pre-bind the functions
-           * @type {Function}
-           * @private
-           */
-          this._onKeyDown = this._onKeyDown.bind(this);
-          /**
-           * pre-bind the functions
-           * @type {Function}
-           * @private
-           */
-          this._onMouseMove = this._onMouseMove.bind(this);
-          // let listen for tab.. once pressed we can fire up and show the accessibility layer
-          globalThis.addEventListener('keydown', this._onKeyDown, false);
-      }
-      Object.defineProperty(AccessibilityManager.prototype, "isActive", {
-          /**
-           * Value of `true` if accessibility is currently active and accessibility layers are showing.
-           * @member {boolean}
-           * @readonly
-           */
-          get: function () {
-              return this._isActive;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(AccessibilityManager.prototype, "isMobileAccessibility", {
-          /**
-           * Value of `true` if accessibility is enabled for touch devices.
-           * @member {boolean}
-           * @readonly
-           */
-          get: function () {
-              return this._isMobileAccessibility;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Creates the touch hooks.
-       * @private
-       */
-      AccessibilityManager.prototype.createTouchHook = function () {
-          var _this = this;
-          var 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', function () {
-              _this._isMobileAccessibility = true;
-              _this.activate();
-              _this.destroyTouchHook();
-          });
-          document.body.appendChild(hookDiv);
-          this._hookDiv = hookDiv;
-      };
-      /**
-       * Destroys the touch hooks.
-       * @private
-       */
-      AccessibilityManager.prototype.destroyTouchHook = function () {
-          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
-       */
-      AccessibilityManager.prototype.activate = function () {
-          var _a;
-          if (this._isActive) {
-              return;
-          }
-          this._isActive = true;
-          globalThis.document.addEventListener('mousemove', this._onMouseMove, true);
-          globalThis.removeEventListener('keydown', this._onKeyDown, false);
-          this.renderer.on('postrender', this.update, this);
-          (_a = this.renderer.view.parentNode) === null || _a === void 0 ? void 0 : _a.appendChild(this.div);
-      };
-      /**
-       * Deactivating will cause the Accessibility layer to be hidden.
-       * This is called when a user moves the mouse.
-       * @private
-       */
-      AccessibilityManager.prototype.deactivate = function () {
-          var _a;
-          if (!this._isActive || this._isMobileAccessibility) {
-              return;
-          }
-          this._isActive = false;
-          globalThis.document.removeEventListener('mousemove', this._onMouseMove, true);
-          globalThis.addEventListener('keydown', this._onKeyDown, false);
-          this.renderer.off('postrender', this.update);
-          (_a = this.div.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(this.div);
-      };
-      /**
-       * This recursive function will run through the scene graph and add any new accessible objects to the DOM layer.
-       * @private
-       * @param {PIXI.Container} displayObject - The DisplayObject to check.
-       */
-      AccessibilityManager.prototype.updateAccessibleObjects = function (displayObject) {
-          if (!displayObject.visible || !displayObject.accessibleChildren) {
-              return;
-          }
-          if (displayObject.accessible && displayObject.interactive) {
-              if (!displayObject._accessibleActive) {
-                  this.addChild(displayObject);
-              }
-              displayObject.renderId = this.renderId;
-          }
-          var children = displayObject.children;
-          if (children) {
-              for (var i = 0; i < children.length; i++) {
-                  this.updateAccessibleObjects(children[i]);
-              }
-          }
-      };
-      /**
-       * Before each render this function will ensure that all divs are mapped correctly to their DisplayObjects.
-       * @private
-       */
-      AccessibilityManager.prototype.update = function () {
-          /* On Android default web browser, tab order seems to be calculated by position rather than tabIndex,
-          *  moving buttons can cause focus to flicker between two buttons making it hard/impossible to navigate,
-          *  so I am just running update every half a second, seems to fix it.
-          */
-          var now = performance.now();
-          if (isMobile.android.device && now < this.androidUpdateCount) {
-              return;
-          }
-          this.androidUpdateCount = now + this.androidUpdateFrequency;
-          if (!this.renderer.renderingToScreen) {
-              return;
-          }
-          // update children...
-          if (this.renderer._lastObjectRendered) {
-              this.updateAccessibleObjects(this.renderer._lastObjectRendered);
-          }
-          var _a = this.renderer.view.getBoundingClientRect(), left = _a.left, top = _a.top, width = _a.width, height = _a.height;
-          var _b = this.renderer, viewWidth = _b.width, viewHeight = _b.height, resolution = _b.resolution;
-          var sx = (width / viewWidth) * resolution;
-          var sy = (height / viewHeight) * resolution;
-          var div = this.div;
-          div.style.left = left + "px";
-          div.style.top = top + "px";
-          div.style.width = viewWidth + "px";
-          div.style.height = viewHeight + "px";
-          for (var i = 0; i < this.children.length; i++) {
-              var 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 {
-                  // map div to display..
-                  div = child._accessibleDiv;
-                  var hitArea = child.hitArea;
-                  var 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();
-                      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";
-                      // update button titles and hints if they exist and they've changed
-                      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);
-                      }
-                  }
-                  // the title or index may have changed, if so lets update it!
-                  if (child.accessibleTitle !== div.title || child.tabIndex !== div.tabIndex) {
-                      div.title = child.accessibleTitle;
-                      div.tabIndex = child.tabIndex;
-                      if (this.debug)
-                          { this.updateDebugHTML(div); }
-                  }
-              }
-          }
-          // increment the render id..
-          this.renderId++;
-      };
-      /**
-       * private function that will visually add the information to the
-       * accessability div
-       * @param {HTMLElement} div -
-       */
-      AccessibilityManager.prototype.updateDebugHTML = function (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 {PIXI.Rectangle} hitArea - Bounds of the child
-       */
-      AccessibilityManager.prototype.capHitArea = function (hitArea) {
-          if (hitArea.x < 0) {
-              hitArea.width += hitArea.x;
-              hitArea.x = 0;
-          }
-          if (hitArea.y < 0) {
-              hitArea.height += hitArea.y;
-              hitArea.y = 0;
-          }
-          var _a = this.renderer, viewWidth = _a.width, viewHeight = _a.height;
-          if (hitArea.x + hitArea.width > viewWidth) {
-              hitArea.width = viewWidth - hitArea.x;
-          }
-          if (hitArea.y + hitArea.height > viewHeight) {
-              hitArea.height = viewHeight - hitArea.y;
-          }
-      };
-      /**
-       * Adds a DisplayObject to the accessibility manager
-       * @private
-       * @param {PIXI.DisplayObject} displayObject - The child to make accessible.
-       */
-      AccessibilityManager.prototype.addChild = function (displayObject) {
-          //    this.activate();
-          var 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';
-              // ARIA attributes ensure that button title and hint updates are announced properly
-              if (navigator.userAgent.toLowerCase().indexOf('chrome') > -1) {
-                  // Chrome doesn't need aria-live to work as intended; in fact it just gets more confused.
-                  div.setAttribute('aria-live', 'off');
-              }
-              else {
-                  div.setAttribute('aria-live', 'polite');
-              }
-              if (navigator.userAgent.match(/rv:.*Gecko\//)) {
-                  // FireFox needs this to announce only the new button name
-                  div.setAttribute('aria-relevant', 'additions');
-              }
-              else {
-                  // required by IE, other browsers don't much care
-                  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));
-          }
-          // set pointer events
-          div.style.pointerEvents = displayObject.accessiblePointerEvents;
-          // set the type, this defaults to button!
-          div.type = displayObject.accessibleType;
-          if (displayObject.accessibleTitle && displayObject.accessibleTitle !== null) {
-              div.title = displayObject.accessibleTitle;
-          }
-          else if (!displayObject.accessibleHint
-              || displayObject.accessibleHint === null) {
-              div.title = "displayObject " + displayObject.tabIndex;
-          }
-          if (displayObject.accessibleHint
-              && displayObject.accessibleHint !== null) {
-              div.setAttribute('aria-label', displayObject.accessibleHint);
-          }
-          if (this.debug)
-              { this.updateDebugHTML(div); }
-          displayObject._accessibleActive = true;
-          displayObject._accessibleDiv = div;
-          div.displayObject = displayObject;
-          this.children.push(displayObject);
-          this.div.appendChild(displayObject._accessibleDiv);
-          displayObject._accessibleDiv.tabIndex = displayObject.tabIndex;
-      };
-      /**
-       * Maps the div button press to pixi's InteractionManager (click)
-       * @private
-       * @param {MouseEvent} e - The click event.
-       */
-      AccessibilityManager.prototype._onClick = function (e) {
-          var interactionManager = this.renderer.plugins.interaction;
-          var displayObject = e.target.displayObject;
-          var eventData = interactionManager.eventData;
-          interactionManager.dispatchEvent(displayObject, 'click', eventData);
-          interactionManager.dispatchEvent(displayObject, 'pointertap', eventData);
-          interactionManager.dispatchEvent(displayObject, 'tap', eventData);
-      };
-      /**
-       * Maps the div focus events to pixi's InteractionManager (mouseover)
-       * @private
-       * @param {FocusEvent} e - The focus event.
-       */
-      AccessibilityManager.prototype._onFocus = function (e) {
-          if (!e.target.getAttribute('aria-live')) {
-              e.target.setAttribute('aria-live', 'assertive');
-          }
-          var interactionManager = this.renderer.plugins.interaction;
-          var displayObject = e.target.displayObject;
-          var eventData = interactionManager.eventData;
-          interactionManager.dispatchEvent(displayObject, 'mouseover', eventData);
-      };
-      /**
-       * Maps the div focus events to pixi's InteractionManager (mouseout)
-       * @private
-       * @param {FocusEvent} e - The focusout event.
-       */
-      AccessibilityManager.prototype._onFocusOut = function (e) {
-          if (!e.target.getAttribute('aria-live')) {
-              e.target.setAttribute('aria-live', 'polite');
-          }
-          var interactionManager = this.renderer.plugins.interaction;
-          var displayObject = e.target.displayObject;
-          var eventData = interactionManager.eventData;
-          interactionManager.dispatchEvent(displayObject, 'mouseout', eventData);
-      };
-      /**
-       * Is called when a key is pressed
-       * @private
-       * @param {KeyboardEvent} e - The keydown event.
-       */
-      AccessibilityManager.prototype._onKeyDown = function (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.
-       */
-      AccessibilityManager.prototype._onMouseMove = function (e) {
-          if (e.movementX === 0 && e.movementY === 0) {
-              return;
-          }
-          this.deactivate();
-      };
-      /** Destroys the accessibility manager */
-      AccessibilityManager.prototype.destroy = function () {
-          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 */
-      AccessibilityManager.extension = {
-          name: 'accessibility',
-          type: [
-              exports.ExtensionType.RendererPlugin,
-              exports.ExtensionType.CanvasRendererPlugin ],
-      };
-      return AccessibilityManager;
-  }());
-
-  /*!
-   * @pixi/interaction - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/interaction is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Holds all information related to an Interaction event
-   * @memberof PIXI
-   */
-  var InteractionData = /** @class */ (function () {
-      function InteractionData() {
-          /**
-           * Pressure applied by the pointing device during the event. A Touch's force property
-           * will be represented by this value.
-           * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pressure
-           */
-          this.pressure = 0;
-          /**
-           * From TouchEvents (not PointerEvents triggered by touches), the rotationAngle of the Touch.
-           * @see https://developer.mozilla.org/en-US/docs/Web/API/Touch/rotationAngle
-           */
-          this.rotationAngle = 0;
-          /**
-           * Twist of a stylus pointer.
-           * @see https://w3c.github.io/pointerevents/#pointerevent-interface
-           */
-          this.twist = 0;
-          /**
-           * Barrel pressure on a stylus pointer.
-           * @see https://w3c.github.io/pointerevents/#pointerevent-interface
-           */
-          this.tangentialPressure = 0;
-          this.global = new Point();
-          this.target = null;
-          this.originalEvent = null;
-          this.identifier = null;
-          this.isPrimary = false;
-          this.button = 0;
-          this.buttons = 0;
-          this.width = 0;
-          this.height = 0;
-          this.tiltX = 0;
-          this.tiltY = 0;
-          this.pointerType = null;
-          this.pressure = 0;
-          this.rotationAngle = 0;
-          this.twist = 0;
-          this.tangentialPressure = 0;
-      }
-      Object.defineProperty(InteractionData.prototype, "pointerId", {
-          /**
-           * The unique identifier of the pointer. It will be the same as `identifier`.
-           * @readonly
-           * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId
-           */
-          get: function () {
-              return this.identifier;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * This will return the local coordinates of the specified displayObject for this InteractionData
-       * @param displayObject - The DisplayObject that you would like the local
-       *  coords off
-       * @param point - A Point object in which to store the value, optional (otherwise
-       *  will create a new point)
-       * @param globalPos - A Point object containing your custom global coords, optional
-       *  (otherwise will use the current global coords)
-       * @returns - A point containing the coordinates of the InteractionData position relative
-       *  to the DisplayObject
-       */
-      InteractionData.prototype.getLocalPosition = function (displayObject, point, globalPos) {
-          return displayObject.worldTransform.applyInverse(globalPos || this.global, point);
-      };
-      /**
-       * Copies properties from normalized event data.
-       * @param {Touch|MouseEvent|PointerEvent} event - The normalized event data
-       */
-      InteractionData.prototype.copyEvent = function (event) {
-          // isPrimary should only change on touchstart/pointerdown, so we don't want to overwrite
-          // it with "false" on later events when our shim for it on touch events might not be
-          // accurate
-          if ('isPrimary' in event && event.isPrimary) {
-              this.isPrimary = true;
-          }
-          this.button = 'button' in event && event.button;
-          // event.buttons is not available in all browsers (ie. Safari), but it does have a non-standard
-          // event.which property instead, which conveys the same information.
-          var buttons = 'buttons' in event && event.buttons;
-          this.buttons = Number.isInteger(buttons) ? buttons : 'which' in event && event.which;
-          this.width = 'width' in event && event.width;
-          this.height = 'height' in event && event.height;
-          this.tiltX = 'tiltX' in event && event.tiltX;
-          this.tiltY = 'tiltY' in event && event.tiltY;
-          this.pointerType = 'pointerType' in event && event.pointerType;
-          this.pressure = 'pressure' in event && event.pressure;
-          this.rotationAngle = 'rotationAngle' in event && event.rotationAngle;
-          this.twist = ('twist' in event && event.twist) || 0;
-          this.tangentialPressure = ('tangentialPressure' in event && event.tangentialPressure) || 0;
-      };
-      /** Resets the data for pooling. */
-      InteractionData.prototype.reset = function () {
-          // isPrimary is the only property that we really need to reset - everything else is
-          // guaranteed to be overwritten
-          this.isPrimary = false;
-      };
-      return InteractionData;
-  }());
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$h = function(d, b) {
-      extendStatics$h = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$h(d, b);
-  };
-
-  function __extends$h(d, b) {
-      extendStatics$h(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * Event class that mimics native DOM events.
-   * @memberof PIXI
-   */
-  var InteractionEvent = /** @class */ (function () {
-      function InteractionEvent() {
-          this.stopped = false;
-          this.stopsPropagatingAt = null;
-          this.stopPropagationHint = false;
-          this.target = null;
-          this.currentTarget = null;
-          this.type = null;
-          this.data = null;
-      }
-      /** Prevents event from reaching any objects other than the current object. */
-      InteractionEvent.prototype.stopPropagation = function () {
-          this.stopped = true;
-          this.stopPropagationHint = true;
-          this.stopsPropagatingAt = this.currentTarget;
-      };
-      /** Resets the event. */
-      InteractionEvent.prototype.reset = function () {
-          this.stopped = false;
-          this.stopsPropagatingAt = null;
-          this.stopPropagationHint = false;
-          this.currentTarget = null;
-          this.target = null;
-      };
-      return InteractionEvent;
-  }());
-
-  /**
-   * DisplayObjects with the {@link PIXI.interactiveTarget} mixin use this class to track interactions
-   * @class
-   * @private
-   * @memberof PIXI
-   */
-  var InteractionTrackingData = /** @class */ (function () {
-      /**
-       * @param {number} pointerId - Unique pointer id of the event
-       * @private
-       */
-      function InteractionTrackingData(pointerId) {
-          this._pointerId = pointerId;
-          this._flags = InteractionTrackingData.FLAGS.NONE;
-      }
-      /**
-       *
-       * @private
-       * @param {number} flag - The interaction flag to set
-       * @param {boolean} yn - Should the flag be set or unset
-       */
-      InteractionTrackingData.prototype._doSet = function (flag, yn) {
-          if (yn) {
-              this._flags = this._flags | flag;
-          }
-          else {
-              this._flags = this._flags & (~flag);
-          }
-      };
-      Object.defineProperty(InteractionTrackingData.prototype, "pointerId", {
-          /**
-           * Unique pointer id of the event
-           * @readonly
-           * @private
-           * @member {number}
-           */
-          get: function () {
-              return this._pointerId;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(InteractionTrackingData.prototype, "flags", {
-          /**
-           * State of the tracking data, expressed as bit flags
-           * @private
-           * @member {number}
-           */
-          get: function () {
-              return this._flags;
-          },
-          set: function (flags) {
-              this._flags = flags;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(InteractionTrackingData.prototype, "none", {
-          /**
-           * Is the tracked event inactive (not over or down)?
-           * @private
-           * @member {number}
-           */
-          get: function () {
-              return this._flags === InteractionTrackingData.FLAGS.NONE;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(InteractionTrackingData.prototype, "over", {
-          /**
-           * Is the tracked event over the DisplayObject?
-           * @private
-           * @member {boolean}
-           */
-          get: function () {
-              return (this._flags & InteractionTrackingData.FLAGS.OVER) !== 0;
-          },
-          set: function (yn) {
-              this._doSet(InteractionTrackingData.FLAGS.OVER, yn);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(InteractionTrackingData.prototype, "rightDown", {
-          /**
-           * Did the right mouse button come down in the DisplayObject?
-           * @private
-           * @member {boolean}
-           */
-          get: function () {
-              return (this._flags & InteractionTrackingData.FLAGS.RIGHT_DOWN) !== 0;
-          },
-          set: function (yn) {
-              this._doSet(InteractionTrackingData.FLAGS.RIGHT_DOWN, yn);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(InteractionTrackingData.prototype, "leftDown", {
-          /**
-           * Did the left mouse button come down in the DisplayObject?
-           * @private
-           * @member {boolean}
-           */
-          get: function () {
-              return (this._flags & InteractionTrackingData.FLAGS.LEFT_DOWN) !== 0;
-          },
-          set: function (yn) {
-              this._doSet(InteractionTrackingData.FLAGS.LEFT_DOWN, yn);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      InteractionTrackingData.FLAGS = Object.freeze({
-          NONE: 0,
-          OVER: 1 << 0,
-          LEFT_DOWN: 1 << 1,
-          RIGHT_DOWN: 1 << 2,
-      });
-      return InteractionTrackingData;
-  }());
-
-  /**
-   * Strategy how to search through stage tree for interactive objects
-   * @memberof PIXI
-   */
-  var TreeSearch = /** @class */ (function () {
-      function TreeSearch() {
-          this._tempPoint = new Point();
-      }
-      /**
-       * Recursive implementation for findHit
-       * @private
-       * @param interactionEvent - event containing the point that
-       *  is tested for collision
-       * @param displayObject - the displayObject
-       *  that will be hit test (recursively crawls its children)
-       * @param func - the function that will be called on each interactive object. The
-       *  interactionEvent, displayObject and hit will be passed to the function
-       * @param hitTest - this indicates if the objects inside should be hit test against the point
-       * @param interactive - Whether the displayObject is interactive
-       * @returns - Returns true if the displayObject hit the point
-       */
-      TreeSearch.prototype.recursiveFindHit = function (interactionEvent, displayObject, func, hitTest, interactive) {
-          var _a;
-          if (!displayObject || !displayObject.visible) {
-              return false;
-          }
-          var point = interactionEvent.data.global;
-          // Took a little while to rework this function correctly! But now it is done and nice and optimized! ^_^
-          //
-          // This function will now loop through all objects and then only hit test the objects it HAS
-          // to, not all of them. MUCH faster..
-          // An object will be hit test if the following is true:
-          //
-          // 1: It is interactive.
-          // 2: It belongs to a parent that is interactive AND one of the parents children have not already been hit.
-          //
-          // As another little optimization once an interactive object has been hit we can carry on
-          // through the scenegraph, but we know that there will be no more hits! So we can avoid extra hit tests
-          // A final optimization is that an object is not hit test directly if a child has already been hit.
-          interactive = displayObject.interactive || interactive;
-          var hit = false;
-          var interactiveParent = interactive;
-          // Flag here can set to false if the event is outside the parents hitArea or mask
-          var hitTestChildren = true;
-          // If there is a hitArea, no need to test against anything else if the pointer is not within the hitArea
-          // There is also no longer a need to hitTest children.
-          if (displayObject.hitArea) {
-              if (hitTest) {
-                  displayObject.worldTransform.applyInverse(point, this._tempPoint);
-                  if (!displayObject.hitArea.contains(this._tempPoint.x, this._tempPoint.y)) {
-                      hitTest = false;
-                      hitTestChildren = false;
-                  }
-                  else {
-                      hit = true;
-                  }
-              }
-              interactiveParent = false;
-          }
-          // If there is a mask, no need to hitTest against anything else if the pointer is not within the mask.
-          // We still want to hitTestChildren, however, to ensure a mouseout can still be generated.
-          // https://github.com/pixijs/pixi.js/issues/5135
-          else if (displayObject._mask) {
-              if (hitTest) {
-                  var maskObject = (displayObject._mask.isMaskData
-                      ? displayObject._mask.maskObject : displayObject._mask);
-                  if (maskObject && !((_a = maskObject.containsPoint) === null || _a === void 0 ? void 0 : _a.call(maskObject, point))) {
-                      hitTest = false;
-                  }
-              }
-          }
-          // ** FREE TIP **! If an object is not interactive or has no buttons in it
-          // (such as a game scene!) set interactiveChildren to false for that displayObject.
-          // This will allow PixiJS to completely ignore and bypass checking the displayObjects children.
-          if (hitTestChildren && displayObject.interactiveChildren && displayObject.children) {
-              var children = displayObject.children;
-              for (var i = children.length - 1; i >= 0; i--) {
-                  var child = children[i];
-                  // time to get recursive.. if this function will return if something is hit..
-                  var childHit = this.recursiveFindHit(interactionEvent, child, func, hitTest, interactiveParent);
-                  if (childHit) {
-                      // its a good idea to check if a child has lost its parent.
-                      // this means it has been removed whilst looping so its best
-                      if (!child.parent) {
-                          continue;
-                      }
-                      // we no longer need to hit test any more objects in this container as we we
-                      // now know the parent has been hit
-                      interactiveParent = false;
-                      // If the child is interactive , that means that the object hit was actually
-                      // interactive and not just the child of an interactive object.
-                      // This means we no longer need to hit test anything else. We still need to run
-                      // through all objects, but we don't need to perform any hit tests.
-                      if (childHit) {
-                          if (interactionEvent.target) {
-                              hitTest = false;
-                          }
-                          hit = true;
-                      }
-                  }
-              }
-          }
-          // no point running this if the item is not interactive or does not have an interactive parent.
-          if (interactive) {
-              // if we are hit testing (as in we have no hit any objects yet)
-              // We also don't need to worry about hit testing if once of the displayObjects children
-              // has already been hit - but only if it was interactive, otherwise we need to keep
-              // looking for an interactive child, just in case we hit one
-              if (hitTest && !interactionEvent.target) {
-                  // already tested against hitArea if it is defined
-                  if (!displayObject.hitArea && displayObject.containsPoint) {
-                      if (displayObject.containsPoint(point)) {
-                          hit = true;
-                      }
-                  }
-              }
-              if (displayObject.interactive) {
-                  if (hit && !interactionEvent.target) {
-                      interactionEvent.target = displayObject;
-                  }
-                  if (func) {
-                      func(interactionEvent, displayObject, !!hit);
-                  }
-              }
-          }
-          return hit;
-      };
-      /**
-       * This function is provides a neat way of crawling through the scene graph and running a
-       * specified function on all interactive objects it finds. It will also take care of hit
-       * testing the interactive objects and passes the hit across in the function.
-       * @private
-       * @param interactionEvent - event containing the point that
-       *  is tested for collision
-       * @param displayObject - the displayObject
-       *  that will be hit test (recursively crawls its children)
-       * @param func - the function that will be called on each interactive object. The
-       *  interactionEvent, displayObject and hit will be passed to the function
-       * @param hitTest - this indicates if the objects inside should be hit test against the point
-       * @returns - Returns true if the displayObject hit the point
-       */
-      TreeSearch.prototype.findHit = function (interactionEvent, displayObject, func, hitTest) {
-          this.recursiveFindHit(interactionEvent, displayObject, func, hitTest, false);
-      };
-      return TreeSearch;
-  }());
-
-  /**
-   * Interface for classes that represent a hit area.
-   *
-   * It is implemented by the following classes:
-   * - {@link PIXI.Circle}
-   * - {@link PIXI.Ellipse}
-   * - {@link PIXI.Polygon}
-   * - {@link PIXI.RoundedRectangle}
-   * @interface IHitArea
-   * @memberof PIXI
-   */
-  /**
-   * Checks whether the x and y coordinates given are contained within this area
-   * @method
-   * @name contains
-   * @memberof PIXI.IHitArea#
-   * @param {number} x - The X coordinate of the point to test
-   * @param {number} y - The Y coordinate of the point to test
-   * @returns {boolean} Whether the x/y coordinates are within this area
-   */
-  /**
-   * Default property values of interactive objects
-   * Used by {@link PIXI.InteractionManager} to automatically give all DisplayObjects these properties
-   * @private
-   * @name interactiveTarget
-   * @type {object}
-   * @memberof PIXI
-   * @example
-   *      function MyObject() {}
-   *
-   *      Object.assign(
-   *          DisplayObject.prototype,
-   *          PIXI.interactiveTarget
-   *      );
-   */
-  var interactiveTarget = {
-      interactive: false,
-      interactiveChildren: true,
-      hitArea: null,
-      /**
-       * If enabled, the mouse cursor use the pointer behavior when hovered over the displayObject if it is interactive
-       * Setting this changes the 'cursor' property to `'pointer'`.
-       * @example
-       * const sprite = new PIXI.Sprite(texture);
-       * sprite.interactive = true;
-       * sprite.buttonMode = true;
-       * @member {boolean}
-       * @memberof PIXI.DisplayObject#
-       */
-      get buttonMode() {
-          return this.cursor === 'pointer';
-      },
-      set buttonMode(value) {
-          if (value) {
-              this.cursor = 'pointer';
-          }
-          else if (this.cursor === 'pointer') {
-              this.cursor = null;
-          }
-      },
-      /**
-       * This defines what cursor mode is used when the mouse cursor
-       * is hovered over the displayObject.
-       * @example
-       * const sprite = new PIXI.Sprite(texture);
-       * sprite.interactive = true;
-       * sprite.cursor = 'wait';
-       * @see https://developer.mozilla.org/en/docs/Web/CSS/cursor
-       * @member {string}
-       * @memberof PIXI.DisplayObject#
-       */
-      cursor: null,
-      /**
-       * Internal set of all active pointers, by identifier
-       * @member {Map<number, InteractionTrackingData>}
-       * @memberof PIXI.DisplayObject#
-       * @private
-       */
-      get trackedPointers() {
-          if (this._trackedPointers === undefined)
-              { this._trackedPointers = {}; }
-          return this._trackedPointers;
-      },
-      /**
-       * Map of all tracked pointers, by identifier. Use trackedPointers to access.
-       * @private
-       * @type {Map<number, InteractionTrackingData>}
-       */
-      _trackedPointers: undefined,
-  };
-
-  // Mix interactiveTarget into DisplayObject.prototype
-  DisplayObject.mixin(interactiveTarget);
-  var MOUSE_POINTER_ID = 1;
-  // helpers for hitTest() - only used inside hitTest()
-  var hitTestEvent = {
-      target: null,
-      data: {
-          global: null,
-      },
-  };
-  /**
-   * The interaction manager deals with mouse, touch and pointer events.
-   *
-   * Any DisplayObject can be interactive if its `interactive` property is set to true.
-   *
-   * This manager also supports multitouch.
-   *
-   * An instance of this class is automatically created by default, and can be found at `renderer.plugins.interaction`
-   * @memberof PIXI
-   */
-  var InteractionManager = /** @class */ (function (_super) {
-      __extends$h(InteractionManager, _super);
-      /**
-       * @param {PIXI.CanvasRenderer|PIXI.Renderer} renderer - A reference to the current renderer
-       * @param options - The options for the manager.
-       * @param {boolean} [options.autoPreventDefault=true] - Should the manager automatically prevent default browser actions.
-       * @param {number} [options.interactionFrequency=10] - Maximum frequency (ms) at pointer over/out states will be checked.
-       * @param {number} [options.useSystemTicker=true] - Whether to add {@link tickerUpdate} to {@link PIXI.Ticker.system}.
-       */
-      function InteractionManager(renderer, options) {
-          var _this = _super.call(this) || this;
-          options = options || {};
-          _this.renderer = renderer;
-          _this.autoPreventDefault = options.autoPreventDefault !== undefined ? options.autoPreventDefault : true;
-          _this.interactionFrequency = options.interactionFrequency || 10;
-          _this.mouse = new InteractionData();
-          _this.mouse.identifier = MOUSE_POINTER_ID;
-          // setting the mouse to start off far off screen will mean that mouse over does
-          //  not get called before we even move the mouse.
-          _this.mouse.global.set(-999999);
-          _this.activeInteractionData = {};
-          _this.activeInteractionData[MOUSE_POINTER_ID] = _this.mouse;
-          _this.interactionDataPool = [];
-          _this.eventData = new InteractionEvent();
-          _this.interactionDOMElement = null;
-          _this.moveWhenInside = false;
-          _this.eventsAdded = false;
-          _this.tickerAdded = false;
-          _this.mouseOverRenderer = !('PointerEvent' in globalThis);
-          _this.supportsTouchEvents = 'ontouchstart' in globalThis;
-          _this.supportsPointerEvents = !!globalThis.PointerEvent;
-          // this will make it so that you don't have to call bind all the time
-          _this.onPointerUp = _this.onPointerUp.bind(_this);
-          _this.processPointerUp = _this.processPointerUp.bind(_this);
-          _this.onPointerCancel = _this.onPointerCancel.bind(_this);
-          _this.processPointerCancel = _this.processPointerCancel.bind(_this);
-          _this.onPointerDown = _this.onPointerDown.bind(_this);
-          _this.processPointerDown = _this.processPointerDown.bind(_this);
-          _this.onPointerMove = _this.onPointerMove.bind(_this);
-          _this.processPointerMove = _this.processPointerMove.bind(_this);
-          _this.onPointerOut = _this.onPointerOut.bind(_this);
-          _this.processPointerOverOut = _this.processPointerOverOut.bind(_this);
-          _this.onPointerOver = _this.onPointerOver.bind(_this);
-          _this.cursorStyles = {
-              default: 'inherit',
-              pointer: 'pointer',
-          };
-          _this.currentCursorMode = null;
-          _this.cursor = null;
-          _this.resolution = 1;
-          _this.delayedEvents = [];
-          _this.search = new TreeSearch();
-          _this._tempDisplayObject = new TemporaryDisplayObject();
-          _this._eventListenerOptions = { capture: true, passive: false };
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is pressed on the display
-           * object.
-           * @event PIXI.InteractionManager#mousedown
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-           * on the display object.
-           * @event PIXI.InteractionManager#rightdown
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is released over the display
-           * object.
-           * @event PIXI.InteractionManager#mouseup
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is released
-           * over the display object.
-           * @event PIXI.InteractionManager#rightup
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is pressed and released on
-           * the display object.
-           * @event PIXI.InteractionManager#click
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-           * and released on the display object.
-           * @event PIXI.InteractionManager#rightclick
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is released outside the
-           * display object that initially registered a
-           * [mousedown]{@link PIXI.InteractionManager#event:mousedown}.
-           * @event PIXI.InteractionManager#mouseupoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is released
-           * outside the display object that initially registered a
-           * [rightdown]{@link PIXI.InteractionManager#event:rightdown}.
-           * @event PIXI.InteractionManager#rightupoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device (usually a mouse) is moved while over the display object
-           * @event PIXI.InteractionManager#mousemove
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device (usually a mouse) is moved onto the display object
-           * @event PIXI.InteractionManager#mouseover
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device (usually a mouse) is moved off the display object
-           * @event PIXI.InteractionManager#mouseout
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is pressed on the display object.
-           * @event PIXI.InteractionManager#pointerdown
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is released over the display object.
-           * Not always fired when some buttons are held down while others are released. In those cases,
-           * use [mousedown]{@link PIXI.InteractionManager#event:mousedown} and
-           * [mouseup]{@link PIXI.InteractionManager#event:mouseup} instead.
-           * @event PIXI.InteractionManager#pointerup
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when the operating system cancels a pointer event
-           * @event PIXI.InteractionManager#pointercancel
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is pressed and released on the display object.
-           * @event PIXI.InteractionManager#pointertap
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is released outside the display object that initially
-           * registered a [pointerdown]{@link PIXI.InteractionManager#event:pointerdown}.
-           * @event PIXI.InteractionManager#pointerupoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device is moved while over the display object
-           * @event PIXI.InteractionManager#pointermove
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device is moved onto the display object
-           * @event PIXI.InteractionManager#pointerover
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device is moved off the display object
-           * @event PIXI.InteractionManager#pointerout
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is placed on the display object.
-           * @event PIXI.InteractionManager#touchstart
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is removed from the display object.
-           * @event PIXI.InteractionManager#touchend
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when the operating system cancels a touch
-           * @event PIXI.InteractionManager#touchcancel
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is placed and removed from the display object.
-           * @event PIXI.InteractionManager#tap
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is removed outside of the display object that initially
-           * registered a [touchstart]{@link PIXI.InteractionManager#event:touchstart}.
-           * @event PIXI.InteractionManager#touchendoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is moved along the display object.
-           * @event PIXI.InteractionManager#touchmove
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is pressed on the display.
-           * object. DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#mousedown
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-           * on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#rightdown
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is released over the display
-           * object. DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#mouseup
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is released
-           * over the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#rightup
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is pressed and released on
-           * the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#click
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is pressed
-           * and released on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#rightclick
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button (usually a mouse left-button) is released outside the
-           * display object that initially registered a
-           * [mousedown]{@link PIXI.DisplayObject#event:mousedown}.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#mouseupoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device secondary button (usually a mouse right-button) is released
-           * outside the display object that initially registered a
-           * [rightdown]{@link PIXI.DisplayObject#event:rightdown}.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#rightupoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device (usually a mouse) is moved while over the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#mousemove
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device (usually a mouse) is moved onto the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#mouseover
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device (usually a mouse) is moved off the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#mouseout
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is pressed on the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointerdown
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is released over the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointerup
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when the operating system cancels a pointer event.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointercancel
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is pressed and released on the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointertap
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device button is released outside the display object that initially
-           * registered a [pointerdown]{@link PIXI.DisplayObject#event:pointerdown}.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointerupoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device is moved while over the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointermove
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device is moved onto the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointerover
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a pointer device is moved off the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#pointerout
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is placed on the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#touchstart
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is removed from the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#touchend
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when the operating system cancels a touch.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#touchcancel
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is placed and removed from the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#tap
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is removed outside of the display object that initially
-           * registered a [touchstart]{@link PIXI.DisplayObject#event:touchstart}.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#touchendoutside
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          /**
-           * Fired when a touch point is moved along the display object.
-           * DisplayObject's `interactive` property must be set to `true` to fire event.
-           *
-           * This comes from the @pixi/interaction package.
-           * @event PIXI.DisplayObject#touchmove
-           * @param {PIXI.InteractionEvent} event - Interaction event
-           */
-          _this._useSystemTicker = options.useSystemTicker !== undefined ? options.useSystemTicker : true;
-          _this.setTargetElement(_this.renderer.view, _this.renderer.resolution);
-          return _this;
-      }
-      Object.defineProperty(InteractionManager.prototype, "useSystemTicker", {
-          /**
-           * Should the InteractionManager automatically add {@link tickerUpdate} to {@link PIXI.Ticker.system}.
-           * @default true
-           */
-          get: function () {
-              return this._useSystemTicker;
-          },
-          set: function (useSystemTicker) {
-              this._useSystemTicker = useSystemTicker;
-              if (useSystemTicker) {
-                  this.addTickerListener();
-              }
-              else {
-                  this.removeTickerListener();
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(InteractionManager.prototype, "lastObjectRendered", {
-          /**
-           * Last rendered object or temp object.
-           * @readonly
-           * @protected
-           */
-          get: function () {
-              return this.renderer._lastObjectRendered || this._tempDisplayObject;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Hit tests a point against the display tree, returning the first interactive object that is hit.
-       * @param globalPoint - A point to hit test with, in global space.
-       * @param root - The root display object to start from. If omitted, defaults
-       * to the last rendered root of the associated renderer.
-       * @returns - The hit display object, if any.
-       */
-      InteractionManager.prototype.hitTest = function (globalPoint, root) {
-          // clear the target for our hit test
-          hitTestEvent.target = null;
-          // assign the global point
-          hitTestEvent.data.global = globalPoint;
-          // ensure safety of the root
-          if (!root) {
-              root = this.lastObjectRendered;
-          }
-          // run the hit test
-          this.processInteractive(hitTestEvent, root, null, true);
-          // return our found object - it'll be null if we didn't hit anything
-          return hitTestEvent.target;
-      };
-      /**
-       * Sets the DOM element which will receive mouse/touch events. This is useful for when you have
-       * other DOM elements on top of the renderers Canvas element. With this you'll be bale to delegate
-       * another DOM element to receive those events.
-       * @param element - the DOM element which will receive mouse and touch events.
-       * @param resolution - The resolution / device pixel ratio of the new element (relative to the canvas).
-       */
-      InteractionManager.prototype.setTargetElement = function (element, resolution) {
-          if (resolution === void 0) { resolution = 1; }
-          this.removeTickerListener();
-          this.removeEvents();
-          this.interactionDOMElement = element;
-          this.resolution = resolution;
-          this.addEvents();
-          this.addTickerListener();
-      };
-      /** Adds the ticker listener. */
-      InteractionManager.prototype.addTickerListener = function () {
-          if (this.tickerAdded || !this.interactionDOMElement || !this._useSystemTicker) {
-              return;
-          }
-          Ticker.system.add(this.tickerUpdate, this, exports.UPDATE_PRIORITY.INTERACTION);
-          this.tickerAdded = true;
-      };
-      /** Removes the ticker listener. */
-      InteractionManager.prototype.removeTickerListener = function () {
-          if (!this.tickerAdded) {
-              return;
-          }
-          Ticker.system.remove(this.tickerUpdate, this);
-          this.tickerAdded = false;
-      };
-      /** Registers all the DOM events. */
-      InteractionManager.prototype.addEvents = function () {
-          if (this.eventsAdded || !this.interactionDOMElement) {
-              return;
-          }
-          var style = this.interactionDOMElement.style;
-          if (globalThis.navigator.msPointerEnabled) {
-              style.msContentZooming = 'none';
-              style.msTouchAction = 'none';
-          }
-          else if (this.supportsPointerEvents) {
-              style.touchAction = 'none';
-          }
-          /*
-           * These events are added first, so that if pointer events are normalized, they are fired
-           * in the same order as non-normalized events. ie. pointer event 1st, mouse / touch 2nd
-           */
-          if (this.supportsPointerEvents) {
-              globalThis.document.addEventListener('pointermove', this.onPointerMove, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('pointerdown', this.onPointerDown, this._eventListenerOptions);
-              // pointerout is fired in addition to pointerup (for touch events) and pointercancel
-              // we already handle those, so for the purposes of what we do in onPointerOut, we only
-              // care about the pointerleave event
-              this.interactionDOMElement.addEventListener('pointerleave', this.onPointerOut, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('pointerover', this.onPointerOver, this._eventListenerOptions);
-              globalThis.addEventListener('pointercancel', this.onPointerCancel, this._eventListenerOptions);
-              globalThis.addEventListener('pointerup', this.onPointerUp, this._eventListenerOptions);
-          }
-          else {
-              globalThis.document.addEventListener('mousemove', this.onPointerMove, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('mousedown', this.onPointerDown, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('mouseout', this.onPointerOut, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('mouseover', this.onPointerOver, this._eventListenerOptions);
-              globalThis.addEventListener('mouseup', this.onPointerUp, this._eventListenerOptions);
-          }
-          // always look directly for touch events so that we can provide original data
-          // In a future version we should change this to being just a fallback and rely solely on
-          // PointerEvents whenever available
-          if (this.supportsTouchEvents) {
-              this.interactionDOMElement.addEventListener('touchstart', this.onPointerDown, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('touchcancel', this.onPointerCancel, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('touchend', this.onPointerUp, this._eventListenerOptions);
-              this.interactionDOMElement.addEventListener('touchmove', this.onPointerMove, this._eventListenerOptions);
-          }
-          this.eventsAdded = true;
-      };
-      /** Removes all the DOM events that were previously registered. */
-      InteractionManager.prototype.removeEvents = function () {
-          if (!this.eventsAdded || !this.interactionDOMElement) {
-              return;
-          }
-          var style = this.interactionDOMElement.style;
-          if (globalThis.navigator.msPointerEnabled) {
-              style.msContentZooming = '';
-              style.msTouchAction = '';
-          }
-          else if (this.supportsPointerEvents) {
-              style.touchAction = '';
-          }
-          if (this.supportsPointerEvents) {
-              globalThis.document.removeEventListener('pointermove', this.onPointerMove, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('pointerdown', this.onPointerDown, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('pointerleave', this.onPointerOut, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('pointerover', this.onPointerOver, this._eventListenerOptions);
-              globalThis.removeEventListener('pointercancel', this.onPointerCancel, this._eventListenerOptions);
-              globalThis.removeEventListener('pointerup', this.onPointerUp, this._eventListenerOptions);
-          }
-          else {
-              globalThis.document.removeEventListener('mousemove', this.onPointerMove, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('mousedown', this.onPointerDown, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('mouseout', this.onPointerOut, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('mouseover', this.onPointerOver, this._eventListenerOptions);
-              globalThis.removeEventListener('mouseup', this.onPointerUp, this._eventListenerOptions);
-          }
-          if (this.supportsTouchEvents) {
-              this.interactionDOMElement.removeEventListener('touchstart', this.onPointerDown, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('touchcancel', this.onPointerCancel, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('touchend', this.onPointerUp, this._eventListenerOptions);
-              this.interactionDOMElement.removeEventListener('touchmove', this.onPointerMove, this._eventListenerOptions);
-          }
-          this.interactionDOMElement = null;
-          this.eventsAdded = false;
-      };
-      /**
-       * Updates the state of interactive objects if at least {@link interactionFrequency}
-       * milliseconds have passed since the last invocation.
-       *
-       * Invoked by a throttled ticker update from {@link PIXI.Ticker.system}.
-       * @param deltaTime - time delta since the last call
-       */
-      InteractionManager.prototype.tickerUpdate = function (deltaTime) {
-          this._deltaTime += deltaTime;
-          if (this._deltaTime < this.interactionFrequency) {
-              return;
-          }
-          this._deltaTime = 0;
-          this.update();
-      };
-      /** Updates the state of interactive objects. */
-      InteractionManager.prototype.update = function () {
-          if (!this.interactionDOMElement) {
-              return;
-          }
-          // if the user move the mouse this check has already been done using the mouse move!
-          if (this._didMove) {
-              this._didMove = false;
-              return;
-          }
-          this.cursor = null;
-          // Resets the flag as set by a stopPropagation call. This flag is usually reset by a user interaction of any kind,
-          // but there was a scenario of a display object moving under a static mouse cursor.
-          // In this case, mouseover and mouseevents would not pass the flag test in dispatchEvent function
-          for (var k in this.activeInteractionData) {
-              // eslint-disable-next-line no-prototype-builtins
-              if (this.activeInteractionData.hasOwnProperty(k)) {
-                  var interactionData = this.activeInteractionData[k];
-                  if (interactionData.originalEvent && interactionData.pointerType !== 'touch') {
-                      var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, interactionData.originalEvent, interactionData);
-                      this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerOverOut, true);
-                  }
-              }
-          }
-          this.setCursorMode(this.cursor);
-      };
-      /**
-       * Sets the current cursor mode, handling any callbacks or CSS style changes.
-       * @param mode - cursor mode, a key from the cursorStyles dictionary
-       */
-      InteractionManager.prototype.setCursorMode = function (mode) {
-          mode = mode || 'default';
-          var applyStyles = true;
-          // offscreen canvas does not support setting styles, but cursor modes can be functions,
-          // in order to handle pixi rendered cursors, so we can't bail
-          if (globalThis.OffscreenCanvas && this.interactionDOMElement instanceof OffscreenCanvas) {
-              applyStyles = false;
-          }
-          // if the mode didn't actually change, bail early
-          if (this.currentCursorMode === mode) {
-              return;
-          }
-          this.currentCursorMode = mode;
-          var style = this.cursorStyles[mode];
-          // only do things if there is a cursor style for it
-          if (style) {
-              switch (typeof style) {
-                  case 'string':
-                      // string styles are handled as cursor CSS
-                      if (applyStyles) {
-                          this.interactionDOMElement.style.cursor = style;
-                      }
-                      break;
-                  case 'function':
-                      // functions are just called, and passed the cursor mode
-                      style(mode);
-                      break;
-                  case 'object':
-                      // if it is an object, assume that it is a dictionary of CSS styles,
-                      // apply it to the interactionDOMElement
-                      if (applyStyles) {
-                          Object.assign(this.interactionDOMElement.style, style);
-                      }
-                      break;
-              }
-          }
-          else if (applyStyles && typeof mode === 'string' && !Object.prototype.hasOwnProperty.call(this.cursorStyles, mode)) {
-              // if it mode is a string (not a Symbol) and cursorStyles doesn't have any entry
-              // for the mode, then assume that the dev wants it to be CSS for the cursor.
-              this.interactionDOMElement.style.cursor = mode;
-          }
-      };
-      /**
-       * Dispatches an event on the display object that was interacted with.
-       * @param displayObject - the display object in question
-       * @param eventString - the name of the event (e.g, mousedown)
-       * @param eventData - the event data object
-       */
-      InteractionManager.prototype.dispatchEvent = function (displayObject, eventString, eventData) {
-          // Even if the event was stopped, at least dispatch any remaining events
-          // for the same display object.
-          if (!eventData.stopPropagationHint || displayObject === eventData.stopsPropagatingAt) {
-              eventData.currentTarget = displayObject;
-              eventData.type = eventString;
-              displayObject.emit(eventString, eventData);
-              if (displayObject[eventString]) {
-                  displayObject[eventString](eventData);
-              }
-          }
-      };
-      /**
-       * Puts a event on a queue to be dispatched later. This is used to guarantee correct
-       * ordering of over/out events.
-       * @param displayObject - the display object in question
-       * @param eventString - the name of the event (e.g, mousedown)
-       * @param eventData - the event data object
-       */
-      InteractionManager.prototype.delayDispatchEvent = function (displayObject, eventString, eventData) {
-          this.delayedEvents.push({ displayObject: displayObject, eventString: eventString, eventData: eventData });
-      };
-      /**
-       * Maps x and y coords from a DOM object and maps them correctly to the PixiJS view. The
-       * resulting value is stored in the point. This takes into account the fact that the DOM
-       * element could be scaled and positioned anywhere on the screen.
-       * @param point - the point that the result will be stored in
-       * @param x - the x coord of the position to map
-       * @param y - the y coord of the position to map
-       */
-      InteractionManager.prototype.mapPositionToPoint = function (point, x, y) {
-          var rect;
-          // IE 11 fix
-          if (!this.interactionDOMElement.parentElement) {
-              rect = {
-                  x: 0,
-                  y: 0,
-                  width: this.interactionDOMElement.width,
-                  height: this.interactionDOMElement.height,
-                  left: 0,
-                  top: 0
-              };
-          }
-          else {
-              rect = this.interactionDOMElement.getBoundingClientRect();
-          }
-          var resolutionMultiplier = 1.0 / this.resolution;
-          point.x = ((x - rect.left) * (this.interactionDOMElement.width / rect.width)) * resolutionMultiplier;
-          point.y = ((y - rect.top) * (this.interactionDOMElement.height / rect.height)) * resolutionMultiplier;
-      };
-      /**
-       * This function is provides a neat way of crawling through the scene graph and running a
-       * specified function on all interactive objects it finds. It will also take care of hit
-       * testing the interactive objects and passes the hit across in the function.
-       * @protected
-       * @param interactionEvent - event containing the point that
-       *  is tested for collision
-       * @param displayObject - the displayObject
-       *  that will be hit test (recursively crawls its children)
-       * @param func - the function that will be called on each interactive object. The
-       *  interactionEvent, displayObject and hit will be passed to the function
-       * @param hitTest - indicates whether we want to calculate hits
-       *  or just iterate through all interactive objects
-       */
-      InteractionManager.prototype.processInteractive = function (interactionEvent, displayObject, func, hitTest) {
-          var hit = this.search.findHit(interactionEvent, displayObject, func, hitTest);
-          var delayedEvents = this.delayedEvents;
-          if (!delayedEvents.length) {
-              return hit;
-          }
-          // Reset the propagation hint, because we start deeper in the tree again.
-          interactionEvent.stopPropagationHint = false;
-          var delayedLen = delayedEvents.length;
-          this.delayedEvents = [];
-          for (var i = 0; i < delayedLen; i++) {
-              var _a = delayedEvents[i], displayObject_1 = _a.displayObject, eventString = _a.eventString, eventData = _a.eventData;
-              // When we reach the object we wanted to stop propagating at,
-              // set the propagation hint.
-              if (eventData.stopsPropagatingAt === displayObject_1) {
-                  eventData.stopPropagationHint = true;
-              }
-              this.dispatchEvent(displayObject_1, eventString, eventData);
-          }
-          return hit;
-      };
-      /**
-       * Is called when the pointer button is pressed down on the renderer element
-       * @param originalEvent - The DOM event of a pointer button being pressed down
-       */
-      InteractionManager.prototype.onPointerDown = function (originalEvent) {
-          // if we support touch events, then only use those for touch events, not pointer events
-          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
-              { return; }
-          var events = this.normalizeToPointerData(originalEvent);
-          /*
-           * No need to prevent default on natural pointer events, as there are no side effects
-           * Normalized events, however, may have the double mousedown/touchstart issue on the native android browser,
-           * so still need to be prevented.
-           */
-          // Guaranteed that there will be at least one event in events, and all events must have the same pointer type
-          if (this.autoPreventDefault && events[0].isNormalized) {
-              var cancelable = originalEvent.cancelable || !('cancelable' in originalEvent);
-              if (cancelable) {
-                  originalEvent.preventDefault();
-              }
-          }
-          var eventLen = events.length;
-          for (var i = 0; i < eventLen; i++) {
-              var event = events[i];
-              var interactionData = this.getInteractionDataForPointerId(event);
-              var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-              interactionEvent.data.originalEvent = originalEvent;
-              this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerDown, true);
-              this.emit('pointerdown', interactionEvent);
-              if (event.pointerType === 'touch') {
-                  this.emit('touchstart', interactionEvent);
-              }
-              // emit a mouse event for "pen" pointers, the way a browser would emit a fallback event
-              else if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-                  var isRightButton = event.button === 2;
-                  this.emit(isRightButton ? 'rightdown' : 'mousedown', this.eventData);
-              }
-          }
-      };
-      /**
-       * Processes the result of the pointer down check and dispatches the event if need be
-       * @param interactionEvent - The interaction event wrapping the DOM event
-       * @param displayObject - The display object that was tested
-       * @param hit - the result of the hit test on the display object
-       */
-      InteractionManager.prototype.processPointerDown = function (interactionEvent, displayObject, hit) {
-          var data = interactionEvent.data;
-          var id = interactionEvent.data.identifier;
-          if (hit) {
-              if (!displayObject.trackedPointers[id]) {
-                  displayObject.trackedPointers[id] = new InteractionTrackingData(id);
-              }
-              this.dispatchEvent(displayObject, 'pointerdown', interactionEvent);
-              if (data.pointerType === 'touch') {
-                  this.dispatchEvent(displayObject, 'touchstart', interactionEvent);
-              }
-              else if (data.pointerType === 'mouse' || data.pointerType === 'pen') {
-                  var isRightButton = data.button === 2;
-                  if (isRightButton) {
-                      displayObject.trackedPointers[id].rightDown = true;
-                  }
-                  else {
-                      displayObject.trackedPointers[id].leftDown = true;
-                  }
-                  this.dispatchEvent(displayObject, isRightButton ? 'rightdown' : 'mousedown', interactionEvent);
-              }
-          }
-      };
-      /**
-       * Is called when the pointer button is released on the renderer element
-       * @param originalEvent - The DOM event of a pointer button being released
-       * @param cancelled - true if the pointer is cancelled
-       * @param func - Function passed to {@link processInteractive}
-       */
-      InteractionManager.prototype.onPointerComplete = function (originalEvent, cancelled, func) {
-          var events = this.normalizeToPointerData(originalEvent);
-          var eventLen = events.length;
-          // if the event wasn't targeting our canvas, then consider it to be pointerupoutside
-          // in all cases (unless it was a pointercancel)
-          var target = originalEvent.target;
-          // if in shadow DOM use composedPath to access target
-          if (originalEvent.composedPath && originalEvent.composedPath().length > 0) {
-              target = originalEvent.composedPath()[0];
-          }
-          var eventAppend = target !== this.interactionDOMElement ? 'outside' : '';
-          for (var i = 0; i < eventLen; i++) {
-              var event = events[i];
-              var interactionData = this.getInteractionDataForPointerId(event);
-              var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-              interactionEvent.data.originalEvent = originalEvent;
-              // perform hit testing for events targeting our canvas or cancel events
-              this.processInteractive(interactionEvent, this.lastObjectRendered, func, cancelled || !eventAppend);
-              this.emit(cancelled ? 'pointercancel' : "pointerup" + eventAppend, interactionEvent);
-              if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-                  var isRightButton = event.button === 2;
-                  this.emit(isRightButton ? "rightup" + eventAppend : "mouseup" + eventAppend, interactionEvent);
-              }
-              else if (event.pointerType === 'touch') {
-                  this.emit(cancelled ? 'touchcancel' : "touchend" + eventAppend, interactionEvent);
-                  this.releaseInteractionDataForPointerId(event.pointerId);
-              }
-          }
-      };
-      /**
-       * Is called when the pointer button is cancelled
-       * @param event - The DOM event of a pointer button being released
-       */
-      InteractionManager.prototype.onPointerCancel = function (event) {
-          // if we support touch events, then only use those for touch events, not pointer events
-          if (this.supportsTouchEvents && event.pointerType === 'touch')
-              { return; }
-          this.onPointerComplete(event, true, this.processPointerCancel);
-      };
-      /**
-       * Processes the result of the pointer cancel check and dispatches the event if need be
-       * @param interactionEvent - The interaction event wrapping the DOM event
-       * @param displayObject - The display object that was tested
-       */
-      InteractionManager.prototype.processPointerCancel = function (interactionEvent, displayObject) {
-          var data = interactionEvent.data;
-          var id = interactionEvent.data.identifier;
-          if (displayObject.trackedPointers[id] !== undefined) {
-              delete displayObject.trackedPointers[id];
-              this.dispatchEvent(displayObject, 'pointercancel', interactionEvent);
-              if (data.pointerType === 'touch') {
-                  this.dispatchEvent(displayObject, 'touchcancel', interactionEvent);
-              }
-          }
-      };
-      /**
-       * Is called when the pointer button is released on the renderer element
-       * @param event - The DOM event of a pointer button being released
-       */
-      InteractionManager.prototype.onPointerUp = function (event) {
-          // if we support touch events, then only use those for touch events, not pointer events
-          if (this.supportsTouchEvents && event.pointerType === 'touch')
-              { return; }
-          this.onPointerComplete(event, false, this.processPointerUp);
-      };
-      /**
-       * Processes the result of the pointer up check and dispatches the event if need be
-       * @param interactionEvent - The interaction event wrapping the DOM event
-       * @param displayObject - The display object that was tested
-       * @param hit - the result of the hit test on the display object
-       */
-      InteractionManager.prototype.processPointerUp = function (interactionEvent, displayObject, hit) {
-          var data = interactionEvent.data;
-          var id = interactionEvent.data.identifier;
-          var trackingData = displayObject.trackedPointers[id];
-          var isTouch = data.pointerType === 'touch';
-          var isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');
-          // need to track mouse down status in the mouse block so that we can emit
-          // event in a later block
-          var isMouseTap = false;
-          // Mouse only
-          if (isMouse) {
-              var isRightButton = data.button === 2;
-              var flags = InteractionTrackingData.FLAGS;
-              var test = isRightButton ? flags.RIGHT_DOWN : flags.LEFT_DOWN;
-              var isDown = trackingData !== undefined && (trackingData.flags & test);
-              if (hit) {
-                  this.dispatchEvent(displayObject, isRightButton ? 'rightup' : 'mouseup', interactionEvent);
-                  if (isDown) {
-                      this.dispatchEvent(displayObject, isRightButton ? 'rightclick' : 'click', interactionEvent);
-                      // because we can confirm that the mousedown happened on this object, flag for later emit of pointertap
-                      isMouseTap = true;
-                  }
-              }
-              else if (isDown) {
-                  this.dispatchEvent(displayObject, isRightButton ? 'rightupoutside' : 'mouseupoutside', interactionEvent);
-              }
-              // update the down state of the tracking data
-              if (trackingData) {
-                  if (isRightButton) {
-                      trackingData.rightDown = false;
-                  }
-                  else {
-                      trackingData.leftDown = false;
-                  }
-              }
-          }
-          // Pointers and Touches, and Mouse
-          if (hit) {
-              this.dispatchEvent(displayObject, 'pointerup', interactionEvent);
-              if (isTouch)
-                  { this.dispatchEvent(displayObject, 'touchend', interactionEvent); }
-              if (trackingData) {
-                  // emit pointertap if not a mouse, or if the mouse block decided it was a tap
-                  if (!isMouse || isMouseTap) {
-                      this.dispatchEvent(displayObject, 'pointertap', interactionEvent);
-                  }
-                  if (isTouch) {
-                      this.dispatchEvent(displayObject, 'tap', interactionEvent);
-                      // touches are no longer over (if they ever were) when we get the touchend
-                      // so we should ensure that we don't keep pretending that they are
-                      trackingData.over = false;
-                  }
-              }
-          }
-          else if (trackingData) {
-              this.dispatchEvent(displayObject, 'pointerupoutside', interactionEvent);
-              if (isTouch)
-                  { this.dispatchEvent(displayObject, 'touchendoutside', interactionEvent); }
-          }
-          // Only remove the tracking data if there is no over/down state still associated with it
-          if (trackingData && trackingData.none) {
-              delete displayObject.trackedPointers[id];
-          }
-      };
-      /**
-       * Is called when the pointer moves across the renderer element
-       * @param originalEvent - The DOM event of a pointer moving
-       */
-      InteractionManager.prototype.onPointerMove = function (originalEvent) {
-          // if we support touch events, then only use those for touch events, not pointer events
-          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
-              { return; }
-          var events = this.normalizeToPointerData(originalEvent);
-          if (events[0].pointerType === 'mouse' || events[0].pointerType === 'pen') {
-              this._didMove = true;
-              this.cursor = null;
-          }
-          var eventLen = events.length;
-          for (var i = 0; i < eventLen; i++) {
-              var event = events[i];
-              var interactionData = this.getInteractionDataForPointerId(event);
-              var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-              interactionEvent.data.originalEvent = originalEvent;
-              this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerMove, true);
-              this.emit('pointermove', interactionEvent);
-              if (event.pointerType === 'touch')
-                  { this.emit('touchmove', interactionEvent); }
-              if (event.pointerType === 'mouse' || event.pointerType === 'pen')
-                  { this.emit('mousemove', interactionEvent); }
-          }
-          if (events[0].pointerType === 'mouse') {
-              this.setCursorMode(this.cursor);
-              // TODO BUG for parents interactive object (border order issue)
-          }
-      };
-      /**
-       * Processes the result of the pointer move check and dispatches the event if need be
-       * @param interactionEvent - The interaction event wrapping the DOM event
-       * @param displayObject - The display object that was tested
-       * @param hit - the result of the hit test on the display object
-       */
-      InteractionManager.prototype.processPointerMove = function (interactionEvent, displayObject, hit) {
-          var data = interactionEvent.data;
-          var isTouch = data.pointerType === 'touch';
-          var isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');
-          if (isMouse) {
-              this.processPointerOverOut(interactionEvent, displayObject, hit);
-          }
-          if (!this.moveWhenInside || hit) {
-              this.dispatchEvent(displayObject, 'pointermove', interactionEvent);
-              if (isTouch)
-                  { this.dispatchEvent(displayObject, 'touchmove', interactionEvent); }
-              if (isMouse)
-                  { this.dispatchEvent(displayObject, 'mousemove', interactionEvent); }
-          }
-      };
-      /**
-       * Is called when the pointer is moved out of the renderer element
-       * @private
-       * @param {PointerEvent} originalEvent - The DOM event of a pointer being moved out
-       */
-      InteractionManager.prototype.onPointerOut = function (originalEvent) {
-          // if we support touch events, then only use those for touch events, not pointer events
-          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
-              { return; }
-          var events = this.normalizeToPointerData(originalEvent);
-          // Only mouse and pointer can call onPointerOut, so events will always be length 1
-          var event = events[0];
-          if (event.pointerType === 'mouse') {
-              this.mouseOverRenderer = false;
-              this.setCursorMode(null);
-          }
-          var interactionData = this.getInteractionDataForPointerId(event);
-          var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-          interactionEvent.data.originalEvent = event;
-          this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerOverOut, false);
-          this.emit('pointerout', interactionEvent);
-          if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-              this.emit('mouseout', interactionEvent);
-          }
-          else {
-              // we can get touchleave events after touchend, so we want to make sure we don't
-              // introduce memory leaks
-              this.releaseInteractionDataForPointerId(interactionData.identifier);
-          }
-      };
-      /**
-       * Processes the result of the pointer over/out check and dispatches the event if need be.
-       * @param interactionEvent - The interaction event wrapping the DOM event
-       * @param displayObject - The display object that was tested
-       * @param hit - the result of the hit test on the display object
-       */
-      InteractionManager.prototype.processPointerOverOut = function (interactionEvent, displayObject, hit) {
-          var data = interactionEvent.data;
-          var id = interactionEvent.data.identifier;
-          var isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');
-          var trackingData = displayObject.trackedPointers[id];
-          // if we just moused over the display object, then we need to track that state
-          if (hit && !trackingData) {
-              trackingData = displayObject.trackedPointers[id] = new InteractionTrackingData(id);
-          }
-          if (trackingData === undefined)
-              { return; }
-          if (hit && this.mouseOverRenderer) {
-              if (!trackingData.over) {
-                  trackingData.over = true;
-                  this.delayDispatchEvent(displayObject, 'pointerover', interactionEvent);
-                  if (isMouse) {
-                      this.delayDispatchEvent(displayObject, 'mouseover', interactionEvent);
-                  }
-              }
-              // only change the cursor if it has not already been changed (by something deeper in the
-              // display tree)
-              if (isMouse && this.cursor === null) {
-                  this.cursor = displayObject.cursor;
-              }
-          }
-          else if (trackingData.over) {
-              trackingData.over = false;
-              this.dispatchEvent(displayObject, 'pointerout', this.eventData);
-              if (isMouse) {
-                  this.dispatchEvent(displayObject, 'mouseout', interactionEvent);
-              }
-              // if there is no mouse down information for the pointer, then it is safe to delete
-              if (trackingData.none) {
-                  delete displayObject.trackedPointers[id];
-              }
-          }
-      };
-      /**
-       * Is called when the pointer is moved into the renderer element.
-       * @param originalEvent - The DOM event of a pointer button being moved into the renderer view.
-       */
-      InteractionManager.prototype.onPointerOver = function (originalEvent) {
-          if (this.supportsTouchEvents && originalEvent.pointerType === 'touch')
-              { return; }
-          var events = this.normalizeToPointerData(originalEvent);
-          // Only mouse and pointer can call onPointerOver, so events will always be length 1
-          var event = events[0];
-          var interactionData = this.getInteractionDataForPointerId(event);
-          var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
-          interactionEvent.data.originalEvent = event;
-          if (event.pointerType === 'mouse') {
-              this.mouseOverRenderer = true;
-          }
-          this.emit('pointerover', interactionEvent);
-          if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
-              this.emit('mouseover', interactionEvent);
-          }
-      };
-      /**
-       * Get InteractionData for a given pointerId. Store that data as well.
-       * @param event - Normalized pointer event, output from normalizeToPointerData.
-       * @returns - Interaction data for the given pointer identifier.
-       */
-      InteractionManager.prototype.getInteractionDataForPointerId = function (event) {
-          var pointerId = event.pointerId;
-          var interactionData;
-          if (pointerId === MOUSE_POINTER_ID || event.pointerType === 'mouse') {
-              interactionData = this.mouse;
-          }
-          else if (this.activeInteractionData[pointerId]) {
-              interactionData = this.activeInteractionData[pointerId];
-          }
-          else {
-              interactionData = this.interactionDataPool.pop() || new InteractionData();
-              interactionData.identifier = pointerId;
-              this.activeInteractionData[pointerId] = interactionData;
-          }
-          // copy properties from the event, so that we can make sure that touch/pointer specific
-          // data is available
-          interactionData.copyEvent(event);
-          return interactionData;
-      };
-      /**
-       * Return unused InteractionData to the pool, for a given pointerId
-       * @param pointerId - Identifier from a pointer event
-       */
-      InteractionManager.prototype.releaseInteractionDataForPointerId = function (pointerId) {
-          var interactionData = this.activeInteractionData[pointerId];
-          if (interactionData) {
-              delete this.activeInteractionData[pointerId];
-              interactionData.reset();
-              this.interactionDataPool.push(interactionData);
-          }
-      };
-      /**
-       * Configure an InteractionEvent to wrap a DOM PointerEvent and InteractionData
-       * @param interactionEvent - The event to be configured
-       * @param pointerEvent - The DOM event that will be paired with the InteractionEvent
-       * @param interactionData - The InteractionData that will be paired
-       *        with the InteractionEvent
-       * @returns - the interaction event that was passed in
-       */
-      InteractionManager.prototype.configureInteractionEventForDOMEvent = function (interactionEvent, pointerEvent, interactionData) {
-          interactionEvent.data = interactionData;
-          this.mapPositionToPoint(interactionData.global, pointerEvent.clientX, pointerEvent.clientY);
-          // Not really sure why this is happening, but it's how a previous version handled things
-          if (pointerEvent.pointerType === 'touch') {
-              pointerEvent.globalX = interactionData.global.x;
-              pointerEvent.globalY = interactionData.global.y;
-          }
-          interactionData.originalEvent = pointerEvent;
-          interactionEvent.reset();
-          return interactionEvent;
-      };
-      /**
-       * Ensures that the original event object contains all data that a regular pointer event would have
-       * @param {TouchEvent|MouseEvent|PointerEvent} event - The original event data from a touch or mouse event
-       * @returns - An array containing a single normalized pointer event, in the case of a pointer
-       *  or mouse event, or a multiple normalized pointer events if there are multiple changed touches
-       */
-      InteractionManager.prototype.normalizeToPointerData = function (event) {
-          var normalizedEvents = [];
-          if (this.supportsTouchEvents && event instanceof TouchEvent) {
-              for (var i = 0, li = event.changedTouches.length; i < li; i++) {
-                  var touch = event.changedTouches[i];
-                  if (typeof touch.button === 'undefined')
-                      { touch.button = event.touches.length ? 1 : 0; }
-                  if (typeof touch.buttons === 'undefined')
-                      { touch.buttons = event.touches.length ? 1 : 0; }
-                  if (typeof touch.isPrimary === 'undefined') {
-                      touch.isPrimary = event.touches.length === 1 && event.type === 'touchstart';
-                  }
-                  if (typeof touch.width === 'undefined')
-                      { touch.width = touch.radiusX || 1; }
-                  if (typeof touch.height === 'undefined')
-                      { touch.height = touch.radiusY || 1; }
-                  if (typeof touch.tiltX === 'undefined')
-                      { touch.tiltX = 0; }
-                  if (typeof touch.tiltY === 'undefined')
-                      { touch.tiltY = 0; }
-                  if (typeof touch.pointerType === 'undefined')
-                      { touch.pointerType = 'touch'; }
-                  if (typeof touch.pointerId === 'undefined')
-                      { touch.pointerId = touch.identifier || 0; }
-                  if (typeof touch.pressure === 'undefined')
-                      { touch.pressure = touch.force || 0.5; }
-                  if (typeof touch.twist === 'undefined')
-                      { touch.twist = 0; }
-                  if (typeof touch.tangentialPressure === 'undefined')
-                      { touch.tangentialPressure = 0; }
-                  // TODO: Remove these, as layerX/Y is not a standard, is deprecated, has uneven
-                  // support, and the fill ins are not quite the same
-                  // offsetX/Y might be okay, but is not the same as clientX/Y when the canvas's top
-                  // left is not 0,0 on the page
-                  if (typeof touch.layerX === 'undefined')
-                      { touch.layerX = touch.offsetX = touch.clientX; }
-                  if (typeof touch.layerY === 'undefined')
-                      { touch.layerY = touch.offsetY = touch.clientY; }
-                  // mark the touch as normalized, just so that we know we did it
-                  touch.isNormalized = true;
-                  normalizedEvents.push(touch);
-              }
-          }
-          // apparently PointerEvent subclasses MouseEvent, so yay
-          else if (!globalThis.MouseEvent
-              || (event instanceof MouseEvent && (!this.supportsPointerEvents || !(event instanceof globalThis.PointerEvent)))) {
-              var tempEvent = event;
-              if (typeof tempEvent.isPrimary === 'undefined')
-                  { tempEvent.isPrimary = true; }
-              if (typeof tempEvent.width === 'undefined')
-                  { tempEvent.width = 1; }
-              if (typeof tempEvent.height === 'undefined')
-                  { tempEvent.height = 1; }
-              if (typeof tempEvent.tiltX === 'undefined')
-                  { tempEvent.tiltX = 0; }
-              if (typeof tempEvent.tiltY === 'undefined')
-                  { tempEvent.tiltY = 0; }
-              if (typeof tempEvent.pointerType === 'undefined')
-                  { tempEvent.pointerType = 'mouse'; }
-              if (typeof tempEvent.pointerId === 'undefined')
-                  { tempEvent.pointerId = MOUSE_POINTER_ID; }
-              if (typeof tempEvent.pressure === 'undefined')
-                  { tempEvent.pressure = 0.5; }
-              if (typeof tempEvent.twist === 'undefined')
-                  { tempEvent.twist = 0; }
-              if (typeof tempEvent.tangentialPressure === 'undefined')
-                  { tempEvent.tangentialPressure = 0; }
-              // mark the mouse event as normalized, just so that we know we did it
-              tempEvent.isNormalized = true;
-              normalizedEvents.push(tempEvent);
-          }
-          else {
-              normalizedEvents.push(event);
-          }
-          return normalizedEvents;
-      };
-      /** Destroys the interaction manager. */
-      InteractionManager.prototype.destroy = function () {
-          this.removeEvents();
-          this.removeTickerListener();
-          this.removeAllListeners();
-          this.renderer = null;
-          this.mouse = null;
-          this.eventData = null;
-          this.interactionDOMElement = null;
-          this.onPointerDown = null;
-          this.processPointerDown = null;
-          this.onPointerUp = null;
-          this.processPointerUp = null;
-          this.onPointerCancel = null;
-          this.processPointerCancel = null;
-          this.onPointerMove = null;
-          this.processPointerMove = null;
-          this.onPointerOut = null;
-          this.processPointerOverOut = null;
-          this.onPointerOver = null;
-          this.search = null;
-      };
-      /** @ignore */
-      InteractionManager.extension = {
-          name: 'interaction',
-          type: [
-              exports.ExtensionType.RendererPlugin,
-              exports.ExtensionType.CanvasRendererPlugin ],
-      };
-      return InteractionManager;
-  }(eventemitter3));
-
-  /*!
-   * @pixi/extract - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/extract is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  var TEMP_RECT = new Rectangle();
-  var BYTES_PER_PIXEL = 4;
-  /**
-   * This class provides renderer-specific plugins for exporting content from a renderer.
-   * For instance, these plugins can be used for saving an Image, Canvas element or for exporting the raw image data (pixels).
-   *
-   * Do not instantiate these plugins directly. It is available from the `renderer.plugins` property.
-   * See {@link PIXI.CanvasRenderer#plugins} or {@link PIXI.Renderer#plugins}.
-   * @example
-   * // Create a new app (will auto-add extract plugin to renderer)
-   * const app = new PIXI.Application();
-   *
-   * // Draw a red circle
-   * const graphics = new PIXI.Graphics()
-   *     .beginFill(0xFF0000)
-   *     .drawCircle(0, 0, 50);
-   *
-   * // Render the graphics as an HTMLImageElement
-   * const image = app.renderer.plugins.extract.image(graphics);
-   * document.body.appendChild(image);
-   * @memberof PIXI
-   */
-  var Extract = /** @class */ (function () {
-      /**
-       * @param renderer - A reference to the current renderer
-       */
-      function Extract(renderer) {
-          this.renderer = renderer;
-      }
-      /**
-       * Will return a HTML Image of the target
-       * @param target - A displayObject or renderTexture
-       *  to convert. If left empty will use the main renderer
-       * @param format - Image format, e.g. "image/jpeg" or "image/webp".
-       * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.
-       * @returns - HTML Image of the target
-       */
-      Extract.prototype.image = function (target, format, quality) {
-          var image = new Image();
-          image.src = this.base64(target, format, quality);
-          return image;
-      };
-      /**
-       * Will return a base64 encoded string of this target. It works by calling
-       *  `Extract.getCanvas` and then running toDataURL on that.
-       * @param target - A displayObject or renderTexture
-       *  to convert. If left empty will use the main renderer
-       * @param format - Image format, e.g. "image/jpeg" or "image/webp".
-       * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.
-       * @returns - A base64 encoded string of the texture.
-       */
-      Extract.prototype.base64 = function (target, format, quality) {
-          return this.canvas(target).toDataURL(format, quality);
-      };
-      /**
-       * Creates a Canvas element, renders this target to it and then returns it.
-       * @param target - A displayObject or renderTexture
-       *  to convert. If left empty will use the main renderer
-       * @param frame - The frame the extraction is restricted to.
-       * @returns - A Canvas element with the texture rendered on.
-       */
-      Extract.prototype.canvas = function (target, frame) {
-          var _a = this._rawPixels(target, frame), pixels = _a.pixels, width = _a.width, height = _a.height, flipY = _a.flipY;
-          var canvasBuffer = new CanvasRenderTarget(width, height, 1);
-          // Add the pixels to the canvas
-          var canvasData = canvasBuffer.context.getImageData(0, 0, width, height);
-          Extract.arrayPostDivide(pixels, canvasData.data);
-          canvasBuffer.context.putImageData(canvasData, 0, 0);
-          // Flipping pixels
-          if (flipY) {
-              var target_1 = new CanvasRenderTarget(canvasBuffer.width, canvasBuffer.height, 1);
-              target_1.context.scale(1, -1);
-              // We can't render to itself because we should be empty before render.
-              target_1.context.drawImage(canvasBuffer.canvas, 0, -height);
-              canvasBuffer.destroy();
-              canvasBuffer = target_1;
-          }
-          // Send the canvas back
-          return canvasBuffer.canvas;
-      };
-      /**
-       * Will return a one-dimensional array containing the pixel data of the entire texture in RGBA
-       * order, with integer values between 0 and 255 (included).
-       * @param target - A displayObject or renderTexture
-       *  to convert. If left empty will use the main renderer
-       * @param frame - The frame the extraction is restricted to.
-       * @returns - One-dimensional array containing the pixel data of the entire texture
-       */
-      Extract.prototype.pixels = function (target, frame) {
-          var pixels = this._rawPixels(target, frame).pixels;
-          Extract.arrayPostDivide(pixels, pixels);
-          return pixels;
-      };
-      Extract.prototype._rawPixels = function (target, frame) {
-          var renderer = this.renderer;
-          var resolution;
-          var flipY = false;
-          var renderTexture;
-          var generated = false;
-          if (target) {
-              if (target instanceof RenderTexture) {
-                  renderTexture = target;
-              }
-              else {
-                  var multisample = renderer.context.webGLVersion >= 2 ? renderer.multisample : exports.MSAA_QUALITY.NONE;
-                  renderTexture = this.renderer.generateTexture(target, { multisample: multisample });
-                  if (multisample !== exports.MSAA_QUALITY.NONE) {
-                      // Resolve the multisampled texture to a non-multisampled texture
-                      var resolvedTexture = RenderTexture.create({
-                          width: renderTexture.width,
-                          height: renderTexture.height,
-                      });
-                      renderer.framebuffer.bind(renderTexture.framebuffer);
-                      renderer.framebuffer.blit(resolvedTexture.framebuffer);
-                      renderer.framebuffer.bind(null);
-                      renderTexture.destroy(true);
-                      renderTexture = resolvedTexture;
-                  }
-                  generated = true;
-              }
-          }
-          if (renderTexture) {
-              resolution = renderTexture.baseTexture.resolution;
-              frame = frame !== null && frame !== void 0 ? frame : renderTexture.frame;
-              flipY = false;
-              renderer.renderTexture.bind(renderTexture);
-          }
-          else {
-              resolution = renderer.resolution;
-              if (!frame) {
-                  frame = TEMP_RECT;
-                  frame.width = renderer.width;
-                  frame.height = renderer.height;
-              }
-              flipY = true;
-              renderer.renderTexture.bind(null);
-          }
-          var width = Math.round(frame.width * resolution);
-          var height = Math.round(frame.height * resolution);
-          var pixels = new Uint8Array(BYTES_PER_PIXEL * width * height);
-          // Read pixels to the array
-          var gl = renderer.gl;
-          gl.readPixels(Math.round(frame.x * resolution), Math.round(frame.y * resolution), width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-          if (generated) {
-              renderTexture.destroy(true);
-          }
-          return { pixels: pixels, width: width, height: height, flipY: flipY };
-      };
-      /** Destroys the extract. */
-      Extract.prototype.destroy = function () {
-          this.renderer = null;
-      };
-      /**
-       * Takes premultiplied pixel data and produces regular pixel data
-       * @private
-       * @param pixels - array of pixel data
-       * @param out - output array
-       */
-      Extract.arrayPostDivide = function (pixels, out) {
-          for (var i = 0; i < pixels.length; i += 4) {
-              var alpha = out[i + 3] = pixels[i + 3];
-              if (alpha !== 0) {
-                  out[i] = Math.round(Math.min(pixels[i] * 255.0 / alpha, 255.0));
-                  out[i + 1] = Math.round(Math.min(pixels[i + 1] * 255.0 / alpha, 255.0));
-                  out[i + 2] = Math.round(Math.min(pixels[i + 2] * 255.0 / alpha, 255.0));
-              }
-              else {
-                  out[i] = pixels[i];
-                  out[i + 1] = pixels[i + 1];
-                  out[i + 2] = pixels[i + 2];
-              }
-          }
-      };
-      /** @ignore */
-      Extract.extension = {
-          name: 'extract',
-          type: exports.ExtensionType.RendererPlugin,
-      };
-      return Extract;
-  }());
-
-  /*!
-   * @pixi/loaders - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/loaders is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /* jshint -W097 */
-  /**
-   * @memberof PIXI
-   */
-  var SignalBinding = /** @class */ (function () {
-      /**
-       * SignalBinding constructor.
-       * @constructs SignalBinding
-       * @param {Function} fn - Event handler to be called.
-       * @param {boolean} [once=false] - Should this listener be removed after dispatch
-       * @param {object} [thisArg] - The context of the callback function.
-       * @api private
-       */
-      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-      function SignalBinding(fn, once, thisArg) {
-          if (once === void 0) { once = false; }
-          this._fn = fn;
-          this._once = once;
-          this._thisArg = thisArg;
-          this._next = this._prev = this._owner = null;
-      }
-      SignalBinding.prototype.detach = function () {
-          if (this._owner === null)
-              { return false; }
-          this._owner.detach(this);
-          return true;
-      };
-      return SignalBinding;
-  }());
-  /**
-   * @param self
-   * @param node
-   * @private
-   */
-  function _addSignalBinding(self, node) {
-      if (!self._head) {
-          self._head = node;
-          self._tail = node;
-      }
-      else {
-          self._tail._next = node;
-          node._prev = self._tail;
-          self._tail = node;
-      }
-      node._owner = self;
-      return node;
-  }
-  /**
-   * @memberof PIXI
-   */
-  var Signal = /** @class */ (function () {
-      /**
-       * MiniSignal constructor.
-       * @example
-       * let mySignal = new Signal();
-       * let binding = mySignal.add(onSignal);
-       * mySignal.dispatch('foo', 'bar');
-       * mySignal.detach(binding);
-       */
-      function Signal() {
-          this._head = this._tail = undefined;
-      }
-      /**
-       * Return an array of attached SignalBinding.
-       * @param {boolean} [exists=false] - We only need to know if there are handlers.
-       * @returns {PIXI.SignalBinding[] | boolean} Array of attached SignalBinding or Boolean if called with exists = true
-       * @api public
-       */
-      Signal.prototype.handlers = function (exists) {
-          if (exists === void 0) { exists = false; }
-          var node = this._head;
-          if (exists)
-              { return !!node; }
-          var ee = [];
-          while (node) {
-              ee.push(node);
-              node = node._next;
-          }
-          return ee;
-      };
-      /**
-       * Return true if node is a SignalBinding attached to this MiniSignal
-       * @param {PIXI.SignalBinding} node - Node to check.
-       * @returns {boolean} True if node is attache to mini-signal
-       */
-      Signal.prototype.has = function (node) {
-          if (!(node instanceof SignalBinding)) {
-              throw new Error('MiniSignal#has(): First arg must be a SignalBinding object.');
-          }
-          return node._owner === this;
-      };
-      /**
-       * Dispaches a signal to all registered listeners.
-       * @param {...any} args
-       * @returns {boolean} Indication if we've emitted an event.
-       */
-      Signal.prototype.dispatch = function () {
-          var arguments$1 = arguments;
-
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments$1[_i];
-          }
-          var node = this._head;
-          if (!node)
-              { return false; }
-          while (node) {
-              if (node._once)
-                  { this.detach(node); }
-              node._fn.apply(node._thisArg, args);
-              node = node._next;
-          }
-          return true;
-      };
-      /**
-       * Register a new listener.
-       * @param {Function} fn - Callback function.
-       * @param {object} [thisArg] - The context of the callback function.
-       * @returns {PIXI.SignalBinding} The SignalBinding node that was added.
-       */
-      Signal.prototype.add = function (fn, thisArg) {
-          if (thisArg === void 0) { thisArg = null; }
-          if (typeof fn !== 'function') {
-              throw new Error('MiniSignal#add(): First arg must be a Function.');
-          }
-          return _addSignalBinding(this, new SignalBinding(fn, false, thisArg));
-      };
-      /**
-       * Register a new listener that will be executed only once.
-       * @param {Function} fn - Callback function.
-       * @param {object} [thisArg] - The context of the callback function.
-       * @returns {PIXI.SignalBinding} The SignalBinding node that was added.
-       */
-      Signal.prototype.once = function (fn, thisArg) {
-          if (thisArg === void 0) { thisArg = null; }
-          if (typeof fn !== 'function') {
-              throw new Error('MiniSignal#once(): First arg must be a Function.');
-          }
-          return _addSignalBinding(this, new SignalBinding(fn, true, thisArg));
-      };
-      /**
-       * Remove binding object.
-       * @param {PIXI.SignalBinding} node - The binding node that will be removed.
-       * @returns {Signal} The instance on which this method was called.
-        @api public */
-      Signal.prototype.detach = function (node) {
-          if (!(node instanceof SignalBinding)) {
-              throw new Error('MiniSignal#detach(): First arg must be a SignalBinding object.');
-          }
-          if (node._owner !== this)
-              { return this; } // todo: or error?
-          if (node._prev)
-              { node._prev._next = node._next; }
-          if (node._next)
-              { node._next._prev = node._prev; }
-          if (node === this._head) { // first node
-              this._head = node._next;
-              if (node._next === null) {
-                  this._tail = null;
-              }
-          }
-          else if (node === this._tail) { // last node
-              this._tail = node._prev;
-              this._tail._next = null;
-          }
-          node._owner = null;
-          return this;
-      };
-      /**
-       * Detach all listeners.
-       * @returns {Signal} The instance on which this method was called.
-       */
-      Signal.prototype.detachAll = function () {
-          var node = this._head;
-          if (!node)
-              { return this; }
-          this._head = this._tail = null;
-          while (node) {
-              node._owner = null;
-              node = node._next;
-          }
-          return this;
-      };
-      return Signal;
-  }());
-
-  /**
-   * function from npm package `parseUri`, converted to TS to avoid leftpad incident
-   * @param {string} str
-   * @param [opts] - options
-   * @param {boolean} [opts.strictMode] - type of parser
-   */
-  function parseUri(str, opts) {
-      opts = opts || {};
-      var o = {
-          // eslint-disable-next-line max-len
-          key: ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'],
-          q: {
-              name: 'queryKey',
-              parser: /(?:^|&)([^&=]*)=?([^&]*)/g
-          },
-          parser: {
-              // eslint-disable-next-line max-len
-              strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
-              // eslint-disable-next-line max-len
-              loose: /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
-          }
-      };
-      var m = o.parser[opts.strictMode ? 'strict' : 'loose'].exec(str);
-      var uri = {};
-      var i = 14;
-      while (i--)
-          { uri[o.key[i]] = m[i] || ''; }
-      uri[o.q.name] = {};
-      uri[o.key[12]].replace(o.q.parser, function (_t0, t1, t2) {
-          if (t1)
-              { uri[o.q.name][t1] = t2; }
-      });
-      return uri;
-  }
-
-  // tests if CORS is supported in XHR, if not we need to use XDR
-  var useXdr;
-  var tempAnchor = null;
-  // some status constants
-  var STATUS_NONE = 0;
-  var STATUS_OK = 200;
-  var STATUS_EMPTY = 204;
-  var STATUS_IE_BUG_EMPTY = 1223;
-  var STATUS_TYPE_OK = 2;
-  // noop
-  function _noop$1() { }
-  /**
-   * Quick helper to set a value on one of the extension maps. Ensures there is no
-   * dot at the start of the extension.
-   * @ignore
-   * @param map - The map to set on.
-   * @param extname - The extension (or key) to set.
-   * @param val - The value to set.
-   */
-  function setExtMap(map, extname, val) {
-      if (extname && extname.indexOf('.') === 0) {
-          extname = extname.substring(1);
-      }
-      if (!extname) {
-          return;
-      }
-      map[extname] = val;
-  }
-  /**
-   * Quick helper to get string xhr type.
-   * @ignore
-   * @param xhr - The request to check.
-   * @returns The type.
-   */
-  function reqType(xhr) {
-      return xhr.toString().replace('object ', '');
-  }
-  /**
-   * Manages the state and loading of a resource and all child resources.
-   *
-   * Can be extended in `GlobalMixins.LoaderResource`.
-   * @memberof PIXI
-   */
-  exports.LoaderResource = /** @class */ (function () {
-      /**
-       * @param {string} name - The name of the resource to load.
-       * @param {string|string[]} url - The url for this resource, for audio/video loads you can pass
-       *      an array of sources.
-       * @param {object} [options] - The options for the load.
-       * @param {string|boolean} [options.crossOrigin] - Is this request cross-origin? Default is to
-       *      determine automatically.
-       * @param {number} [options.timeout=0] - A timeout in milliseconds for the load. If the load takes
-       *      longer than this time it is cancelled and the load is considered a failure. If this value is
-       *      set to `0` then there is no explicit timeout.
-       * @param {PIXI.LoaderResource.LOAD_TYPE} [options.loadType=LOAD_TYPE.XHR] - How should this resource
-       *      be loaded?
-       * @param {PIXI.LoaderResource.XHR_RESPONSE_TYPE} [options.xhrType=XHR_RESPONSE_TYPE.DEFAULT] - How
-       *      should the data being loaded be interpreted when using XHR?
-       * @param {PIXI.LoaderResource.IMetadata} [options.metadata] - Extra configuration for middleware
-       *      and the Resource object.
-       */
-      function LoaderResource(name, url, options) {
-          /**
-           * The `dequeue` method that will be used a storage place for the async queue dequeue method
-           * used privately by the loader.
-           * @private
-           * @member {Function}
-           */
-          this._dequeue = _noop$1;
-          /**
-           * Used a storage place for the on load binding used privately by the loader.
-           * @private
-           * @member {Function}
-           */
-          this._onLoadBinding = null;
-          /**
-           * The timer for element loads to check if they timeout.
-           * @private
-           */
-          this._elementTimer = 0;
-          /**
-           * The `complete` function bound to this resource's context.
-           * @private
-           * @type {Function}
-           */
-          this._boundComplete = null;
-          /**
-           * The `_onError` function bound to this resource's context.
-           * @private
-           * @type {Function}
-           */
-          this._boundOnError = null;
-          /**
-           * The `_onProgress` function bound to this resource's context.
-           * @private
-           * @type {Function}
-           */
-          this._boundOnProgress = null;
-          /**
-           * The `_onTimeout` function bound to this resource's context.
-           * @private
-           * @type {Function}
-           */
-          this._boundOnTimeout = null;
-          this._boundXhrOnError = null;
-          this._boundXhrOnTimeout = null;
-          this._boundXhrOnAbort = null;
-          this._boundXhrOnLoad = null;
-          if (typeof name !== 'string' || typeof url !== 'string') {
-              throw new Error('Both name and url are required for constructing a resource.');
-          }
-          options = options || {};
-          this._flags = 0;
-          // set data url flag, needs to be set early for some _determineX checks to work.
-          this._setFlag(LoaderResource.STATUS_FLAGS.DATA_URL, url.indexOf('data:') === 0);
-          this.name = name;
-          this.url = url;
-          this.extension = this._getExtension();
-          this.data = null;
-          this.crossOrigin = options.crossOrigin === true ? 'anonymous' : options.crossOrigin;
-          this.timeout = options.timeout || 0;
-          this.loadType = options.loadType || this._determineLoadType();
-          // The type used to load the resource via XHR. If unset, determined automatically.
-          this.xhrType = options.xhrType;
-          // Extra info for middleware, and controlling specifics about how the resource loads.
-          // Note that if you pass in a `loadElement`, the Resource class takes ownership of it.
-          // Meaning it will modify it as it sees fit.
-          this.metadata = options.metadata || {};
-          // The error that occurred while loading (if any).
-          this.error = null;
-          // The XHR object that was used to load this resource. This is only set
-          // when `loadType` is `LoaderResource.LOAD_TYPE.XHR`.
-          this.xhr = null;
-          // The child resources this resource owns.
-          this.children = [];
-          // The resource type.
-          this.type = LoaderResource.TYPE.UNKNOWN;
-          // The progress chunk owned by this resource.
-          this.progressChunk = 0;
-          // The `dequeue` method that will be used a storage place for the async queue dequeue method
-          // used privately by the loader.
-          this._dequeue = _noop$1;
-          // Used a storage place for the on load binding used privately by the loader.
-          this._onLoadBinding = null;
-          // The timer for element loads to check if they timeout.
-          this._elementTimer = 0;
-          this._boundComplete = this.complete.bind(this);
-          this._boundOnError = this._onError.bind(this);
-          this._boundOnProgress = this._onProgress.bind(this);
-          this._boundOnTimeout = this._onTimeout.bind(this);
-          // xhr callbacks
-          this._boundXhrOnError = this._xhrOnError.bind(this);
-          this._boundXhrOnTimeout = this._xhrOnTimeout.bind(this);
-          this._boundXhrOnAbort = this._xhrOnAbort.bind(this);
-          this._boundXhrOnLoad = this._xhrOnLoad.bind(this);
-          // Dispatched when the resource beings to load.
-          this.onStart = new Signal();
-          // Dispatched each time progress of this resource load updates.
-          // Not all resources types and loader systems can support this event
-          // so sometimes it may not be available. If the resource
-          // is being loaded on a modern browser, using XHR, and the remote server
-          // properly sets Content-Length headers, then this will be available.
-          this.onProgress = new Signal();
-          // Dispatched once this resource has loaded, if there was an error it will
-          // be in the `error` property.
-          this.onComplete = new Signal();
-          // Dispatched after this resource has had all the *after* middleware run on it.
-          this.onAfterMiddleware = new Signal();
-      }
-      /**
-       * Sets the load type to be used for a specific extension.
-       * @static
-       * @param {string} extname - The extension to set the type for, e.g. "png" or "fnt"
-       * @param {PIXI.LoaderResource.LOAD_TYPE} loadType - The load type to set it to.
-       */
-      LoaderResource.setExtensionLoadType = function (extname, loadType) {
-          setExtMap(LoaderResource._loadTypeMap, extname, loadType);
-      };
-      /**
-       * Sets the load type to be used for a specific extension.
-       * @static
-       * @param {string} extname - The extension to set the type for, e.g. "png" or "fnt"
-       * @param {PIXI.LoaderResource.XHR_RESPONSE_TYPE} xhrType - The xhr type to set it to.
-       */
-      LoaderResource.setExtensionXhrType = function (extname, xhrType) {
-          setExtMap(LoaderResource._xhrTypeMap, extname, xhrType);
-      };
-      Object.defineProperty(LoaderResource.prototype, "isDataUrl", {
-          /**
-           * When the resource starts to load.
-           * @memberof PIXI.LoaderResource
-           * @callback OnStartSignal
-           * @param {PIXI.Resource} resource - The resource that the event happened on.
-           */
-          /**
-           * When the resource reports loading progress.
-           * @memberof PIXI.LoaderResource
-           * @callback OnProgressSignal
-           * @param {PIXI.Resource} resource - The resource that the event happened on.
-           * @param {number} percentage - The progress of the load in the range [0, 1].
-           */
-          /**
-           * When the resource finishes loading.
-           * @memberof PIXI.LoaderResource
-           * @callback OnCompleteSignal
-           * @param {PIXI.Resource} resource - The resource that the event happened on.
-           */
-          /**
-           * @memberof PIXI.LoaderResource
-           * @typedef {object} IMetadata
-           * @property {HTMLImageElement|HTMLAudioElement|HTMLVideoElement} [loadElement=null] - The
-           *      element to use for loading, instead of creating one.
-           * @property {boolean} [skipSource=false] - Skips adding source(s) to the load element. This
-           *      is useful if you want to pass in a `loadElement` that you already added load sources to.
-           * @property {string|string[]} [mimeType] - The mime type to use for the source element
-           *      of a video/audio elment. If the urls are an array, you can pass this as an array as well
-           *      where each index is the mime type to use for the corresponding url index.
-           */
-          /**
-           * Stores whether or not this url is a data url.
-           * @readonly
-           * @member {boolean}
-           */
-          get: function () {
-              return this._hasFlag(LoaderResource.STATUS_FLAGS.DATA_URL);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(LoaderResource.prototype, "isComplete", {
-          /**
-           * Describes if this resource has finished loading. Is true when the resource has completely
-           * loaded.
-           * @readonly
-           * @member {boolean}
-           */
-          get: function () {
-              return this._hasFlag(LoaderResource.STATUS_FLAGS.COMPLETE);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(LoaderResource.prototype, "isLoading", {
-          /**
-           * Describes if this resource is currently loading. Is true when the resource starts loading,
-           * and is false again when complete.
-           * @readonly
-           * @member {boolean}
-           */
-          get: function () {
-              return this._hasFlag(LoaderResource.STATUS_FLAGS.LOADING);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Marks the resource as complete. */
-      LoaderResource.prototype.complete = function () {
-          this._clearEvents();
-          this._finish();
-      };
-      /**
-       * Aborts the loading of this resource, with an optional message.
-       * @param {string} message - The message to use for the error
-       */
-      LoaderResource.prototype.abort = function (message) {
-          // abort can be called multiple times, ignore subsequent calls.
-          if (this.error) {
-              return;
-          }
-          // store error
-          this.error = new Error(message);
-          // clear events before calling aborts
-          this._clearEvents();
-          // abort the actual loading
-          if (this.xhr) {
-              this.xhr.abort();
-          }
-          else if (this.xdr) {
-              this.xdr.abort();
-          }
-          else if (this.data) {
-              // single source
-              if (this.data.src) {
-                  this.data.src = LoaderResource.EMPTY_GIF;
-              }
-              // multi-source
-              else {
-                  while (this.data.firstChild) {
-                      this.data.removeChild(this.data.firstChild);
-                  }
-              }
-          }
-          // done now.
-          this._finish();
-      };
-      /**
-       * Kicks off loading of this resource. This method is asynchronous.
-       * @param {PIXI.LoaderResource.OnCompleteSignal} [cb] - Optional callback to call once the resource is loaded.
-       */
-      LoaderResource.prototype.load = function (cb) {
-          var _this = this;
-          if (this.isLoading) {
-              return;
-          }
-          if (this.isComplete) {
-              if (cb) {
-                  setTimeout(function () { return cb(_this); }, 1);
-              }
-              return;
-          }
-          else if (cb) {
-              this.onComplete.once(cb);
-          }
-          this._setFlag(LoaderResource.STATUS_FLAGS.LOADING, true);
-          this.onStart.dispatch(this);
-          // if unset, determine the value
-          if (this.crossOrigin === false || typeof this.crossOrigin !== 'string') {
-              this.crossOrigin = this._determineCrossOrigin(this.url);
-          }
-          switch (this.loadType) {
-              case LoaderResource.LOAD_TYPE.IMAGE:
-                  this.type = LoaderResource.TYPE.IMAGE;
-                  this._loadElement('image');
-                  break;
-              case LoaderResource.LOAD_TYPE.AUDIO:
-                  this.type = LoaderResource.TYPE.AUDIO;
-                  this._loadSourceElement('audio');
-                  break;
-              case LoaderResource.LOAD_TYPE.VIDEO:
-                  this.type = LoaderResource.TYPE.VIDEO;
-                  this._loadSourceElement('video');
-                  break;
-              case LoaderResource.LOAD_TYPE.XHR:
-              /* falls through */
-              default:
-                  if (typeof useXdr === 'undefined') {
-                      useXdr = !!(globalThis.XDomainRequest && !('withCredentials' in (new XMLHttpRequest())));
-                  }
-                  if (useXdr && this.crossOrigin) {
-                      this._loadXdr();
-                  }
-                  else {
-                      this._loadXhr();
-                  }
-                  break;
-          }
-      };
-      /**
-       * Checks if the flag is set.
-       * @param flag - The flag to check.
-       * @returns True if the flag is set.
-       */
-      LoaderResource.prototype._hasFlag = function (flag) {
-          return (this._flags & flag) !== 0;
-      };
-      /**
-       * (Un)Sets the flag.
-       * @param flag - The flag to (un)set.
-       * @param value - Whether to set or (un)set the flag.
-       */
-      LoaderResource.prototype._setFlag = function (flag, value) {
-          this._flags = value ? (this._flags | flag) : (this._flags & ~flag);
-      };
-      /** Clears all the events from the underlying loading source. */
-      LoaderResource.prototype._clearEvents = function () {
-          clearTimeout(this._elementTimer);
-          if (this.data && this.data.removeEventListener) {
-              this.data.removeEventListener('error', this._boundOnError, false);
-              this.data.removeEventListener('load', this._boundComplete, false);
-              this.data.removeEventListener('progress', this._boundOnProgress, false);
-              this.data.removeEventListener('canplaythrough', this._boundComplete, false);
-          }
-          if (this.xhr) {
-              if (this.xhr.removeEventListener) {
-                  this.xhr.removeEventListener('error', this._boundXhrOnError, false);
-                  this.xhr.removeEventListener('timeout', this._boundXhrOnTimeout, false);
-                  this.xhr.removeEventListener('abort', this._boundXhrOnAbort, false);
-                  this.xhr.removeEventListener('progress', this._boundOnProgress, false);
-                  this.xhr.removeEventListener('load', this._boundXhrOnLoad, false);
-              }
-              else {
-                  this.xhr.onerror = null;
-                  this.xhr.ontimeout = null;
-                  this.xhr.onprogress = null;
-                  this.xhr.onload = null;
-              }
-          }
-      };
-      /** Finalizes the load. */
-      LoaderResource.prototype._finish = function () {
-          if (this.isComplete) {
-              throw new Error('Complete called again for an already completed resource.');
-          }
-          this._setFlag(LoaderResource.STATUS_FLAGS.COMPLETE, true);
-          this._setFlag(LoaderResource.STATUS_FLAGS.LOADING, false);
-          this.onComplete.dispatch(this);
-      };
-      /**
-       * Loads this resources using an element that has a single source,
-       * like an HTMLImageElement.
-       * @private
-       * @param type - The type of element to use.
-       */
-      LoaderResource.prototype._loadElement = function (type) {
-          if (this.metadata.loadElement) {
-              this.data = this.metadata.loadElement;
-          }
-          else if (type === 'image' && typeof globalThis.Image !== 'undefined') {
-              this.data = new Image();
-          }
-          else {
-              this.data = document.createElement(type);
-          }
-          if (this.crossOrigin) {
-              this.data.crossOrigin = this.crossOrigin;
-          }
-          if (!this.metadata.skipSource) {
-              this.data.src = this.url;
-          }
-          this.data.addEventListener('error', this._boundOnError, false);
-          this.data.addEventListener('load', this._boundComplete, false);
-          this.data.addEventListener('progress', this._boundOnProgress, false);
-          if (this.timeout) {
-              this._elementTimer = setTimeout(this._boundOnTimeout, this.timeout);
-          }
-      };
-      /**
-       * Loads this resources using an element that has multiple sources,
-       * like an HTMLAudioElement or HTMLVideoElement.
-       * @param type - The type of element to use.
-       */
-      LoaderResource.prototype._loadSourceElement = function (type) {
-          if (this.metadata.loadElement) {
-              this.data = this.metadata.loadElement;
-          }
-          else if (type === 'audio' && typeof globalThis.Audio !== 'undefined') {
-              this.data = new Audio();
-          }
-          else {
-              this.data = document.createElement(type);
-          }
-          if (this.data === null) {
-              this.abort("Unsupported element: " + type);
-              return;
-          }
-          if (this.crossOrigin) {
-              this.data.crossOrigin = this.crossOrigin;
-          }
-          if (!this.metadata.skipSource) {
-              // support for CocoonJS Canvas+ runtime, lacks document.createElement('source')
-              if (navigator.isCocoonJS) {
-                  this.data.src = Array.isArray(this.url) ? this.url[0] : this.url;
-              }
-              else if (Array.isArray(this.url)) {
-                  var mimeTypes = this.metadata.mimeType;
-                  for (var i = 0; i < this.url.length; ++i) {
-                      this.data.appendChild(this._createSource(type, this.url[i], Array.isArray(mimeTypes) ? mimeTypes[i] : mimeTypes));
-                  }
-              }
-              else {
-                  var mimeTypes = this.metadata.mimeType;
-                  this.data.appendChild(this._createSource(type, this.url, Array.isArray(mimeTypes) ? mimeTypes[0] : mimeTypes));
-              }
-          }
-          this.data.addEventListener('error', this._boundOnError, false);
-          this.data.addEventListener('load', this._boundComplete, false);
-          this.data.addEventListener('progress', this._boundOnProgress, false);
-          this.data.addEventListener('canplaythrough', this._boundComplete, false);
-          this.data.load();
-          if (this.timeout) {
-              this._elementTimer = setTimeout(this._boundOnTimeout, this.timeout);
-          }
-      };
-      /** Loads this resources using an XMLHttpRequest. */
-      LoaderResource.prototype._loadXhr = function () {
-          // if unset, determine the value
-          if (typeof this.xhrType !== 'string') {
-              this.xhrType = this._determineXhrType();
-          }
-          var xhr = this.xhr = new XMLHttpRequest();
-          // send credentials when crossOrigin with credentials requested
-          if (this.crossOrigin === 'use-credentials') {
-              xhr.withCredentials = true;
-          }
-          // set the request type and url
-          xhr.open('GET', this.url, true);
-          xhr.timeout = this.timeout;
-          // load json as text and parse it ourselves. We do this because some browsers
-          // *cough* safari *cough* can't deal with it.
-          if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.JSON
-              || this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT) {
-              xhr.responseType = LoaderResource.XHR_RESPONSE_TYPE.TEXT;
-          }
-          else {
-              xhr.responseType = this.xhrType;
-          }
-          xhr.addEventListener('error', this._boundXhrOnError, false);
-          xhr.addEventListener('timeout', this._boundXhrOnTimeout, false);
-          xhr.addEventListener('abort', this._boundXhrOnAbort, false);
-          xhr.addEventListener('progress', this._boundOnProgress, false);
-          xhr.addEventListener('load', this._boundXhrOnLoad, false);
-          xhr.send();
-      };
-      /** Loads this resources using an XDomainRequest. This is here because we need to support IE9 (gross). */
-      LoaderResource.prototype._loadXdr = function () {
-          // if unset, determine the value
-          if (typeof this.xhrType !== 'string') {
-              this.xhrType = this._determineXhrType();
-          }
-          var xdr = this.xhr = new globalThis.XDomainRequest(); // eslint-disable-line no-undef
-          // XDomainRequest has a few quirks. Occasionally it will abort requests
-          // A way to avoid this is to make sure ALL callbacks are set even if not used
-          // More info here: http://stackoverflow.com/questions/15786966/xdomainrequest-aborts-post-on-ie-9
-          xdr.timeout = this.timeout || 5000; // XDR needs a timeout value or it breaks in IE9
-          xdr.onerror = this._boundXhrOnError;
-          xdr.ontimeout = this._boundXhrOnTimeout;
-          xdr.onprogress = this._boundOnProgress;
-          xdr.onload = this._boundXhrOnLoad;
-          xdr.open('GET', this.url, true);
-          // Note: The xdr.send() call is wrapped in a timeout to prevent an
-          // issue with the interface where some requests are lost if multiple
-          // XDomainRequests are being sent at the same time.
-          // Some info here: https://github.com/photonstorm/phaser/issues/1248
-          setTimeout(function () { return xdr.send(); }, 1);
-      };
-      /**
-       * Creates a source used in loading via an element.
-       * @param type - The element type (video or audio).
-       * @param url - The source URL to load from.
-       * @param [mime] - The mime type of the video
-       * @returns The source element.
-       */
-      LoaderResource.prototype._createSource = function (type, url, mime) {
-          if (!mime) {
-              mime = type + "/" + this._getExtension(url);
-          }
-          var source = document.createElement('source');
-          source.src = url;
-          source.type = mime;
-          return source;
-      };
-      /**
-       * Called if a load errors out.
-       * @param event - The error event from the element that emits it.
-       */
-      LoaderResource.prototype._onError = function (event) {
-          this.abort("Failed to load element using: " + event.target.nodeName);
-      };
-      /**
-       * Called if a load progress event fires for an element or xhr/xdr.
-       * @param event - Progress event.
-       */
-      LoaderResource.prototype._onProgress = function (event) {
-          if (event && event.lengthComputable) {
-              this.onProgress.dispatch(this, event.loaded / event.total);
-          }
-      };
-      /** Called if a timeout event fires for an element. */
-      LoaderResource.prototype._onTimeout = function () {
-          this.abort("Load timed out.");
-      };
-      /** Called if an error event fires for xhr/xdr. */
-      LoaderResource.prototype._xhrOnError = function () {
-          var xhr = this.xhr;
-          this.abort(reqType(xhr) + " Request failed. Status: " + xhr.status + ", text: \"" + xhr.statusText + "\"");
-      };
-      /** Called if an error event fires for xhr/xdr. */
-      LoaderResource.prototype._xhrOnTimeout = function () {
-          var xhr = this.xhr;
-          this.abort(reqType(xhr) + " Request timed out.");
-      };
-      /** Called if an abort event fires for xhr/xdr. */
-      LoaderResource.prototype._xhrOnAbort = function () {
-          var xhr = this.xhr;
-          this.abort(reqType(xhr) + " Request was aborted by the user.");
-      };
-      /** Called when data successfully loads from an xhr/xdr request. */
-      LoaderResource.prototype._xhrOnLoad = function () {
-          var xhr = this.xhr;
-          var text = '';
-          var status = typeof xhr.status === 'undefined' ? STATUS_OK : xhr.status; // XDR has no `.status`, assume 200.
-          // responseText is accessible only if responseType is '' or 'text' and on older browsers
-          if (xhr.responseType === '' || xhr.responseType === 'text' || typeof xhr.responseType === 'undefined') {
-              text = xhr.responseText;
-          }
-          // status can be 0 when using the `file://` protocol so we also check if a response is set.
-          // If it has a response, we assume 200; otherwise a 0 status code with no contents is an aborted request.
-          if (status === STATUS_NONE && (text.length > 0 || xhr.responseType === LoaderResource.XHR_RESPONSE_TYPE.BUFFER)) {
-              status = STATUS_OK;
-          }
-          // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request
-          else if (status === STATUS_IE_BUG_EMPTY) {
-              status = STATUS_EMPTY;
-          }
-          var statusType = (status / 100) | 0;
-          if (statusType === STATUS_TYPE_OK) {
-              // if text, just return it
-              if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.TEXT) {
-                  this.data = text;
-                  this.type = LoaderResource.TYPE.TEXT;
-              }
-              // if json, parse into json object
-              else if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.JSON) {
-                  try {
-                      this.data = JSON.parse(text);
-                      this.type = LoaderResource.TYPE.JSON;
-                  }
-                  catch (e) {
-                      this.abort("Error trying to parse loaded json: " + e);
-                      return;
-                  }
-              }
-              // if xml, parse into an xml document or div element
-              else if (this.xhrType === LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT) {
-                  try {
-                      if (globalThis.DOMParser) {
-                          var domparser = new DOMParser();
-                          this.data = domparser.parseFromString(text, 'text/xml');
-                      }
-                      else {
-                          var div = document.createElement('div');
-                          div.innerHTML = text;
-                          this.data = div;
-                      }
-                      this.type = LoaderResource.TYPE.XML;
-                  }
-                  catch (e$1) {
-                      this.abort("Error trying to parse loaded xml: " + e$1);
-                      return;
-                  }
-              }
-              // other types just return the response
-              else {
-                  this.data = xhr.response || text;
-              }
-          }
-          else {
-              this.abort("[" + xhr.status + "] " + xhr.statusText + ": " + xhr.responseURL);
-              return;
-          }
-          this.complete();
-      };
-      /**
-       * Sets the `crossOrigin` property for this resource based on if the url
-       * for this resource is cross-origin. If crossOrigin was manually set, this
-       * function does nothing.
-       * @private
-       * @param url - The url to test.
-       * @param [loc=globalThis.location] - The location object to test against.
-       * @returns The crossOrigin value to use (or empty string for none).
-       */
-      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-      LoaderResource.prototype._determineCrossOrigin = function (url, loc) {
-          // data: and javascript: urls are considered same-origin
-          if (url.indexOf('data:') === 0) {
-              return '';
-          }
-          // A sandboxed iframe without the 'allow-same-origin' attribute will have a special
-          // origin designed not to match globalThis.location.origin, and will always require
-          // crossOrigin requests regardless of whether the location matches.
-          if (globalThis.origin !== globalThis.location.origin) {
-              return 'anonymous';
-          }
-          // default is globalThis.location
-          loc = loc || globalThis.location;
-          if (!tempAnchor) {
-              tempAnchor = document.createElement('a');
-          }
-          // let the browser determine the full href for the url of this resource and then
-          // parse with the node url lib, we can't use the properties of the anchor element
-          // because they don't work in IE9 :(
-          tempAnchor.href = url;
-          var parsedUrl = parseUri(tempAnchor.href, { strictMode: true });
-          var samePort = (!parsedUrl.port && loc.port === '') || (parsedUrl.port === loc.port);
-          var protocol = parsedUrl.protocol ? parsedUrl.protocol + ":" : '';
-          // if cross origin
-          if (parsedUrl.host !== loc.hostname || !samePort || protocol !== loc.protocol) {
-              return 'anonymous';
-          }
-          return '';
-      };
-      /**
-       * Determines the responseType of an XHR request based on the extension of the
-       * resource being loaded.
-       * @private
-       * @returns {PIXI.LoaderResource.XHR_RESPONSE_TYPE} The responseType to use.
-       */
-      LoaderResource.prototype._determineXhrType = function () {
-          return LoaderResource._xhrTypeMap[this.extension] || LoaderResource.XHR_RESPONSE_TYPE.TEXT;
-      };
-      /**
-       * Determines the loadType of a resource based on the extension of the
-       * resource being loaded.
-       * @private
-       * @returns {PIXI.LoaderResource.LOAD_TYPE} The loadType to use.
-       */
-      LoaderResource.prototype._determineLoadType = function () {
-          return LoaderResource._loadTypeMap[this.extension] || LoaderResource.LOAD_TYPE.XHR;
-      };
-      /**
-       * Extracts the extension (sans '.') of the file being loaded by the resource.
-       * @param [url] - url to parse, `this.url` by default.
-       * @returns The extension.
-       */
-      LoaderResource.prototype._getExtension = function (url) {
-          if (url === void 0) { url = this.url; }
-          var ext = '';
-          if (this.isDataUrl) {
-              var slashIndex = url.indexOf('/');
-              ext = url.substring(slashIndex + 1, url.indexOf(';', slashIndex));
-          }
-          else {
-              var queryStart = url.indexOf('?');
-              var hashStart = url.indexOf('#');
-              var index = Math.min(queryStart > -1 ? queryStart : url.length, hashStart > -1 ? hashStart : url.length);
-              url = url.substring(0, index);
-              ext = url.substring(url.lastIndexOf('.') + 1);
-          }
-          return ext.toLowerCase();
-      };
-      /**
-       * Determines the mime type of an XHR request based on the responseType of
-       * resource being loaded.
-       * @param type - The type to get a mime type for.
-       * @private
-       * @returns The mime type to use.
-       */
-      LoaderResource.prototype._getMimeFromXhrType = function (type) {
-          switch (type) {
-              case LoaderResource.XHR_RESPONSE_TYPE.BUFFER:
-                  return 'application/octet-binary';
-              case LoaderResource.XHR_RESPONSE_TYPE.BLOB:
-                  return 'application/blob';
-              case LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT:
-                  return 'application/xml';
-              case LoaderResource.XHR_RESPONSE_TYPE.JSON:
-                  return 'application/json';
-              case LoaderResource.XHR_RESPONSE_TYPE.DEFAULT:
-              case LoaderResource.XHR_RESPONSE_TYPE.TEXT:
-              /* falls through */
-              default:
-                  return 'text/plain';
-          }
-      };
-      return LoaderResource;
-  }());
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  (function (LoaderResource) {
-      (function (STATUS_FLAGS) {
-          /** None */
-          STATUS_FLAGS[STATUS_FLAGS["NONE"] = 0] = "NONE";
-          /** Data URL */
-          STATUS_FLAGS[STATUS_FLAGS["DATA_URL"] = 1] = "DATA_URL";
-          /** Complete */
-          STATUS_FLAGS[STATUS_FLAGS["COMPLETE"] = 2] = "COMPLETE";
-          /** Loading */
-          STATUS_FLAGS[STATUS_FLAGS["LOADING"] = 4] = "LOADING";
-      })(LoaderResource.STATUS_FLAGS || (LoaderResource.STATUS_FLAGS = {}));
-      (function (TYPE) {
-          /** Unknown */
-          TYPE[TYPE["UNKNOWN"] = 0] = "UNKNOWN";
-          /** JSON */
-          TYPE[TYPE["JSON"] = 1] = "JSON";
-          /** XML */
-          TYPE[TYPE["XML"] = 2] = "XML";
-          /** Image */
-          TYPE[TYPE["IMAGE"] = 3] = "IMAGE";
-          /** Audio */
-          TYPE[TYPE["AUDIO"] = 4] = "AUDIO";
-          /** Video */
-          TYPE[TYPE["VIDEO"] = 5] = "VIDEO";
-          /** Plain text */
-          TYPE[TYPE["TEXT"] = 6] = "TEXT";
-      })(LoaderResource.TYPE || (LoaderResource.TYPE = {}));
-      (function (LOAD_TYPE) {
-          /** Uses XMLHttpRequest to load the resource. */
-          LOAD_TYPE[LOAD_TYPE["XHR"] = 1] = "XHR";
-          /** Uses an `Image` object to load the resource. */
-          LOAD_TYPE[LOAD_TYPE["IMAGE"] = 2] = "IMAGE";
-          /** Uses an `Audio` object to load the resource. */
-          LOAD_TYPE[LOAD_TYPE["AUDIO"] = 3] = "AUDIO";
-          /** Uses a `Video` object to load the resource. */
-          LOAD_TYPE[LOAD_TYPE["VIDEO"] = 4] = "VIDEO";
-      })(LoaderResource.LOAD_TYPE || (LoaderResource.LOAD_TYPE = {}));
-      (function (XHR_RESPONSE_TYPE) {
-          /** string */
-          XHR_RESPONSE_TYPE["DEFAULT"] = "text";
-          /** ArrayBuffer */
-          XHR_RESPONSE_TYPE["BUFFER"] = "arraybuffer";
-          /** Blob */
-          XHR_RESPONSE_TYPE["BLOB"] = "blob";
-          /** Document */
-          XHR_RESPONSE_TYPE["DOCUMENT"] = "document";
-          /** Object */
-          XHR_RESPONSE_TYPE["JSON"] = "json";
-          /** String */
-          XHR_RESPONSE_TYPE["TEXT"] = "text";
-      })(LoaderResource.XHR_RESPONSE_TYPE || (LoaderResource.XHR_RESPONSE_TYPE = {}));
-      LoaderResource._loadTypeMap = {
-          // images
-          gif: LoaderResource.LOAD_TYPE.IMAGE,
-          png: LoaderResource.LOAD_TYPE.IMAGE,
-          bmp: LoaderResource.LOAD_TYPE.IMAGE,
-          jpg: LoaderResource.LOAD_TYPE.IMAGE,
-          jpeg: LoaderResource.LOAD_TYPE.IMAGE,
-          tif: LoaderResource.LOAD_TYPE.IMAGE,
-          tiff: LoaderResource.LOAD_TYPE.IMAGE,
-          webp: LoaderResource.LOAD_TYPE.IMAGE,
-          tga: LoaderResource.LOAD_TYPE.IMAGE,
-          avif: LoaderResource.LOAD_TYPE.IMAGE,
-          svg: LoaderResource.LOAD_TYPE.IMAGE,
-          'svg+xml': LoaderResource.LOAD_TYPE.IMAGE,
-          // audio
-          mp3: LoaderResource.LOAD_TYPE.AUDIO,
-          ogg: LoaderResource.LOAD_TYPE.AUDIO,
-          wav: LoaderResource.LOAD_TYPE.AUDIO,
-          // videos
-          mp4: LoaderResource.LOAD_TYPE.VIDEO,
-          webm: LoaderResource.LOAD_TYPE.VIDEO,
-      };
-      LoaderResource._xhrTypeMap = {
-          // xml
-          xhtml: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
-          html: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
-          htm: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
-          xml: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
-          tmx: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
-          svg: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
-          // This was added to handle Tiled Tileset XML, but .tsx is also a TypeScript React Component.
-          // Since it is way less likely for people to be loading TypeScript files instead of Tiled files,
-          // this should probably be fine.
-          tsx: LoaderResource.XHR_RESPONSE_TYPE.DOCUMENT,
-          // images
-          gif: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          png: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          bmp: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          jpg: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          jpeg: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          tif: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          tiff: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          webp: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          tga: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          avif: LoaderResource.XHR_RESPONSE_TYPE.BLOB,
-          // json
-          json: LoaderResource.XHR_RESPONSE_TYPE.JSON,
-          // text
-          text: LoaderResource.XHR_RESPONSE_TYPE.TEXT,
-          txt: LoaderResource.XHR_RESPONSE_TYPE.TEXT,
-          // fonts
-          ttf: LoaderResource.XHR_RESPONSE_TYPE.BUFFER,
-          otf: LoaderResource.XHR_RESPONSE_TYPE.BUFFER,
-      };
-      // We can't set the `src` attribute to empty string, so on abort we set it to this 1px transparent gif
-      LoaderResource.EMPTY_GIF = 'data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
-  })(exports.LoaderResource || (exports.LoaderResource = {}));
-
-  /**
-   * Smaller version of the async library constructs.
-   * @ignore
-   */
-  function _noop() {
-  }
-  /**
-   * Ensures a function is only called once.
-   * @ignore
-   * @param {Function} fn - The function to wrap.
-   * @returns {Function} The wrapping function.
-   */
-  function onlyOnce(fn) {
-      return function onceWrapper() {
-          var arguments$1 = arguments;
-
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments$1[_i];
-          }
-          if (fn === null) {
-              throw new Error('Callback was already called.');
-          }
-          var callFn = fn;
-          fn = null;
-          callFn.apply(this, args);
-      };
-  }
-  /**
-   * @private
-   * @memberof PIXI
-   */
-  var AsyncQueueItem = /** @class */ (function () {
-      /**
-       * @param data
-       * @param callback
-       * @private
-       */
-      function AsyncQueueItem(data, callback) {
-          this.data = data;
-          this.callback = callback;
-      }
-      return AsyncQueueItem;
-  }());
-  /**
-   * @private
-   * @memberof PIXI
-   */
-  var AsyncQueue = /** @class */ (function () {
-      /**
-       * @param worker
-       * @param concurrency
-       * @private
-       */
-      function AsyncQueue(worker, concurrency) {
-          var _this = this;
-          if (concurrency === void 0) { concurrency = 1; }
-          this.workers = 0;
-          this.saturated = _noop;
-          this.unsaturated = _noop;
-          this.empty = _noop;
-          this.drain = _noop;
-          this.error = _noop;
-          this.started = false;
-          this.paused = false;
-          this._tasks = [];
-          this._insert = function (data, insertAtFront, callback) {
-              if (callback && typeof callback !== 'function') {
-                  throw new Error('task callback must be a function');
-              }
-              _this.started = true;
-              // eslint-disable-next-line no-eq-null,eqeqeq
-              if (data == null && _this.idle()) {
-                  // call drain immediately if there are no tasks
-                  setTimeout(function () { return _this.drain(); }, 1);
-                  return;
-              }
-              var item = new AsyncQueueItem(data, typeof callback === 'function' ? callback : _noop);
-              if (insertAtFront) {
-                  _this._tasks.unshift(item);
-              }
-              else {
-                  _this._tasks.push(item);
-              }
-              setTimeout(_this.process, 1);
-          };
-          this.process = function () {
-              while (!_this.paused && _this.workers < _this.concurrency && _this._tasks.length) {
-                  var task = _this._tasks.shift();
-                  if (_this._tasks.length === 0) {
-                      _this.empty();
-                  }
-                  _this.workers += 1;
-                  if (_this.workers === _this.concurrency) {
-                      _this.saturated();
-                  }
-                  _this._worker(task.data, onlyOnce(_this._next(task)));
-              }
-          };
-          this._worker = worker;
-          if (concurrency === 0) {
-              throw new Error('Concurrency must not be zero');
-          }
-          this.concurrency = concurrency;
-          this.buffer = concurrency / 4.0;
-      }
-      /**
-       * @param task
-       * @private
-       */
-      AsyncQueue.prototype._next = function (task) {
-          var _this = this;
-          return function () {
-              var arguments$1 = arguments;
-
-              var args = [];
-              for (var _i = 0; _i < arguments.length; _i++) {
-                  args[_i] = arguments$1[_i];
-              }
-              _this.workers -= 1;
-              task.callback.apply(task, args);
-              // eslint-disable-next-line no-eq-null,eqeqeq
-              if (args[0] != null) {
-                  _this.error(args[0], task.data);
-              }
-              if (_this.workers <= (_this.concurrency - _this.buffer)) {
-                  _this.unsaturated();
-              }
-              if (_this.idle()) {
-                  _this.drain();
-              }
-              _this.process();
-          };
-      };
-      // That was in object
-      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-      AsyncQueue.prototype.push = function (data, callback) {
-          this._insert(data, false, callback);
-      };
-      AsyncQueue.prototype.kill = function () {
-          this.workers = 0;
-          this.drain = _noop;
-          this.started = false;
-          this._tasks = [];
-      };
-      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-      AsyncQueue.prototype.unshift = function (data, callback) {
-          this._insert(data, true, callback);
-      };
-      AsyncQueue.prototype.length = function () {
-          return this._tasks.length;
-      };
-      AsyncQueue.prototype.running = function () {
-          return this.workers;
-      };
-      AsyncQueue.prototype.idle = function () {
-          return this._tasks.length + this.workers === 0;
-      };
-      AsyncQueue.prototype.pause = function () {
-          if (this.paused === true) {
-              return;
-          }
-          this.paused = true;
-      };
-      AsyncQueue.prototype.resume = function () {
-          if (this.paused === false) {
-              return;
-          }
-          this.paused = false;
-          // Need to call this.process once per concurrent
-          // worker to preserve full concurrency after pause
-          for (var w = 1; w <= this.concurrency; w++) {
-              this.process();
-          }
-      };
-      /**
-       * Iterates an array in series.
-       * @param {Array.<*>} array - Array to iterate.
-       * @param {Function} iterator - Function to call for each element.
-       * @param {Function} callback - Function to call when done, or on error.
-       * @param {boolean} [deferNext=false] - Break synchronous each loop by calling next with a setTimeout of 1.
-       */
-      AsyncQueue.eachSeries = function (array, iterator, callback, deferNext) {
-          var i = 0;
-          var len = array.length;
-          function next(err) {
-              if (err || i === len) {
-                  if (callback) {
-                      callback(err);
-                  }
-                  return;
-              }
-              if (deferNext) {
-                  setTimeout(function () {
-                      iterator(array[i++], next);
-                  }, 1);
-              }
-              else {
-                  iterator(array[i++], next);
-              }
-          }
-          next();
-      };
-      /**
-       * Async queue implementation,
-       * @param {Function} worker - The worker function to call for each task.
-       * @param {number} concurrency - How many workers to run in parrallel.
-       * @returns {*} The async queue object.
-       */
-      AsyncQueue.queue = function (worker, concurrency) {
-          return new AsyncQueue(worker, concurrency);
-      };
-      return AsyncQueue;
-  }());
-
-  // some constants
-  var MAX_PROGRESS = 100;
-  var rgxExtractUrlHash = /(#[\w-]+)?$/;
-  /**
-   * The new loader, forked from Resource Loader by Chad Engler: https://github.com/englercj/resource-loader
-   *
-   * ```js
-   * const loader = PIXI.Loader.shared; // PixiJS exposes a premade instance for you to use.
-   * // or
-   * const loader = new PIXI.Loader(); // You can also create your own if you want
-   *
-   * const sprites = {};
-   *
-   * // Chainable `add` to enqueue a resource
-   * loader.add('bunny', 'data/bunny.png')
-   *       .add('spaceship', 'assets/spritesheet.json');
-   * loader.add('scoreFont', 'assets/score.fnt');
-   *
-   * // Chainable `pre` to add a middleware that runs for each resource, *before* loading that resource.
-   * // This is useful to implement custom caching modules (using filesystem, indexeddb, memory, etc).
-   * loader.pre(cachingMiddleware);
-   *
-   * // Chainable `use` to add a middleware that runs for each resource, *after* loading that resource.
-   * // This is useful to implement custom parsing modules (like spritesheet parsers, spine parser, etc).
-   * loader.use(parsingMiddleware);
-   *
-   * // The `load` method loads the queue of resources, and calls the passed in callback called once all
-   * // resources have loaded.
-   * loader.load((loader, resources) => {
-   *     // resources is an object where the key is the name of the resource loaded and the value is the resource object.
-   *     // They have a couple default properties:
-   *     // - `url`: The URL that the resource was loaded from
-   *     // - `error`: The error that happened when trying to load (if any)
-   *     // - `data`: The raw data that was loaded
-   *     // also may contain other properties based on the middleware that runs.
-   *     sprites.bunny = new PIXI.TilingSprite(resources.bunny.texture);
-   *     sprites.spaceship = new PIXI.TilingSprite(resources.spaceship.texture);
-   *     sprites.scoreFont = new PIXI.TilingSprite(resources.scoreFont.texture);
-   * });
-   *
-   * // throughout the process multiple signals can be dispatched.
-   * loader.onProgress.add(() => {}); // called once per loaded/errored file
-   * loader.onError.add(() => {}); // called once per errored file
-   * loader.onLoad.add(() => {}); // called once per loaded file
-   * loader.onComplete.add(() => {}); // called once when the queued resources all load.
-   * ```
-   * @memberof PIXI
-   */
-  var Loader = /** @class */ (function () {
-      /**
-       * @param baseUrl - The base url for all resources loaded by this loader.
-       * @param concurrency - The number of resources to load concurrently.
-       */
-      function Loader(baseUrl, concurrency) {
-          var _this = this;
-          if (baseUrl === void 0) { baseUrl = ''; }
-          if (concurrency === void 0) { concurrency = 10; }
-          /** The progress percent of the loader going through the queue. */
-          this.progress = 0;
-          /** Loading state of the loader, true if it is currently loading resources. */
-          this.loading = false;
-          /**
-           * A querystring to append to every URL added to the loader.
-           *
-           * This should be a valid query string *without* the question-mark (`?`). The loader will
-           * also *not* escape values for you. Make sure to escape your parameters with
-           * [`encodeURIComponent`](https://mdn.io/encodeURIComponent) before assigning this property.
-           * @example
-           * const loader = new Loader();
-           *
-           * loader.defaultQueryString = 'user=me&password=secret';
-           *
-           * // This will request 'image.png?user=me&password=secret'
-           * loader.add('image.png').load();
-           *
-           * loader.reset();
-           *
-           * // This will request 'image.png?v=1&user=me&password=secret'
-           * loader.add('iamge.png?v=1').load();
-           */
-          this.defaultQueryString = '';
-          /** The middleware to run before loading each resource. */
-          this._beforeMiddleware = [];
-          /** The middleware to run after loading each resource. */
-          this._afterMiddleware = [];
-          /** The tracks the resources we are currently completing parsing for. */
-          this._resourcesParsing = [];
-          /**
-           * The `_loadResource` function bound with this object context.
-           * @param r - The resource to load
-           * @param d - The dequeue function
-           */
-          this._boundLoadResource = function (r, d) { return _this._loadResource(r, d); };
-          /** All the resources for this loader keyed by name. */
-          this.resources = {};
-          this.baseUrl = baseUrl;
-          this._beforeMiddleware = [];
-          this._afterMiddleware = [];
-          this._resourcesParsing = [];
-          this._boundLoadResource = function (r, d) { return _this._loadResource(r, d); };
-          this._queue = AsyncQueue.queue(this._boundLoadResource, concurrency);
-          this._queue.pause();
-          this.resources = {};
-          this.onProgress = new Signal();
-          this.onError = new Signal();
-          this.onLoad = new Signal();
-          this.onStart = new Signal();
-          this.onComplete = new Signal();
-          for (var i = 0; i < Loader._plugins.length; ++i) {
-              var plugin = Loader._plugins[i];
-              var pre = plugin.pre, use = plugin.use;
-              if (pre) {
-                  this.pre(pre);
-              }
-              if (use) {
-                  this.use(use);
-              }
-          }
-          this._protected = false;
-      }
-      /**
-       * Same as add, params have strict order
-       * @private
-       * @param name - The name of the resource to load.
-       * @param url - The url for this resource, relative to the baseUrl of this loader.
-       * @param options - The options for the load.
-       * @param callback - Function to call when this specific resource completes loading.
-       * @returns The loader itself.
-       */
-      Loader.prototype._add = function (name, url, options, callback) {
-          // if loading already you can only add resources that have a parent.
-          if (this.loading && (!options || !options.parentResource)) {
-              throw new Error('Cannot add resources while the loader is running.');
-          }
-          // check if resource already exists.
-          if (this.resources[name]) {
-              throw new Error("Resource named \"" + name + "\" already exists.");
-          }
-          // add base url if this isn't an absolute url
-          url = this._prepareUrl(url);
-          // create the store the resource
-          this.resources[name] = new exports.LoaderResource(name, url, options);
-          if (typeof callback === 'function') {
-              this.resources[name].onAfterMiddleware.once(callback);
-          }
-          // if actively loading, make sure to adjust progress chunks for that parent and its children
-          if (this.loading) {
-              var parent = options.parentResource;
-              var incompleteChildren = [];
-              for (var i = 0; i < parent.children.length; ++i) {
-                  if (!parent.children[i].isComplete) {
-                      incompleteChildren.push(parent.children[i]);
-                  }
-              }
-              var fullChunk = parent.progressChunk * (incompleteChildren.length + 1); // +1 for parent
-              var eachChunk = fullChunk / (incompleteChildren.length + 2); // +2 for parent & new child
-              parent.children.push(this.resources[name]);
-              parent.progressChunk = eachChunk;
-              for (var i = 0; i < incompleteChildren.length; ++i) {
-                  incompleteChildren[i].progressChunk = eachChunk;
-              }
-              this.resources[name].progressChunk = eachChunk;
-          }
-          // add the resource to the queue
-          this._queue.push(this.resources[name]);
-          return this;
-      };
-      /* eslint-enable require-jsdoc,valid-jsdoc */
-      /**
-       * Sets up a middleware function that will run *before* the
-       * resource is loaded.
-       * @param fn - The middleware function to register.
-       * @returns The loader itself.
-       */
-      Loader.prototype.pre = function (fn) {
-          this._beforeMiddleware.push(fn);
-          return this;
-      };
-      /**
-       * Sets up a middleware function that will run *after* the
-       * resource is loaded.
-       * @param fn - The middleware function to register.
-       * @returns The loader itself.
-       */
-      Loader.prototype.use = function (fn) {
-          this._afterMiddleware.push(fn);
-          return this;
-      };
-      /**
-       * Resets the queue of the loader to prepare for a new load.
-       * @returns The loader itself.
-       */
-      Loader.prototype.reset = function () {
-          this.progress = 0;
-          this.loading = false;
-          this._queue.kill();
-          this._queue.pause();
-          // abort all resource loads
-          for (var k in this.resources) {
-              var res = this.resources[k];
-              if (res._onLoadBinding) {
-                  res._onLoadBinding.detach();
-              }
-              if (res.isLoading) {
-                  res.abort('loader reset');
-              }
-          }
-          this.resources = {};
-          return this;
-      };
-      /**
-       * Starts loading the queued resources.
-       * @param cb - Optional callback that will be bound to the `complete` event.
-       * @returns The loader itself.
-       */
-      Loader.prototype.load = function (cb) {
-          deprecation('6.5.0', '@pixi/loaders is being replaced with @pixi/assets in the next major release.');
-          // register complete callback if they pass one
-          if (typeof cb === 'function') {
-              this.onComplete.once(cb);
-          }
-          // if the queue has already started we are done here
-          if (this.loading) {
-              return this;
-          }
-          if (this._queue.idle()) {
-              this._onStart();
-              this._onComplete();
-          }
-          else {
-              // distribute progress chunks
-              var numTasks = this._queue._tasks.length;
-              var chunk = MAX_PROGRESS / numTasks;
-              for (var i = 0; i < this._queue._tasks.length; ++i) {
-                  this._queue._tasks[i].data.progressChunk = chunk;
-              }
-              // notify we are starting
-              this._onStart();
-              // start loading
-              this._queue.resume();
-          }
-          return this;
-      };
-      Object.defineProperty(Loader.prototype, "concurrency", {
-          /**
-           * The number of resources to load concurrently.
-           * @default 10
-           */
-          get: function () {
-              return this._queue.concurrency;
-          },
-          set: function (concurrency) {
-              this._queue.concurrency = concurrency;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Prepares a url for usage based on the configuration of this object
-       * @param url - The url to prepare.
-       * @returns The prepared url.
-       */
-      Loader.prototype._prepareUrl = function (url) {
-          var parsedUrl = parseUri(url, { strictMode: true });
-          var result;
-          // absolute url, just use it as is.
-          if (parsedUrl.protocol || !parsedUrl.path || url.indexOf('//') === 0) {
-              result = url;
-          }
-          // if baseUrl doesn't end in slash and url doesn't start with slash, then add a slash inbetween
-          else if (this.baseUrl.length
-              && this.baseUrl.lastIndexOf('/') !== this.baseUrl.length - 1
-              && url.charAt(0) !== '/') {
-              result = this.baseUrl + "/" + url;
-          }
-          else {
-              result = this.baseUrl + url;
-          }
-          // if we need to add a default querystring, there is a bit more work
-          if (this.defaultQueryString) {
-              var hash = rgxExtractUrlHash.exec(result)[0];
-              result = result.slice(0, result.length - hash.length);
-              if (result.indexOf('?') !== -1) {
-                  result += "&" + this.defaultQueryString;
-              }
-              else {
-                  result += "?" + this.defaultQueryString;
-              }
-              result += hash;
-          }
-          return result;
-      };
-      /**
-       * Loads a single resource.
-       * @param resource - The resource to load.
-       * @param dequeue - The function to call when we need to dequeue this item.
-       */
-      Loader.prototype._loadResource = function (resource, dequeue) {
-          var _this = this;
-          resource._dequeue = dequeue;
-          // run before middleware
-          AsyncQueue.eachSeries(this._beforeMiddleware, function (fn, next) {
-              fn.call(_this, resource, function () {
-                  // if the before middleware marks the resource as complete,
-                  // break and don't process any more before middleware
-                  next(resource.isComplete ? {} : null);
-              });
-          }, function () {
-              if (resource.isComplete) {
-                  _this._onLoad(resource);
-              }
-              else {
-                  resource._onLoadBinding = resource.onComplete.once(_this._onLoad, _this);
-                  resource.load();
-              }
-          }, true);
-      };
-      /** Called once loading has started. */
-      Loader.prototype._onStart = function () {
-          this.progress = 0;
-          this.loading = true;
-          this.onStart.dispatch(this);
-      };
-      /** Called once each resource has loaded. */
-      Loader.prototype._onComplete = function () {
-          this.progress = MAX_PROGRESS;
-          this.loading = false;
-          this.onComplete.dispatch(this, this.resources);
-      };
-      /**
-       * Called each time a resources is loaded.
-       * @param resource - The resource that was loaded
-       */
-      Loader.prototype._onLoad = function (resource) {
-          var _this = this;
-          resource._onLoadBinding = null;
-          // remove this resource from the async queue, and add it to our list of resources that are being parsed
-          this._resourcesParsing.push(resource);
-          resource._dequeue();
-          // run all the after middleware for this resource
-          AsyncQueue.eachSeries(this._afterMiddleware, function (fn, next) {
-              fn.call(_this, resource, next);
-          }, function () {
-              resource.onAfterMiddleware.dispatch(resource);
-              _this.progress = Math.min(MAX_PROGRESS, _this.progress + resource.progressChunk);
-              _this.onProgress.dispatch(_this, resource);
-              if (resource.error) {
-                  _this.onError.dispatch(resource.error, _this, resource);
-              }
-              else {
-                  _this.onLoad.dispatch(_this, resource);
-              }
-              _this._resourcesParsing.splice(_this._resourcesParsing.indexOf(resource), 1);
-              // do completion check
-              if (_this._queue.idle() && _this._resourcesParsing.length === 0) {
-                  _this._onComplete();
-              }
-          }, true);
-      };
-      /** Destroy the loader, removes references. */
-      Loader.prototype.destroy = function () {
-          if (!this._protected) {
-              this.reset();
-          }
-      };
-      Object.defineProperty(Loader, "shared", {
-          /** A premade instance of the loader that can be used to load resources. */
-          get: function () {
-              var shared = Loader._shared;
-              if (!shared) {
-                  shared = new Loader();
-                  shared._protected = true;
-                  Loader._shared = shared;
-              }
-              return shared;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Use the {@link PIXI.extensions.add} API to register plugins.
-       * @deprecated since 6.5.0
-       * @param plugin - The plugin to add
-       * @returns Reference to PIXI.Loader for chaining
-       */
-      Loader.registerPlugin = function (plugin) {
-          deprecation('6.5.0', 'Loader.registerPlugin() is deprecated, use extensions.add() instead.');
-          extensions.add({
-              type: exports.ExtensionType.Loader,
-              ref: plugin,
-          });
-          return Loader;
-      };
-      Loader._plugins = [];
-      return Loader;
-  }());
-  extensions.handleByList(exports.ExtensionType.Loader, Loader._plugins);
-  Loader.prototype.add = function add(name, url, options, callback) {
-      // special case of an array of objects or urls
-      if (Array.isArray(name)) {
-          for (var i = 0; i < name.length; ++i) {
-              this.add(name[i]);
-          }
-          return this;
-      }
-      // if an object is passed instead of params
-      if (typeof name === 'object') {
-          options = name;
-          callback = url || options.callback || options.onComplete;
-          url = options.url;
-          name = options.name || options.key || options.url;
-      }
-      // case where no name is passed shift all args over by one.
-      if (typeof url !== 'string') {
-          callback = options;
-          options = url;
-          url = name;
-      }
-      // now that we shifted make sure we have a proper url.
-      if (typeof url !== 'string') {
-          throw new Error('No url passed to add resource to loader.');
-      }
-      // options are optional so people might pass a function and no options
-      if (typeof options === 'function') {
-          callback = options;
-          options = null;
-      }
-      return this._add(name, url, options, callback);
-  };
-
-  /**
-   * Application plugin for supporting loader option. Installing the LoaderPlugin
-   * is not necessary if using **pixi.js** or **pixi.js-legacy**.
-   * @example
-   * import {AppLoaderPlugin} from '@pixi/loaders';
-   * import {extensions} from '@pixi/core';
-   * extensions.add(AppLoaderPlugin);
-   * @memberof PIXI
-   */
-  var AppLoaderPlugin = /** @class */ (function () {
-      function AppLoaderPlugin() {
-      }
-      /**
-       * Called on application constructor
-       * @param options
-       * @private
-       */
-      AppLoaderPlugin.init = function (options) {
-          options = Object.assign({
-              sharedLoader: false,
-          }, options);
-          this.loader = options.sharedLoader ? Loader.shared : new Loader();
-      };
-      /**
-       * Called when application destroyed
-       * @private
-       */
-      AppLoaderPlugin.destroy = function () {
-          if (this.loader) {
-              this.loader.destroy();
-              this.loader = null;
-          }
-      };
-      /** @ignore */
-      AppLoaderPlugin.extension = exports.ExtensionType.Application;
-      return AppLoaderPlugin;
-  }());
-
-  /**
-   * Loader plugin for handling Texture resources.
-   * @memberof PIXI
-   */
-  var TextureLoader = /** @class */ (function () {
-      function TextureLoader() {
-      }
-      /** Handle SVG elements a text, render with SVGResource. */
-      TextureLoader.add = function () {
-          exports.LoaderResource.setExtensionLoadType('svg', exports.LoaderResource.LOAD_TYPE.XHR);
-          exports.LoaderResource.setExtensionXhrType('svg', exports.LoaderResource.XHR_RESPONSE_TYPE.TEXT);
-      };
-      /**
-       * Called after a resource is loaded.
-       * @see PIXI.Loader.loaderMiddleware
-       * @param resource
-       * @param {Function} next
-       */
-      TextureLoader.use = function (resource, next) {
-          // create a new texture if the data is an Image object
-          if (resource.data && (resource.type === exports.LoaderResource.TYPE.IMAGE || resource.extension === 'svg')) {
-              var data = resource.data, url = resource.url, name = resource.name, metadata = resource.metadata;
-              Texture.fromLoader(data, url, name, metadata).then(function (texture) {
-                  resource.texture = texture;
-                  next();
-              })
-                  // TODO: handle errors in Texture.fromLoader
-                  // so we can pass them to the Loader
-                  .catch(next);
-          }
-          else {
-              next();
-          }
-      };
-      /** @ignore */
-      TextureLoader.extension = exports.ExtensionType.Loader;
-      return TextureLoader;
-  }());
-
-  var _keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-  /**
-   * Encodes binary into base64.
-   * @function encodeBinary
-   * @param {string} input - The input data to encode.
-   * @returns {string} The encoded base64 string
-   */
-  function encodeBinary(input) {
-      var output = '';
-      var inx = 0;
-      while (inx < input.length) {
-          // Fill byte buffer array
-          var bytebuffer = [0, 0, 0];
-          var encodedCharIndexes = [0, 0, 0, 0];
-          for (var jnx = 0; jnx < bytebuffer.length; ++jnx) {
-              if (inx < input.length) {
-                  // throw away high-order byte, as documented at:
-                  // https://developer.mozilla.org/En/Using_XMLHttpRequest#Handling_binary_data
-                  bytebuffer[jnx] = input.charCodeAt(inx++) & 0xff;
-              }
-              else {
-                  bytebuffer[jnx] = 0;
-              }
-          }
-          // Get each encoded character, 6 bits at a time
-          // index 1: first 6 bits
-          encodedCharIndexes[0] = bytebuffer[0] >> 2;
-          // index 2: second 6 bits (2 least significant bits from input byte 1 + 4 most significant bits from byte 2)
-          encodedCharIndexes[1] = ((bytebuffer[0] & 0x3) << 4) | (bytebuffer[1] >> 4);
-          // index 3: third 6 bits (4 least significant bits from input byte 2 + 2 most significant bits from byte 3)
-          encodedCharIndexes[2] = ((bytebuffer[1] & 0x0f) << 2) | (bytebuffer[2] >> 6);
-          // index 3: forth 6 bits (6 least significant bits from input byte 3)
-          encodedCharIndexes[3] = bytebuffer[2] & 0x3f;
-          // Determine whether padding happened, and adjust accordingly
-          var paddingBytes = inx - (input.length - 1);
-          switch (paddingBytes) {
-              case 2:
-                  // Set last 2 characters to padding char
-                  encodedCharIndexes[3] = 64;
-                  encodedCharIndexes[2] = 64;
-                  break;
-              case 1:
-                  // Set last character to padding char
-                  encodedCharIndexes[3] = 64;
-                  break;
-          }
-          // Now we will grab each appropriate character out of our keystring
-          // based on our index array and append it to the output string
-          for (var jnx = 0; jnx < encodedCharIndexes.length; ++jnx) {
-              output += _keyStr.charAt(encodedCharIndexes[jnx]);
-          }
-      }
-      return output;
-  }
-
-  /**
-   * A middleware for transforming XHR loaded Blobs into more useful objects
-   * @ignore
-   * @function parsing
-   * @example
-   * import { Loader, middleware } from 'resource-loader';
-   * const loader = new Loader();
-   * loader.use(middleware.parsing);
-   * @param resource - Current Resource
-   * @param next - Callback when complete
-   */
-  function parsing(resource, next) {
-      if (!resource.data) {
-          next();
-          return;
-      }
-      // if this was an XHR load of a blob
-      if (resource.xhr && resource.xhrType === exports.LoaderResource.XHR_RESPONSE_TYPE.BLOB) {
-          // if there is no blob support we probably got a binary string back
-          if (!self.Blob || typeof resource.data === 'string') {
-              var type = resource.xhr.getResponseHeader('content-type');
-              // this is an image, convert the binary string into a data url
-              if (type && type.indexOf('image') === 0) {
-                  resource.data = new Image();
-                  resource.data.src = "data:" + type + ";base64," + encodeBinary(resource.xhr.responseText);
-                  resource.type = exports.LoaderResource.TYPE.IMAGE;
-                  // wait until the image loads and then callback
-                  resource.data.onload = function () {
-                      resource.data.onload = null;
-                      next();
-                  };
-                  // next will be called on load
-                  return;
-              }
-          }
-          // if content type says this is an image, then we should transform the blob into an Image object
-          else if (resource.data.type.indexOf('image') === 0) {
-              var Url_1 = globalThis.URL || globalThis.webkitURL;
-              var src_1 = Url_1.createObjectURL(resource.data);
-              resource.blob = resource.data;
-              resource.data = new Image();
-              resource.data.src = src_1;
-              resource.type = exports.LoaderResource.TYPE.IMAGE;
-              // cleanup the no longer used blob after the image loads
-              // TODO: Is this correct? Will the image be invalid after revoking?
-              resource.data.onload = function () {
-                  Url_1.revokeObjectURL(src_1);
-                  resource.data.onload = null;
-                  next();
-              };
-              // next will be called on load.
-              return;
-          }
-      }
-      next();
-  }
-
-  /**
-   * Parse any blob into more usable objects (e.g. Image).
-   * @memberof PIXI
-   */
-  var ParsingLoader = /** @class */ (function () {
-      function ParsingLoader() {
-      }
-      /** @ignore */
-      ParsingLoader.extension = exports.ExtensionType.Loader;
-      ParsingLoader.use = parsing;
-      return ParsingLoader;
-  }());
-
-  extensions.add(TextureLoader, ParsingLoader);
-
-  /*!
-   * @pixi/compressed-textures - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/compressed-textures is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  var _a$2;
-  /**
-   * WebGL internal formats, including compressed texture formats provided by extensions
-   * @memberof PIXI
-   * @static
-   * @name INTERNAL_FORMATS
-   * @enum {number}
-   * @property {number} [COMPRESSED_RGB_S3TC_DXT1_EXT=0x83F0] -
-   * @property {number} [COMPRESSED_RGBA_S3TC_DXT1_EXT=0x83F1] -
-   * @property {number} [COMPRESSED_RGBA_S3TC_DXT3_EXT=0x83F2] -
-   * @property {number} [COMPRESSED_RGBA_S3TC_DXT5_EXT=0x83F3] -
-   * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=35917] -
-   * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=35918] -
-   * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=35919] -
-   * @property {number} [COMPRESSED_SRGB_S3TC_DXT1_EXT=35916] -
-   * @property {number} [COMPRESSED_R11_EAC=0x9270] -
-   * @property {number} [COMPRESSED_SIGNED_R11_EAC=0x9271] -
-   * @property {number} [COMPRESSED_RG11_EAC=0x9272] -
-   * @property {number} [COMPRESSED_SIGNED_RG11_EAC=0x9273] -
-   * @property {number} [COMPRESSED_RGB8_ETC2=0x9274] -
-   * @property {number} [COMPRESSED_RGBA8_ETC2_EAC=0x9278] -
-   * @property {number} [COMPRESSED_SRGB8_ETC2=0x9275] -
-   * @property {number} [COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=0x9279] -
-   * @property {number} [COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=0x9276] -
-   * @property {number} [COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=0x9277] -
-   * @property {number} [COMPRESSED_RGB_PVRTC_4BPPV1_IMG=0x8C00] -
-   * @property {number} [COMPRESSED_RGBA_PVRTC_4BPPV1_IMG=0x8C02] -
-   * @property {number} [COMPRESSED_RGB_PVRTC_2BPPV1_IMG=0x8C01] -
-   * @property {number} [COMPRESSED_RGBA_PVRTC_2BPPV1_IMG=0x8C03] -
-   * @property {number} [COMPRESSED_RGB_ETC1_WEBGL=0x8D64] -
-   * @property {number} [COMPRESSED_RGB_ATC_WEBGL=0x8C92] -
-   * @property {number} [COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL=0x8C92] -
-   * @property {number} [COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL=0x87EE] -
-   * @property {number} [COMPRESSED_RGBA_ASTC_4x4_KHR=0x93B0] -
-   */
-  exports.INTERNAL_FORMATS = void 0;
-  (function (INTERNAL_FORMATS) {
-      // WEBGL_compressed_texture_s3tc
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT";
-      // WEBGL_compressed_texture_s3tc_srgb
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT";
-      // WEBGL_compressed_texture_etc
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA8_ETC2_EAC"] = 37496] = "COMPRESSED_RGBA8_ETC2_EAC";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ETC2"] = 37493] = "COMPRESSED_SRGB8_ETC2";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37497] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37494] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37495] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2";
-      // WEBGL_compressed_texture_pvrtc
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG";
-      // WEBGL_compressed_texture_etc1
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL";
-      // WEBGL_compressed_texture_atc
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL";
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL";
-      // WEBGL_compressed_texture_astc
-      /* eslint-disable-next-line camelcase */
-      INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR";
-  })(exports.INTERNAL_FORMATS || (exports.INTERNAL_FORMATS = {}));
-  /**
-   * Maps the compressed texture formats in {@link PIXI.INTERNAL_FORMATS} to the number of bytes taken by
-   * each texel.
-   * @memberof PIXI
-   * @static
-   * @ignore
-   */
-  var INTERNAL_FORMAT_TO_BYTES_PER_PIXEL = (_a$2 = {},
-      // WEBGL_compressed_texture_s3tc
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_S3TC_DXT1_EXT] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT] = 1,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT] = 1,
-      // WEBGL_compressed_texture_s3tc
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_S3TC_DXT1_EXT] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT] = 1,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT] = 1,
-      // WEBGL_compressed_texture_etc
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_R11_EAC] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SIGNED_R11_EAC] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RG11_EAC] = 1,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SIGNED_RG11_EAC] = 1,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB8_ETC2] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA8_ETC2_EAC] = 1,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB8_ETC2] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC] = 1,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 0.5,
-      // WEBGL_compressed_texture_pvrtc
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = 0.25,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = 0.25,
-      // WEBGL_compressed_texture_etc1
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_ETC1_WEBGL] = 0.5,
-      // @see https://www.khronos.org/registry/OpenGL/extensions/AMD/AMD_compressed_ATC_texture.txt
-      // WEBGL_compressed_texture_atc
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGB_ATC_WEBGL] = 0.5,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = 1,
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = 1,
-      // @see https://registry.khronos.org/OpenGL/extensions/KHR/KHR_texture_compression_astc_hdr.txt
-      // WEBGL_compressed_texture_astc
-      /* eslint-disable-next-line camelcase */
-      _a$2[exports.INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_4x4_KHR] = 1,
-      _a$2);
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$g = function(d, b) {
-      extendStatics$g = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$g(d, b);
-  };
-
-  function __extends$g(d, b) {
-      extendStatics$g(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  function __awaiter(thisArg, _arguments, P, generator) {
-      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-      return new (P || (P = Promise))(function (resolve, reject) {
-          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-          step((generator = generator.apply(thisArg, _arguments || [])).next());
-      });
-  }
-
-  function __generator(thisArg, body) {
-      var _ = { label: 0, sent: function() { if (t[0] & 1) { throw t[1]; } return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-      function verb(n) { return function (v) { return step([n, v]); }; }
-      function step(op) {
-          if (f) { throw new TypeError("Generator is already executing."); }
-          while (_) { try {
-              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) { return t; }
-              if (y = 0, t) { op = [op[0] & 2, t.value]; }
-              switch (op[0]) {
-                  case 0: case 1: t = op; break;
-                  case 4: _.label++; return { value: op[1], done: false };
-                  case 5: _.label++; y = op[1]; op = [0]; continue;
-                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                  default:
-                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                      if (t[2]) { _.ops.pop(); }
-                      _.trys.pop(); continue;
-              }
-              op = body.call(thisArg, _);
-          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } }
-          if (op[0] & 5) { throw op[1]; } return { value: op[0] ? op[1] : void 0, done: true };
-      }
-  }
-
-  /**
-   * Resource that fetches texture data over the network and stores it in a buffer.
-   * @class
-   * @extends PIXI.Resource
-   * @memberof PIXI
-   */
-  var BlobResource = /** @class */ (function (_super) {
-      __extends$g(BlobResource, _super);
-      /**
-       * @param {string} source - the URL of the texture file
-       * @param {PIXI.IBlobOptions} options
-       * @param {boolean}[options.autoLoad] - whether to fetch the data immediately;
-       *  you can fetch it later via {@link BlobResource#load}
-       * @param {boolean}[options.width] - the width in pixels.
-       * @param {boolean}[options.height] - the height in pixels.
-       */
-      function BlobResource(source, options) {
-          if (options === void 0) { options = { width: 1, height: 1, autoLoad: true }; }
-          var _this = this;
-          var origin;
-          var data;
-          if (typeof source === 'string') {
-              origin = source;
-              data = new Uint8Array();
-          }
-          else {
-              origin = null;
-              data = source;
-          }
-          _this = _super.call(this, data, options) || this;
-          /**
-           * The URL of the texture file
-           * @member {string}
-           */
-          _this.origin = origin;
-          /**
-           * The viewable buffer on the data
-           * @member {ViewableBuffer}
-           */
-          // HINT: BlobResource allows "null" sources, assuming the child class provides an alternative
-          _this.buffer = data ? new ViewableBuffer(data) : null;
-          // Allow autoLoad = "undefined" still load the resource by default
-          if (_this.origin && options.autoLoad !== false) {
-              _this.load();
-          }
-          if (data && data.length) {
-              _this.loaded = true;
-              _this.onBlobLoaded(_this.buffer.rawBinaryData);
-          }
-          return _this;
-      }
-      BlobResource.prototype.onBlobLoaded = function (_data) {
-          // TODO: Override this method
-      };
-      /** Loads the blob */
-      BlobResource.prototype.load = function () {
-          return __awaiter(this, void 0, Promise, function () {
-              var response, blob, arrayBuffer;
-              return __generator(this, function (_a) {
-                  switch (_a.label) {
-                      case 0: return [4 /*yield*/, fetch(this.origin)];
-                      case 1:
-                          response = _a.sent();
-                          return [4 /*yield*/, response.blob()];
-                      case 2:
-                          blob = _a.sent();
-                          return [4 /*yield*/, blob.arrayBuffer()];
-                      case 3:
-                          arrayBuffer = _a.sent();
-                          this.data = new Uint32Array(arrayBuffer);
-                          this.buffer = new ViewableBuffer(arrayBuffer);
-                          this.loaded = true;
-                          this.onBlobLoaded(arrayBuffer);
-                          this.update();
-                          return [2 /*return*/, this];
-                  }
-              });
-          });
-      };
-      return BlobResource;
-  }(BufferResource));
-
-  /**
-   * Resource for compressed texture formats, as follows: S3TC/DXTn (& their sRGB formats), ATC, ASTC, ETC 1/2, PVRTC.
-   *
-   * Compressed textures improve performance when rendering is texture-bound. The texture data stays compressed in
-   * graphics memory, increasing memory locality and speeding up texture fetches. These formats can also be used to store
-   * more detail in the same amount of memory.
-   *
-   * For most developers, container file formats are a better abstraction instead of directly handling raw texture
-   * data. PixiJS provides native support for the following texture file formats (via {@link PIXI.Loader}):
-   *
-   * **.dds** - the DirectDraw Surface file format stores DXTn (DXT-1,3,5) data. See {@link PIXI.DDSLoader}
-   * **.ktx** - the Khronos Texture Container file format supports storing all the supported WebGL compression formats.
-   *  See {@link PIXI.KTXLoader}.
-   * **.basis** - the BASIS supercompressed file format stores texture data in an internal format that is transcoded
-   *  to the compression format supported on the device at _runtime_. It also supports transcoding into a uncompressed
-   *  format as a fallback; you must install the `@pixi/basis-loader`, `@pixi/basis-transcoder` packages separately to
-   *  use these files. See {@link PIXI.BasisLoader}.
-   *
-   * The loaders for the aforementioned formats use `CompressedTextureResource` internally. It is strongly suggested that
-   * they be used instead.
-   *
-   * ## Working directly with CompressedTextureResource
-   *
-   * Since `CompressedTextureResource` inherits `BlobResource`, you can provide it a URL pointing to a file containing
-   * the raw texture data (with no file headers!):
-   *
-   * ```js
-   * // The resource backing the texture data for your textures.
-   * // NOTE: You can also provide a ArrayBufferView instead of a URL. This is used when loading data from a container file
-   * //   format such as KTX, DDS, or BASIS.
-   * const compressedResource = new PIXI.CompressedTextureResource("bunny.dxt5", {
-   *   format: PIXI.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-   *   width: 256,
-   *   height: 256
-   * });
-   *
-   * // You can create a base-texture to the cache, so that future `Texture`s can be created using the `Texture.from` API.
-   * const baseTexture = new PIXI.BaseTexture(compressedResource, { pmaMode: PIXI.ALPHA_MODES.NPM });
-   *
-   * // Create a Texture to add to the TextureCache
-   * const texture = new PIXI.Texture(baseTexture);
-   *
-   * // Add baseTexture & texture to the global texture cache
-   * PIXI.BaseTexture.addToCache(baseTexture, "bunny.dxt5");
-   * PIXI.Texture.addToCache(texture, "bunny.dxt5");
-   * ```
-   * @memberof PIXI
-   */
-  var CompressedTextureResource = /** @class */ (function (_super) {
-      __extends$g(CompressedTextureResource, _super);
-      /**
-       * @param source - the buffer/URL holding the compressed texture data
-       * @param options
-       * @param {PIXI.INTERNAL_FORMATS} options.format - the compression format
-       * @param {number} options.width - the image width in pixels.
-       * @param {number} options.height - the image height in pixels.
-       * @param {number} [options.level=1] - the mipmap levels stored in the compressed texture, including level 0.
-       * @param {number} [options.levelBuffers] - the buffers for each mipmap level. `CompressedTextureResource` can allows you
-       *      to pass `null` for `source`, for cases where each level is stored in non-contiguous memory.
-       */
-      function CompressedTextureResource(source, options) {
-          var _this = _super.call(this, source, options) || this;
-          _this.format = options.format;
-          _this.levels = options.levels || 1;
-          _this._width = options.width;
-          _this._height = options.height;
-          _this._extension = CompressedTextureResource._formatToExtension(_this.format);
-          if (options.levelBuffers || _this.buffer) {
-              // ViewableBuffer doesn't support byteOffset :-( so allow source to be Uint8Array
-              _this._levelBuffers = options.levelBuffers
-                  || CompressedTextureResource._createLevelBuffers(source instanceof Uint8Array ? source : _this.buffer.uint8View, _this.format, _this.levels, 4, 4, // PVRTC has 8x4 blocks in 2bpp mode
-                  _this.width, _this.height);
-          }
-          return _this;
-      }
-      /**
-       * @override
-       * @param renderer - A reference to the current renderer
-       * @param _texture - the texture
-       * @param _glTexture - texture instance for this webgl context
-       */
-      CompressedTextureResource.prototype.upload = function (renderer, _texture, _glTexture) {
-          var gl = renderer.gl;
-          var extension = renderer.context.extensions[this._extension];
-          if (!extension) {
-              throw new Error(this._extension + " textures are not supported on the current machine");
-          }
-          if (!this._levelBuffers) {
-              // Do not try to upload data before BlobResource loads, unless the levelBuffers were provided directly!
-              return false;
-          }
-          for (var i = 0, j = this.levels; i < j; i++) {
-              var _a = this._levelBuffers[i], levelID = _a.levelID, levelWidth = _a.levelWidth, levelHeight = _a.levelHeight, levelBuffer = _a.levelBuffer;
-              gl.compressedTexImage2D(gl.TEXTURE_2D, levelID, this.format, levelWidth, levelHeight, 0, levelBuffer);
-          }
-          return true;
-      };
-      /** @protected */
-      CompressedTextureResource.prototype.onBlobLoaded = function () {
-          this._levelBuffers = CompressedTextureResource._createLevelBuffers(this.buffer.uint8View, this.format, this.levels, 4, 4, // PVRTC has 8x4 blocks in 2bpp mode
-          this.width, this.height);
-      };
-      /**
-       * Returns the key (to ContextSystem#extensions) for the WebGL extension supporting the compression format
-       * @private
-       * @param format - the compression format to get the extension for.
-       */
-      CompressedTextureResource._formatToExtension = function (format) {
-          if (format >= 0x83F0 && format <= 0x83F3) {
-              return 's3tc';
-          }
-          else if (format >= 0x9270 && format <= 0x9279) {
-              return 'etc';
-          }
-          else if (format >= 0x8C00 && format <= 0x8C03) {
-              return 'pvrtc';
-          }
-          else if (format >= 0x8D64) {
-              return 'etc1';
-          }
-          else if (format >= 0x8C92 && format <= 0x87EE) {
-              return 'atc';
-          }
-          throw new Error('Invalid (compressed) texture format given!');
-      };
-      /**
-       * Pre-creates buffer views for each mipmap level
-       * @private
-       * @param buffer -
-       * @param format - compression formats
-       * @param levels - mipmap levels
-       * @param blockWidth -
-       * @param blockHeight -
-       * @param imageWidth - width of the image in pixels
-       * @param imageHeight - height of the image in pixels
-       */
-      CompressedTextureResource._createLevelBuffers = function (buffer, format, levels, blockWidth, blockHeight, imageWidth, imageHeight) {
-          // The byte-size of the first level buffer
-          var buffers = new Array(levels);
-          var offset = buffer.byteOffset;
-          var levelWidth = imageWidth;
-          var levelHeight = imageHeight;
-          var alignedLevelWidth = (levelWidth + blockWidth - 1) & ~(blockWidth - 1);
-          var alignedLevelHeight = (levelHeight + blockHeight - 1) & ~(blockHeight - 1);
-          var levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];
-          for (var i = 0; i < levels; i++) {
-              buffers[i] = {
-                  levelID: i,
-                  levelWidth: levels > 1 ? levelWidth : alignedLevelWidth,
-                  levelHeight: levels > 1 ? levelHeight : alignedLevelHeight,
-                  levelBuffer: new Uint8Array(buffer.buffer, offset, levelSize)
-              };
-              offset += levelSize;
-              // Calculate levelBuffer dimensions for next iteration
-              levelWidth = (levelWidth >> 1) || 1;
-              levelHeight = (levelHeight >> 1) || 1;
-              alignedLevelWidth = (levelWidth + blockWidth - 1) & ~(blockWidth - 1);
-              alignedLevelHeight = (levelHeight + blockHeight - 1) & ~(blockHeight - 1);
-              levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];
-          }
-          return buffers;
-      };
-      return CompressedTextureResource;
-  }(BlobResource));
-
-  /* eslint-enable camelcase */
-  /**
-   * Loader plugin for handling compressed textures for all platforms.
-   * @class
-   * @memberof PIXI
-   * @implements {PIXI.ILoaderPlugin}
-   */
-  var CompressedTextureLoader = /** @class */ (function () {
-      function CompressedTextureLoader() {
-      }
-      /**
-       * Called after a compressed-textures manifest is loaded.
-       *
-       * This will then load the correct compression format for the device. Your manifest should adhere
-       * to the following schema:
-       *
-       * ```js
-       * import { INTERNAL_FORMATS } from '@pixi/constants';
-       *
-       * type CompressedTextureManifest = {
-       *  textures: Array<{ src: string, format?: keyof INTERNAL_FORMATS}>,
-       *  cacheID: string;
-       * };
-       * ```
-       *
-       * This is an example of a .json manifest file
-       *
-       * ```json
-       * {
-       *   "cacheID":"asset",
-       *   "textures":[
-       *     { "src":"asset.fallback.png" },
-       *     { "format":"COMPRESSED_RGBA_S3TC_DXT5_EXT", "src":"asset.s3tc.ktx" },
-       *     { "format":"COMPRESSED_RGBA8_ETC2_EAC", "src":"asset.etc.ktx" },
-       *     { "format":"RGBA_PVRTC_4BPPV1_IMG", "src":"asset.pvrtc.ktx" }
-       *   ]
-       * }
-       * ```
-       */
-      CompressedTextureLoader.use = function (resource, next) {
-          var data = resource.data;
-          var loader = this;
-          if (resource.type === exports.LoaderResource.TYPE.JSON
-              && data
-              && data.cacheID
-              && data.textures) {
-              var textures = data.textures;
-              var textureURL = void 0;
-              var fallbackURL = void 0;
-              // Search for an extension that holds one the formats
-              for (var i = 0, j = textures.length; i < j; i++) {
-                  var texture = textures[i];
-                  var url_1 = texture.src;
-                  var format = texture.format;
-                  if (!format) {
-                      fallbackURL = url_1;
-                  }
-                  if (CompressedTextureLoader.textureFormats[format]) {
-                      textureURL = url_1;
-                      break;
-                  }
-              }
-              textureURL = textureURL || fallbackURL;
-              // Make sure we have a URL
-              if (!textureURL) {
-                  next(new Error("Cannot load compressed-textures in " + resource.url + ", make sure you provide a fallback"));
-                  return;
-              }
-              if (textureURL === resource.url) {
-                  // Prevent infinite loops
-                  next(new Error('URL of compressed texture cannot be the same as the manifest\'s URL'));
-                  return;
-              }
-              var loadOptions = {
-                  crossOrigin: resource.crossOrigin,
-                  metadata: resource.metadata.imageMetadata,
-                  parentResource: resource
-              };
-              var resourcePath = url.resolve(resource.url.replace(loader.baseUrl, ''), textureURL);
-              var resourceName = data.cacheID;
-              // The appropriate loader should register the texture
-              loader.add(resourceName, resourcePath, loadOptions, function (res) {
-                  if (res.error) {
-                      next(res.error);
-                      return;
-                  }
-                  var _a = res.texture, texture = _a === void 0 ? null : _a, _b = res.textures, textures = _b === void 0 ? {} : _b;
-                  // Make sure texture/textures is assigned to parent resource
-                  Object.assign(resource, { texture: texture, textures: textures });
-                  // Pass along any error
-                  next();
-              });
-          }
-          else {
-              next();
-          }
-      };
-      Object.defineProperty(CompressedTextureLoader, "textureExtensions", {
-          /**  Map of available texture extensions. */
-          get: function () {
-              if (!CompressedTextureLoader._textureExtensions) {
-                  // Auto-detect WebGL compressed-texture extensions
-                  var canvas = settings.ADAPTER.createCanvas();
-                  var gl = canvas.getContext('webgl');
-                  if (!gl) {
-                      console.warn('WebGL not available for compressed textures. Silently failing.');
-                      return {};
-                  }
-                  var extensions = {
-                      s3tc: gl.getExtension('WEBGL_compressed_texture_s3tc'),
-                      s3tc_sRGB: gl.getExtension('WEBGL_compressed_texture_s3tc_srgb'),
-                      etc: gl.getExtension('WEBGL_compressed_texture_etc'),
-                      etc1: gl.getExtension('WEBGL_compressed_texture_etc1'),
-                      pvrtc: gl.getExtension('WEBGL_compressed_texture_pvrtc')
-                          || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc'),
-                      atc: gl.getExtension('WEBGL_compressed_texture_atc'),
-                      astc: gl.getExtension('WEBGL_compressed_texture_astc')
-                  };
-                  CompressedTextureLoader._textureExtensions = extensions;
-              }
-              return CompressedTextureLoader._textureExtensions;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(CompressedTextureLoader, "textureFormats", {
-          /** Map of available texture formats. */
-          get: function () {
-              if (!CompressedTextureLoader._textureFormats) {
-                  var extensions = CompressedTextureLoader.textureExtensions;
-                  CompressedTextureLoader._textureFormats = {};
-                  // Assign all available compressed-texture formats
-                  for (var extensionName in extensions) {
-                      var extension = extensions[extensionName];
-                      if (!extension) {
-                          continue;
-                      }
-                      Object.assign(CompressedTextureLoader._textureFormats, Object.getPrototypeOf(extension));
-                  }
-              }
-              return CompressedTextureLoader._textureFormats;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** @ignore */
-      CompressedTextureLoader.extension = exports.ExtensionType.Loader;
-      return CompressedTextureLoader;
-  }());
-
-  /**
-   * Creates base-textures and textures for each compressed-texture resource and adds them into the global
-   * texture cache. The first texture has two IDs - `${url}`, `${url}-1`; while the rest have an ID of the
-   * form `${url}-i`.
-   * @param url - the original address of the resources
-   * @param resources - the resources backing texture data
-   * @ignore
-   */
-  function registerCompressedTextures(url, resources, metadata) {
-      var result = {
-          textures: {},
-          texture: null,
-      };
-      if (!resources) {
-          return result;
-      }
-      var textures = resources.map(function (resource) {
-          return (new Texture(new BaseTexture(resource, Object.assign({
-              mipmap: exports.MIPMAP_MODES.OFF,
-              alphaMode: exports.ALPHA_MODES.NO_PREMULTIPLIED_ALPHA
-          }, metadata))));
-      });
-      textures.forEach(function (texture, i) {
-          var baseTexture = texture.baseTexture;
-          var cacheID = url + "-" + (i + 1);
-          BaseTexture.addToCache(baseTexture, cacheID);
-          Texture.addToCache(texture, cacheID);
-          if (i === 0) {
-              BaseTexture.addToCache(baseTexture, url);
-              Texture.addToCache(texture, url);
-              result.texture = texture;
-          }
-          result.textures[cacheID] = texture;
-      });
-      return result;
-  }
-
-  var _a$1, _b$1;
-  var DDS_MAGIC_SIZE = 4;
-  var DDS_HEADER_SIZE = 124;
-  var DDS_HEADER_PF_SIZE = 32;
-  var DDS_HEADER_DX10_SIZE = 20;
-  // DDS file format magic word
-  var DDS_MAGIC = 0x20534444;
-  /**
-   * DWORD offsets of the DDS file header fields (relative to file start).
-   * @ignore
-   */
-  var DDS_FIELDS = {
-      SIZE: 1,
-      FLAGS: 2,
-      HEIGHT: 3,
-      WIDTH: 4,
-      MIPMAP_COUNT: 7,
-      PIXEL_FORMAT: 19,
-  };
-  /**
-   * DWORD offsets of the DDS PIXEL_FORMAT fields.
-   * @ignore
-   */
-  var DDS_PF_FIELDS = {
-      SIZE: 0,
-      FLAGS: 1,
-      FOURCC: 2,
-      RGB_BITCOUNT: 3,
-      R_BIT_MASK: 4,
-      G_BIT_MASK: 5,
-      B_BIT_MASK: 6,
-      A_BIT_MASK: 7
-  };
-  /**
-   * DWORD offsets of the DDS_HEADER_DX10 fields.
-   * @ignore
-   */
-  var DDS_DX10_FIELDS = {
-      DXGI_FORMAT: 0,
-      RESOURCE_DIMENSION: 1,
-      MISC_FLAG: 2,
-      ARRAY_SIZE: 3,
-      MISC_FLAGS2: 4
-  };
-  /**
-   * @see https://docs.microsoft.com/en-us/windows/win32/api/dxgiformat/ne-dxgiformat-dxgi_format
-   * @ignore
-   */
-  // This is way over-blown for us! Lend us a hand, and remove the ones that aren't used (but set the remaining
-  // ones to their correct value)
-  var DXGI_FORMAT;
-  (function (DXGI_FORMAT) {
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_UNKNOWN"] = 0] = "DXGI_FORMAT_UNKNOWN";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_TYPELESS"] = 1] = "DXGI_FORMAT_R32G32B32A32_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_FLOAT"] = 2] = "DXGI_FORMAT_R32G32B32A32_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_UINT"] = 3] = "DXGI_FORMAT_R32G32B32A32_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32A32_SINT"] = 4] = "DXGI_FORMAT_R32G32B32A32_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_TYPELESS"] = 5] = "DXGI_FORMAT_R32G32B32_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_FLOAT"] = 6] = "DXGI_FORMAT_R32G32B32_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_UINT"] = 7] = "DXGI_FORMAT_R32G32B32_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32B32_SINT"] = 8] = "DXGI_FORMAT_R32G32B32_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_TYPELESS"] = 9] = "DXGI_FORMAT_R16G16B16A16_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_FLOAT"] = 10] = "DXGI_FORMAT_R16G16B16A16_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_UNORM"] = 11] = "DXGI_FORMAT_R16G16B16A16_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_UINT"] = 12] = "DXGI_FORMAT_R16G16B16A16_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_SNORM"] = 13] = "DXGI_FORMAT_R16G16B16A16_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16B16A16_SINT"] = 14] = "DXGI_FORMAT_R16G16B16A16_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_TYPELESS"] = 15] = "DXGI_FORMAT_R32G32_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_FLOAT"] = 16] = "DXGI_FORMAT_R32G32_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_UINT"] = 17] = "DXGI_FORMAT_R32G32_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G32_SINT"] = 18] = "DXGI_FORMAT_R32G32_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32G8X24_TYPELESS"] = 19] = "DXGI_FORMAT_R32G8X24_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D32_FLOAT_S8X24_UINT"] = 20] = "DXGI_FORMAT_D32_FLOAT_S8X24_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS"] = 21] = "DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_X32_TYPELESS_G8X24_UINT"] = 22] = "DXGI_FORMAT_X32_TYPELESS_G8X24_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10A2_TYPELESS"] = 23] = "DXGI_FORMAT_R10G10B10A2_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10A2_UNORM"] = 24] = "DXGI_FORMAT_R10G10B10A2_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10A2_UINT"] = 25] = "DXGI_FORMAT_R10G10B10A2_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R11G11B10_FLOAT"] = 26] = "DXGI_FORMAT_R11G11B10_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_TYPELESS"] = 27] = "DXGI_FORMAT_R8G8B8A8_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_UNORM"] = 28] = "DXGI_FORMAT_R8G8B8A8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_UNORM_SRGB"] = 29] = "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_UINT"] = 30] = "DXGI_FORMAT_R8G8B8A8_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_SNORM"] = 31] = "DXGI_FORMAT_R8G8B8A8_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8B8A8_SINT"] = 32] = "DXGI_FORMAT_R8G8B8A8_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_TYPELESS"] = 33] = "DXGI_FORMAT_R16G16_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_FLOAT"] = 34] = "DXGI_FORMAT_R16G16_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_UNORM"] = 35] = "DXGI_FORMAT_R16G16_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_UINT"] = 36] = "DXGI_FORMAT_R16G16_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_SNORM"] = 37] = "DXGI_FORMAT_R16G16_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16G16_SINT"] = 38] = "DXGI_FORMAT_R16G16_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_TYPELESS"] = 39] = "DXGI_FORMAT_R32_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D32_FLOAT"] = 40] = "DXGI_FORMAT_D32_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_FLOAT"] = 41] = "DXGI_FORMAT_R32_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_UINT"] = 42] = "DXGI_FORMAT_R32_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R32_SINT"] = 43] = "DXGI_FORMAT_R32_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R24G8_TYPELESS"] = 44] = "DXGI_FORMAT_R24G8_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D24_UNORM_S8_UINT"] = 45] = "DXGI_FORMAT_D24_UNORM_S8_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R24_UNORM_X8_TYPELESS"] = 46] = "DXGI_FORMAT_R24_UNORM_X8_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_X24_TYPELESS_G8_UINT"] = 47] = "DXGI_FORMAT_X24_TYPELESS_G8_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_TYPELESS"] = 48] = "DXGI_FORMAT_R8G8_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_UNORM"] = 49] = "DXGI_FORMAT_R8G8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_UINT"] = 50] = "DXGI_FORMAT_R8G8_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_SNORM"] = 51] = "DXGI_FORMAT_R8G8_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_SINT"] = 52] = "DXGI_FORMAT_R8G8_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_TYPELESS"] = 53] = "DXGI_FORMAT_R16_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_FLOAT"] = 54] = "DXGI_FORMAT_R16_FLOAT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_D16_UNORM"] = 55] = "DXGI_FORMAT_D16_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_UNORM"] = 56] = "DXGI_FORMAT_R16_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_UINT"] = 57] = "DXGI_FORMAT_R16_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_SNORM"] = 58] = "DXGI_FORMAT_R16_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R16_SINT"] = 59] = "DXGI_FORMAT_R16_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_TYPELESS"] = 60] = "DXGI_FORMAT_R8_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_UNORM"] = 61] = "DXGI_FORMAT_R8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_UINT"] = 62] = "DXGI_FORMAT_R8_UINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_SNORM"] = 63] = "DXGI_FORMAT_R8_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8_SINT"] = 64] = "DXGI_FORMAT_R8_SINT";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_A8_UNORM"] = 65] = "DXGI_FORMAT_A8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R1_UNORM"] = 66] = "DXGI_FORMAT_R1_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R9G9B9E5_SHAREDEXP"] = 67] = "DXGI_FORMAT_R9G9B9E5_SHAREDEXP";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R8G8_B8G8_UNORM"] = 68] = "DXGI_FORMAT_R8G8_B8G8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_G8R8_G8B8_UNORM"] = 69] = "DXGI_FORMAT_G8R8_G8B8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC1_TYPELESS"] = 70] = "DXGI_FORMAT_BC1_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC1_UNORM"] = 71] = "DXGI_FORMAT_BC1_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC1_UNORM_SRGB"] = 72] = "DXGI_FORMAT_BC1_UNORM_SRGB";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC2_TYPELESS"] = 73] = "DXGI_FORMAT_BC2_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC2_UNORM"] = 74] = "DXGI_FORMAT_BC2_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC2_UNORM_SRGB"] = 75] = "DXGI_FORMAT_BC2_UNORM_SRGB";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC3_TYPELESS"] = 76] = "DXGI_FORMAT_BC3_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC3_UNORM"] = 77] = "DXGI_FORMAT_BC3_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC3_UNORM_SRGB"] = 78] = "DXGI_FORMAT_BC3_UNORM_SRGB";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC4_TYPELESS"] = 79] = "DXGI_FORMAT_BC4_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC4_UNORM"] = 80] = "DXGI_FORMAT_BC4_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC4_SNORM"] = 81] = "DXGI_FORMAT_BC4_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC5_TYPELESS"] = 82] = "DXGI_FORMAT_BC5_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC5_UNORM"] = 83] = "DXGI_FORMAT_BC5_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC5_SNORM"] = 84] = "DXGI_FORMAT_BC5_SNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B5G6R5_UNORM"] = 85] = "DXGI_FORMAT_B5G6R5_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B5G5R5A1_UNORM"] = 86] = "DXGI_FORMAT_B5G5R5A1_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8A8_UNORM"] = 87] = "DXGI_FORMAT_B8G8R8A8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8X8_UNORM"] = 88] = "DXGI_FORMAT_B8G8R8X8_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM"] = 89] = "DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8A8_TYPELESS"] = 90] = "DXGI_FORMAT_B8G8R8A8_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8A8_UNORM_SRGB"] = 91] = "DXGI_FORMAT_B8G8R8A8_UNORM_SRGB";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8X8_TYPELESS"] = 92] = "DXGI_FORMAT_B8G8R8X8_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B8G8R8X8_UNORM_SRGB"] = 93] = "DXGI_FORMAT_B8G8R8X8_UNORM_SRGB";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC6H_TYPELESS"] = 94] = "DXGI_FORMAT_BC6H_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC6H_UF16"] = 95] = "DXGI_FORMAT_BC6H_UF16";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC6H_SF16"] = 96] = "DXGI_FORMAT_BC6H_SF16";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC7_TYPELESS"] = 97] = "DXGI_FORMAT_BC7_TYPELESS";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC7_UNORM"] = 98] = "DXGI_FORMAT_BC7_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_BC7_UNORM_SRGB"] = 99] = "DXGI_FORMAT_BC7_UNORM_SRGB";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_AYUV"] = 100] = "DXGI_FORMAT_AYUV";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y410"] = 101] = "DXGI_FORMAT_Y410";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y416"] = 102] = "DXGI_FORMAT_Y416";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_NV12"] = 103] = "DXGI_FORMAT_NV12";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P010"] = 104] = "DXGI_FORMAT_P010";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P016"] = 105] = "DXGI_FORMAT_P016";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_420_OPAQUE"] = 106] = "DXGI_FORMAT_420_OPAQUE";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_YUY2"] = 107] = "DXGI_FORMAT_YUY2";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y210"] = 108] = "DXGI_FORMAT_Y210";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_Y216"] = 109] = "DXGI_FORMAT_Y216";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_NV11"] = 110] = "DXGI_FORMAT_NV11";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_AI44"] = 111] = "DXGI_FORMAT_AI44";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_IA44"] = 112] = "DXGI_FORMAT_IA44";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P8"] = 113] = "DXGI_FORMAT_P8";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_A8P8"] = 114] = "DXGI_FORMAT_A8P8";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_B4G4R4A4_UNORM"] = 115] = "DXGI_FORMAT_B4G4R4A4_UNORM";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_P208"] = 116] = "DXGI_FORMAT_P208";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_V208"] = 117] = "DXGI_FORMAT_V208";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_V408"] = 118] = "DXGI_FORMAT_V408";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE"] = 119] = "DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE"] = 120] = "DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE";
-      DXGI_FORMAT[DXGI_FORMAT["DXGI_FORMAT_FORCE_UINT"] = 121] = "DXGI_FORMAT_FORCE_UINT";
-  })(DXGI_FORMAT || (DXGI_FORMAT = {}));
-  /**
-   * Possible values of the field {@link DDS_DX10_FIELDS.RESOURCE_DIMENSION}
-   * @ignore
-   */
-  var D3D10_RESOURCE_DIMENSION;
-  (function (D3D10_RESOURCE_DIMENSION) {
-      D3D10_RESOURCE_DIMENSION[D3D10_RESOURCE_DIMENSION["DDS_DIMENSION_TEXTURE1D"] = 2] = "DDS_DIMENSION_TEXTURE1D";
-      D3D10_RESOURCE_DIMENSION[D3D10_RESOURCE_DIMENSION["DDS_DIMENSION_TEXTURE2D"] = 3] = "DDS_DIMENSION_TEXTURE2D";
-      D3D10_RESOURCE_DIMENSION[D3D10_RESOURCE_DIMENSION["DDS_DIMENSION_TEXTURE3D"] = 6] = "DDS_DIMENSION_TEXTURE3D";
-  })(D3D10_RESOURCE_DIMENSION || (D3D10_RESOURCE_DIMENSION = {}));
-  var PF_FLAGS = 1;
-  // PIXEL_FORMAT flags
-  var DDPF_ALPHA = 0x2;
-  var DDPF_FOURCC = 0x4;
-  var DDPF_RGB = 0x40;
-  var DDPF_YUV = 0x200;
-  var DDPF_LUMINANCE = 0x20000;
-  // Four character codes for DXTn formats
-  var FOURCC_DXT1 = 0x31545844;
-  var FOURCC_DXT3 = 0x33545844;
-  var FOURCC_DXT5 = 0x35545844;
-  var FOURCC_DX10 = 0x30315844;
-  // Cubemap texture flag (for DDS_DX10_FIELDS.MISC_FLAG)
-  var DDS_RESOURCE_MISC_TEXTURECUBE = 0x4;
-  /**
-   * Maps `FOURCC_*` formats to internal formats (see {@link PIXI.INTERNAL_FORMATS}).
-   * @ignore
-   */
-  var FOURCC_TO_FORMAT = (_a$1 = {},
-      _a$1[FOURCC_DXT1] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
-      _a$1[FOURCC_DXT3] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-      _a$1[FOURCC_DXT5] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-      _a$1);
-  /**
-   * Maps {@link DXGI_FORMAT} to types/internal-formats (see {@link PIXI.TYPES}, {@link PIXI.INTERNAL_FORMATS})
-   * @ignore
-   */
-  var DXGI_TO_FORMAT = (_b$1 = {},
-      // WEBGL_compressed_texture_s3tc
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC1_TYPELESS] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC2_TYPELESS] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC3_TYPELESS] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM] = exports.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-      // WEBGL_compressed_texture_s3tc_srgb
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM_SRGB] = exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM_SRGB] = exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
-      _b$1[DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM_SRGB] = exports.INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
-      _b$1);
-  /**
-   * @class
-   * @memberof PIXI
-   * @implements {PIXI.ILoaderPlugin}
-   * @see https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide
-   */
-  /**
-   * Parses the DDS file header, generates base-textures, and puts them into the texture cache.
-   * @param arrayBuffer
-   */
-  function parseDDS(arrayBuffer) {
-      var data = new Uint32Array(arrayBuffer);
-      var magicWord = data[0];
-      if (magicWord !== DDS_MAGIC) {
-          throw new Error('Invalid DDS file magic word');
-      }
-      var header = new Uint32Array(arrayBuffer, 0, DDS_HEADER_SIZE / Uint32Array.BYTES_PER_ELEMENT);
-      // DDS header fields
-      var height = header[DDS_FIELDS.HEIGHT];
-      var width = header[DDS_FIELDS.WIDTH];
-      var mipmapCount = header[DDS_FIELDS.MIPMAP_COUNT];
-      // PIXEL_FORMAT fields
-      var pixelFormat = new Uint32Array(arrayBuffer, DDS_FIELDS.PIXEL_FORMAT * Uint32Array.BYTES_PER_ELEMENT, DDS_HEADER_PF_SIZE / Uint32Array.BYTES_PER_ELEMENT);
-      var formatFlags = pixelFormat[PF_FLAGS];
-      // File contains compressed texture(s)
-      if (formatFlags & DDPF_FOURCC) {
-          var fourCC = pixelFormat[DDS_PF_FIELDS.FOURCC];
-          // File contains one DXTn compressed texture
-          if (fourCC !== FOURCC_DX10) {
-              var internalFormat_1 = FOURCC_TO_FORMAT[fourCC];
-              var dataOffset_1 = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;
-              var texData = new Uint8Array(arrayBuffer, dataOffset_1);
-              var resource = new CompressedTextureResource(texData, {
-                  format: internalFormat_1,
-                  width: width,
-                  height: height,
-                  levels: mipmapCount // CompressedTextureResource will separate the levelBuffers for us!
-              });
-              return [resource];
-          }
-          // FOURCC_DX10 indicates there is a 20-byte DDS_HEADER_DX10 after DDS_HEADER
-          var dx10Offset = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;
-          var dx10Header = new Uint32Array(data.buffer, dx10Offset, DDS_HEADER_DX10_SIZE / Uint32Array.BYTES_PER_ELEMENT);
-          var dxgiFormat = dx10Header[DDS_DX10_FIELDS.DXGI_FORMAT];
-          var resourceDimension = dx10Header[DDS_DX10_FIELDS.RESOURCE_DIMENSION];
-          var miscFlag = dx10Header[DDS_DX10_FIELDS.MISC_FLAG];
-          var arraySize = dx10Header[DDS_DX10_FIELDS.ARRAY_SIZE];
-          // Map dxgiFormat to PIXI.INTERNAL_FORMATS
-          var internalFormat_2 = DXGI_TO_FORMAT[dxgiFormat];
-          if (internalFormat_2 === undefined) {
-              throw new Error("DDSParser cannot parse texture data with DXGI format " + dxgiFormat);
-          }
-          if (miscFlag === DDS_RESOURCE_MISC_TEXTURECUBE) {
-              // FIXME: Anybody excited about cubemap compressed textures?
-              throw new Error('DDSParser does not support cubemap textures');
-          }
-          if (resourceDimension === D3D10_RESOURCE_DIMENSION.DDS_DIMENSION_TEXTURE3D) {
-              // FIXME: Anybody excited about 3D compressed textures?
-              throw new Error('DDSParser does not supported 3D texture data');
-          }
-          // Uint8Array buffers of image data, including all mipmap levels in each image
-          var imageBuffers = new Array();
-          var dataOffset = DDS_MAGIC_SIZE
-              + DDS_HEADER_SIZE
-              + DDS_HEADER_DX10_SIZE;
-          if (arraySize === 1) {
-              // No need bothering with the imageSize calculation!
-              imageBuffers.push(new Uint8Array(arrayBuffer, dataOffset));
-          }
-          else {
-              // Calculate imageSize for each texture, and then locate each image's texture data
-              var pixelSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[internalFormat_2];
-              var imageSize = 0;
-              var levelWidth = width;
-              var levelHeight = height;
-              for (var i = 0; i < mipmapCount; i++) {
-                  var alignedLevelWidth = Math.max(1, (levelWidth + 3) & ~3);
-                  var alignedLevelHeight = Math.max(1, (levelHeight + 3) & ~3);
-                  var levelSize = alignedLevelWidth * alignedLevelHeight * pixelSize;
-                  imageSize += levelSize;
-                  levelWidth = levelWidth >>> 1;
-                  levelHeight = levelHeight >>> 1;
-              }
-              var imageOffset = dataOffset;
-              // NOTE: Cubemaps have 6-images per texture (but they aren't supported so ^_^)
-              for (var i = 0; i < arraySize; i++) {
-                  imageBuffers.push(new Uint8Array(arrayBuffer, imageOffset, imageSize));
-                  imageOffset += imageSize;
-              }
-          }
-          // Uint8Array -> CompressedTextureResource, and we're done!
-          return imageBuffers.map(function (buffer) { return new CompressedTextureResource(buffer, {
-              format: internalFormat_2,
-              width: width,
-              height: height,
-              levels: mipmapCount
-          }); });
-      }
-      if (formatFlags & DDPF_RGB) {
-          // FIXME: We might want to allow uncompressed *.dds files?
-          throw new Error('DDSParser does not support uncompressed texture data.');
-      }
-      if (formatFlags & DDPF_YUV) {
-          // FIXME: Does anybody need this feature?
-          throw new Error('DDSParser does not supported YUV uncompressed texture data.');
-      }
-      if (formatFlags & DDPF_LUMINANCE) {
-          // FIXME: Microsoft says older DDS filers use this feature! Probably not worth the effort!
-          throw new Error('DDSParser does not support single-channel (lumninance) texture data!');
-      }
-      if (formatFlags & DDPF_ALPHA) {
-          // FIXME: I'm tired! See above =)
-          throw new Error('DDSParser does not support single-channel (alpha) texture data!');
-      }
-      throw new Error('DDSParser failed to load a texture file due to an unknown reason!');
-  }
-
-  var _a$3, _b, _c;
-  /**
-   * The 12-byte KTX file identifier
-   * @see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/#2.1
-   * @ignore
-   */
-  var FILE_IDENTIFIER = [0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A];
-  /**
-   * The value stored in the "endianness" field.
-   * @see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/#2.2
-   * @ignore
-   */
-  var ENDIANNESS = 0x04030201;
-  /**
-   * Byte offsets of the KTX file header fields
-   * @ignore
-   */
-  var KTX_FIELDS = {
-      FILE_IDENTIFIER: 0,
-      ENDIANNESS: 12,
-      GL_TYPE: 16,
-      GL_TYPE_SIZE: 20,
-      GL_FORMAT: 24,
-      GL_INTERNAL_FORMAT: 28,
-      GL_BASE_INTERNAL_FORMAT: 32,
-      PIXEL_WIDTH: 36,
-      PIXEL_HEIGHT: 40,
-      PIXEL_DEPTH: 44,
-      NUMBER_OF_ARRAY_ELEMENTS: 48,
-      NUMBER_OF_FACES: 52,
-      NUMBER_OF_MIPMAP_LEVELS: 56,
-      BYTES_OF_KEY_VALUE_DATA: 60
-  };
-  /**
-   * Byte size of the file header fields in {@code KTX_FIELDS}
-   * @ignore
-   */
-  var FILE_HEADER_SIZE = 64;
-  /**
-   * Maps {@link PIXI.TYPES} to the bytes taken per component, excluding those ones that are bit-fields.
-   * @ignore
-   */
-  var TYPES_TO_BYTES_PER_COMPONENT = (_a$3 = {},
-      _a$3[exports.TYPES.UNSIGNED_BYTE] = 1,
-      _a$3[exports.TYPES.UNSIGNED_SHORT] = 2,
-      _a$3[exports.TYPES.INT] = 4,
-      _a$3[exports.TYPES.UNSIGNED_INT] = 4,
-      _a$3[exports.TYPES.FLOAT] = 4,
-      _a$3[exports.TYPES.HALF_FLOAT] = 8,
-      _a$3);
-  /**
-   * Number of components in each {@link PIXI.FORMATS}
-   * @ignore
-   */
-  var FORMATS_TO_COMPONENTS = (_b = {},
-      _b[exports.FORMATS.RGBA] = 4,
-      _b[exports.FORMATS.RGB] = 3,
-      _b[exports.FORMATS.RG] = 2,
-      _b[exports.FORMATS.RED] = 1,
-      _b[exports.FORMATS.LUMINANCE] = 1,
-      _b[exports.FORMATS.LUMINANCE_ALPHA] = 2,
-      _b[exports.FORMATS.ALPHA] = 1,
-      _b);
-  /**
-   * Number of bytes per pixel in bit-field types in {@link PIXI.TYPES}
-   * @ignore
-   */
-  var TYPES_TO_BYTES_PER_PIXEL = (_c = {},
-      _c[exports.TYPES.UNSIGNED_SHORT_4_4_4_4] = 2,
-      _c[exports.TYPES.UNSIGNED_SHORT_5_5_5_1] = 2,
-      _c[exports.TYPES.UNSIGNED_SHORT_5_6_5] = 2,
-      _c);
-  function parseKTX(url, arrayBuffer, loadKeyValueData) {
-      if (loadKeyValueData === void 0) { loadKeyValueData = false; }
-      var dataView = new DataView(arrayBuffer);
-      if (!validate(url, dataView)) {
-          return null;
-      }
-      var littleEndian = dataView.getUint32(KTX_FIELDS.ENDIANNESS, true) === ENDIANNESS;
-      var glType = dataView.getUint32(KTX_FIELDS.GL_TYPE, littleEndian);
-      // const glTypeSize = dataView.getUint32(KTX_FIELDS.GL_TYPE_SIZE, littleEndian);
-      var glFormat = dataView.getUint32(KTX_FIELDS.GL_FORMAT, littleEndian);
-      var glInternalFormat = dataView.getUint32(KTX_FIELDS.GL_INTERNAL_FORMAT, littleEndian);
-      var pixelWidth = dataView.getUint32(KTX_FIELDS.PIXEL_WIDTH, littleEndian);
-      var pixelHeight = dataView.getUint32(KTX_FIELDS.PIXEL_HEIGHT, littleEndian) || 1; // "pixelHeight = 0" -> "1"
-      var pixelDepth = dataView.getUint32(KTX_FIELDS.PIXEL_DEPTH, littleEndian) || 1; // ^^
-      var numberOfArrayElements = dataView.getUint32(KTX_FIELDS.NUMBER_OF_ARRAY_ELEMENTS, littleEndian) || 1; // ^^
-      var numberOfFaces = dataView.getUint32(KTX_FIELDS.NUMBER_OF_FACES, littleEndian);
-      var numberOfMipmapLevels = dataView.getUint32(KTX_FIELDS.NUMBER_OF_MIPMAP_LEVELS, littleEndian);
-      var bytesOfKeyValueData = dataView.getUint32(KTX_FIELDS.BYTES_OF_KEY_VALUE_DATA, littleEndian);
-      // Whether the platform architecture is little endian. If littleEndian !== platformLittleEndian, then the
-      // file contents must be endian-converted!
-      // TODO: Endianness conversion
-      // const platformLittleEndian = new Uint8Array((new Uint32Array([ENDIANNESS])).buffer)[0] === 0x01;
-      if (pixelHeight === 0 || pixelDepth !== 1) {
-          throw new Error('Only 2D textures are supported');
-      }
-      if (numberOfFaces !== 1) {
-          throw new Error('CubeTextures are not supported by KTXLoader yet!');
-      }
-      if (numberOfArrayElements !== 1) {
-          // TODO: Support splitting array-textures into multiple BaseTextures
-          throw new Error('WebGL does not support array textures');
-      }
-      // TODO: 8x4 blocks for 2bpp pvrtc
-      var blockWidth = 4;
-      var blockHeight = 4;
-      var alignedWidth = (pixelWidth + 3) & ~3;
-      var alignedHeight = (pixelHeight + 3) & ~3;
-      var imageBuffers = new Array(numberOfArrayElements);
-      var imagePixels = pixelWidth * pixelHeight;
-      if (glType === 0) {
-          // Align to 16 pixels (4x4 blocks)
-          imagePixels = alignedWidth * alignedHeight;
-      }
-      var imagePixelByteSize;
-      if (glType !== 0) {
-          // Uncompressed texture format
-          if (TYPES_TO_BYTES_PER_COMPONENT[glType]) {
-              imagePixelByteSize = TYPES_TO_BYTES_PER_COMPONENT[glType] * FORMATS_TO_COMPONENTS[glFormat];
-          }
-          else {
-              imagePixelByteSize = TYPES_TO_BYTES_PER_PIXEL[glType];
-          }
-      }
-      else {
-          imagePixelByteSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[glInternalFormat];
-      }
-      if (imagePixelByteSize === undefined) {
-          throw new Error('Unable to resolve the pixel format stored in the *.ktx file!');
-      }
-      var kvData = loadKeyValueData
-          ? parseKvData(dataView, bytesOfKeyValueData, littleEndian)
-          : null;
-      var imageByteSize = imagePixels * imagePixelByteSize;
-      var mipByteSize = imageByteSize;
-      var mipWidth = pixelWidth;
-      var mipHeight = pixelHeight;
-      var alignedMipWidth = alignedWidth;
-      var alignedMipHeight = alignedHeight;
-      var imageOffset = FILE_HEADER_SIZE + bytesOfKeyValueData;
-      for (var mipmapLevel = 0; mipmapLevel < numberOfMipmapLevels; mipmapLevel++) {
-          var imageSize = dataView.getUint32(imageOffset, littleEndian);
-          var elementOffset = imageOffset + 4;
-          for (var arrayElement = 0; arrayElement < numberOfArrayElements; arrayElement++) {
-              // TODO: Maybe support 3D textures? :-)
-              // for (let zSlice = 0; zSlice < pixelDepth; zSlice)
-              var mips = imageBuffers[arrayElement];
-              if (!mips) {
-                  mips = imageBuffers[arrayElement] = new Array(numberOfMipmapLevels);
-              }
-              mips[mipmapLevel] = {
-                  levelID: mipmapLevel,
-                  // don't align mipWidth when texture not compressed! (glType not zero)
-                  levelWidth: numberOfMipmapLevels > 1 || glType !== 0 ? mipWidth : alignedMipWidth,
-                  levelHeight: numberOfMipmapLevels > 1 || glType !== 0 ? mipHeight : alignedMipHeight,
-                  levelBuffer: new Uint8Array(arrayBuffer, elementOffset, mipByteSize)
-              };
-              elementOffset += mipByteSize;
-          }
-          // HINT: Aligns to 4-byte boundary after jumping imageSize (in lieu of mipPadding)
-          imageOffset += imageSize + 4; // (+4 to jump the imageSize field itself)
-          imageOffset = imageOffset % 4 !== 0 ? imageOffset + 4 - (imageOffset % 4) : imageOffset;
-          // Calculate mipWidth, mipHeight for _next_ iteration
-          mipWidth = (mipWidth >> 1) || 1;
-          mipHeight = (mipHeight >> 1) || 1;
-          alignedMipWidth = (mipWidth + blockWidth - 1) & ~(blockWidth - 1);
-          alignedMipHeight = (mipHeight + blockHeight - 1) & ~(blockHeight - 1);
-          // Each mipmap level is 4-times smaller?
-          mipByteSize = alignedMipWidth * alignedMipHeight * imagePixelByteSize;
-      }
-      // We use the levelBuffers feature of CompressedTextureResource b/c texture data is image-major, not level-major.
-      if (glType !== 0) {
-          return {
-              uncompressed: imageBuffers.map(function (levelBuffers) {
-                  var buffer = levelBuffers[0].levelBuffer;
-                  var convertToInt = false;
-                  if (glType === exports.TYPES.FLOAT) {
-                      buffer = new Float32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
-                  }
-                  else if (glType === exports.TYPES.UNSIGNED_INT) {
-                      convertToInt = true;
-                      buffer = new Uint32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
-                  }
-                  else if (glType === exports.TYPES.INT) {
-                      convertToInt = true;
-                      buffer = new Int32Array(levelBuffers[0].levelBuffer.buffer, levelBuffers[0].levelBuffer.byteOffset, levelBuffers[0].levelBuffer.byteLength / 4);
-                  }
-                  return {
-                      resource: new BufferResource(buffer, {
-                          width: levelBuffers[0].levelWidth,
-                          height: levelBuffers[0].levelHeight,
-                      }),
-                      type: glType,
-                      format: convertToInt ? convertFormatToInteger(glFormat) : glFormat,
-                  };
-              }),
-              kvData: kvData
-          };
-      }
-      return {
-          compressed: imageBuffers.map(function (levelBuffers) { return new CompressedTextureResource(null, {
-              format: glInternalFormat,
-              width: pixelWidth,
-              height: pixelHeight,
-              levels: numberOfMipmapLevels,
-              levelBuffers: levelBuffers,
-          }); }),
-          kvData: kvData
-      };
-  }
-  /**
-   * Checks whether the arrayBuffer contains a valid *.ktx file.
-   * @param url
-   * @param dataView
-   */
-  function validate(url, dataView) {
-      // NOTE: Do not optimize this into 3 32-bit integer comparison because the endianness
-      // of the data is not specified.
-      for (var i = 0; i < FILE_IDENTIFIER.length; i++) {
-          if (dataView.getUint8(i) !== FILE_IDENTIFIER[i]) {
-              console.error(url + " is not a valid *.ktx file!");
-              return false;
-          }
-      }
-      return true;
-  }
-  function convertFormatToInteger(format) {
-      switch (format) {
-          case exports.FORMATS.RGBA: return exports.FORMATS.RGBA_INTEGER;
-          case exports.FORMATS.RGB: return exports.FORMATS.RGB_INTEGER;
-          case exports.FORMATS.RG: return exports.FORMATS.RG_INTEGER;
-          case exports.FORMATS.RED: return exports.FORMATS.RED_INTEGER;
-          default: return format;
-      }
-  }
-  function parseKvData(dataView, bytesOfKeyValueData, littleEndian) {
-      var kvData = new Map();
-      var bytesIntoKeyValueData = 0;
-      while (bytesIntoKeyValueData < bytesOfKeyValueData) {
-          var keyAndValueByteSize = dataView.getUint32(FILE_HEADER_SIZE + bytesIntoKeyValueData, littleEndian);
-          var keyAndValueByteOffset = FILE_HEADER_SIZE + bytesIntoKeyValueData + 4;
-          var valuePadding = 3 - ((keyAndValueByteSize + 3) % 4);
-          // Bounds check
-          if (keyAndValueByteSize === 0 || keyAndValueByteSize > bytesOfKeyValueData - bytesIntoKeyValueData) {
-              console.error('KTXLoader: keyAndValueByteSize out of bounds');
-              break;
-          }
-          // Note: keyNulByte can't be 0 otherwise the key is an empty string.
-          var keyNulByte = 0;
-          for (; keyNulByte < keyAndValueByteSize; keyNulByte++) {
-              if (dataView.getUint8(keyAndValueByteOffset + keyNulByte) === 0x00) {
-                  break;
-              }
-          }
-          if (keyNulByte === -1) {
-              console.error('KTXLoader: Failed to find null byte terminating kvData key');
-              break;
-          }
-          var key = new TextDecoder().decode(new Uint8Array(dataView.buffer, keyAndValueByteOffset, keyNulByte));
-          var value = new DataView(dataView.buffer, keyAndValueByteOffset + keyNulByte + 1, keyAndValueByteSize - keyNulByte - 1);
-          kvData.set(key, value);
-          // 4 = the keyAndValueByteSize field itself
-          // keyAndValueByteSize = the bytes taken by the key and value
-          // valuePadding = extra padding to align with 4 bytes
-          bytesIntoKeyValueData += 4 + keyAndValueByteSize + valuePadding;
-      }
-      return kvData;
-  }
-
-  // Set DDS files to be loaded as an ArrayBuffer
-  exports.LoaderResource.setExtensionXhrType('dds', exports.LoaderResource.XHR_RESPONSE_TYPE.BUFFER);
-  /**
-   * @class
-   * @memberof PIXI
-   * @implements {PIXI.ILoaderPlugin}
-   * @see https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide
-   */
-  var DDSLoader = /** @class */ (function () {
-      function DDSLoader() {
-      }
-      /**
-       * Registers a DDS compressed texture
-       * @see PIXI.Loader.loaderMiddleware
-       * @param resource - loader resource that is checked to see if it is a DDS file
-       * @param next - callback Function to call when done
-       */
-      DDSLoader.use = function (resource, next) {
-          if (resource.extension === 'dds' && resource.data) {
-              try {
-                  Object.assign(resource, registerCompressedTextures(resource.name || resource.url, parseDDS(resource.data), resource.metadata));
-              }
-              catch (err) {
-                  next(err);
-                  return;
-              }
-          }
-          next();
-      };
-      /** @ignore */
-      DDSLoader.extension = exports.ExtensionType.Loader;
-      return DDSLoader;
-  }());
-
-  // Set KTX files to be loaded as an ArrayBuffer
-  exports.LoaderResource.setExtensionXhrType('ktx', exports.LoaderResource.XHR_RESPONSE_TYPE.BUFFER);
-  /**
-   * Loader plugin for handling KTX texture container files.
-   *
-   * This KTX loader does not currently support the following features:
-   * * cube textures
-   * * 3D textures
-   * * endianness conversion for big-endian machines
-   * * embedded *.basis files
-   *
-   * It does supports the following features:
-   * * multiple textures per file
-   * * mipmapping (only for compressed formats)
-   * * vendor-specific key/value data parsing (enable {@link PIXI.KTXLoader.loadKeyValueData})
-   * @class
-   * @memberof PIXI
-   * @implements {PIXI.ILoaderPlugin}
-   */
-  var KTXLoader = /** @class */ (function () {
-      function KTXLoader() {
-      }
-      /**
-       * Called after a KTX file is loaded.
-       *
-       * This will parse the KTX file header and add a {@code BaseTexture} to the texture
-       * cache.
-       * @see PIXI.Loader.loaderMiddleware
-       * @param resource - loader resource that is checked to see if it is a KTX file
-       * @param next - callback Function to call when done
-       */
-      KTXLoader.use = function (resource, next) {
-          if (resource.extension === 'ktx' && resource.data) {
-              try {
-                  var url_1 = resource.name || resource.url;
-                  var _a = parseKTX(url_1, resource.data, this.loadKeyValueData), compressed = _a.compressed, uncompressed = _a.uncompressed, kvData_1 = _a.kvData;
-                  if (compressed) {
-                      var result = registerCompressedTextures(url_1, compressed, resource.metadata);
-                      if (kvData_1 && result.textures) {
-                          for (var textureId in result.textures) {
-                              result.textures[textureId].baseTexture.ktxKeyValueData = kvData_1;
-                          }
-                      }
-                      Object.assign(resource, result);
-                  }
-                  else if (uncompressed) {
-                      var textures_1 = {};
-                      uncompressed.forEach(function (image, i) {
-                          var texture = new Texture(new BaseTexture(image.resource, {
-                              mipmap: exports.MIPMAP_MODES.OFF,
-                              alphaMode: exports.ALPHA_MODES.NO_PREMULTIPLIED_ALPHA,
-                              type: image.type,
-                              format: image.format,
-                          }));
-                          var cacheID = url_1 + "-" + (i + 1);
-                          if (kvData_1)
-                              { texture.baseTexture.ktxKeyValueData = kvData_1; }
-                          BaseTexture.addToCache(texture.baseTexture, cacheID);
-                          Texture.addToCache(texture, cacheID);
-                          if (i === 0) {
-                              textures_1[url_1] = texture;
-                              BaseTexture.addToCache(texture.baseTexture, url_1);
-                              Texture.addToCache(texture, url_1);
-                          }
-                          textures_1[cacheID] = texture;
-                      });
-                      Object.assign(resource, { textures: textures_1 });
-                  }
-              }
-              catch (err) {
-                  next(err);
-                  return;
-              }
-          }
-          next();
-      };
-      /** @ignore */
-      KTXLoader.extension = exports.ExtensionType.Loader;
-      /**
-       * If set to `true`, {@link PIXI.KTXLoader} will parse key-value data in KTX textures. This feature relies
-       * on the [Encoding Standard]{@link https://encoding.spec.whatwg.org}.
-       *
-       * The key-value data will be available on the base-textures as {@code PIXI.BaseTexture.ktxKeyValueData}. They
-       * will hold a reference to the texture data buffer, so make sure to delete key-value data once you are done
-       * using it.
-       */
-      KTXLoader.loadKeyValueData = false;
-      return KTXLoader;
-  }());
-
-  /*!
-   * @pixi/particle-container - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/particle-container is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$f = function(d, b) {
-      extendStatics$f = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$f(d, b);
-  };
-
-  function __extends$f(d, b) {
-      extendStatics$f(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * The ParticleContainer class is a really fast version of the Container built solely for speed,
-   * so use when you need a lot of sprites or particles.
-   *
-   * The tradeoff of the ParticleContainer is that most advanced functionality will not work.
-   * ParticleContainer implements the basic object transform (position, scale, rotation)
-   * and some advanced functionality like tint (as of v4.5.6).
-   *
-   * Other more advanced functionality like masking, children, filters, etc will not work on sprites in this batch.
-   *
-   * It's extremely easy to use:
-   * ```js
-   * let container = new ParticleContainer();
-   *
-   * for (let i = 0; i < 100; ++i)
-   * {
-   *     let sprite = PIXI.Sprite.from("myImage.png");
-   *     container.addChild(sprite);
-   * }
-   * ```
-   *
-   * And here you have a hundred sprites that will be rendered at the speed of light.
-   * @memberof PIXI
-   */
-  var ParticleContainer = /** @class */ (function (_super) {
-      __extends$f(ParticleContainer, _super);
-      /**
-       * @param maxSize - The maximum number of particles that can be rendered by the container.
-       *  Affects size of allocated buffers.
-       * @param properties - The properties of children that should be uploaded to the gpu and applied.
-       * @param {boolean} [properties.vertices=false] - When true, vertices be uploaded and applied.
-       *                  if sprite's ` scale/anchor/trim/frame/orig` is dynamic, please set `true`.
-       * @param {boolean} [properties.position=true] - When true, position be uploaded and applied.
-       * @param {boolean} [properties.rotation=false] - When true, rotation be uploaded and applied.
-       * @param {boolean} [properties.uvs=false] - When true, uvs be uploaded and applied.
-       * @param {boolean} [properties.tint=false] - When true, alpha and tint be uploaded and applied.
-       * @param {number} [batchSize=16384] - Number of particles per batch. If less than maxSize, it uses maxSize instead.
-       * @param {boolean} [autoResize=false] - If true, container allocates more batches in case
-       *  there are more than `maxSize` particles.
-       */
-      function ParticleContainer(maxSize, properties, batchSize, autoResize) {
-          if (maxSize === void 0) { maxSize = 1500; }
-          if (batchSize === void 0) { batchSize = 16384; }
-          if (autoResize === void 0) { autoResize = false; }
-          var _this = _super.call(this) || this;
-          // Making sure the batch size is valid
-          // 65535 is max vertex index in the index buffer (see ParticleRenderer)
-          // so max number of particles is 65536 / 4 = 16384
-          var maxBatchSize = 16384;
-          if (batchSize > maxBatchSize) {
-              batchSize = maxBatchSize;
-          }
-          _this._properties = [false, true, false, false, false];
-          _this._maxSize = maxSize;
-          _this._batchSize = batchSize;
-          _this._buffers = null;
-          _this._bufferUpdateIDs = [];
-          _this._updateID = 0;
-          _this.interactiveChildren = false;
-          _this.blendMode = exports.BLEND_MODES.NORMAL;
-          _this.autoResize = autoResize;
-          _this.roundPixels = true;
-          _this.baseTexture = null;
-          _this.setProperties(properties);
-          _this._tint = 0;
-          _this.tintRgb = new Float32Array(4);
-          _this.tint = 0xFFFFFF;
-          return _this;
-      }
-      /**
-       * Sets the private properties array to dynamic / static based on the passed properties object
-       * @param properties - The properties to be uploaded
-       */
-      ParticleContainer.prototype.setProperties = function (properties) {
-          if (properties) {
-              this._properties[0] = 'vertices' in properties || 'scale' in properties
-                  ? !!properties.vertices || !!properties.scale : this._properties[0];
-              this._properties[1] = 'position' in properties ? !!properties.position : this._properties[1];
-              this._properties[2] = 'rotation' in properties ? !!properties.rotation : this._properties[2];
-              this._properties[3] = 'uvs' in properties ? !!properties.uvs : this._properties[3];
-              this._properties[4] = 'tint' in properties || 'alpha' in properties
-                  ? !!properties.tint || !!properties.alpha : this._properties[4];
-          }
-      };
-      ParticleContainer.prototype.updateTransform = function () {
-          // TODO don't need to!
-          this.displayObjectUpdateTransform();
-      };
-      Object.defineProperty(ParticleContainer.prototype, "tint", {
-          /**
-           * The tint applied to the container. This is a hex value.
-           * A value of 0xFFFFFF will remove any tint effect.
-           * IMPORTANT: This is a WebGL only feature and will be ignored by the canvas renderer.
-           * @default 0xFFFFFF
-           */
-          get: function () {
-              return this._tint;
-          },
-          set: function (value) {
-              this._tint = value;
-              hex2rgb(value, this.tintRgb);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Renders the container using the WebGL renderer.
-       * @param renderer - The WebGL renderer.
-       */
-      ParticleContainer.prototype.render = function (renderer) {
-          var _this = this;
-          if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable) {
-              return;
-          }
-          if (!this.baseTexture) {
-              this.baseTexture = this.children[0]._texture.baseTexture;
-              if (!this.baseTexture.valid) {
-                  this.baseTexture.once('update', function () { return _this.onChildrenChange(0); });
-              }
-          }
-          renderer.batch.setObjectRenderer(renderer.plugins.particle);
-          renderer.plugins.particle.render(this);
-      };
-      /**
-       * Set the flag that static data should be updated to true
-       * @param smallestChildIndex - The smallest child index.
-       */
-      ParticleContainer.prototype.onChildrenChange = function (smallestChildIndex) {
-          var bufferIndex = Math.floor(smallestChildIndex / this._batchSize);
-          while (this._bufferUpdateIDs.length < bufferIndex) {
-              this._bufferUpdateIDs.push(0);
-          }
-          this._bufferUpdateIDs[bufferIndex] = ++this._updateID;
-      };
-      ParticleContainer.prototype.dispose = function () {
-          if (this._buffers) {
-              for (var i = 0; i < this._buffers.length; ++i) {
-                  this._buffers[i].destroy();
-              }
-              this._buffers = null;
-          }
-      };
-      /**
-       * Destroys the container
-       * @param options - Options parameter. A boolean will act as if all options
-       *  have been set to that value
-       * @param {boolean} [options.children=false] - if set to true, all the children will have their
-       *  destroy method called as well. 'options' will be passed on to those calls.
-       * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
-       *  Should it destroy the texture of the child sprite
-       * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
-       *  Should it destroy the base texture of the child sprite
-       */
-      ParticleContainer.prototype.destroy = function (options) {
-          _super.prototype.destroy.call(this, options);
-          this.dispose();
-          this._properties = null;
-          this._buffers = null;
-          this._bufferUpdateIDs = null;
-      };
-      return ParticleContainer;
-  }(Container));
-
-  /*
-   * @author Mat Groves
-   *
-   * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
-   * for creating the original PixiJS version!
-   * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that
-   * they now share 4 bytes on the vertex buffer
-   *
-   * Heavily inspired by LibGDX's ParticleBuffer:
-   * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleBuffer.java
-   */
-  /**
-   * The particle buffer manages the static and dynamic buffers for a particle container.
-   * @private
-   * @memberof PIXI
-   */
-  var ParticleBuffer = /** @class */ (function () {
-      /**
-       * @param {object} properties - The properties to upload.
-       * @param {boolean[]} dynamicPropertyFlags - Flags for which properties are dynamic.
-       * @param {number} size - The size of the batch.
-       */
-      function ParticleBuffer(properties, dynamicPropertyFlags, size) {
-          this.geometry = new Geometry();
-          this.indexBuffer = null;
-          this.size = size;
-          this.dynamicProperties = [];
-          this.staticProperties = [];
-          for (var i = 0; i < properties.length; ++i) {
-              var property = properties[i];
-              // Make copy of properties object so that when we edit the offset it doesn't
-              // change all other instances of the object literal
-              property = {
-                  attributeName: property.attributeName,
-                  size: property.size,
-                  uploadFunction: property.uploadFunction,
-                  type: property.type || exports.TYPES.FLOAT,
-                  offset: property.offset,
-              };
-              if (dynamicPropertyFlags[i]) {
-                  this.dynamicProperties.push(property);
-              }
-              else {
-                  this.staticProperties.push(property);
-              }
-          }
-          this.staticStride = 0;
-          this.staticBuffer = null;
-          this.staticData = null;
-          this.staticDataUint32 = null;
-          this.dynamicStride = 0;
-          this.dynamicBuffer = null;
-          this.dynamicData = null;
-          this.dynamicDataUint32 = null;
-          this._updateID = 0;
-          this.initBuffers();
-      }
-      /** Sets up the renderer context and necessary buffers. */
-      ParticleBuffer.prototype.initBuffers = function () {
-          var geometry = this.geometry;
-          var dynamicOffset = 0;
-          this.indexBuffer = new Buffer(createIndicesForQuads(this.size), true, true);
-          geometry.addIndex(this.indexBuffer);
-          this.dynamicStride = 0;
-          for (var i = 0; i < this.dynamicProperties.length; ++i) {
-              var property = this.dynamicProperties[i];
-              property.offset = dynamicOffset;
-              dynamicOffset += property.size;
-              this.dynamicStride += property.size;
-          }
-          var dynBuffer = new ArrayBuffer(this.size * this.dynamicStride * 4 * 4);
-          this.dynamicData = new Float32Array(dynBuffer);
-          this.dynamicDataUint32 = new Uint32Array(dynBuffer);
-          this.dynamicBuffer = new Buffer(this.dynamicData, false, false);
-          // static //
-          var staticOffset = 0;
-          this.staticStride = 0;
-          for (var i = 0; i < this.staticProperties.length; ++i) {
-              var property = this.staticProperties[i];
-              property.offset = staticOffset;
-              staticOffset += property.size;
-              this.staticStride += property.size;
-          }
-          var statBuffer = new ArrayBuffer(this.size * this.staticStride * 4 * 4);
-          this.staticData = new Float32Array(statBuffer);
-          this.staticDataUint32 = new Uint32Array(statBuffer);
-          this.staticBuffer = new Buffer(this.staticData, true, false);
-          for (var i = 0; i < this.dynamicProperties.length; ++i) {
-              var property = this.dynamicProperties[i];
-              geometry.addAttribute(property.attributeName, this.dynamicBuffer, 0, property.type === exports.TYPES.UNSIGNED_BYTE, property.type, this.dynamicStride * 4, property.offset * 4);
-          }
-          for (var i = 0; i < this.staticProperties.length; ++i) {
-              var property = this.staticProperties[i];
-              geometry.addAttribute(property.attributeName, this.staticBuffer, 0, property.type === exports.TYPES.UNSIGNED_BYTE, property.type, this.staticStride * 4, property.offset * 4);
-          }
-      };
-      /**
-       * Uploads the dynamic properties.
-       * @param children - The children to upload.
-       * @param startIndex - The index to start at.
-       * @param amount - The number to upload.
-       */
-      ParticleBuffer.prototype.uploadDynamic = function (children, startIndex, amount) {
-          for (var i = 0; i < this.dynamicProperties.length; i++) {
-              var property = this.dynamicProperties[i];
-              property.uploadFunction(children, startIndex, amount, property.type === exports.TYPES.UNSIGNED_BYTE ? this.dynamicDataUint32 : this.dynamicData, this.dynamicStride, property.offset);
-          }
-          this.dynamicBuffer._updateID++;
-      };
-      /**
-       * Uploads the static properties.
-       * @param children - The children to upload.
-       * @param startIndex - The index to start at.
-       * @param amount - The number to upload.
-       */
-      ParticleBuffer.prototype.uploadStatic = function (children, startIndex, amount) {
-          for (var i = 0; i < this.staticProperties.length; i++) {
-              var property = this.staticProperties[i];
-              property.uploadFunction(children, startIndex, amount, property.type === exports.TYPES.UNSIGNED_BYTE ? this.staticDataUint32 : this.staticData, this.staticStride, property.offset);
-          }
-          this.staticBuffer._updateID++;
-      };
-      /** Destroys the ParticleBuffer. */
-      ParticleBuffer.prototype.destroy = function () {
-          this.indexBuffer = null;
-          this.dynamicProperties = null;
-          this.dynamicBuffer = null;
-          this.dynamicData = null;
-          this.dynamicDataUint32 = null;
-          this.staticProperties = null;
-          this.staticBuffer = null;
-          this.staticData = null;
-          this.staticDataUint32 = null;
-          // all buffers are destroyed inside geometry
-          this.geometry.destroy();
-      };
-      return ParticleBuffer;
-  }());
-
-  var fragment$6 = "varying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform sampler2D uSampler;\n\nvoid main(void){\n    vec4 color = texture2D(uSampler, vTextureCoord) * vColor;\n    gl_FragColor = color;\n}";
-
-  var vertex$3 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\n\nattribute vec2 aPositionCoord;\nattribute float aRotation;\n\nuniform mat3 translationMatrix;\nuniform vec4 uColor;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nvoid main(void){\n    float x = (aVertexPosition.x) * cos(aRotation) - (aVertexPosition.y) * sin(aRotation);\n    float y = (aVertexPosition.x) * sin(aRotation) + (aVertexPosition.y) * cos(aRotation);\n\n    vec2 v = vec2(x, y);\n    v = v + aPositionCoord;\n\n    gl_Position = vec4((translationMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = aTextureCoord;\n    vColor = aColor * uColor;\n}\n";
-
-  /*
-   * @author Mat Groves
-   *
-   * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
-   * for creating the original PixiJS version!
-   * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they now
-   * share 4 bytes on the vertex buffer
-   *
-   * Heavily inspired by LibGDX's ParticleRenderer:
-   * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleRenderer.java
-   */
-  /**
-   * Renderer for Particles that is designer for speed over feature set.
-   * @memberof PIXI
-   */
-  var ParticleRenderer = /** @class */ (function (_super) {
-      __extends$f(ParticleRenderer, _super);
-      /**
-       * @param renderer - The renderer this sprite batch works for.
-       */
-      function ParticleRenderer(renderer) {
-          var _this = _super.call(this, renderer) || this;
-          // 65535 is max vertex index in the index buffer (see ParticleRenderer)
-          // so max number of particles is 65536 / 4 = 16384
-          // and max number of element in the index buffer is 16384 * 6 = 98304
-          // Creating a full index buffer, overhead is 98304 * 2 = 196Ko
-          // let numIndices = 98304;
-          _this.shader = null;
-          _this.properties = null;
-          _this.tempMatrix = new Matrix();
-          _this.properties = [
-              // verticesData
-              {
-                  attributeName: 'aVertexPosition',
-                  size: 2,
-                  uploadFunction: _this.uploadVertices,
-                  offset: 0,
-              },
-              // positionData
-              {
-                  attributeName: 'aPositionCoord',
-                  size: 2,
-                  uploadFunction: _this.uploadPosition,
-                  offset: 0,
-              },
-              // rotationData
-              {
-                  attributeName: 'aRotation',
-                  size: 1,
-                  uploadFunction: _this.uploadRotation,
-                  offset: 0,
-              },
-              // uvsData
-              {
-                  attributeName: 'aTextureCoord',
-                  size: 2,
-                  uploadFunction: _this.uploadUvs,
-                  offset: 0,
-              },
-              // tintData
-              {
-                  attributeName: 'aColor',
-                  size: 1,
-                  type: exports.TYPES.UNSIGNED_BYTE,
-                  uploadFunction: _this.uploadTint,
-                  offset: 0,
-              } ];
-          _this.shader = Shader.from(vertex$3, fragment$6, {});
-          _this.state = State.for2d();
-          return _this;
-      }
-      /**
-       * Renders the particle container object.
-       * @param container - The container to render using this ParticleRenderer.
-       */
-      ParticleRenderer.prototype.render = function (container) {
-          var children = container.children;
-          var maxSize = container._maxSize;
-          var batchSize = container._batchSize;
-          var renderer = this.renderer;
-          var totalChildren = children.length;
-          if (totalChildren === 0) {
-              return;
-          }
-          else if (totalChildren > maxSize && !container.autoResize) {
-              totalChildren = maxSize;
-          }
-          var buffers = container._buffers;
-          if (!buffers) {
-              buffers = container._buffers = this.generateBuffers(container);
-          }
-          var baseTexture = children[0]._texture.baseTexture;
-          var premultiplied = baseTexture.alphaMode > 0;
-          // if the uvs have not updated then no point rendering just yet!
-          this.state.blendMode = correctBlendMode(container.blendMode, premultiplied);
-          renderer.state.set(this.state);
-          var gl = renderer.gl;
-          var m = container.worldTransform.copyTo(this.tempMatrix);
-          m.prepend(renderer.globalUniforms.uniforms.projectionMatrix);
-          this.shader.uniforms.translationMatrix = m.toArray(true);
-          this.shader.uniforms.uColor = premultiplyRgba(container.tintRgb, container.worldAlpha, this.shader.uniforms.uColor, premultiplied);
-          this.shader.uniforms.uSampler = baseTexture;
-          this.renderer.shader.bind(this.shader);
-          var updateStatic = false;
-          // now lets upload and render the buffers..
-          for (var i = 0, j = 0; i < totalChildren; i += batchSize, j += 1) {
-              var amount = (totalChildren - i);
-              if (amount > batchSize) {
-                  amount = batchSize;
-              }
-              if (j >= buffers.length) {
-                  buffers.push(this._generateOneMoreBuffer(container));
-              }
-              var buffer = buffers[j];
-              // we always upload the dynamic
-              buffer.uploadDynamic(children, i, amount);
-              var bid = container._bufferUpdateIDs[j] || 0;
-              updateStatic = updateStatic || (buffer._updateID < bid);
-              // we only upload the static content when we have to!
-              if (updateStatic) {
-                  buffer._updateID = container._updateID;
-                  buffer.uploadStatic(children, i, amount);
-              }
-              // bind the buffer
-              renderer.geometry.bind(buffer.geometry);
-              gl.drawElements(gl.TRIANGLES, amount * 6, gl.UNSIGNED_SHORT, 0);
-          }
-      };
-      /**
-       * Creates one particle buffer for each child in the container we want to render and updates internal properties.
-       * @param container - The container to render using this ParticleRenderer
-       * @returns - The buffers
-       */
-      ParticleRenderer.prototype.generateBuffers = function (container) {
-          var buffers = [];
-          var size = container._maxSize;
-          var batchSize = container._batchSize;
-          var dynamicPropertyFlags = container._properties;
-          for (var i = 0; i < size; i += batchSize) {
-              buffers.push(new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize));
-          }
-          return buffers;
-      };
-      /**
-       * Creates one more particle buffer, because container has autoResize feature.
-       * @param container - The container to render using this ParticleRenderer
-       * @returns - The generated buffer
-       */
-      ParticleRenderer.prototype._generateOneMoreBuffer = function (container) {
-          var batchSize = container._batchSize;
-          var dynamicPropertyFlags = container._properties;
-          return new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize);
-      };
-      /**
-       * Uploads the vertices.
-       * @param children - the array of sprites to render
-       * @param startIndex - the index to start from in the children array
-       * @param amount - the amount of children that will have their vertices uploaded
-       * @param array - The vertices to upload.
-       * @param stride - Stride to use for iteration.
-       * @param offset - Offset to start at.
-       */
-      ParticleRenderer.prototype.uploadVertices = function (children, startIndex, amount, array, stride, offset) {
-          var w0 = 0;
-          var w1 = 0;
-          var h0 = 0;
-          var h1 = 0;
-          for (var i = 0; i < amount; ++i) {
-              var sprite = children[startIndex + i];
-              var texture = sprite._texture;
-              var sx = sprite.scale.x;
-              var sy = sprite.scale.y;
-              var trim = texture.trim;
-              var orig = texture.orig;
-              if (trim) {
-                  // if the sprite is trimmed and is not a tilingsprite then we need to add the
-                  // extra space before transforming the sprite coords..
-                  w1 = trim.x - (sprite.anchor.x * orig.width);
-                  w0 = w1 + trim.width;
-                  h1 = trim.y - (sprite.anchor.y * orig.height);
-                  h0 = h1 + trim.height;
-              }
-              else {
-                  w0 = (orig.width) * (1 - sprite.anchor.x);
-                  w1 = (orig.width) * -sprite.anchor.x;
-                  h0 = orig.height * (1 - sprite.anchor.y);
-                  h1 = orig.height * -sprite.anchor.y;
-              }
-              array[offset] = w1 * sx;
-              array[offset + 1] = h1 * sy;
-              array[offset + stride] = w0 * sx;
-              array[offset + stride + 1] = h1 * sy;
-              array[offset + (stride * 2)] = w0 * sx;
-              array[offset + (stride * 2) + 1] = h0 * sy;
-              array[offset + (stride * 3)] = w1 * sx;
-              array[offset + (stride * 3) + 1] = h0 * sy;
-              offset += stride * 4;
-          }
-      };
-      /**
-       * Uploads the position.
-       * @param children - the array of sprites to render
-       * @param startIndex - the index to start from in the children array
-       * @param amount - the amount of children that will have their positions uploaded
-       * @param array - The vertices to upload.
-       * @param stride - Stride to use for iteration.
-       * @param offset - Offset to start at.
-       */
-      ParticleRenderer.prototype.uploadPosition = function (children, startIndex, amount, array, stride, offset) {
-          for (var i = 0; i < amount; i++) {
-              var spritePosition = children[startIndex + i].position;
-              array[offset] = spritePosition.x;
-              array[offset + 1] = spritePosition.y;
-              array[offset + stride] = spritePosition.x;
-              array[offset + stride + 1] = spritePosition.y;
-              array[offset + (stride * 2)] = spritePosition.x;
-              array[offset + (stride * 2) + 1] = spritePosition.y;
-              array[offset + (stride * 3)] = spritePosition.x;
-              array[offset + (stride * 3) + 1] = spritePosition.y;
-              offset += stride * 4;
-          }
-      };
-      /**
-       * Uploads the rotation.
-       * @param children - the array of sprites to render
-       * @param startIndex - the index to start from in the children array
-       * @param amount - the amount of children that will have their rotation uploaded
-       * @param array - The vertices to upload.
-       * @param stride - Stride to use for iteration.
-       * @param offset - Offset to start at.
-       */
-      ParticleRenderer.prototype.uploadRotation = function (children, startIndex, amount, array, stride, offset) {
-          for (var i = 0; i < amount; i++) {
-              var spriteRotation = children[startIndex + i].rotation;
-              array[offset] = spriteRotation;
-              array[offset + stride] = spriteRotation;
-              array[offset + (stride * 2)] = spriteRotation;
-              array[offset + (stride * 3)] = spriteRotation;
-              offset += stride * 4;
-          }
-      };
-      /**
-       * Uploads the UVs.
-       * @param children - the array of sprites to render
-       * @param startIndex - the index to start from in the children array
-       * @param amount - the amount of children that will have their rotation uploaded
-       * @param array - The vertices to upload.
-       * @param stride - Stride to use for iteration.
-       * @param offset - Offset to start at.
-       */
-      ParticleRenderer.prototype.uploadUvs = function (children, startIndex, amount, array, stride, offset) {
-          for (var i = 0; i < amount; ++i) {
-              var textureUvs = children[startIndex + i]._texture._uvs;
-              if (textureUvs) {
-                  array[offset] = textureUvs.x0;
-                  array[offset + 1] = textureUvs.y0;
-                  array[offset + stride] = textureUvs.x1;
-                  array[offset + stride + 1] = textureUvs.y1;
-                  array[offset + (stride * 2)] = textureUvs.x2;
-                  array[offset + (stride * 2) + 1] = textureUvs.y2;
-                  array[offset + (stride * 3)] = textureUvs.x3;
-                  array[offset + (stride * 3) + 1] = textureUvs.y3;
-                  offset += stride * 4;
-              }
-              else {
-                  // TODO you know this can be easier!
-                  array[offset] = 0;
-                  array[offset + 1] = 0;
-                  array[offset + stride] = 0;
-                  array[offset + stride + 1] = 0;
-                  array[offset + (stride * 2)] = 0;
-                  array[offset + (stride * 2) + 1] = 0;
-                  array[offset + (stride * 3)] = 0;
-                  array[offset + (stride * 3) + 1] = 0;
-                  offset += stride * 4;
-              }
-          }
-      };
-      /**
-       * Uploads the tint.
-       * @param children - the array of sprites to render
-       * @param startIndex - the index to start from in the children array
-       * @param amount - the amount of children that will have their rotation uploaded
-       * @param array - The vertices to upload.
-       * @param stride - Stride to use for iteration.
-       * @param offset - Offset to start at.
-       */
-      ParticleRenderer.prototype.uploadTint = function (children, startIndex, amount, array, stride, offset) {
-          for (var i = 0; i < amount; ++i) {
-              var sprite = children[startIndex + i];
-              var premultiplied = sprite._texture.baseTexture.alphaMode > 0;
-              var alpha = sprite.alpha;
-              // we dont call extra function if alpha is 1.0, that's faster
-              var argb = alpha < 1.0 && premultiplied
-                  ? premultiplyTint(sprite._tintRGB, alpha) : sprite._tintRGB + (alpha * 255 << 24);
-              array[offset] = argb;
-              array[offset + stride] = argb;
-              array[offset + (stride * 2)] = argb;
-              array[offset + (stride * 3)] = argb;
-              offset += stride * 4;
-          }
-      };
-      /** Destroys the ParticleRenderer. */
-      ParticleRenderer.prototype.destroy = function () {
-          _super.prototype.destroy.call(this);
-          if (this.shader) {
-              this.shader.destroy();
-              this.shader = null;
-          }
-          this.tempMatrix = null;
-      };
-      /** @ignore */
-      ParticleRenderer.extension = {
-          name: 'particle',
-          type: exports.ExtensionType.RendererPlugin,
-      };
-      return ParticleRenderer;
-  }(ObjectRenderer));
-
-  /*!
-   * @pixi/graphics - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/graphics is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Supported line joints in `PIXI.LineStyle` for graphics.
-   * @see PIXI.Graphics#lineStyle
-   * @see https://graphicdesign.stackexchange.com/questions/59018/what-is-a-bevel-join-of-two-lines-exactly-illustrator
-   * @name LINE_JOIN
-   * @memberof PIXI
-   * @static
-   * @enum {string}
-   * @property {string} MITER - 'miter': make a sharp corner where outer part of lines meet
-   * @property {string} BEVEL - 'bevel': add a square butt at each end of line segment and fill the triangle at turn
-   * @property {string} ROUND - 'round': add an arc at the joint
-   */
-  exports.LINE_JOIN = void 0;
-  (function (LINE_JOIN) {
-      LINE_JOIN["MITER"] = "miter";
-      LINE_JOIN["BEVEL"] = "bevel";
-      LINE_JOIN["ROUND"] = "round";
-  })(exports.LINE_JOIN || (exports.LINE_JOIN = {}));
-  /**
-   * Support line caps in `PIXI.LineStyle` for graphics.
-   * @see PIXI.Graphics#lineStyle
-   * @name LINE_CAP
-   * @memberof PIXI
-   * @static
-   * @enum {string}
-   * @property {string} BUTT - 'butt': don't add any cap at line ends (leaves orthogonal edges)
-   * @property {string} ROUND - 'round': add semicircle at ends
-   * @property {string} SQUARE - 'square': add square at end (like `BUTT` except more length at end)
-   */
-  exports.LINE_CAP = void 0;
-  (function (LINE_CAP) {
-      LINE_CAP["BUTT"] = "butt";
-      LINE_CAP["ROUND"] = "round";
-      LINE_CAP["SQUARE"] = "square";
-  })(exports.LINE_CAP || (exports.LINE_CAP = {}));
-  /**
-   * Graphics curves resolution settings. If `adaptive` flag is set to `true`,
-   * the resolution is calculated based on the curve's length to ensure better visual quality.
-   * Adaptive draw works with `bezierCurveTo` and `quadraticCurveTo`.
-   * @static
-   * @constant
-   * @memberof PIXI
-   * @name GRAPHICS_CURVES
-   * @type {object}
-   * @property {boolean} [adaptive=true] - flag indicating if the resolution should be adaptive
-   * @property {number} [maxLength=10] - maximal length of a single segment of the curve (if adaptive = false, ignored)
-   * @property {number} [minSegments=8] - minimal number of segments in the curve (if adaptive = false, ignored)
-   * @property {number} [maxSegments=2048] - maximal number of segments in the curve (if adaptive = false, ignored)
-   */
-  var GRAPHICS_CURVES = {
-      adaptive: true,
-      maxLength: 10,
-      minSegments: 8,
-      maxSegments: 2048,
-      epsilon: 0.0001,
-      _segmentsCount: function (length, defaultSegments) {
-          if (defaultSegments === void 0) { defaultSegments = 20; }
-          if (!this.adaptive || !length || isNaN(length)) {
-              return defaultSegments;
-          }
-          var result = Math.ceil(length / this.maxLength);
-          if (result < this.minSegments) {
-              result = this.minSegments;
-          }
-          else if (result > this.maxSegments) {
-              result = this.maxSegments;
-          }
-          return result;
-      },
-  };
-
-  /**
-   * Fill style object for Graphics.
-   * @memberof PIXI
-   */
-  var FillStyle = /** @class */ (function () {
-      function FillStyle() {
-          /**
-           * The hex color value used when coloring the Graphics object.
-           * @default 0xFFFFFF
-           */
-          this.color = 0xFFFFFF;
-          /** The alpha value used when filling the Graphics object. */
-          this.alpha = 1.0;
-          /**
-           * The texture to be used for the fill.
-           * @default 0
-           */
-          this.texture = Texture.WHITE;
-          /**
-           * The transform applied to the texture.
-           * @default null
-           */
-          this.matrix = null;
-          /** If the current fill is visible. */
-          this.visible = false;
-          this.reset();
-      }
-      /** Clones the object */
-      FillStyle.prototype.clone = function () {
-          var obj = new FillStyle();
-          obj.color = this.color;
-          obj.alpha = this.alpha;
-          obj.texture = this.texture;
-          obj.matrix = this.matrix;
-          obj.visible = this.visible;
-          return obj;
-      };
-      /** Reset */
-      FillStyle.prototype.reset = function () {
-          this.color = 0xFFFFFF;
-          this.alpha = 1;
-          this.texture = Texture.WHITE;
-          this.matrix = null;
-          this.visible = false;
-      };
-      /** Destroy and don't use after this. */
-      FillStyle.prototype.destroy = function () {
-          this.texture = null;
-          this.matrix = null;
-      };
-      return FillStyle;
-  }());
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$e = function(d, b) {
-      extendStatics$e = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$e(d, b);
-  };
-
-  function __extends$e(d, b) {
-      extendStatics$e(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  function fixOrientation(points, hole) {
-      var _a, _b;
-      if (hole === void 0) { hole = false; }
-      var m = points.length;
-      if (m < 6) {
-          return;
-      }
-      var area = 0;
-      for (var i = 0, x1 = points[m - 2], y1 = points[m - 1]; i < m; i += 2) {
-          var x2 = points[i];
-          var y2 = points[i + 1];
-          area += (x2 - x1) * (y2 + y1);
-          x1 = x2;
-          y1 = y2;
-      }
-      if ((!hole && area > 0) || (hole && area <= 0)) {
-          var n = m / 2;
-          for (var i = n + (n % 2); i < m; i += 2) {
-              var i1 = m - i - 2;
-              var i2 = m - i - 1;
-              var i3 = i;
-              var i4 = i + 1;
-              _a = [points[i3], points[i1]], points[i1] = _a[0], points[i3] = _a[1];
-              _b = [points[i4], points[i2]], points[i2] = _b[0], points[i4] = _b[1];
-          }
-      }
-  }
-  /**
-   * Builds a polygon to draw
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
-   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
-   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
-   */
-  var buildPoly = {
-      build: function (graphicsData) {
-          graphicsData.points = graphicsData.shape.points.slice();
-      },
-      triangulate: function (graphicsData, graphicsGeometry) {
-          var points = graphicsData.points;
-          var holes = graphicsData.holes;
-          var verts = graphicsGeometry.points;
-          var indices = graphicsGeometry.indices;
-          if (points.length >= 6) {
-              fixOrientation(points, false);
-              var holeArray = [];
-              // Process holes..
-              for (var i = 0; i < holes.length; i++) {
-                  var hole = holes[i];
-                  fixOrientation(hole.points, true);
-                  holeArray.push(points.length / 2);
-                  points = points.concat(hole.points);
-              }
-              // sort color
-              var triangles = earcut_1(points, holeArray, 2);
-              if (!triangles) {
-                  return;
-              }
-              var vertPos = verts.length / 2;
-              for (var i = 0; i < triangles.length; i += 3) {
-                  indices.push(triangles[i] + vertPos);
-                  indices.push(triangles[i + 1] + vertPos);
-                  indices.push(triangles[i + 2] + vertPos);
-              }
-              for (var i = 0; i < points.length; i++) {
-                  verts.push(points[i]);
-              }
-          }
-      },
-  };
-
-  // for type only
-  /**
-   * Builds a circle to draw
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object to draw
-   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
-   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
-   */
-  var buildCircle = {
-      build: function (graphicsData) {
-          // need to convert points to a nice regular data
-          var points = graphicsData.points;
-          var x;
-          var y;
-          var dx;
-          var dy;
-          var rx;
-          var ry;
-          if (graphicsData.type === exports.SHAPES.CIRC) {
-              var circle = graphicsData.shape;
-              x = circle.x;
-              y = circle.y;
-              rx = ry = circle.radius;
-              dx = dy = 0;
-          }
-          else if (graphicsData.type === exports.SHAPES.ELIP) {
-              var ellipse = graphicsData.shape;
-              x = ellipse.x;
-              y = ellipse.y;
-              rx = ellipse.width;
-              ry = ellipse.height;
-              dx = dy = 0;
-          }
-          else {
-              var roundedRect = graphicsData.shape;
-              var halfWidth = roundedRect.width / 2;
-              var halfHeight = roundedRect.height / 2;
-              x = roundedRect.x + halfWidth;
-              y = roundedRect.y + halfHeight;
-              rx = ry = Math.max(0, Math.min(roundedRect.radius, Math.min(halfWidth, halfHeight)));
-              dx = halfWidth - rx;
-              dy = halfHeight - ry;
-          }
-          if (!(rx >= 0 && ry >= 0 && dx >= 0 && dy >= 0)) {
-              points.length = 0;
-              return;
-          }
-          // Choose a number of segments such that the maximum absolute deviation from the circle is approximately 0.029
-          var n = Math.ceil(2.3 * Math.sqrt(rx + ry));
-          var m = (n * 8) + (dx ? 4 : 0) + (dy ? 4 : 0);
-          points.length = m;
-          if (m === 0) {
-              return;
-          }
-          if (n === 0) {
-              points.length = 8;
-              points[0] = points[6] = x + dx;
-              points[1] = points[3] = y + dy;
-              points[2] = points[4] = x - dx;
-              points[5] = points[7] = y - dy;
-              return;
-          }
-          var j1 = 0;
-          var j2 = (n * 4) + (dx ? 2 : 0) + 2;
-          var j3 = j2;
-          var j4 = m;
-          {
-              var x0 = dx + rx;
-              var y0 = dy;
-              var x1 = x + x0;
-              var x2 = x - x0;
-              var y1 = y + y0;
-              points[j1++] = x1;
-              points[j1++] = y1;
-              points[--j2] = y1;
-              points[--j2] = x2;
-              if (dy) {
-                  var y2 = y - y0;
-                  points[j3++] = x2;
-                  points[j3++] = y2;
-                  points[--j4] = y2;
-                  points[--j4] = x1;
-              }
-          }
-          for (var i = 1; i < n; i++) {
-              var a = Math.PI / 2 * (i / n);
-              var x0 = dx + (Math.cos(a) * rx);
-              var y0 = dy + (Math.sin(a) * ry);
-              var x1 = x + x0;
-              var x2 = x - x0;
-              var y1 = y + y0;
-              var y2 = y - y0;
-              points[j1++] = x1;
-              points[j1++] = y1;
-              points[--j2] = y1;
-              points[--j2] = x2;
-              points[j3++] = x2;
-              points[j3++] = y2;
-              points[--j4] = y2;
-              points[--j4] = x1;
-          }
-          {
-              var x0 = dx;
-              var y0 = dy + ry;
-              var x1 = x + x0;
-              var x2 = x - x0;
-              var y1 = y + y0;
-              var y2 = y - y0;
-              points[j1++] = x1;
-              points[j1++] = y1;
-              points[--j4] = y2;
-              points[--j4] = x1;
-              if (dx) {
-                  points[j1++] = x2;
-                  points[j1++] = y1;
-                  points[--j4] = y2;
-                  points[--j4] = x2;
-              }
-          }
-      },
-      triangulate: function (graphicsData, graphicsGeometry) {
-          var points = graphicsData.points;
-          var verts = graphicsGeometry.points;
-          var indices = graphicsGeometry.indices;
-          if (points.length === 0) {
-              return;
-          }
-          var vertPos = verts.length / 2;
-          var center = vertPos;
-          var x;
-          var y;
-          if (graphicsData.type !== exports.SHAPES.RREC) {
-              var circle = graphicsData.shape;
-              x = circle.x;
-              y = circle.y;
-          }
-          else {
-              var roundedRect = graphicsData.shape;
-              x = roundedRect.x + (roundedRect.width / 2);
-              y = roundedRect.y + (roundedRect.height / 2);
-          }
-          var matrix = graphicsData.matrix;
-          // Push center (special point)
-          verts.push(graphicsData.matrix ? (matrix.a * x) + (matrix.c * y) + matrix.tx : x, graphicsData.matrix ? (matrix.b * x) + (matrix.d * y) + matrix.ty : y);
-          vertPos++;
-          verts.push(points[0], points[1]);
-          for (var i = 2; i < points.length; i += 2) {
-              verts.push(points[i], points[i + 1]);
-              // add some uvs
-              indices.push(vertPos++, center, vertPos);
-          }
-          indices.push(center + 1, center, vertPos);
-      },
-  };
-
-  /**
-   * Builds a rectangle to draw
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
-   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
-   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
-   */
-  var buildRectangle = {
-      build: function (graphicsData) {
-          // --- //
-          // need to convert points to a nice regular data
-          //
-          var rectData = graphicsData.shape;
-          var x = rectData.x;
-          var y = rectData.y;
-          var width = rectData.width;
-          var height = rectData.height;
-          var points = graphicsData.points;
-          points.length = 0;
-          points.push(x, y, x + width, y, x + width, y + height, x, y + height);
-      },
-      triangulate: function (graphicsData, graphicsGeometry) {
-          var points = graphicsData.points;
-          var verts = graphicsGeometry.points;
-          var vertPos = verts.length / 2;
-          verts.push(points[0], points[1], points[2], points[3], points[6], points[7], points[4], points[5]);
-          graphicsGeometry.indices.push(vertPos, vertPos + 1, vertPos + 2, vertPos + 1, vertPos + 2, vertPos + 3);
-      },
-  };
-
-  /**
-   * Calculate a single point for a quadratic bezier curve.
-   * Utility function used by quadraticBezierCurve.
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {number} n1 - first number
-   * @param {number} n2 - second number
-   * @param {number} perc - percentage
-   * @returns {number} the result
-   */
-  function getPt(n1, n2, perc) {
-      var diff = n2 - n1;
-      return n1 + (diff * perc);
-  }
-  /**
-   * Calculate the points for a quadratic bezier curve. (helper function..)
-   * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {number} fromX - Origin point x
-   * @param {number} fromY - Origin point x
-   * @param {number} cpX - Control point x
-   * @param {number} cpY - Control point y
-   * @param {number} toX - Destination point x
-   * @param {number} toY - Destination point y
-   * @param {number[]} [out=[]] - The output array to add points into. If not passed, a new array is created.
-   * @returns {number[]} an array of points
-   */
-  function quadraticBezierCurve(fromX, fromY, cpX, cpY, toX, toY, out) {
-      if (out === void 0) { out = []; }
-      var n = 20;
-      var points = out;
-      var xa = 0;
-      var ya = 0;
-      var xb = 0;
-      var yb = 0;
-      var x = 0;
-      var y = 0;
-      for (var i = 0, j = 0; i <= n; ++i) {
-          j = i / n;
-          // The Green Line
-          xa = getPt(fromX, cpX, j);
-          ya = getPt(fromY, cpY, j);
-          xb = getPt(cpX, toX, j);
-          yb = getPt(cpY, toY, j);
-          // The Black Dot
-          x = getPt(xa, xb, j);
-          y = getPt(ya, yb, j);
-          // Handle case when first curve points overlaps and earcut fails to triangulate
-          if (i === 0 && points[points.length - 2] === x && points[points.length - 1] === y) {
-              continue;
-          }
-          points.push(x, y);
-      }
-      return points;
-  }
-  /**
-   * Builds a rounded rectangle to draw
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {PIXI.WebGLGraphicsData} graphicsData - The graphics object containing all the necessary properties
-   * @param {object} webGLData - an object containing all the WebGL-specific information to create this shape
-   * @param {object} webGLDataNativeLines - an object containing all the WebGL-specific information to create nativeLines
-   */
-  var buildRoundedRectangle = {
-      build: function (graphicsData) {
-          if (Graphics.nextRoundedRectBehavior) {
-              buildCircle.build(graphicsData);
-              return;
-          }
-          var rrectData = graphicsData.shape;
-          var points = graphicsData.points;
-          var x = rrectData.x;
-          var y = rrectData.y;
-          var width = rrectData.width;
-          var height = rrectData.height;
-          // Don't allow negative radius or greater than half the smallest width
-          var radius = Math.max(0, Math.min(rrectData.radius, Math.min(width, height) / 2));
-          points.length = 0;
-          // No radius, do a simple rectangle
-          if (!radius) {
-              points.push(x, y, x + width, y, x + width, y + height, x, y + height);
-          }
-          else {
-              quadraticBezierCurve(x, y + radius, x, y, x + radius, y, points);
-              quadraticBezierCurve(x + width - radius, y, x + width, y, x + width, y + radius, points);
-              quadraticBezierCurve(x + width, y + height - radius, x + width, y + height, x + width - radius, y + height, points);
-              quadraticBezierCurve(x + radius, y + height, x, y + height, x, y + height - radius, points);
-          }
-      },
-      triangulate: function (graphicsData, graphicsGeometry) {
-          if (Graphics.nextRoundedRectBehavior) {
-              buildCircle.triangulate(graphicsData, graphicsGeometry);
-              return;
-          }
-          var points = graphicsData.points;
-          var verts = graphicsGeometry.points;
-          var indices = graphicsGeometry.indices;
-          var vecPos = verts.length / 2;
-          var triangles = earcut_1(points, null, 2);
-          for (var i = 0, j = triangles.length; i < j; i += 3) {
-              indices.push(triangles[i] + vecPos);
-              //     indices.push(triangles[i] + vecPos);
-              indices.push(triangles[i + 1] + vecPos);
-              //   indices.push(triangles[i + 2] + vecPos);
-              indices.push(triangles[i + 2] + vecPos);
-          }
-          for (var i = 0, j = points.length; i < j; i++) {
-              verts.push(points[i], points[++i]);
-          }
-      },
-  };
-
-  /**
-   * Buffers vertices to draw a square cap.
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {number} x - X-coord of end point
-   * @param {number} y - Y-coord of end point
-   * @param {number} nx - X-coord of line normal pointing inside
-   * @param {number} ny - Y-coord of line normal pointing inside
-   * @param {number} innerWeight - Weight of inner points
-   * @param {number} outerWeight - Weight of outer points
-   * @param {boolean} clockwise - Whether the cap is drawn clockwise
-   * @param {Array<number>} verts - vertex buffer
-   * @returns {number} - no. of vertices pushed
-   */
-  function square(x, y, nx, ny, innerWeight, outerWeight, clockwise, /* rotation for square (true at left end, false at right end) */ verts) {
-      var ix = x - (nx * innerWeight);
-      var iy = y - (ny * innerWeight);
-      var ox = x + (nx * outerWeight);
-      var oy = y + (ny * outerWeight);
-      /* Rotate nx,ny for extension vector */
-      var exx;
-      var eyy;
-      if (clockwise) {
-          exx = ny;
-          eyy = -nx;
-      }
-      else {
-          exx = -ny;
-          eyy = nx;
-      }
-      /* [i|0]x,y extended at cap */
-      var eix = ix + exx;
-      var eiy = iy + eyy;
-      var eox = ox + exx;
-      var eoy = oy + eyy;
-      /* Square itself must be inserted clockwise*/
-      verts.push(eix, eiy);
-      verts.push(eox, eoy);
-      return 2;
-  }
-  /**
-   * Buffers vertices to draw an arc at the line joint or cap.
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {number} cx - X-coord of center
-   * @param {number} cy - Y-coord of center
-   * @param {number} sx - X-coord of arc start
-   * @param {number} sy - Y-coord of arc start
-   * @param {number} ex - X-coord of arc end
-   * @param {number} ey - Y-coord of arc end
-   * @param {Array<number>} verts - buffer of vertices
-   * @param {boolean} clockwise - orientation of vertices
-   * @returns {number} - no. of vertices pushed
-   */
-  function round(cx, cy, sx, sy, ex, ey, verts, clockwise) {
-      var cx2p0x = sx - cx;
-      var cy2p0y = sy - cy;
-      var angle0 = Math.atan2(cx2p0x, cy2p0y);
-      var angle1 = Math.atan2(ex - cx, ey - cy);
-      if (clockwise && angle0 < angle1) {
-          angle0 += Math.PI * 2;
-      }
-      else if (!clockwise && angle0 > angle1) {
-          angle1 += Math.PI * 2;
-      }
-      var startAngle = angle0;
-      var angleDiff = angle1 - angle0;
-      var absAngleDiff = Math.abs(angleDiff);
-      /* if (absAngleDiff >= PI_LBOUND && absAngleDiff <= PI_UBOUND)
-      {
-          const r1x = cx - nxtPx;
-          const r1y = cy - nxtPy;
-
-          if (r1x === 0)
-          {
-              if (r1y > 0)
-              {
-                  angleDiff = -angleDiff;
-              }
-          }
-          else if (r1x >= -GRAPHICS_CURVES.epsilon)
-          {
-              angleDiff = -angleDiff;
-          }
-      }*/
-      var radius = Math.sqrt((cx2p0x * cx2p0x) + (cy2p0y * cy2p0y));
-      var segCount = ((15 * absAngleDiff * Math.sqrt(radius) / Math.PI) >> 0) + 1;
-      var angleInc = angleDiff / segCount;
-      startAngle += angleInc;
-      if (clockwise) {
-          verts.push(cx, cy);
-          verts.push(sx, sy);
-          for (var i = 1, angle = startAngle; i < segCount; i++, angle += angleInc) {
-              verts.push(cx, cy);
-              verts.push(cx + ((Math.sin(angle) * radius)), cy + ((Math.cos(angle) * radius)));
-          }
-          verts.push(cx, cy);
-          verts.push(ex, ey);
-      }
-      else {
-          verts.push(sx, sy);
-          verts.push(cx, cy);
-          for (var i = 1, angle = startAngle; i < segCount; i++, angle += angleInc) {
-              verts.push(cx + ((Math.sin(angle) * radius)), cy + ((Math.cos(angle) * radius)));
-              verts.push(cx, cy);
-          }
-          verts.push(ex, ey);
-          verts.push(cx, cy);
-      }
-      return segCount * 2;
-  }
-  /**
-   * Builds a line to draw using the polygon method.
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {PIXI.GraphicsData} graphicsData - The graphics object containing all the necessary properties
-   * @param {PIXI.GraphicsGeometry} graphicsGeometry - Geometry where to append output
-   */
-  function buildNonNativeLine(graphicsData, graphicsGeometry) {
-      var shape = graphicsData.shape;
-      var points = graphicsData.points || shape.points.slice();
-      var eps = graphicsGeometry.closePointEps;
-      if (points.length === 0) {
-          return;
-      }
-      // if the line width is an odd number add 0.5 to align to a whole pixel
-      // commenting this out fixes #711 and #1620
-      // if (graphicsData.lineWidth%2)
-      // {
-      //     for (i = 0; i < points.length; i++)
-      //     {
-      //         points[i] += 0.5;
-      //     }
-      // }
-      var style = graphicsData.lineStyle;
-      // get first and last point.. figure out the middle!
-      var firstPoint = new Point(points[0], points[1]);
-      var lastPoint = new Point(points[points.length - 2], points[points.length - 1]);
-      var closedShape = shape.type !== exports.SHAPES.POLY || shape.closeStroke;
-      var closedPath = Math.abs(firstPoint.x - lastPoint.x) < eps
-          && Math.abs(firstPoint.y - lastPoint.y) < eps;
-      // if the first point is the last point - gonna have issues :)
-      if (closedShape) {
-          // need to clone as we are going to slightly modify the shape..
-          points = points.slice();
-          if (closedPath) {
-              points.pop();
-              points.pop();
-              lastPoint.set(points[points.length - 2], points[points.length - 1]);
-          }
-          var midPointX = (firstPoint.x + lastPoint.x) * 0.5;
-          var midPointY = (lastPoint.y + firstPoint.y) * 0.5;
-          points.unshift(midPointX, midPointY);
-          points.push(midPointX, midPointY);
-      }
-      var verts = graphicsGeometry.points;
-      var length = points.length / 2;
-      var indexCount = points.length;
-      var indexStart = verts.length / 2;
-      // Max. inner and outer width
-      var width = style.width / 2;
-      var widthSquared = width * width;
-      var miterLimitSquared = style.miterLimit * style.miterLimit;
-      /* Line segments of interest where (x1,y1) forms the corner. */
-      var x0 = points[0];
-      var y0 = points[1];
-      var x1 = points[2];
-      var y1 = points[3];
-      var x2 = 0;
-      var y2 = 0;
-      /* perp[?](x|y) = the line normal with magnitude lineWidth. */
-      var perpx = -(y0 - y1);
-      var perpy = x0 - x1;
-      var perp1x = 0;
-      var perp1y = 0;
-      var dist = Math.sqrt((perpx * perpx) + (perpy * perpy));
-      perpx /= dist;
-      perpy /= dist;
-      perpx *= width;
-      perpy *= width;
-      var ratio = style.alignment; // 0.5;
-      var innerWeight = (1 - ratio) * 2;
-      var outerWeight = ratio * 2;
-      if (!closedShape) {
-          if (style.cap === exports.LINE_CAP.ROUND) {
-              indexCount += round(x0 - (perpx * (innerWeight - outerWeight) * 0.5), y0 - (perpy * (innerWeight - outerWeight) * 0.5), x0 - (perpx * innerWeight), y0 - (perpy * innerWeight), x0 + (perpx * outerWeight), y0 + (perpy * outerWeight), verts, true) + 2;
-          }
-          else if (style.cap === exports.LINE_CAP.SQUARE) {
-              indexCount += square(x0, y0, perpx, perpy, innerWeight, outerWeight, true, verts);
-          }
-      }
-      // Push first point (below & above vertices)
-      verts.push(x0 - (perpx * innerWeight), y0 - (perpy * innerWeight));
-      verts.push(x0 + (perpx * outerWeight), y0 + (perpy * outerWeight));
-      for (var i = 1; i < length - 1; ++i) {
-          x0 = points[(i - 1) * 2];
-          y0 = points[((i - 1) * 2) + 1];
-          x1 = points[i * 2];
-          y1 = points[(i * 2) + 1];
-          x2 = points[(i + 1) * 2];
-          y2 = points[((i + 1) * 2) + 1];
-          perpx = -(y0 - y1);
-          perpy = x0 - x1;
-          dist = Math.sqrt((perpx * perpx) + (perpy * perpy));
-          perpx /= dist;
-          perpy /= dist;
-          perpx *= width;
-          perpy *= width;
-          perp1x = -(y1 - y2);
-          perp1y = x1 - x2;
-          dist = Math.sqrt((perp1x * perp1x) + (perp1y * perp1y));
-          perp1x /= dist;
-          perp1y /= dist;
-          perp1x *= width;
-          perp1y *= width;
-          /* d[x|y](0|1) = the component displacement between points p(0,1|1,2) */
-          var dx0 = x1 - x0;
-          var dy0 = y0 - y1;
-          var dx1 = x1 - x2;
-          var dy1 = y2 - y1;
-          /* +ve if internal angle < 90 degree, -ve if internal angle > 90 degree. */
-          var dot = (dx0 * dx1) + (dy0 * dy1);
-          /* +ve if internal angle counterclockwise, -ve if internal angle clockwise. */
-          var cross = (dy0 * dx1) - (dy1 * dx0);
-          var clockwise = (cross < 0);
-          /* Going nearly parallel? */
-          /* atan(0.001) ~= 0.001 rad ~= 0.057 degree */
-          if (Math.abs(cross) < 0.001 * Math.abs(dot)) {
-              verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight));
-              verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight));
-              /* 180 degree corner? */
-              if (dot >= 0) {
-                  if (style.join === exports.LINE_JOIN.ROUND) {
-                      indexCount += round(x1, y1, x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight), verts, false) + 4;
-                  }
-                  else {
-                      indexCount += 2;
-                  }
-                  verts.push(x1 - (perp1x * outerWeight), y1 - (perp1y * outerWeight));
-                  verts.push(x1 + (perp1x * innerWeight), y1 + (perp1y * innerWeight));
-              }
-              continue;
-          }
-          /* p[x|y] is the miter point. pdist is the distance between miter point and p1. */
-          var c1 = ((-perpx + x0) * (-perpy + y1)) - ((-perpx + x1) * (-perpy + y0));
-          var c2 = ((-perp1x + x2) * (-perp1y + y1)) - ((-perp1x + x1) * (-perp1y + y2));
-          var px = ((dx0 * c2) - (dx1 * c1)) / cross;
-          var py = ((dy1 * c1) - (dy0 * c2)) / cross;
-          var pdist = ((px - x1) * (px - x1)) + ((py - y1) * (py - y1));
-          /* Inner miter point */
-          var imx = x1 + ((px - x1) * innerWeight);
-          var imy = y1 + ((py - y1) * innerWeight);
-          /* Outer miter point */
-          var omx = x1 - ((px - x1) * outerWeight);
-          var omy = y1 - ((py - y1) * outerWeight);
-          /* Is the inside miter point too far away, creating a spike? */
-          var smallerInsideSegmentSq = Math.min((dx0 * dx0) + (dy0 * dy0), (dx1 * dx1) + (dy1 * dy1));
-          var insideWeight = clockwise ? innerWeight : outerWeight;
-          var smallerInsideDiagonalSq = smallerInsideSegmentSq + (insideWeight * insideWeight * widthSquared);
-          var insideMiterOk = pdist <= smallerInsideDiagonalSq;
-          if (insideMiterOk) {
-              if (style.join === exports.LINE_JOIN.BEVEL || pdist / widthSquared > miterLimitSquared) {
-                  if (clockwise) /* rotating at inner angle */ {
-                      verts.push(imx, imy); // inner miter point
-                      verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight)); // first segment's outer vertex
-                      verts.push(imx, imy); // inner miter point
-                      verts.push(x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight)); // second segment's outer vertex
-                  }
-                  else /* rotating at outer angle */ {
-                      verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight)); // first segment's inner vertex
-                      verts.push(omx, omy); // outer miter point
-                      verts.push(x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight)); // second segment's outer vertex
-                      verts.push(omx, omy); // outer miter point
-                  }
-                  indexCount += 2;
-              }
-              else if (style.join === exports.LINE_JOIN.ROUND) {
-                  if (clockwise) /* arc is outside */ {
-                      verts.push(imx, imy);
-                      verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight));
-                      indexCount += round(x1, y1, x1 + (perpx * outerWeight), y1 + (perpy * outerWeight), x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight), verts, true) + 4;
-                      verts.push(imx, imy);
-                      verts.push(x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight));
-                  }
-                  else /* arc is inside */ {
-                      verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight));
-                      verts.push(omx, omy);
-                      indexCount += round(x1, y1, x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight), verts, false) + 4;
-                      verts.push(x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight));
-                      verts.push(omx, omy);
-                  }
-              }
-              else {
-                  verts.push(imx, imy);
-                  verts.push(omx, omy);
-              }
-          }
-          else // inside miter is NOT ok
-           {
-              verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight)); // first segment's inner vertex
-              verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight)); // first segment's outer vertex
-              if (style.join === exports.LINE_JOIN.ROUND) {
-                  if (clockwise) /* arc is outside */ {
-                      indexCount += round(x1, y1, x1 + (perpx * outerWeight), y1 + (perpy * outerWeight), x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight), verts, true) + 2;
-                  }
-                  else /* arc is inside */ {
-                      indexCount += round(x1, y1, x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight), verts, false) + 2;
-                  }
-              }
-              else if (style.join === exports.LINE_JOIN.MITER && pdist / widthSquared <= miterLimitSquared) {
-                  if (clockwise) {
-                      verts.push(omx, omy); // inner miter point
-                      verts.push(omx, omy); // inner miter point
-                  }
-                  else {
-                      verts.push(imx, imy); // outer miter point
-                      verts.push(imx, imy); // outer miter point
-                  }
-                  indexCount += 2;
-              }
-              verts.push(x1 - (perp1x * innerWeight), y1 - (perp1y * innerWeight)); // second segment's inner vertex
-              verts.push(x1 + (perp1x * outerWeight), y1 + (perp1y * outerWeight)); // second segment's outer vertex
-              indexCount += 2;
-          }
-      }
-      x0 = points[(length - 2) * 2];
-      y0 = points[((length - 2) * 2) + 1];
-      x1 = points[(length - 1) * 2];
-      y1 = points[((length - 1) * 2) + 1];
-      perpx = -(y0 - y1);
-      perpy = x0 - x1;
-      dist = Math.sqrt((perpx * perpx) + (perpy * perpy));
-      perpx /= dist;
-      perpy /= dist;
-      perpx *= width;
-      perpy *= width;
-      verts.push(x1 - (perpx * innerWeight), y1 - (perpy * innerWeight));
-      verts.push(x1 + (perpx * outerWeight), y1 + (perpy * outerWeight));
-      if (!closedShape) {
-          if (style.cap === exports.LINE_CAP.ROUND) {
-              indexCount += round(x1 - (perpx * (innerWeight - outerWeight) * 0.5), y1 - (perpy * (innerWeight - outerWeight) * 0.5), x1 - (perpx * innerWeight), y1 - (perpy * innerWeight), x1 + (perpx * outerWeight), y1 + (perpy * outerWeight), verts, false) + 2;
-          }
-          else if (style.cap === exports.LINE_CAP.SQUARE) {
-              indexCount += square(x1, y1, perpx, perpy, innerWeight, outerWeight, false, verts);
-          }
-      }
-      var indices = graphicsGeometry.indices;
-      var eps2 = GRAPHICS_CURVES.epsilon * GRAPHICS_CURVES.epsilon;
-      // indices.push(indexStart);
-      for (var i = indexStart; i < indexCount + indexStart - 2; ++i) {
-          x0 = verts[(i * 2)];
-          y0 = verts[(i * 2) + 1];
-          x1 = verts[(i + 1) * 2];
-          y1 = verts[((i + 1) * 2) + 1];
-          x2 = verts[(i + 2) * 2];
-          y2 = verts[((i + 2) * 2) + 1];
-          /* Skip zero area triangles */
-          if (Math.abs((x0 * (y1 - y2)) + (x1 * (y2 - y0)) + (x2 * (y0 - y1))) < eps2) {
-              continue;
-          }
-          indices.push(i, i + 1, i + 2);
-      }
-  }
-  /**
-   * Builds a line to draw using the gl.drawArrays(gl.LINES) method
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {PIXI.GraphicsData} graphicsData - The graphics object containing all the necessary properties
-   * @param {PIXI.GraphicsGeometry} graphicsGeometry - Geometry where to append output
-   */
-  function buildNativeLine(graphicsData, graphicsGeometry) {
-      var i = 0;
-      var shape = graphicsData.shape;
-      var points = graphicsData.points || shape.points;
-      var closedShape = shape.type !== exports.SHAPES.POLY || shape.closeStroke;
-      if (points.length === 0)
-          { return; }
-      var verts = graphicsGeometry.points;
-      var indices = graphicsGeometry.indices;
-      var length = points.length / 2;
-      var startIndex = verts.length / 2;
-      var currentIndex = startIndex;
-      verts.push(points[0], points[1]);
-      for (i = 1; i < length; i++) {
-          verts.push(points[i * 2], points[(i * 2) + 1]);
-          indices.push(currentIndex, currentIndex + 1);
-          currentIndex++;
-      }
-      if (closedShape) {
-          indices.push(currentIndex, startIndex);
-      }
-  }
-  /**
-   * Builds a line to draw
-   *
-   * Ignored from docs since it is not directly exposed.
-   * @ignore
-   * @private
-   * @param {PIXI.GraphicsData} graphicsData - The graphics object containing all the necessary properties
-   * @param {PIXI.GraphicsGeometry} graphicsGeometry - Geometry where to append output
-   */
-  function buildLine(graphicsData, graphicsGeometry) {
-      if (graphicsData.lineStyle.native) {
-          buildNativeLine(graphicsData, graphicsGeometry);
-      }
-      else {
-          buildNonNativeLine(graphicsData, graphicsGeometry);
-      }
-  }
-
-  /**
-   * Utilities for arc curves.
-   * @private
-   */
-  var ArcUtils = /** @class */ (function () {
-      function ArcUtils() {
-      }
-      /**
-       * The arcTo() method creates an arc/curve between two tangents on the canvas.
-       *
-       * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
-       * @private
-       * @param x1 - The x-coordinate of the beginning of the arc
-       * @param y1 - The y-coordinate of the beginning of the arc
-       * @param x2 - The x-coordinate of the end of the arc
-       * @param y2 - The y-coordinate of the end of the arc
-       * @param radius - The radius of the arc
-       * @param points -
-       * @returns - If the arc length is valid, return center of circle, radius and other info otherwise `null`.
-       */
-      ArcUtils.curveTo = function (x1, y1, x2, y2, radius, points) {
-          var fromX = points[points.length - 2];
-          var fromY = points[points.length - 1];
-          var a1 = fromY - y1;
-          var b1 = fromX - x1;
-          var a2 = y2 - y1;
-          var b2 = x2 - x1;
-          var mm = Math.abs((a1 * b2) - (b1 * a2));
-          if (mm < 1.0e-8 || radius === 0) {
-              if (points[points.length - 2] !== x1 || points[points.length - 1] !== y1) {
-                  points.push(x1, y1);
-              }
-              return null;
-          }
-          var dd = (a1 * a1) + (b1 * b1);
-          var cc = (a2 * a2) + (b2 * b2);
-          var tt = (a1 * a2) + (b1 * b2);
-          var k1 = radius * Math.sqrt(dd) / mm;
-          var k2 = radius * Math.sqrt(cc) / mm;
-          var j1 = k1 * tt / dd;
-          var j2 = k2 * tt / cc;
-          var cx = (k1 * b2) + (k2 * b1);
-          var cy = (k1 * a2) + (k2 * a1);
-          var px = b1 * (k2 + j1);
-          var py = a1 * (k2 + j1);
-          var qx = b2 * (k1 + j2);
-          var qy = a2 * (k1 + j2);
-          var startAngle = Math.atan2(py - cy, px - cx);
-          var endAngle = Math.atan2(qy - cy, qx - cx);
-          return {
-              cx: (cx + x1),
-              cy: (cy + y1),
-              radius: radius,
-              startAngle: startAngle,
-              endAngle: endAngle,
-              anticlockwise: (b1 * a2 > b2 * a1),
-          };
-      };
-      /* eslint-disable max-len */
-      /**
-       * The arc method creates an arc/curve (used to create circles, or parts of circles).
-       * @private
-       * @param _startX - Start x location of arc
-       * @param _startY - Start y location of arc
-       * @param cx - The x-coordinate of the center of the circle
-       * @param cy - The y-coordinate of the center of the circle
-       * @param radius - The radius of the circle
-       * @param startAngle - The starting angle, in radians (0 is at the 3 o'clock position
-       *  of the arc's circle)
-       * @param endAngle - The ending angle, in radians
-       * @param _anticlockwise - Specifies whether the drawing should be
-       *  counter-clockwise or clockwise. False is default, and indicates clockwise, while true
-       *  indicates counter-clockwise.
-       * @param points - Collection of points to add to
-       */
-      ArcUtils.arc = function (_startX, _startY, cx, cy, radius, startAngle, endAngle, _anticlockwise, points) {
-          var sweep = endAngle - startAngle;
-          var n = GRAPHICS_CURVES._segmentsCount(Math.abs(sweep) * radius, Math.ceil(Math.abs(sweep) / PI_2) * 40);
-          var theta = (sweep) / (n * 2);
-          var theta2 = theta * 2;
-          var cTheta = Math.cos(theta);
-          var sTheta = Math.sin(theta);
-          var segMinus = n - 1;
-          var remainder = (segMinus % 1) / segMinus;
-          for (var i = 0; i <= segMinus; ++i) {
-              var real = i + (remainder * i);
-              var angle = ((theta) + startAngle + (theta2 * real));
-              var c = Math.cos(angle);
-              var s = -Math.sin(angle);
-              points.push((((cTheta * c) + (sTheta * s)) * radius) + cx, (((cTheta * -s) + (sTheta * c)) * radius) + cy);
-          }
-      };
-      return ArcUtils;
-  }());
-
-  /**
-   * Utilities for bezier curves
-   * @private
-   */
-  var BezierUtils = /** @class */ (function () {
-      function BezierUtils() {
-      }
-      /**
-       * Calculate length of bezier curve.
-       * Analytical solution is impossible, since it involves an integral that does not integrate in general.
-       * Therefore numerical solution is used.
-       * @private
-       * @param fromX - Starting point x
-       * @param fromY - Starting point y
-       * @param cpX - Control point x
-       * @param cpY - Control point y
-       * @param cpX2 - Second Control point x
-       * @param cpY2 - Second Control point y
-       * @param toX - Destination point x
-       * @param toY - Destination point y
-       * @returns - Length of bezier curve
-       */
-      BezierUtils.curveLength = function (fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY) {
-          var n = 10;
-          var result = 0.0;
-          var t = 0.0;
-          var t2 = 0.0;
-          var t3 = 0.0;
-          var nt = 0.0;
-          var nt2 = 0.0;
-          var nt3 = 0.0;
-          var x = 0.0;
-          var y = 0.0;
-          var dx = 0.0;
-          var dy = 0.0;
-          var prevX = fromX;
-          var prevY = fromY;
-          for (var i = 1; i <= n; ++i) {
-              t = i / n;
-              t2 = t * t;
-              t3 = t2 * t;
-              nt = (1.0 - t);
-              nt2 = nt * nt;
-              nt3 = nt2 * nt;
-              x = (nt3 * fromX) + (3.0 * nt2 * t * cpX) + (3.0 * nt * t2 * cpX2) + (t3 * toX);
-              y = (nt3 * fromY) + (3.0 * nt2 * t * cpY) + (3 * nt * t2 * cpY2) + (t3 * toY);
-              dx = prevX - x;
-              dy = prevY - y;
-              prevX = x;
-              prevY = y;
-              result += Math.sqrt((dx * dx) + (dy * dy));
-          }
-          return result;
-      };
-      /**
-       * Calculate the points for a bezier curve and then draws it.
-       *
-       * Ignored from docs since it is not directly exposed.
-       * @ignore
-       * @param cpX - Control point x
-       * @param cpY - Control point y
-       * @param cpX2 - Second Control point x
-       * @param cpY2 - Second Control point y
-       * @param toX - Destination point x
-       * @param toY - Destination point y
-       * @param points - Path array to push points into
-       */
-      BezierUtils.curveTo = function (cpX, cpY, cpX2, cpY2, toX, toY, points) {
-          var fromX = points[points.length - 2];
-          var fromY = points[points.length - 1];
-          points.length -= 2;
-          var n = GRAPHICS_CURVES._segmentsCount(BezierUtils.curveLength(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY));
-          var dt = 0;
-          var dt2 = 0;
-          var dt3 = 0;
-          var t2 = 0;
-          var t3 = 0;
-          points.push(fromX, fromY);
-          for (var i = 1, j = 0; i <= n; ++i) {
-              j = i / n;
-              dt = (1 - j);
-              dt2 = dt * dt;
-              dt3 = dt2 * dt;
-              t2 = j * j;
-              t3 = t2 * j;
-              points.push((dt3 * fromX) + (3 * dt2 * j * cpX) + (3 * dt * t2 * cpX2) + (t3 * toX), (dt3 * fromY) + (3 * dt2 * j * cpY) + (3 * dt * t2 * cpY2) + (t3 * toY));
-          }
-      };
-      return BezierUtils;
-  }());
-
-  /**
-   * Utilities for quadratic curves.
-   * @private
-   */
-  var QuadraticUtils = /** @class */ (function () {
-      function QuadraticUtils() {
-      }
-      /**
-       * Calculate length of quadratic curve
-       * @see {@link http://www.malczak.linuxpl.com/blog/quadratic-bezier-curve-length/}
-       * for the detailed explanation of math behind this.
-       * @private
-       * @param fromX - x-coordinate of curve start point
-       * @param fromY - y-coordinate of curve start point
-       * @param cpX - x-coordinate of curve control point
-       * @param cpY - y-coordinate of curve control point
-       * @param toX - x-coordinate of curve end point
-       * @param toY - y-coordinate of curve end point
-       * @returns - Length of quadratic curve
-       */
-      QuadraticUtils.curveLength = function (fromX, fromY, cpX, cpY, toX, toY) {
-          var ax = fromX - (2.0 * cpX) + toX;
-          var ay = fromY - (2.0 * cpY) + toY;
-          var bx = (2.0 * cpX) - (2.0 * fromX);
-          var by = (2.0 * cpY) - (2.0 * fromY);
-          var a = 4.0 * ((ax * ax) + (ay * ay));
-          var b = 4.0 * ((ax * bx) + (ay * by));
-          var c = (bx * bx) + (by * by);
-          var s = 2.0 * Math.sqrt(a + b + c);
-          var a2 = Math.sqrt(a);
-          var a32 = 2.0 * a * a2;
-          var c2 = 2.0 * Math.sqrt(c);
-          var ba = b / a2;
-          return ((a32 * s)
-              + (a2 * b * (s - c2))
-              + (((4.0 * c * a) - (b * b))
-                  * Math.log(((2.0 * a2) + ba + s) / (ba + c2)))) / (4.0 * a32);
-      };
-      /**
-       * Calculate the points for a quadratic bezier curve and then draws it.
-       * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
-       * @private
-       * @param cpX - Control point x
-       * @param cpY - Control point y
-       * @param toX - Destination point x
-       * @param toY - Destination point y
-       * @param points - Points to add segments to.
-       */
-      QuadraticUtils.curveTo = function (cpX, cpY, toX, toY, points) {
-          var fromX = points[points.length - 2];
-          var fromY = points[points.length - 1];
-          var n = GRAPHICS_CURVES._segmentsCount(QuadraticUtils.curveLength(fromX, fromY, cpX, cpY, toX, toY));
-          var xa = 0;
-          var ya = 0;
-          for (var i = 1; i <= n; ++i) {
-              var j = i / n;
-              xa = fromX + ((cpX - fromX) * j);
-              ya = fromY + ((cpY - fromY) * j);
-              points.push(xa + (((cpX + ((toX - cpX) * j)) - xa) * j), ya + (((cpY + ((toY - cpY) * j)) - ya) * j));
-          }
-      };
-      return QuadraticUtils;
-  }());
-
-  /**
-   * A structure to hold interim batch objects for Graphics.
-   * @memberof PIXI.graphicsUtils
-   */
-  var BatchPart = /** @class */ (function () {
-      function BatchPart() {
-          this.reset();
-      }
-      /**
-       * Begin batch part.
-       * @param style
-       * @param startIndex
-       * @param attribStart
-       */
-      BatchPart.prototype.begin = function (style, startIndex, attribStart) {
-          this.reset();
-          this.style = style;
-          this.start = startIndex;
-          this.attribStart = attribStart;
-      };
-      /**
-       * End batch part.
-       * @param endIndex
-       * @param endAttrib
-       */
-      BatchPart.prototype.end = function (endIndex, endAttrib) {
-          this.attribSize = endAttrib - this.attribStart;
-          this.size = endIndex - this.start;
-      };
-      BatchPart.prototype.reset = function () {
-          this.style = null;
-          this.size = 0;
-          this.start = 0;
-          this.attribStart = 0;
-          this.attribSize = 0;
-      };
-      return BatchPart;
-  }());
-
-  /**
-   * Generalized convenience utilities for Graphics.
-   * @namespace graphicsUtils
-   * @memberof PIXI
-   */
-  var _a;
-  /**
-   * Map of fill commands for each shape type.
-   * @memberof PIXI.graphicsUtils
-   * @member {object} FILL_COMMANDS
-   */
-  var FILL_COMMANDS = (_a = {},
-      _a[exports.SHAPES.POLY] = buildPoly,
-      _a[exports.SHAPES.CIRC] = buildCircle,
-      _a[exports.SHAPES.ELIP] = buildCircle,
-      _a[exports.SHAPES.RECT] = buildRectangle,
-      _a[exports.SHAPES.RREC] = buildRoundedRectangle,
-      _a);
-  /**
-   * Batch pool, stores unused batches for preventing allocations.
-   * @memberof PIXI.graphicsUtils
-   * @member {Array<PIXI.graphicsUtils.BatchPart>} BATCH_POOL
-   */
-  var BATCH_POOL = [];
-  /**
-   * Draw call pool, stores unused draw calls for preventing allocations.
-   * @memberof PIXI.graphicsUtils
-   * @member {Array<PIXI.BatchDrawCall>} DRAW_CALL_POOL
-   */
-  var DRAW_CALL_POOL = [];
-
-  /**
-   * A class to contain data useful for Graphics objects
-   * @memberof PIXI
-   */
-  var GraphicsData = /** @class */ (function () {
-      /**
-       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - The shape object to draw.
-       * @param fillStyle - the width of the line to draw
-       * @param lineStyle - the color of the line to draw
-       * @param matrix - Transform matrix
-       */
-      function GraphicsData(shape, fillStyle, lineStyle, matrix) {
-          if (fillStyle === void 0) { fillStyle = null; }
-          if (lineStyle === void 0) { lineStyle = null; }
-          if (matrix === void 0) { matrix = null; }
-          /** The collection of points. */
-          this.points = [];
-          /** The collection of holes. */
-          this.holes = [];
-          this.shape = shape;
-          this.lineStyle = lineStyle;
-          this.fillStyle = fillStyle;
-          this.matrix = matrix;
-          this.type = shape.type;
-      }
-      /**
-       * Creates a new GraphicsData object with the same values as this one.
-       * @returns - Cloned GraphicsData object
-       */
-      GraphicsData.prototype.clone = function () {
-          return new GraphicsData(this.shape, this.fillStyle, this.lineStyle, this.matrix);
-      };
-      /** Destroys the Graphics data. */
-      GraphicsData.prototype.destroy = function () {
-          this.shape = null;
-          this.holes.length = 0;
-          this.holes = null;
-          this.points.length = 0;
-          this.points = null;
-          this.lineStyle = null;
-          this.fillStyle = null;
-      };
-      return GraphicsData;
-  }());
-
-  var tmpPoint = new Point();
-  /**
-   * The Graphics class contains methods used to draw primitive shapes such as lines, circles and
-   * rectangles to the display, and to color and fill them.
-   *
-   * GraphicsGeometry is designed to not be continually updating the geometry since it's expensive
-   * to re-tesselate using **earcut**. Consider using {@link PIXI.Mesh} for this use-case, it's much faster.
-   * @memberof PIXI
-   */
-  var GraphicsGeometry = /** @class */ (function (_super) {
-      __extends$e(GraphicsGeometry, _super);
-      // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-      function GraphicsGeometry() {
-          var _this = _super.call(this) || this;
-          /** Minimal distance between points that are considered different. Affects line tesselation. */
-          _this.closePointEps = 1e-4;
-          /** Padding to add to the bounds. */
-          _this.boundsPadding = 0;
-          _this.uvsFloat32 = null;
-          _this.indicesUint16 = null;
-          _this.batchable = false;
-          /** An array of points to draw, 2 numbers per point */
-          _this.points = [];
-          /** The collection of colors */
-          _this.colors = [];
-          /** The UVs collection */
-          _this.uvs = [];
-          /** The indices of the vertices */
-          _this.indices = [];
-          /** Reference to the texture IDs. */
-          _this.textureIds = [];
-          /**
-           * The collection of drawn shapes.
-           * @member {PIXI.GraphicsData[]}
-           */
-          _this.graphicsData = [];
-          /**
-           * List of current draw calls drived from the batches.
-           * @member {PIXI.BatchDrawCall[]}
-           */
-          _this.drawCalls = [];
-          /** Batches need to regenerated if the geometry is updated. */
-          _this.batchDirty = -1;
-          /**
-           * Intermediate abstract format sent to batch system.
-           * Can be converted to drawCalls or to batchable objects.
-           * @member {PIXI.graphicsUtils.BatchPart[]}
-           */
-          _this.batches = [];
-          /** Used to detect if the graphics object has changed. */
-          _this.dirty = 0;
-          /** Used to check if the cache is dirty. */
-          _this.cacheDirty = -1;
-          /** Used to detect if we cleared the graphicsData. */
-          _this.clearDirty = 0;
-          /** Index of the last batched shape in the stack of calls. */
-          _this.shapeIndex = 0;
-          /** Cached bounds. */
-          _this._bounds = new Bounds();
-          /** The bounds dirty flag. */
-          _this.boundsDirty = -1;
-          return _this;
-      }
-      Object.defineProperty(GraphicsGeometry.prototype, "bounds", {
-          /**
-           * Get the current bounds of the graphic geometry.
-           * @readonly
-           */
-          get: function () {
-              this.updateBatches();
-              if (this.boundsDirty !== this.dirty) {
-                  this.boundsDirty = this.dirty;
-                  this.calculateBounds();
-              }
-              return this._bounds;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Call if you changed graphicsData manually. Empties all batch buffers. */
-      GraphicsGeometry.prototype.invalidate = function () {
-          this.boundsDirty = -1;
-          this.dirty++;
-          this.batchDirty++;
-          this.shapeIndex = 0;
-          this.points.length = 0;
-          this.colors.length = 0;
-          this.uvs.length = 0;
-          this.indices.length = 0;
-          this.textureIds.length = 0;
-          for (var i = 0; i < this.drawCalls.length; i++) {
-              this.drawCalls[i].texArray.clear();
-              DRAW_CALL_POOL.push(this.drawCalls[i]);
-          }
-          this.drawCalls.length = 0;
-          for (var i = 0; i < this.batches.length; i++) {
-              var batchPart = this.batches[i];
-              batchPart.reset();
-              BATCH_POOL.push(batchPart);
-          }
-          this.batches.length = 0;
-      };
-      /**
-       * Clears the graphics that were drawn to this Graphics object, and resets fill and line style settings.
-       * @returns - This GraphicsGeometry object. Good for chaining method calls
-       */
-      GraphicsGeometry.prototype.clear = function () {
-          if (this.graphicsData.length > 0) {
-              this.invalidate();
-              this.clearDirty++;
-              this.graphicsData.length = 0;
-          }
-          return this;
-      };
-      /**
-       * Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
-       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - The shape object to draw.
-       * @param fillStyle - Defines style of the fill.
-       * @param lineStyle - Defines style of the lines.
-       * @param matrix - Transform applied to the points of the shape.
-       * @returns - Returns geometry for chaining.
-       */
-      GraphicsGeometry.prototype.drawShape = function (shape, fillStyle, lineStyle, matrix) {
-          if (fillStyle === void 0) { fillStyle = null; }
-          if (lineStyle === void 0) { lineStyle = null; }
-          if (matrix === void 0) { matrix = null; }
-          var data = new GraphicsData(shape, fillStyle, lineStyle, matrix);
-          this.graphicsData.push(data);
-          this.dirty++;
-          return this;
-      };
-      /**
-       * Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
-       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - The shape object to draw.
-       * @param matrix - Transform applied to the points of the shape.
-       * @returns - Returns geometry for chaining.
-       */
-      GraphicsGeometry.prototype.drawHole = function (shape, matrix) {
-          if (matrix === void 0) { matrix = null; }
-          if (!this.graphicsData.length) {
-              return null;
-          }
-          var data = new GraphicsData(shape, null, null, matrix);
-          var lastShape = this.graphicsData[this.graphicsData.length - 1];
-          data.lineStyle = lastShape.lineStyle;
-          lastShape.holes.push(data);
-          this.dirty++;
-          return this;
-      };
-      /** Destroys the GraphicsGeometry object. */
-      GraphicsGeometry.prototype.destroy = function () {
-          _super.prototype.destroy.call(this);
-          // destroy each of the GraphicsData objects
-          for (var i = 0; i < this.graphicsData.length; ++i) {
-              this.graphicsData[i].destroy();
-          }
-          this.points.length = 0;
-          this.points = null;
-          this.colors.length = 0;
-          this.colors = null;
-          this.uvs.length = 0;
-          this.uvs = null;
-          this.indices.length = 0;
-          this.indices = null;
-          this.indexBuffer.destroy();
-          this.indexBuffer = null;
-          this.graphicsData.length = 0;
-          this.graphicsData = null;
-          this.drawCalls.length = 0;
-          this.drawCalls = null;
-          this.batches.length = 0;
-          this.batches = null;
-          this._bounds = null;
-      };
-      /**
-       * Check to see if a point is contained within this geometry.
-       * @param point - Point to check if it's contained.
-       * @returns {boolean} `true` if the point is contained within geometry.
-       */
-      GraphicsGeometry.prototype.containsPoint = function (point) {
-          var graphicsData = this.graphicsData;
-          for (var i = 0; i < graphicsData.length; ++i) {
-              var data = graphicsData[i];
-              if (!data.fillStyle.visible) {
-                  continue;
-              }
-              // only deal with fills..
-              if (data.shape) {
-                  if (data.matrix) {
-                      data.matrix.applyInverse(point, tmpPoint);
-                  }
-                  else {
-                      tmpPoint.copyFrom(point);
-                  }
-                  if (data.shape.contains(tmpPoint.x, tmpPoint.y)) {
-                      var hitHole = false;
-                      if (data.holes) {
-                          for (var i_1 = 0; i_1 < data.holes.length; i_1++) {
-                              var hole = data.holes[i_1];
-                              if (hole.shape.contains(tmpPoint.x, tmpPoint.y)) {
-                                  hitHole = true;
-                                  break;
-                              }
-                          }
-                      }
-                      if (!hitHole) {
-                          return true;
-                      }
-                  }
-              }
-          }
-          return false;
-      };
-      /**
-       * Generates intermediate batch data. Either gets converted to drawCalls
-       * or used to convert to batch objects directly by the Graphics object.
-       */
-      GraphicsGeometry.prototype.updateBatches = function () {
-          if (!this.graphicsData.length) {
-              this.batchable = true;
-              return;
-          }
-          if (!this.validateBatching()) {
-              return;
-          }
-          this.cacheDirty = this.dirty;
-          var uvs = this.uvs;
-          var graphicsData = this.graphicsData;
-          var batchPart = null;
-          var currentStyle = null;
-          if (this.batches.length > 0) {
-              batchPart = this.batches[this.batches.length - 1];
-              currentStyle = batchPart.style;
-          }
-          for (var i = this.shapeIndex; i < graphicsData.length; i++) {
-              this.shapeIndex++;
-              var data = graphicsData[i];
-              var fillStyle = data.fillStyle;
-              var lineStyle = data.lineStyle;
-              var command = FILL_COMMANDS[data.type];
-              // build out the shapes points..
-              command.build(data);
-              if (data.matrix) {
-                  this.transformPoints(data.points, data.matrix);
-              }
-              if (fillStyle.visible || lineStyle.visible) {
-                  this.processHoles(data.holes);
-              }
-              for (var j = 0; j < 2; j++) {
-                  var style = (j === 0) ? fillStyle : lineStyle;
-                  if (!style.visible)
-                      { continue; }
-                  var nextTexture = style.texture.baseTexture;
-                  var index_1 = this.indices.length;
-                  var attribIndex = this.points.length / 2;
-                  nextTexture.wrapMode = exports.WRAP_MODES.REPEAT;
-                  if (j === 0) {
-                      this.processFill(data);
-                  }
-                  else {
-                      this.processLine(data);
-                  }
-                  var size = (this.points.length / 2) - attribIndex;
-                  if (size === 0)
-                      { continue; }
-                  // close batch if style is different
-                  if (batchPart && !this._compareStyles(currentStyle, style)) {
-                      batchPart.end(index_1, attribIndex);
-                      batchPart = null;
-                  }
-                  // spawn new batch if its first batch or previous was closed
-                  if (!batchPart) {
-                      batchPart = BATCH_POOL.pop() || new BatchPart();
-                      batchPart.begin(style, index_1, attribIndex);
-                      this.batches.push(batchPart);
-                      currentStyle = style;
-                  }
-                  this.addUvs(this.points, uvs, style.texture, attribIndex, size, style.matrix);
-              }
-          }
-          var index = this.indices.length;
-          var attrib = this.points.length / 2;
-          if (batchPart) {
-              batchPart.end(index, attrib);
-          }
-          if (this.batches.length === 0) {
-              // there are no visible styles in GraphicsData
-              // its possible that someone wants Graphics just for the bounds
-              this.batchable = true;
-              return;
-          }
-          var need32 = attrib > 0xffff;
-          // prevent allocation when length is same as buffer
-          if (this.indicesUint16 && this.indices.length === this.indicesUint16.length
-              && need32 === (this.indicesUint16.BYTES_PER_ELEMENT > 2)) {
-              this.indicesUint16.set(this.indices);
-          }
-          else {
-              this.indicesUint16 = need32 ? new Uint32Array(this.indices) : new Uint16Array(this.indices);
-          }
-          // TODO make this a const..
-          this.batchable = this.isBatchable();
-          if (this.batchable) {
-              this.packBatches();
-          }
-          else {
-              this.buildDrawCalls();
-          }
-      };
-      /**
-       * Affinity check
-       * @param styleA
-       * @param styleB
-       */
-      GraphicsGeometry.prototype._compareStyles = function (styleA, styleB) {
-          if (!styleA || !styleB) {
-              return false;
-          }
-          if (styleA.texture.baseTexture !== styleB.texture.baseTexture) {
-              return false;
-          }
-          if (styleA.color + styleA.alpha !== styleB.color + styleB.alpha) {
-              return false;
-          }
-          if (!!styleA.native !== !!styleB.native) {
-              return false;
-          }
-          return true;
-      };
-      /** Test geometry for batching process. */
-      GraphicsGeometry.prototype.validateBatching = function () {
-          if (this.dirty === this.cacheDirty || !this.graphicsData.length) {
-              return false;
-          }
-          for (var i = 0, l = this.graphicsData.length; i < l; i++) {
-              var data = this.graphicsData[i];
-              var fill = data.fillStyle;
-              var line = data.lineStyle;
-              if (fill && !fill.texture.baseTexture.valid)
-                  { return false; }
-              if (line && !line.texture.baseTexture.valid)
-                  { return false; }
-          }
-          return true;
-      };
-      /** Offset the indices so that it works with the batcher. */
-      GraphicsGeometry.prototype.packBatches = function () {
-          this.batchDirty++;
-          this.uvsFloat32 = new Float32Array(this.uvs);
-          var batches = this.batches;
-          for (var i = 0, l = batches.length; i < l; i++) {
-              var batch = batches[i];
-              for (var j = 0; j < batch.size; j++) {
-                  var index = batch.start + j;
-                  this.indicesUint16[index] = this.indicesUint16[index] - batch.attribStart;
-              }
-          }
-      };
-      /**
-       * Checks to see if this graphics geometry can be batched.
-       * Currently it needs to be small enough and not contain any native lines.
-       */
-      GraphicsGeometry.prototype.isBatchable = function () {
-          // prevent heavy mesh batching
-          if (this.points.length > 0xffff * 2) {
-              return false;
-          }
-          var batches = this.batches;
-          for (var i = 0; i < batches.length; i++) {
-              if (batches[i].style.native) {
-                  return false;
-              }
-          }
-          return (this.points.length < GraphicsGeometry.BATCHABLE_SIZE * 2);
-      };
-      /** Converts intermediate batches data to drawCalls. */
-      GraphicsGeometry.prototype.buildDrawCalls = function () {
-          var TICK = ++BaseTexture._globalBatch;
-          for (var i = 0; i < this.drawCalls.length; i++) {
-              this.drawCalls[i].texArray.clear();
-              DRAW_CALL_POOL.push(this.drawCalls[i]);
-          }
-          this.drawCalls.length = 0;
-          var colors = this.colors;
-          var textureIds = this.textureIds;
-          var currentGroup = DRAW_CALL_POOL.pop();
-          if (!currentGroup) {
-              currentGroup = new BatchDrawCall();
-              currentGroup.texArray = new BatchTextureArray();
-          }
-          currentGroup.texArray.count = 0;
-          currentGroup.start = 0;
-          currentGroup.size = 0;
-          currentGroup.type = exports.DRAW_MODES.TRIANGLES;
-          var textureCount = 0;
-          var currentTexture = null;
-          var textureId = 0;
-          var native = false;
-          var drawMode = exports.DRAW_MODES.TRIANGLES;
-          var index = 0;
-          this.drawCalls.push(currentGroup);
-          // TODO - this can be simplified
-          for (var i = 0; i < this.batches.length; i++) {
-              var data = this.batches[i];
-              // TODO add some full on MAX_TEXTURE CODE..
-              var MAX_TEXTURES = 8;
-              // Forced cast for checking `native` without errors
-              var style = data.style;
-              var nextTexture = style.texture.baseTexture;
-              if (native !== !!style.native) {
-                  native = !!style.native;
-                  drawMode = native ? exports.DRAW_MODES.LINES : exports.DRAW_MODES.TRIANGLES;
-                  // force the batch to break!
-                  currentTexture = null;
-                  textureCount = MAX_TEXTURES;
-                  TICK++;
-              }
-              if (currentTexture !== nextTexture) {
-                  currentTexture = nextTexture;
-                  if (nextTexture._batchEnabled !== TICK) {
-                      if (textureCount === MAX_TEXTURES) {
-                          TICK++;
-                          textureCount = 0;
-                          if (currentGroup.size > 0) {
-                              currentGroup = DRAW_CALL_POOL.pop();
-                              if (!currentGroup) {
-                                  currentGroup = new BatchDrawCall();
-                                  currentGroup.texArray = new BatchTextureArray();
-                              }
-                              this.drawCalls.push(currentGroup);
-                          }
-                          currentGroup.start = index;
-                          currentGroup.size = 0;
-                          currentGroup.texArray.count = 0;
-                          currentGroup.type = drawMode;
-                      }
-                      // TODO add this to the render part..
-                      // Hack! Because texture has protected `touched`
-                      nextTexture.touched = 1; // touch;
-                      nextTexture._batchEnabled = TICK;
-                      nextTexture._batchLocation = textureCount;
-                      nextTexture.wrapMode = exports.WRAP_MODES.REPEAT;
-                      currentGroup.texArray.elements[currentGroup.texArray.count++] = nextTexture;
-                      textureCount++;
-                  }
-              }
-              currentGroup.size += data.size;
-              index += data.size;
-              textureId = nextTexture._batchLocation;
-              this.addColors(colors, style.color, style.alpha, data.attribSize, data.attribStart);
-              this.addTextureIds(textureIds, textureId, data.attribSize, data.attribStart);
-          }
-          BaseTexture._globalBatch = TICK;
-          // upload..
-          // merge for now!
-          this.packAttributes();
-      };
-      /** Packs attributes to single buffer. */
-      GraphicsGeometry.prototype.packAttributes = function () {
-          var verts = this.points;
-          var uvs = this.uvs;
-          var colors = this.colors;
-          var textureIds = this.textureIds;
-          // verts are 2 positions.. so we * by 3 as there are 6 properties.. then 4 cos its bytes
-          var glPoints = new ArrayBuffer(verts.length * 3 * 4);
-          var f32 = new Float32Array(glPoints);
-          var u32 = new Uint32Array(glPoints);
-          var p = 0;
-          for (var i = 0; i < verts.length / 2; i++) {
-              f32[p++] = verts[i * 2];
-              f32[p++] = verts[(i * 2) + 1];
-              f32[p++] = uvs[i * 2];
-              f32[p++] = uvs[(i * 2) + 1];
-              u32[p++] = colors[i];
-              f32[p++] = textureIds[i];
-          }
-          this._buffer.update(glPoints);
-          this._indexBuffer.update(this.indicesUint16);
-      };
-      /**
-       * Process fill part of Graphics.
-       * @param data
-       */
-      GraphicsGeometry.prototype.processFill = function (data) {
-          if (data.holes.length) {
-              buildPoly.triangulate(data, this);
-          }
-          else {
-              var command = FILL_COMMANDS[data.type];
-              command.triangulate(data, this);
-          }
-      };
-      /**
-       * Process line part of Graphics.
-       * @param data
-       */
-      GraphicsGeometry.prototype.processLine = function (data) {
-          buildLine(data, this);
-          for (var i = 0; i < data.holes.length; i++) {
-              buildLine(data.holes[i], this);
-          }
-      };
-      /**
-       * Process the holes data.
-       * @param holes
-       */
-      GraphicsGeometry.prototype.processHoles = function (holes) {
-          for (var i = 0; i < holes.length; i++) {
-              var hole = holes[i];
-              var command = FILL_COMMANDS[hole.type];
-              command.build(hole);
-              if (hole.matrix) {
-                  this.transformPoints(hole.points, hole.matrix);
-              }
-          }
-      };
-      /** Update the local bounds of the object. Expensive to use performance-wise. */
-      GraphicsGeometry.prototype.calculateBounds = function () {
-          var bounds = this._bounds;
-          bounds.clear();
-          bounds.addVertexData(this.points, 0, this.points.length);
-          bounds.pad(this.boundsPadding, this.boundsPadding);
-      };
-      /**
-       * Transform points using matrix.
-       * @param points - Points to transform
-       * @param matrix - Transform matrix
-       */
-      GraphicsGeometry.prototype.transformPoints = function (points, matrix) {
-          for (var i = 0; i < points.length / 2; i++) {
-              var x = points[(i * 2)];
-              var y = points[(i * 2) + 1];
-              points[(i * 2)] = (matrix.a * x) + (matrix.c * y) + matrix.tx;
-              points[(i * 2) + 1] = (matrix.b * x) + (matrix.d * y) + matrix.ty;
-          }
-      };
-      /**
-       * Add colors.
-       * @param colors - List of colors to add to
-       * @param color - Color to add
-       * @param alpha - Alpha to use
-       * @param size - Number of colors to add
-       * @param offset
-       */
-      GraphicsGeometry.prototype.addColors = function (colors, color, alpha, size, offset) {
-          if (offset === void 0) { offset = 0; }
-          // TODO use the premultiply bits Ivan added
-          var rgb = (color >> 16) + (color & 0xff00) + ((color & 0xff) << 16);
-          var rgba = premultiplyTint(rgb, alpha);
-          colors.length = Math.max(colors.length, offset + size);
-          for (var i = 0; i < size; i++) {
-              colors[offset + i] = rgba;
-          }
-      };
-      /**
-       * Add texture id that the shader/fragment wants to use.
-       * @param textureIds
-       * @param id
-       * @param size
-       * @param offset
-       */
-      GraphicsGeometry.prototype.addTextureIds = function (textureIds, id, size, offset) {
-          if (offset === void 0) { offset = 0; }
-          textureIds.length = Math.max(textureIds.length, offset + size);
-          for (var i = 0; i < size; i++) {
-              textureIds[offset + i] = id;
-          }
-      };
-      /**
-       * Generates the UVs for a shape.
-       * @param verts - Vertices
-       * @param uvs - UVs
-       * @param texture - Reference to Texture
-       * @param start - Index buffer start index.
-       * @param size - The size/length for index buffer.
-       * @param matrix - Optional transform for all points.
-       */
-      GraphicsGeometry.prototype.addUvs = function (verts, uvs, texture, start, size, matrix) {
-          if (matrix === void 0) { matrix = null; }
-          var index = 0;
-          var uvsStart = uvs.length;
-          var frame = texture.frame;
-          while (index < size) {
-              var x = verts[(start + index) * 2];
-              var y = verts[((start + index) * 2) + 1];
-              if (matrix) {
-                  var nx = (matrix.a * x) + (matrix.c * y) + matrix.tx;
-                  y = (matrix.b * x) + (matrix.d * y) + matrix.ty;
-                  x = nx;
-              }
-              index++;
-              uvs.push(x / frame.width, y / frame.height);
-          }
-          var baseTexture = texture.baseTexture;
-          if (frame.width < baseTexture.width
-              || frame.height < baseTexture.height) {
-              this.adjustUvs(uvs, texture, uvsStart, size);
-          }
-      };
-      /**
-       * Modify uvs array according to position of texture region
-       * Does not work with rotated or trimmed textures
-       * @param uvs - array
-       * @param texture - region
-       * @param start - starting index for uvs
-       * @param size - how many points to adjust
-       */
-      GraphicsGeometry.prototype.adjustUvs = function (uvs, texture, start, size) {
-          var baseTexture = texture.baseTexture;
-          var eps = 1e-6;
-          var finish = start + (size * 2);
-          var frame = texture.frame;
-          var scaleX = frame.width / baseTexture.width;
-          var scaleY = frame.height / baseTexture.height;
-          var offsetX = frame.x / frame.width;
-          var offsetY = frame.y / frame.height;
-          var minX = Math.floor(uvs[start] + eps);
-          var minY = Math.floor(uvs[start + 1] + eps);
-          for (var i = start + 2; i < finish; i += 2) {
-              minX = Math.min(minX, Math.floor(uvs[i] + eps));
-              minY = Math.min(minY, Math.floor(uvs[i + 1] + eps));
-          }
-          offsetX -= minX;
-          offsetY -= minY;
-          for (var i = start; i < finish; i += 2) {
-              uvs[i] = (uvs[i] + offsetX) * scaleX;
-              uvs[i + 1] = (uvs[i + 1] + offsetY) * scaleY;
-          }
-      };
-      /**
-       * The maximum number of points to consider an object "batchable",
-       * able to be batched by the renderer's batch system.
-  \
-       */
-      GraphicsGeometry.BATCHABLE_SIZE = 100;
-      return GraphicsGeometry;
-  }(BatchGeometry));
-
-  /**
-   * Represents the line style for Graphics.
-   * @memberof PIXI
-   */
-  var LineStyle = /** @class */ (function (_super) {
-      __extends$e(LineStyle, _super);
-      function LineStyle() {
-          var _this = _super !== null && _super.apply(this, arguments) || this;
-          /** The width (thickness) of any lines drawn. */
-          _this.width = 0;
-          /** The alignment of any lines drawn (0.5 = middle, 1 = outer, 0 = inner). WebGL only. */
-          _this.alignment = 0.5;
-          /** If true the lines will be draw using LINES instead of TRIANGLE_STRIP. */
-          _this.native = false;
-          /**
-           * Line cap style.
-           * @member {PIXI.LINE_CAP}
-           * @default PIXI.LINE_CAP.BUTT
-           */
-          _this.cap = exports.LINE_CAP.BUTT;
-          /**
-           * Line join style.
-           * @member {PIXI.LINE_JOIN}
-           * @default PIXI.LINE_JOIN.MITER
-           */
-          _this.join = exports.LINE_JOIN.MITER;
-          /** Miter limit. */
-          _this.miterLimit = 10;
-          return _this;
-      }
-      /** Clones the object. */
-      LineStyle.prototype.clone = function () {
-          var obj = new LineStyle();
-          obj.color = this.color;
-          obj.alpha = this.alpha;
-          obj.texture = this.texture;
-          obj.matrix = this.matrix;
-          obj.visible = this.visible;
-          obj.width = this.width;
-          obj.alignment = this.alignment;
-          obj.native = this.native;
-          obj.cap = this.cap;
-          obj.join = this.join;
-          obj.miterLimit = this.miterLimit;
-          return obj;
-      };
-      /** Reset the line style to default. */
-      LineStyle.prototype.reset = function () {
-          _super.prototype.reset.call(this);
-          // Override default line style color
-          this.color = 0x0;
-          this.alignment = 0.5;
-          this.width = 0;
-          this.native = false;
-      };
-      return LineStyle;
-  }(FillStyle));
-
-  var temp = new Float32Array(3);
-  // a default shaders map used by graphics..
-  var DEFAULT_SHADERS = {};
-  /**
-   * The Graphics class is primarily used to render primitive shapes such as lines, circles and
-   * rectangles to the display, and to color and fill them.  However, you can also use a Graphics
-   * object to build a list of primitives to use as a mask, or as a complex hitArea.
-   *
-   * Please note that due to legacy naming conventions, the behavior of some functions in this class
-   * can be confusing.  Each call to `drawRect()`, `drawPolygon()`, etc. actually stores that primitive
-   * in the Geometry class's GraphicsGeometry object for later use in rendering or hit testing - the
-   * functions do not directly draw anything to the screen.  Similarly, the `clear()` function doesn't
-   * change the screen, it simply resets the list of primitives, which can be useful if you want to
-   * rebuild the contents of an existing Graphics object.
-   *
-   * Once a GraphicsGeometry list is built, you can re-use it in other Geometry objects as
-   * an optimization, by passing it into a new Geometry object's constructor.  Because of this
-   * ability, it's important to call `destroy()` on Geometry objects once you are done with them, to
-   * properly dereference each GraphicsGeometry and prevent memory leaks.
-   * @memberof PIXI
-   */
-  var Graphics = /** @class */ (function (_super) {
-      __extends$e(Graphics, _super);
-      /**
-       * @param geometry - Geometry to use, if omitted will create a new GraphicsGeometry instance.
-       */
-      function Graphics(geometry) {
-          if (geometry === void 0) { geometry = null; }
-          var _this = _super.call(this) || this;
-          /**
-           * Represents the vertex and fragment shaders that processes the geometry and runs on the GPU.
-           * Can be shared between multiple Graphics objects.
-           */
-          _this.shader = null;
-          /** Renderer plugin for batching */
-          _this.pluginName = 'batch';
-          /**
-           * Current path
-           * @readonly
-           */
-          _this.currentPath = null;
-          /** A collections of batches! These can be drawn by the renderer batch system. */
-          _this.batches = [];
-          /** Update dirty for limiting calculating tints for batches. */
-          _this.batchTint = -1;
-          /** Update dirty for limiting calculating batches.*/
-          _this.batchDirty = -1;
-          /** Copy of the object vertex data. */
-          _this.vertexData = null;
-          /** Current fill style. */
-          _this._fillStyle = new FillStyle();
-          /** Current line style. */
-          _this._lineStyle = new LineStyle();
-          /** Current shape transform matrix. */
-          _this._matrix = null;
-          /** Current hole mode is enabled. */
-          _this._holeMode = false;
-          /**
-           * Represents the WebGL state the Graphics required to render, excludes shader and geometry. E.g.,
-           * blend mode, culling, depth testing, direction of rendering triangles, backface, etc.
-           */
-          _this.state = State.for2d();
-          _this._geometry = geometry || new GraphicsGeometry();
-          _this._geometry.refCount++;
-          /**
-           * When cacheAsBitmap is set to true the graphics object will be rendered as if it was a sprite.
-           * This is useful if your graphics element does not change often, as it will speed up the rendering
-           * of the object in exchange for taking up texture memory. It is also useful if you need the graphics
-           * object to be anti-aliased, because it will be rendered using canvas. This is not recommended if
-           * you are constantly redrawing the graphics element.
-           * @name cacheAsBitmap
-           * @member {boolean}
-           * @memberof PIXI.Graphics#
-           * @default false
-           */
-          _this._transformID = -1;
-          // Set default
-          _this.tint = 0xFFFFFF;
-          _this.blendMode = exports.BLEND_MODES.NORMAL;
-          return _this;
-      }
-      Object.defineProperty(Graphics.prototype, "geometry", {
-          /**
-           * Includes vertex positions, face indices, normals, colors, UVs, and
-           * custom attributes within buffers, reducing the cost of passing all
-           * this data to the GPU. Can be shared between multiple Mesh or Graphics objects.
-           * @readonly
-           */
-          get: function () {
-              return this._geometry;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Creates a new Graphics object with the same values as this one.
-       * Note that only the geometry of the object is cloned, not its transform (position,scale,etc)
-       * @returns - A clone of the graphics object
-       */
-      Graphics.prototype.clone = function () {
-          this.finishPoly();
-          return new Graphics(this._geometry);
-      };
-      Object.defineProperty(Graphics.prototype, "blendMode", {
-          get: function () {
-              return this.state.blendMode;
-          },
-          /**
-           * The blend mode to be applied to the graphic shape. Apply a value of
-           * `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.  Note that, since each
-           * primitive in the GraphicsGeometry list is rendered sequentially, modes
-           * such as `PIXI.BLEND_MODES.ADD` and `PIXI.BLEND_MODES.MULTIPLY` will
-           * be applied per-primitive.
-           * @default PIXI.BLEND_MODES.NORMAL
-           */
-          set: function (value) {
-              this.state.blendMode = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Graphics.prototype, "tint", {
-          /**
-           * The tint applied to each graphic shape. This is a hex value. A value of
-           * 0xFFFFFF will remove any tint effect.
-           * @default 0xFFFFFF
-           */
-          get: function () {
-              return this._tint;
-          },
-          set: function (value) {
-              this._tint = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Graphics.prototype, "fill", {
-          /**
-           * The current fill style.
-           * @readonly
-           */
-          get: function () {
-              return this._fillStyle;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Graphics.prototype, "line", {
-          /**
-           * The current line style.
-           * @readonly
-           */
-          get: function () {
-              return this._lineStyle;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Graphics.prototype.lineStyle = function (options, color, alpha, alignment, native) {
-          if (options === void 0) { options = null; }
-          if (color === void 0) { color = 0x0; }
-          if (alpha === void 0) { alpha = 1; }
-          if (alignment === void 0) { alignment = 0.5; }
-          if (native === void 0) { native = false; }
-          // Support non-object params: (width, color, alpha, alignment, native)
-          if (typeof options === 'number') {
-              options = { width: options, color: color, alpha: alpha, alignment: alignment, native: native };
-          }
-          return this.lineTextureStyle(options);
-      };
-      /**
-       * Like line style but support texture for line fill.
-       * @param [options] - Collection of options for setting line style.
-       * @param {number} [options.width=0] - width of the line to draw, will update the objects stored style
-       * @param {PIXI.Texture} [options.texture=PIXI.Texture.WHITE] - Texture to use
-       * @param {number} [options.color=0x0] - color of the line to draw, will update the objects stored style.
-       *  Default 0xFFFFFF if texture present.
-       * @param {number} [options.alpha=1] - alpha of the line to draw, will update the objects stored style
-       * @param {PIXI.Matrix} [options.matrix=null] - Texture matrix to transform texture
-       * @param {number} [options.alignment=0.5] - alignment of the line to draw, (0 = inner, 0.5 = middle, 1 = outer).
-       *        WebGL only.
-       * @param {boolean} [options.native=false] - If true the lines will be draw using LINES instead of TRIANGLE_STRIP
-       * @param {PIXI.LINE_CAP}[options.cap=PIXI.LINE_CAP.BUTT] - line cap style
-       * @param {PIXI.LINE_JOIN}[options.join=PIXI.LINE_JOIN.MITER] - line join style
-       * @param {number}[options.miterLimit=10] - miter limit ratio
-       * @returns {PIXI.Graphics} This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.lineTextureStyle = function (options) {
-          // Apply defaults
-          options = Object.assign({
-              width: 0,
-              texture: Texture.WHITE,
-              color: (options && options.texture) ? 0xFFFFFF : 0x0,
-              alpha: 1,
-              matrix: null,
-              alignment: 0.5,
-              native: false,
-              cap: exports.LINE_CAP.BUTT,
-              join: exports.LINE_JOIN.MITER,
-              miterLimit: 10,
-          }, options);
-          if (this.currentPath) {
-              this.startPoly();
-          }
-          var visible = options.width > 0 && options.alpha > 0;
-          if (!visible) {
-              this._lineStyle.reset();
-          }
-          else {
-              if (options.matrix) {
-                  options.matrix = options.matrix.clone();
-                  options.matrix.invert();
-              }
-              Object.assign(this._lineStyle, { visible: visible }, options);
-          }
-          return this;
-      };
-      /**
-       * Start a polygon object internally.
-       * @protected
-       */
-      Graphics.prototype.startPoly = function () {
-          if (this.currentPath) {
-              var points = this.currentPath.points;
-              var len = this.currentPath.points.length;
-              if (len > 2) {
-                  this.drawShape(this.currentPath);
-                  this.currentPath = new Polygon();
-                  this.currentPath.closeStroke = false;
-                  this.currentPath.points.push(points[len - 2], points[len - 1]);
-              }
-          }
-          else {
-              this.currentPath = new Polygon();
-              this.currentPath.closeStroke = false;
-          }
-      };
-      /**
-       * Finish the polygon object.
-       * @protected
-       */
-      Graphics.prototype.finishPoly = function () {
-          if (this.currentPath) {
-              if (this.currentPath.points.length > 2) {
-                  this.drawShape(this.currentPath);
-                  this.currentPath = null;
-              }
-              else {
-                  this.currentPath.points.length = 0;
-              }
-          }
-      };
-      /**
-       * Moves the current drawing position to x, y.
-       * @param x - the X coordinate to move to
-       * @param y - the Y coordinate to move to
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.moveTo = function (x, y) {
-          this.startPoly();
-          this.currentPath.points[0] = x;
-          this.currentPath.points[1] = y;
-          return this;
-      };
-      /**
-       * Draws a line using the current line style from the current drawing position to (x, y);
-       * The current drawing position is then set to (x, y).
-       * @param x - the X coordinate to draw to
-       * @param y - the Y coordinate to draw to
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.lineTo = function (x, y) {
-          if (!this.currentPath) {
-              this.moveTo(0, 0);
-          }
-          // remove duplicates..
-          var points = this.currentPath.points;
-          var fromX = points[points.length - 2];
-          var fromY = points[points.length - 1];
-          if (fromX !== x || fromY !== y) {
-              points.push(x, y);
-          }
-          return this;
-      };
-      /**
-       * Initialize the curve
-       * @param x
-       * @param y
-       */
-      Graphics.prototype._initCurve = function (x, y) {
-          if (x === void 0) { x = 0; }
-          if (y === void 0) { y = 0; }
-          if (this.currentPath) {
-              if (this.currentPath.points.length === 0) {
-                  this.currentPath.points = [x, y];
-              }
-          }
-          else {
-              this.moveTo(x, y);
-          }
-      };
-      /**
-       * Calculate the points for a quadratic bezier curve and then draws it.
-       * Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
-       * @param cpX - Control point x
-       * @param cpY - Control point y
-       * @param toX - Destination point x
-       * @param toY - Destination point y
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.quadraticCurveTo = function (cpX, cpY, toX, toY) {
-          this._initCurve();
-          var points = this.currentPath.points;
-          if (points.length === 0) {
-              this.moveTo(0, 0);
-          }
-          QuadraticUtils.curveTo(cpX, cpY, toX, toY, points);
-          return this;
-      };
-      /**
-       * Calculate the points for a bezier curve and then draws it.
-       * @param cpX - Control point x
-       * @param cpY - Control point y
-       * @param cpX2 - Second Control point x
-       * @param cpY2 - Second Control point y
-       * @param toX - Destination point x
-       * @param toY - Destination point y
-       * @returns This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.bezierCurveTo = function (cpX, cpY, cpX2, cpY2, toX, toY) {
-          this._initCurve();
-          BezierUtils.curveTo(cpX, cpY, cpX2, cpY2, toX, toY, this.currentPath.points);
-          return this;
-      };
-      /**
-       * The arcTo() method creates an arc/curve between two tangents on the canvas.
-       *
-       * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
-       * @param x1 - The x-coordinate of the first tangent point of the arc
-       * @param y1 - The y-coordinate of the first tangent point of the arc
-       * @param x2 - The x-coordinate of the end of the arc
-       * @param y2 - The y-coordinate of the end of the arc
-       * @param radius - The radius of the arc
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.arcTo = function (x1, y1, x2, y2, radius) {
-          this._initCurve(x1, y1);
-          var points = this.currentPath.points;
-          var result = ArcUtils.curveTo(x1, y1, x2, y2, radius, points);
-          if (result) {
-              var cx = result.cx, cy = result.cy, radius_1 = result.radius, startAngle = result.startAngle, endAngle = result.endAngle, anticlockwise = result.anticlockwise;
-              this.arc(cx, cy, radius_1, startAngle, endAngle, anticlockwise);
-          }
-          return this;
-      };
-      /**
-       * The arc method creates an arc/curve (used to create circles, or parts of circles).
-       * @param cx - The x-coordinate of the center of the circle
-       * @param cy - The y-coordinate of the center of the circle
-       * @param radius - The radius of the circle
-       * @param startAngle - The starting angle, in radians (0 is at the 3 o'clock position
-       *  of the arc's circle)
-       * @param endAngle - The ending angle, in radians
-       * @param anticlockwise - Specifies whether the drawing should be
-       *  counter-clockwise or clockwise. False is default, and indicates clockwise, while true
-       *  indicates counter-clockwise.
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.arc = function (cx, cy, radius, startAngle, endAngle, anticlockwise) {
-          if (anticlockwise === void 0) { anticlockwise = false; }
-          if (startAngle === endAngle) {
-              return this;
-          }
-          if (!anticlockwise && endAngle <= startAngle) {
-              endAngle += PI_2;
-          }
-          else if (anticlockwise && startAngle <= endAngle) {
-              startAngle += PI_2;
-          }
-          var sweep = endAngle - startAngle;
-          if (sweep === 0) {
-              return this;
-          }
-          var startX = cx + (Math.cos(startAngle) * radius);
-          var startY = cy + (Math.sin(startAngle) * radius);
-          var eps = this._geometry.closePointEps;
-          // If the currentPath exists, take its points. Otherwise call `moveTo` to start a path.
-          var points = this.currentPath ? this.currentPath.points : null;
-          if (points) {
-              // TODO: make a better fix.
-              // We check how far our start is from the last existing point
-              var xDiff = Math.abs(points[points.length - 2] - startX);
-              var yDiff = Math.abs(points[points.length - 1] - startY);
-              if (xDiff < eps && yDiff < eps) { ; }
-              else {
-                  points.push(startX, startY);
-              }
-          }
-          else {
-              this.moveTo(startX, startY);
-              points = this.currentPath.points;
-          }
-          ArcUtils.arc(startX, startY, cx, cy, radius, startAngle, endAngle, anticlockwise, points);
-          return this;
-      };
-      /**
-       * Specifies a simple one-color fill that subsequent calls to other Graphics methods
-       * (such as lineTo() or drawCircle()) use when drawing.
-       * @param color - the color of the fill
-       * @param alpha - the alpha of the fill
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.beginFill = function (color, alpha) {
-          if (color === void 0) { color = 0; }
-          if (alpha === void 0) { alpha = 1; }
-          return this.beginTextureFill({ texture: Texture.WHITE, color: color, alpha: alpha });
-      };
-      /**
-       * Begin the texture fill
-       * @param options - Object object.
-       * @param {PIXI.Texture} [options.texture=PIXI.Texture.WHITE] - Texture to fill
-       * @param {number} [options.color=0xffffff] - Background to fill behind texture
-       * @param {number} [options.alpha=1] - Alpha of fill
-       * @param {PIXI.Matrix} [options.matrix=null] - Transform matrix
-       * @returns {PIXI.Graphics} This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.beginTextureFill = function (options) {
-          // Apply defaults
-          options = Object.assign({
-              texture: Texture.WHITE,
-              color: 0xFFFFFF,
-              alpha: 1,
-              matrix: null,
-          }, options);
-          if (this.currentPath) {
-              this.startPoly();
-          }
-          var visible = options.alpha > 0;
-          if (!visible) {
-              this._fillStyle.reset();
-          }
-          else {
-              if (options.matrix) {
-                  options.matrix = options.matrix.clone();
-                  options.matrix.invert();
-              }
-              Object.assign(this._fillStyle, { visible: visible }, options);
-          }
-          return this;
-      };
-      /**
-       * Applies a fill to the lines and shapes that were added since the last call to the beginFill() method.
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.endFill = function () {
-          this.finishPoly();
-          this._fillStyle.reset();
-          return this;
-      };
-      /**
-       * Draws a rectangle shape.
-       * @param x - The X coord of the top-left of the rectangle
-       * @param y - The Y coord of the top-left of the rectangle
-       * @param width - The width of the rectangle
-       * @param height - The height of the rectangle
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.drawRect = function (x, y, width, height) {
-          return this.drawShape(new Rectangle(x, y, width, height));
-      };
-      /**
-       * Draw a rectangle shape with rounded/beveled corners.
-       * @param x - The X coord of the top-left of the rectangle
-       * @param y - The Y coord of the top-left of the rectangle
-       * @param width - The width of the rectangle
-       * @param height - The height of the rectangle
-       * @param radius - Radius of the rectangle corners
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.drawRoundedRect = function (x, y, width, height, radius) {
-          return this.drawShape(new RoundedRectangle(x, y, width, height, radius));
-      };
-      /**
-       * Draws a circle.
-       * @param x - The X coordinate of the center of the circle
-       * @param y - The Y coordinate of the center of the circle
-       * @param radius - The radius of the circle
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.drawCircle = function (x, y, radius) {
-          return this.drawShape(new Circle(x, y, radius));
-      };
-      /**
-       * Draws an ellipse.
-       * @param x - The X coordinate of the center of the ellipse
-       * @param y - The Y coordinate of the center of the ellipse
-       * @param width - The half width of the ellipse
-       * @param height - The half height of the ellipse
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.drawEllipse = function (x, y, width, height) {
-          return this.drawShape(new Ellipse(x, y, width, height));
-      };
-      /**
-       * Draws a polygon using the given path.
-       * @param {number[]|PIXI.IPointData[]|PIXI.Polygon} path - The path data used to construct the polygon.
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.drawPolygon = function () {
-          var arguments$1 = arguments;
-
-          var path = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              path[_i] = arguments$1[_i];
-          }
-          var points;
-          var closeStroke = true; // !!this._fillStyle;
-          var poly = path[0];
-          // check if data has points..
-          if (poly.points) {
-              closeStroke = poly.closeStroke;
-              points = poly.points;
-          }
-          else if (Array.isArray(path[0])) {
-              points = path[0];
-          }
-          else {
-              points = path;
-          }
-          var shape = new Polygon(points);
-          shape.closeStroke = closeStroke;
-          this.drawShape(shape);
-          return this;
-      };
-      /**
-       * Draw any shape.
-       * @param {PIXI.Circle|PIXI.Ellipse|PIXI.Polygon|PIXI.Rectangle|PIXI.RoundedRectangle} shape - Shape to draw
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.drawShape = function (shape) {
-          if (!this._holeMode) {
-              this._geometry.drawShape(shape, this._fillStyle.clone(), this._lineStyle.clone(), this._matrix);
-          }
-          else {
-              this._geometry.drawHole(shape, this._matrix);
-          }
-          return this;
-      };
-      /**
-       * Clears the graphics that were drawn to this Graphics object, and resets fill and line style settings.
-       * @returns - This Graphics object. Good for chaining method calls
-       */
-      Graphics.prototype.clear = function () {
-          this._geometry.clear();
-          this._lineStyle.reset();
-          this._fillStyle.reset();
-          this._boundsID++;
-          this._matrix = null;
-          this._holeMode = false;
-          this.currentPath = null;
-          return this;
-      };
-      /**
-       * True if graphics consists of one rectangle, and thus, can be drawn like a Sprite and
-       * masked with gl.scissor.
-       * @returns - True if only 1 rect.
-       */
-      Graphics.prototype.isFastRect = function () {
-          var data = this._geometry.graphicsData;
-          return data.length === 1
-              && data[0].shape.type === exports.SHAPES.RECT
-              && !data[0].matrix
-              && !data[0].holes.length
-              && !(data[0].lineStyle.visible && data[0].lineStyle.width);
-      };
-      /**
-       * Renders the object using the WebGL renderer
-       * @param renderer - The renderer
-       */
-      Graphics.prototype._render = function (renderer) {
-          this.finishPoly();
-          var geometry = this._geometry;
-          // batch part..
-          // batch it!
-          geometry.updateBatches();
-          if (geometry.batchable) {
-              if (this.batchDirty !== geometry.batchDirty) {
-                  this._populateBatches();
-              }
-              this._renderBatched(renderer);
-          }
-          else {
-              // no batching...
-              renderer.batch.flush();
-              this._renderDirect(renderer);
-          }
-      };
-      /** Populating batches for rendering. */
-      Graphics.prototype._populateBatches = function () {
-          var geometry = this._geometry;
-          var blendMode = this.blendMode;
-          var len = geometry.batches.length;
-          this.batchTint = -1;
-          this._transformID = -1;
-          this.batchDirty = geometry.batchDirty;
-          this.batches.length = len;
-          this.vertexData = new Float32Array(geometry.points);
-          for (var i = 0; i < len; i++) {
-              var gI = geometry.batches[i];
-              var color = gI.style.color;
-              var vertexData = new Float32Array(this.vertexData.buffer, gI.attribStart * 4 * 2, gI.attribSize * 2);
-              var uvs = new Float32Array(geometry.uvsFloat32.buffer, gI.attribStart * 4 * 2, gI.attribSize * 2);
-              var indices = new Uint16Array(geometry.indicesUint16.buffer, gI.start * 2, gI.size);
-              var batch = {
-                  vertexData: vertexData,
-                  blendMode: blendMode,
-                  indices: indices,
-                  uvs: uvs,
-                  _batchRGB: hex2rgb(color),
-                  _tintRGB: color,
-                  _texture: gI.style.texture,
-                  alpha: gI.style.alpha,
-                  worldAlpha: 1
-              };
-              this.batches[i] = batch;
-          }
-      };
-      /**
-       * Renders the batches using the BathedRenderer plugin
-       * @param renderer - The renderer
-       */
-      Graphics.prototype._renderBatched = function (renderer) {
-          if (!this.batches.length) {
-              return;
-          }
-          renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
-          this.calculateVertices();
-          this.calculateTints();
-          for (var i = 0, l = this.batches.length; i < l; i++) {
-              var batch = this.batches[i];
-              batch.worldAlpha = this.worldAlpha * batch.alpha;
-              renderer.plugins[this.pluginName].render(batch);
-          }
-      };
-      /**
-       * Renders the graphics direct
-       * @param renderer - The renderer
-       */
-      Graphics.prototype._renderDirect = function (renderer) {
-          var shader = this._resolveDirectShader(renderer);
-          var geometry = this._geometry;
-          var tint = this.tint;
-          var worldAlpha = this.worldAlpha;
-          var uniforms = shader.uniforms;
-          var drawCalls = geometry.drawCalls;
-          // lets set the transfomr
-          uniforms.translationMatrix = this.transform.worldTransform;
-          // and then lets set the tint..
-          uniforms.tint[0] = (((tint >> 16) & 0xFF) / 255) * worldAlpha;
-          uniforms.tint[1] = (((tint >> 8) & 0xFF) / 255) * worldAlpha;
-          uniforms.tint[2] = ((tint & 0xFF) / 255) * worldAlpha;
-          uniforms.tint[3] = worldAlpha;
-          // the first draw call, we can set the uniforms of the shader directly here.
-          // this means that we can tack advantage of the sync function of pixi!
-          // bind and sync uniforms..
-          // there is a way to optimise this..
-          renderer.shader.bind(shader);
-          renderer.geometry.bind(geometry, shader);
-          // set state..
-          renderer.state.set(this.state);
-          // then render the rest of them...
-          for (var i = 0, l = drawCalls.length; i < l; i++) {
-              this._renderDrawCallDirect(renderer, geometry.drawCalls[i]);
-          }
-      };
-      /**
-       * Renders specific DrawCall
-       * @param renderer
-       * @param drawCall
-       */
-      Graphics.prototype._renderDrawCallDirect = function (renderer, drawCall) {
-          var texArray = drawCall.texArray, type = drawCall.type, size = drawCall.size, start = drawCall.start;
-          var groupTextureCount = texArray.count;
-          for (var j = 0; j < groupTextureCount; j++) {
-              renderer.texture.bind(texArray.elements[j], j);
-          }
-          renderer.geometry.draw(type, size, start);
-      };
-      /**
-       * Resolves shader for direct rendering
-       * @param renderer - The renderer
-       */
-      Graphics.prototype._resolveDirectShader = function (renderer) {
-          var shader = this.shader;
-          var pluginName = this.pluginName;
-          if (!shader) {
-              // if there is no shader here, we can use the default shader.
-              // and that only gets created if we actually need it..
-              // but may be more than one plugins for graphics
-              if (!DEFAULT_SHADERS[pluginName]) {
-                  var MAX_TEXTURES = renderer.plugins[pluginName].MAX_TEXTURES;
-                  var sampleValues = new Int32Array(MAX_TEXTURES);
-                  for (var i = 0; i < MAX_TEXTURES; i++) {
-                      sampleValues[i] = i;
-                  }
-                  var uniforms = {
-                      tint: new Float32Array([1, 1, 1, 1]),
-                      translationMatrix: new Matrix(),
-                      default: UniformGroup.from({ uSamplers: sampleValues }, true),
-                  };
-                  var program = renderer.plugins[pluginName]._shader.program;
-                  DEFAULT_SHADERS[pluginName] = new Shader(program, uniforms);
-              }
-              shader = DEFAULT_SHADERS[pluginName];
-          }
-          return shader;
-      };
-      /** Retrieves the bounds of the graphic shape as a rectangle object. */
-      Graphics.prototype._calculateBounds = function () {
-          this.finishPoly();
-          var geometry = this._geometry;
-          // skipping when graphics is empty, like a container
-          if (!geometry.graphicsData.length) {
-              return;
-          }
-          var _a = geometry.bounds, minX = _a.minX, minY = _a.minY, maxX = _a.maxX, maxY = _a.maxY;
-          this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);
-      };
-      /**
-       * Tests if a point is inside this graphics object
-       * @param point - the point to test
-       * @returns - the result of the test
-       */
-      Graphics.prototype.containsPoint = function (point) {
-          this.worldTransform.applyInverse(point, Graphics._TEMP_POINT);
-          return this._geometry.containsPoint(Graphics._TEMP_POINT);
-      };
-      /** Recalculate the tint by applying tint to batches using Graphics tint. */
-      Graphics.prototype.calculateTints = function () {
-          if (this.batchTint !== this.tint) {
-              this.batchTint = this.tint;
-              var tintRGB = hex2rgb(this.tint, temp);
-              for (var i = 0; i < this.batches.length; i++) {
-                  var batch = this.batches[i];
-                  var batchTint = batch._batchRGB;
-                  var r = (tintRGB[0] * batchTint[0]) * 255;
-                  var g = (tintRGB[1] * batchTint[1]) * 255;
-                  var b = (tintRGB[2] * batchTint[2]) * 255;
-                  // TODO Ivan, can this be done in one go?
-                  var color = (r << 16) + (g << 8) + (b | 0);
-                  batch._tintRGB = (color >> 16)
-                      + (color & 0xff00)
-                      + ((color & 0xff) << 16);
-              }
-          }
-      };
-      /** If there's a transform update or a change to the shape of the geometry, recalculate the vertices. */
-      Graphics.prototype.calculateVertices = function () {
-          var wtID = this.transform._worldID;
-          if (this._transformID === wtID) {
-              return;
-          }
-          this._transformID = wtID;
-          var wt = this.transform.worldTransform;
-          var a = wt.a;
-          var b = wt.b;
-          var c = wt.c;
-          var d = wt.d;
-          var tx = wt.tx;
-          var ty = wt.ty;
-          var data = this._geometry.points; // batch.vertexDataOriginal;
-          var vertexData = this.vertexData;
-          var count = 0;
-          for (var i = 0; i < data.length; i += 2) {
-              var x = data[i];
-              var y = data[i + 1];
-              vertexData[count++] = (a * x) + (c * y) + tx;
-              vertexData[count++] = (d * y) + (b * x) + ty;
-          }
-      };
-      /**
-       * Closes the current path.
-       * @returns - Returns itself.
-       */
-      Graphics.prototype.closePath = function () {
-          var currentPath = this.currentPath;
-          if (currentPath) {
-              // we don't need to add extra point in the end because buildLine will take care of that
-              currentPath.closeStroke = true;
-              // ensure that the polygon is completed, and is available for hit detection
-              // (even if the graphics is not rendered yet)
-              this.finishPoly();
-          }
-          return this;
-      };
-      /**
-       * Apply a matrix to the positional data.
-       * @param matrix - Matrix to use for transform current shape.
-       * @returns - Returns itself.
-       */
-      Graphics.prototype.setMatrix = function (matrix) {
-          this._matrix = matrix;
-          return this;
-      };
-      /**
-       * Begin adding holes to the last draw shape
-       * IMPORTANT: holes must be fully inside a shape to work
-       * Also weirdness ensues if holes overlap!
-       * Ellipses, Circles, Rectangles and Rounded Rectangles cannot be holes or host for holes in CanvasRenderer,
-       * please use `moveTo` `lineTo`, `quadraticCurveTo` if you rely on pixi-legacy bundle.
-       * @returns - Returns itself.
-       */
-      Graphics.prototype.beginHole = function () {
-          this.finishPoly();
-          this._holeMode = true;
-          return this;
-      };
-      /**
-       * End adding holes to the last draw shape.
-       * @returns - Returns itself.
-       */
-      Graphics.prototype.endHole = function () {
-          this.finishPoly();
-          this._holeMode = false;
-          return this;
-      };
-      /**
-       * Destroys the Graphics object.
-       * @param options - Options parameter. A boolean will act as if all
-       *  options have been set to that value
-       * @param {boolean} [options.children=false] - if set to true, all the children will have
-       *  their destroy method called as well. 'options' will be passed on to those calls.
-       * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
-       *  Should it destroy the texture of the child sprite
-       * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
-       *  Should it destroy the base texture of the child sprite
-       */
-      Graphics.prototype.destroy = function (options) {
-          this._geometry.refCount--;
-          if (this._geometry.refCount === 0) {
-              this._geometry.dispose();
-          }
-          this._matrix = null;
-          this.currentPath = null;
-          this._lineStyle.destroy();
-          this._lineStyle = null;
-          this._fillStyle.destroy();
-          this._fillStyle = null;
-          this._geometry = null;
-          this.shader = null;
-          this.vertexData = null;
-          this.batches.length = 0;
-          this.batches = null;
-          _super.prototype.destroy.call(this, options);
-      };
-      /**
-       * New rendering behavior for rounded rectangles: circular arcs instead of quadratic bezier curves.
-       * In the next major release, we'll enable this by default.
-       */
-      Graphics.nextRoundedRectBehavior = false;
-      /**
-       * Temporary point to use for containsPoint.
-       * @private
-       */
-      Graphics._TEMP_POINT = new Point();
-      return Graphics;
-  }(Container));
-
-  var graphicsUtils = {
-      buildPoly: buildPoly,
-      buildCircle: buildCircle,
-      buildRectangle: buildRectangle,
-      buildRoundedRectangle: buildRoundedRectangle,
-      buildLine: buildLine,
-      ArcUtils: ArcUtils,
-      BezierUtils: BezierUtils,
-      QuadraticUtils: QuadraticUtils,
-      BatchPart: BatchPart,
-      FILL_COMMANDS: FILL_COMMANDS,
-      BATCH_POOL: BATCH_POOL,
-      DRAW_CALL_POOL: DRAW_CALL_POOL
-  };
-
-  /*!
-   * @pixi/sprite - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/sprite is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$d = function(d, b) {
-      extendStatics$d = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$d(d, b);
-  };
-
-  function __extends$d(d, b) {
-      extendStatics$d(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var tempPoint$2 = new Point();
-  var indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
-  /**
-   * The Sprite object is the base for all textured objects that are rendered to the screen
-   *
-   * A sprite can be created directly from an image like this:
-   *
-   * ```js
-   * let sprite = PIXI.Sprite.from('assets/image.png');
-   * ```
-   *
-   * The more efficient way to create sprites is using a {@link PIXI.Spritesheet},
-   * as swapping base textures when rendering to the screen is inefficient.
-   *
-   * ```js
-   * PIXI.Loader.shared.add("assets/spritesheet.json").load(setup);
-   *
-   * function setup() {
-   *   let sheet = PIXI.Loader.shared.resources["assets/spritesheet.json"].spritesheet;
-   *   let sprite = new PIXI.Sprite(sheet.textures["image.png"]);
-   *   ...
-   * }
-   * ```
-   * @memberof PIXI
-   */
-  var Sprite = /** @class */ (function (_super) {
-      __extends$d(Sprite, _super);
-      /** @param texture - The texture for this sprite. */
-      function Sprite(texture) {
-          var _this = _super.call(this) || this;
-          _this._anchor = new ObservablePoint(_this._onAnchorUpdate, _this, (texture ? texture.defaultAnchor.x : 0), (texture ? texture.defaultAnchor.y : 0));
-          _this._texture = null;
-          _this._width = 0;
-          _this._height = 0;
-          _this._tint = null;
-          _this._tintRGB = null;
-          _this.tint = 0xFFFFFF;
-          _this.blendMode = exports.BLEND_MODES.NORMAL;
-          _this._cachedTint = 0xFFFFFF;
-          _this.uvs = null;
-          // call texture setter
-          _this.texture = texture || Texture.EMPTY;
-          _this.vertexData = new Float32Array(8);
-          _this.vertexTrimmedData = null;
-          _this._transformID = -1;
-          _this._textureID = -1;
-          _this._transformTrimmedID = -1;
-          _this._textureTrimmedID = -1;
-          // Batchable stuff..
-          // TODO could make this a mixin?
-          _this.indices = indices;
-          _this.pluginName = 'batch';
-          /**
-           * Used to fast check if a sprite is.. a sprite!
-           * @member {boolean}
-           */
-          _this.isSprite = true;
-          _this._roundPixels = settings.ROUND_PIXELS;
-          return _this;
-      }
-      /** When the texture is updated, this event will fire to update the scale and frame. */
-      Sprite.prototype._onTextureUpdate = function () {
-          this._textureID = -1;
-          this._textureTrimmedID = -1;
-          this._cachedTint = 0xFFFFFF;
-          // so if _width is 0 then width was not set..
-          if (this._width) {
-              this.scale.x = sign(this.scale.x) * this._width / this._texture.orig.width;
-          }
-          if (this._height) {
-              this.scale.y = sign(this.scale.y) * this._height / this._texture.orig.height;
-          }
-      };
-      /** Called when the anchor position updates. */
-      Sprite.prototype._onAnchorUpdate = function () {
-          this._transformID = -1;
-          this._transformTrimmedID = -1;
-      };
-      /** Calculates worldTransform * vertices, store it in vertexData. */
-      Sprite.prototype.calculateVertices = function () {
-          var texture = this._texture;
-          if (this._transformID === this.transform._worldID && this._textureID === texture._updateID) {
-              return;
-          }
-          // update texture UV here, because base texture can be changed without calling `_onTextureUpdate`
-          if (this._textureID !== texture._updateID) {
-              this.uvs = this._texture._uvs.uvsFloat32;
-          }
-          this._transformID = this.transform._worldID;
-          this._textureID = texture._updateID;
-          // set the vertex data
-          var wt = this.transform.worldTransform;
-          var a = wt.a;
-          var b = wt.b;
-          var c = wt.c;
-          var d = wt.d;
-          var tx = wt.tx;
-          var ty = wt.ty;
-          var vertexData = this.vertexData;
-          var trim = texture.trim;
-          var orig = texture.orig;
-          var anchor = this._anchor;
-          var w0 = 0;
-          var w1 = 0;
-          var h0 = 0;
-          var h1 = 0;
-          if (trim) {
-              // if the sprite is trimmed and is not a tilingsprite then we need to add the extra
-              // space before transforming the sprite coords.
-              w1 = trim.x - (anchor._x * orig.width);
-              w0 = w1 + trim.width;
-              h1 = trim.y - (anchor._y * orig.height);
-              h0 = h1 + trim.height;
-          }
-          else {
-              w1 = -anchor._x * orig.width;
-              w0 = w1 + orig.width;
-              h1 = -anchor._y * orig.height;
-              h0 = h1 + orig.height;
-          }
-          // xy
-          vertexData[0] = (a * w1) + (c * h1) + tx;
-          vertexData[1] = (d * h1) + (b * w1) + ty;
-          // xy
-          vertexData[2] = (a * w0) + (c * h1) + tx;
-          vertexData[3] = (d * h1) + (b * w0) + ty;
-          // xy
-          vertexData[4] = (a * w0) + (c * h0) + tx;
-          vertexData[5] = (d * h0) + (b * w0) + ty;
-          // xy
-          vertexData[6] = (a * w1) + (c * h0) + tx;
-          vertexData[7] = (d * h0) + (b * w1) + ty;
-          if (this._roundPixels) {
-              var resolution = settings.RESOLUTION;
-              for (var i = 0; i < vertexData.length; ++i) {
-                  vertexData[i] = Math.round((vertexData[i] * resolution | 0) / resolution);
-              }
-          }
-      };
-      /**
-       * Calculates worldTransform * vertices for a non texture with a trim. store it in vertexTrimmedData.
-       *
-       * This is used to ensure that the true width and height of a trimmed texture is respected.
-       */
-      Sprite.prototype.calculateTrimmedVertices = function () {
-          if (!this.vertexTrimmedData) {
-              this.vertexTrimmedData = new Float32Array(8);
-          }
-          else if (this._transformTrimmedID === this.transform._worldID && this._textureTrimmedID === this._texture._updateID) {
-              return;
-          }
-          this._transformTrimmedID = this.transform._worldID;
-          this._textureTrimmedID = this._texture._updateID;
-          // lets do some special trim code!
-          var texture = this._texture;
-          var vertexData = this.vertexTrimmedData;
-          var orig = texture.orig;
-          var anchor = this._anchor;
-          // lets calculate the new untrimmed bounds..
-          var wt = this.transform.worldTransform;
-          var a = wt.a;
-          var b = wt.b;
-          var c = wt.c;
-          var d = wt.d;
-          var tx = wt.tx;
-          var ty = wt.ty;
-          var w1 = -anchor._x * orig.width;
-          var w0 = w1 + orig.width;
-          var h1 = -anchor._y * orig.height;
-          var h0 = h1 + orig.height;
-          // xy
-          vertexData[0] = (a * w1) + (c * h1) + tx;
-          vertexData[1] = (d * h1) + (b * w1) + ty;
-          // xy
-          vertexData[2] = (a * w0) + (c * h1) + tx;
-          vertexData[3] = (d * h1) + (b * w0) + ty;
-          // xy
-          vertexData[4] = (a * w0) + (c * h0) + tx;
-          vertexData[5] = (d * h0) + (b * w0) + ty;
-          // xy
-          vertexData[6] = (a * w1) + (c * h0) + tx;
-          vertexData[7] = (d * h0) + (b * w1) + ty;
-      };
-      /**
-       *
-       * Renders the object using the WebGL renderer
-       * @param renderer - The webgl renderer to use.
-       */
-      Sprite.prototype._render = function (renderer) {
-          this.calculateVertices();
-          renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
-          renderer.plugins[this.pluginName].render(this);
-      };
-      /** Updates the bounds of the sprite. */
-      Sprite.prototype._calculateBounds = function () {
-          var trim = this._texture.trim;
-          var orig = this._texture.orig;
-          // First lets check to see if the current texture has a trim..
-          if (!trim || (trim.width === orig.width && trim.height === orig.height)) {
-              // no trim! lets use the usual calculations..
-              this.calculateVertices();
-              this._bounds.addQuad(this.vertexData);
-          }
-          else {
-              // lets calculate a special trimmed bounds...
-              this.calculateTrimmedVertices();
-              this._bounds.addQuad(this.vertexTrimmedData);
-          }
-      };
-      /**
-       * Gets the local bounds of the sprite object.
-       * @param rect - Optional output rectangle.
-       * @returns The bounds.
-       */
-      Sprite.prototype.getLocalBounds = function (rect) {
-          // we can do a fast local bounds if the sprite has no children!
-          if (this.children.length === 0) {
-              if (!this._localBounds) {
-                  this._localBounds = new Bounds();
-              }
-              this._localBounds.minX = this._texture.orig.width * -this._anchor._x;
-              this._localBounds.minY = this._texture.orig.height * -this._anchor._y;
-              this._localBounds.maxX = this._texture.orig.width * (1 - this._anchor._x);
-              this._localBounds.maxY = this._texture.orig.height * (1 - this._anchor._y);
-              if (!rect) {
-                  if (!this._localBoundsRect) {
-                      this._localBoundsRect = new Rectangle();
-                  }
-                  rect = this._localBoundsRect;
-              }
-              return this._localBounds.getRectangle(rect);
-          }
-          return _super.prototype.getLocalBounds.call(this, rect);
-      };
-      /**
-       * Tests if a point is inside this sprite
-       * @param point - the point to test
-       * @returns The result of the test
-       */
-      Sprite.prototype.containsPoint = function (point) {
-          this.worldTransform.applyInverse(point, tempPoint$2);
-          var width = this._texture.orig.width;
-          var height = this._texture.orig.height;
-          var x1 = -width * this.anchor.x;
-          var y1 = 0;
-          if (tempPoint$2.x >= x1 && tempPoint$2.x < x1 + width) {
-              y1 = -height * this.anchor.y;
-              if (tempPoint$2.y >= y1 && tempPoint$2.y < y1 + height) {
-                  return true;
-              }
-          }
-          return false;
-      };
-      /**
-       * Destroys this sprite and optionally its texture and children.
-       * @param options - Options parameter. A boolean will act as if all options
-       *  have been set to that value
-       * @param [options.children=false] - if set to true, all the children will have their destroy
-       *      method called as well. 'options' will be passed on to those calls.
-       * @param [options.texture=false] - Should it destroy the current texture of the sprite as well
-       * @param [options.baseTexture=false] - Should it destroy the base texture of the sprite as well
-       */
-      Sprite.prototype.destroy = function (options) {
-          _super.prototype.destroy.call(this, options);
-          this._texture.off('update', this._onTextureUpdate, this);
-          this._anchor = null;
-          var destroyTexture = typeof options === 'boolean' ? options : options && options.texture;
-          if (destroyTexture) {
-              var destroyBaseTexture = typeof options === 'boolean' ? options : options && options.baseTexture;
-              this._texture.destroy(!!destroyBaseTexture);
-          }
-          this._texture = null;
-      };
-      // some helper functions..
-      /**
-       * Helper function that creates a new sprite based on the source you provide.
-       * The source can be - frame id, image url, video url, canvas element, video element, base texture
-       * @param {string|PIXI.Texture|HTMLCanvasElement|HTMLVideoElement} source - Source to create texture from
-       * @param {object} [options] - See {@link PIXI.BaseTexture}'s constructor for options.
-       * @returns The newly created sprite
-       */
-      Sprite.from = function (source, options) {
-          var texture = (source instanceof Texture)
-              ? source
-              : Texture.from(source, options);
-          return new Sprite(texture);
-      };
-      Object.defineProperty(Sprite.prototype, "roundPixels", {
-          get: function () {
-              return this._roundPixels;
-          },
-          /**
-           * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
-           *
-           * Advantages can include sharper image quality (like text) and faster rendering on canvas.
-           * The main disadvantage is movement of objects may appear less smooth.
-           *
-           * To set the global default, change {@link PIXI.settings.ROUND_PIXELS}.
-           * @default false
-           */
-          set: function (value) {
-              if (this._roundPixels !== value) {
-                  this._transformID = -1;
-              }
-              this._roundPixels = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Sprite.prototype, "width", {
-          /** The width of the sprite, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              return Math.abs(this.scale.x) * this._texture.orig.width;
-          },
-          set: function (value) {
-              var s = sign(this.scale.x) || 1;
-              this.scale.x = s * value / this._texture.orig.width;
-              this._width = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Sprite.prototype, "height", {
-          /** The height of the sprite, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              return Math.abs(this.scale.y) * this._texture.orig.height;
-          },
-          set: function (value) {
-              var s = sign(this.scale.y) || 1;
-              this.scale.y = s * value / this._texture.orig.height;
-              this._height = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Sprite.prototype, "anchor", {
-          /**
-           * The anchor sets the origin point of the sprite. The default value is taken from the {@link PIXI.Texture|Texture}
-           * and passed to the constructor.
-           *
-           * The default is `(0,0)`, this means the sprite's origin is the top left.
-           *
-           * Setting the anchor to `(0.5,0.5)` means the sprite's origin is centered.
-           *
-           * Setting the anchor to `(1,1)` would mean the sprite's origin point will be the bottom right corner.
-           *
-           * If you pass only single parameter, it will set both x and y to the same value as shown in the example below.
-           * @example
-           * const sprite = new PIXI.Sprite(texture);
-           * sprite.anchor.set(0.5); // This will set the origin to center. (0.5) is same as (0.5, 0.5).
-           */
-          get: function () {
-              return this._anchor;
-          },
-          set: function (value) {
-              this._anchor.copyFrom(value);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Sprite.prototype, "tint", {
-          /**
-           * The tint applied to the sprite. This is a hex value.
-           *
-           * A value of 0xFFFFFF will remove any tint effect.
-           * @default 0xFFFFFF
-           */
-          get: function () {
-              return this._tint;
-          },
-          set: function (value) {
-              this._tint = value;
-              this._tintRGB = (value >> 16) + (value & 0xff00) + ((value & 0xff) << 16);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Sprite.prototype, "texture", {
-          /** The texture that the sprite is using. */
-          get: function () {
-              return this._texture;
-          },
-          set: function (value) {
-              if (this._texture === value) {
-                  return;
-              }
-              if (this._texture) {
-                  this._texture.off('update', this._onTextureUpdate, this);
-              }
-              this._texture = value || Texture.EMPTY;
-              this._cachedTint = 0xFFFFFF;
-              this._textureID = -1;
-              this._textureTrimmedID = -1;
-              if (value) {
-                  // wait for the texture to load
-                  if (value.baseTexture.valid) {
-                      this._onTextureUpdate();
-                  }
-                  else {
-                      value.once('update', this._onTextureUpdate, this);
-                  }
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return Sprite;
-  }(Container));
-
-  /*!
-   * @pixi/text - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/text is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$c = function(d, b) {
-      extendStatics$c = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$c(d, b);
-  };
-
-  function __extends$c(d, b) {
-      extendStatics$c(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * Constants that define the type of gradient on text.
-   * @static
-   * @constant
-   * @name TEXT_GRADIENT
-   * @memberof PIXI
-   * @type {object}
-   * @property {number} LINEAR_VERTICAL Vertical gradient
-   * @property {number} LINEAR_HORIZONTAL Linear gradient
-   */
-  exports.TEXT_GRADIENT = void 0;
-  (function (TEXT_GRADIENT) {
-      TEXT_GRADIENT[TEXT_GRADIENT["LINEAR_VERTICAL"] = 0] = "LINEAR_VERTICAL";
-      TEXT_GRADIENT[TEXT_GRADIENT["LINEAR_HORIZONTAL"] = 1] = "LINEAR_HORIZONTAL";
-  })(exports.TEXT_GRADIENT || (exports.TEXT_GRADIENT = {}));
-
-  // disabling eslint for now, going to rewrite this in v5
-  var defaultStyle = {
-      align: 'left',
-      breakWords: false,
-      dropShadow: false,
-      dropShadowAlpha: 1,
-      dropShadowAngle: Math.PI / 6,
-      dropShadowBlur: 0,
-      dropShadowColor: 'black',
-      dropShadowDistance: 5,
-      fill: 'black',
-      fillGradientType: exports.TEXT_GRADIENT.LINEAR_VERTICAL,
-      fillGradientStops: [],
-      fontFamily: 'Arial',
-      fontSize: 26,
-      fontStyle: 'normal',
-      fontVariant: 'normal',
-      fontWeight: 'normal',
-      letterSpacing: 0,
-      lineHeight: 0,
-      lineJoin: 'miter',
-      miterLimit: 10,
-      padding: 0,
-      stroke: 'black',
-      strokeThickness: 0,
-      textBaseline: 'alphabetic',
-      trim: false,
-      whiteSpace: 'pre',
-      wordWrap: false,
-      wordWrapWidth: 100,
-      leading: 0,
-  };
-  var genericFontFamilies = [
-      'serif',
-      'sans-serif',
-      'monospace',
-      'cursive',
-      'fantasy',
-      'system-ui' ];
-  /**
-   * A TextStyle Object contains information to decorate a Text objects.
-   *
-   * An instance can be shared between multiple Text objects; then changing the style will update all text objects using it.
-   *
-   * A tool can be used to generate a text style [here](https://pixijs.io/pixi-text-style).
-   *
-   * @memberof PIXI
-   */
-  var TextStyle = /** @class */ (function () {
-      /**
-       * @param {object} [style] - The style parameters
-       * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center' or 'right'),
-       *  does not affect single line text
-       * @param {boolean} [style.breakWords=false] - Indicates if lines can be wrapped within words, it
-       *  needs wordWrap to be set to true
-       * @param {boolean} [style.dropShadow=false] - Set a drop shadow for the text
-       * @param {number} [style.dropShadowAlpha=1] - Set alpha for the drop shadow
-       * @param {number} [style.dropShadowAngle=Math.PI/6] - Set a angle of the drop shadow
-       * @param {number} [style.dropShadowBlur=0] - Set a shadow blur radius
-       * @param {string|number} [style.dropShadowColor='black'] - A fill style to be used on the dropshadow e.g 'red', '#00FF00'
-       * @param {number} [style.dropShadowDistance=5] - Set a distance of the drop shadow
-       * @param {string|string[]|number|number[]|CanvasGradient|CanvasPattern} [style.fill='black'] - A canvas
-       *  fillstyle that will be used on the text e.g 'red', '#00FF00'. Can be an array to create a gradient
-       *  eg ['#000000','#FFFFFF']
-       * {@link https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillStyle|MDN}
-       * @param {number} [style.fillGradientType=PIXI.TEXT_GRADIENT.LINEAR_VERTICAL] - If fill is an array of colours
-       *  to create a gradient, this can change the type/direction of the gradient. See {@link PIXI.TEXT_GRADIENT}
-       * @param {number[]} [style.fillGradientStops] - If fill is an array of colours to create a gradient, this array can set
-       * the stop points (numbers between 0 and 1) for the color, overriding the default behaviour of evenly spacing them.
-       * @param {string|string[]} [style.fontFamily='Arial'] - The font family
-       * @param {number|string} [style.fontSize=26] - The font size (as a number it converts to px, but as a string,
-       *  equivalents are '26px','20pt','160%' or '1.6em')
-       * @param {string} [style.fontStyle='normal'] - The font style ('normal', 'italic' or 'oblique')
-       * @param {string} [style.fontVariant='normal'] - The font variant ('normal' or 'small-caps')
-       * @param {string} [style.fontWeight='normal'] - The font weight ('normal', 'bold', 'bolder', 'lighter' and '100',
-       *  '200', '300', '400', '500', '600', '700', '800' or '900')
-       * @param {number} [style.leading=0] - The space between lines
-       * @param {number} [style.letterSpacing=0] - The amount of spacing between letters, default is 0
-       * @param {number} [style.lineHeight] - The line height, a number that represents the vertical space that a letter uses
-       * @param {string} [style.lineJoin='miter'] - The lineJoin property sets the type of corner created, it can resolve
-       *      spiked text issues. Possible values "miter" (creates a sharp corner), "round" (creates a round corner) or "bevel"
-       *      (creates a squared corner).
-       * @param {number} [style.miterLimit=10] - The miter limit to use when using the 'miter' lineJoin mode. This can reduce
-       *      or increase the spikiness of rendered text.
-       * @param {number} [style.padding=0] - Occasionally some fonts are cropped. Adding some padding will prevent this from
-       *     happening by adding padding to all sides of the text.
-       * @param {string|number} [style.stroke='black'] - A canvas fillstyle that will be used on the text stroke
-       *  e.g 'blue', '#FCFF00'
-       * @param {number} [style.strokeThickness=0] - A number that represents the thickness of the stroke.
-       *  Default is 0 (no stroke)
-       * @param {boolean} [style.trim=false] - Trim transparent borders
-       * @param {string} [style.textBaseline='alphabetic'] - The baseline of the text that is rendered.
-       * @param {string} [style.whiteSpace='pre'] - Determines whether newlines & spaces are collapsed or preserved "normal"
-       *      (collapse, collapse), "pre" (preserve, preserve) | "pre-line" (preserve, collapse). It needs wordWrap to be set to true
-       * @param {boolean} [style.wordWrap=false] - Indicates if word wrap should be used
-       * @param {number} [style.wordWrapWidth=100] - The width at which text will wrap, it needs wordWrap to be set to true
-       */
-      function TextStyle(style) {
-          this.styleID = 0;
-          this.reset();
-          deepCopyProperties(this, style, style);
-      }
-      /**
-       * Creates a new TextStyle object with the same values as this one.
-       * Note that the only the properties of the object are cloned.
-       *
-       * @return New cloned TextStyle object
-       */
-      TextStyle.prototype.clone = function () {
-          var clonedProperties = {};
-          deepCopyProperties(clonedProperties, this, defaultStyle);
-          return new TextStyle(clonedProperties);
-      };
-      /** Resets all properties to the defaults specified in TextStyle.prototype._default */
-      TextStyle.prototype.reset = function () {
-          deepCopyProperties(this, defaultStyle, defaultStyle);
-      };
-      Object.defineProperty(TextStyle.prototype, "align", {
-          /**
-           * Alignment for multiline text ('left', 'center' or 'right'), does not affect single line text
-           *
-           * @member {string}
-           */
-          get: function () {
-              return this._align;
-          },
-          set: function (align) {
-              if (this._align !== align) {
-                  this._align = align;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "breakWords", {
-          /** Indicates if lines can be wrapped within words, it needs wordWrap to be set to true. */
-          get: function () {
-              return this._breakWords;
-          },
-          set: function (breakWords) {
-              if (this._breakWords !== breakWords) {
-                  this._breakWords = breakWords;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "dropShadow", {
-          /** Set a drop shadow for the text. */
-          get: function () {
-              return this._dropShadow;
-          },
-          set: function (dropShadow) {
-              if (this._dropShadow !== dropShadow) {
-                  this._dropShadow = dropShadow;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "dropShadowAlpha", {
-          /** Set alpha for the drop shadow. */
-          get: function () {
-              return this._dropShadowAlpha;
-          },
-          set: function (dropShadowAlpha) {
-              if (this._dropShadowAlpha !== dropShadowAlpha) {
-                  this._dropShadowAlpha = dropShadowAlpha;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "dropShadowAngle", {
-          /** Set a angle of the drop shadow. */
-          get: function () {
-              return this._dropShadowAngle;
-          },
-          set: function (dropShadowAngle) {
-              if (this._dropShadowAngle !== dropShadowAngle) {
-                  this._dropShadowAngle = dropShadowAngle;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "dropShadowBlur", {
-          /** Set a shadow blur radius. */
-          get: function () {
-              return this._dropShadowBlur;
-          },
-          set: function (dropShadowBlur) {
-              if (this._dropShadowBlur !== dropShadowBlur) {
-                  this._dropShadowBlur = dropShadowBlur;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "dropShadowColor", {
-          /** A fill style to be used on the dropshadow e.g 'red', '#00FF00'. */
-          get: function () {
-              return this._dropShadowColor;
-          },
-          set: function (dropShadowColor) {
-              var outputColor = getColor(dropShadowColor);
-              if (this._dropShadowColor !== outputColor) {
-                  this._dropShadowColor = outputColor;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "dropShadowDistance", {
-          /** Set a distance of the drop shadow. */
-          get: function () {
-              return this._dropShadowDistance;
-          },
-          set: function (dropShadowDistance) {
-              if (this._dropShadowDistance !== dropShadowDistance) {
-                  this._dropShadowDistance = dropShadowDistance;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fill", {
-          /**
-           * A canvas fillstyle that will be used on the text e.g 'red', '#00FF00'.
-           *
-           * Can be an array to create a gradient eg ['#000000','#FFFFFF']
-           * {@link https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillStyle|MDN}
-           *
-           * @member {string|string[]|number|number[]|CanvasGradient|CanvasPattern}
-           */
-          get: function () {
-              return this._fill;
-          },
-          set: function (fill) {
-              // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
-              //       the setter converts to string. See this thread for more details:
-              //       https://github.com/microsoft/TypeScript/issues/2521
-              // TODO: Not sure if getColor works properly with CanvasGradient and/or CanvasPattern, can't pass in
-              //       without casting here.
-              var outputColor = getColor(fill);
-              if (this._fill !== outputColor) {
-                  this._fill = outputColor;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fillGradientType", {
-          /**
-           * If fill is an array of colours to create a gradient, this can change the type/direction of the gradient.
-           *
-           * @see PIXI.TEXT_GRADIENT
-           */
-          get: function () {
-              return this._fillGradientType;
-          },
-          set: function (fillGradientType) {
-              if (this._fillGradientType !== fillGradientType) {
-                  this._fillGradientType = fillGradientType;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fillGradientStops", {
-          /**
-           * If fill is an array of colours to create a gradient, this array can set the stop points
-           * (numbers between 0 and 1) for the color, overriding the default behaviour of evenly spacing them.
-           */
-          get: function () {
-              return this._fillGradientStops;
-          },
-          set: function (fillGradientStops) {
-              if (!areArraysEqual(this._fillGradientStops, fillGradientStops)) {
-                  this._fillGradientStops = fillGradientStops;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fontFamily", {
-          /** The font family. */
-          get: function () {
-              return this._fontFamily;
-          },
-          set: function (fontFamily) {
-              if (this.fontFamily !== fontFamily) {
-                  this._fontFamily = fontFamily;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fontSize", {
-          /**
-           * The font size
-           * (as a number it converts to px, but as a string, equivalents are '26px','20pt','160%' or '1.6em')
-           */
-          get: function () {
-              return this._fontSize;
-          },
-          set: function (fontSize) {
-              if (this._fontSize !== fontSize) {
-                  this._fontSize = fontSize;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fontStyle", {
-          /**
-           * The font style
-           * ('normal', 'italic' or 'oblique')
-           *
-           * @member {string}
-           */
-          get: function () {
-              return this._fontStyle;
-          },
-          set: function (fontStyle) {
-              if (this._fontStyle !== fontStyle) {
-                  this._fontStyle = fontStyle;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fontVariant", {
-          /**
-           * The font variant
-           * ('normal' or 'small-caps')
-           *
-           * @member {string}
-           */
-          get: function () {
-              return this._fontVariant;
-          },
-          set: function (fontVariant) {
-              if (this._fontVariant !== fontVariant) {
-                  this._fontVariant = fontVariant;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "fontWeight", {
-          /**
-           * The font weight
-           * ('normal', 'bold', 'bolder', 'lighter' and '100', '200', '300', '400', '500', '600', '700', 800' or '900')
-           *
-           * @member {string}
-           */
-          get: function () {
-              return this._fontWeight;
-          },
-          set: function (fontWeight) {
-              if (this._fontWeight !== fontWeight) {
-                  this._fontWeight = fontWeight;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "letterSpacing", {
-          /** The amount of spacing between letters, default is 0. */
-          get: function () {
-              return this._letterSpacing;
-          },
-          set: function (letterSpacing) {
-              if (this._letterSpacing !== letterSpacing) {
-                  this._letterSpacing = letterSpacing;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "lineHeight", {
-          /** The line height, a number that represents the vertical space that a letter uses. */
-          get: function () {
-              return this._lineHeight;
-          },
-          set: function (lineHeight) {
-              if (this._lineHeight !== lineHeight) {
-                  this._lineHeight = lineHeight;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "leading", {
-          /** The space between lines. */
-          get: function () {
-              return this._leading;
-          },
-          set: function (leading) {
-              if (this._leading !== leading) {
-                  this._leading = leading;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "lineJoin", {
-          /**
-           * The lineJoin property sets the type of corner created, it can resolve spiked text issues.
-           * Default is 'miter' (creates a sharp corner).
-           *
-           * @member {string}
-           */
-          get: function () {
-              return this._lineJoin;
-          },
-          set: function (lineJoin) {
-              if (this._lineJoin !== lineJoin) {
-                  this._lineJoin = lineJoin;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "miterLimit", {
-          /**
-           * The miter limit to use when using the 'miter' lineJoin mode.
-           *
-           * This can reduce or increase the spikiness of rendered text.
-           */
-          get: function () {
-              return this._miterLimit;
-          },
-          set: function (miterLimit) {
-              if (this._miterLimit !== miterLimit) {
-                  this._miterLimit = miterLimit;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "padding", {
-          /**
-           * Occasionally some fonts are cropped. Adding some padding will prevent this from happening
-           * by adding padding to all sides of the text.
-           */
-          get: function () {
-              return this._padding;
-          },
-          set: function (padding) {
-              if (this._padding !== padding) {
-                  this._padding = padding;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "stroke", {
-          /**
-           * A canvas fillstyle that will be used on the text stroke
-           * e.g 'blue', '#FCFF00'
-           */
-          get: function () {
-              return this._stroke;
-          },
-          set: function (stroke) {
-              // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
-              //       the setter converts to string. See this thread for more details:
-              //       https://github.com/microsoft/TypeScript/issues/2521
-              var outputColor = getColor(stroke);
-              if (this._stroke !== outputColor) {
-                  this._stroke = outputColor;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "strokeThickness", {
-          /**
-           * A number that represents the thickness of the stroke.
-           *
-           * @default 0
-           */
-          get: function () {
-              return this._strokeThickness;
-          },
-          set: function (strokeThickness) {
-              if (this._strokeThickness !== strokeThickness) {
-                  this._strokeThickness = strokeThickness;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "textBaseline", {
-          /**
-           * The baseline of the text that is rendered.
-           *
-           * @member {string}
-           */
-          get: function () {
-              return this._textBaseline;
-          },
-          set: function (textBaseline) {
-              if (this._textBaseline !== textBaseline) {
-                  this._textBaseline = textBaseline;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "trim", {
-          /** Trim transparent borders. */
-          get: function () {
-              return this._trim;
-          },
-          set: function (trim) {
-              if (this._trim !== trim) {
-                  this._trim = trim;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "whiteSpace", {
-          /**
-           * How newlines and spaces should be handled.
-           * Default is 'pre' (preserve, preserve).
-           *
-           *  value       | New lines     |   Spaces
-           *  ---         | ---           |   ---
-           * 'normal'     | Collapse      |   Collapse
-           * 'pre'        | Preserve      |   Preserve
-           * 'pre-line'   | Preserve      |   Collapse
-           *
-           * @member {string}
-           */
-          get: function () {
-              return this._whiteSpace;
-          },
-          set: function (whiteSpace) {
-              if (this._whiteSpace !== whiteSpace) {
-                  this._whiteSpace = whiteSpace;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "wordWrap", {
-          /** Indicates if word wrap should be used. */
-          get: function () {
-              return this._wordWrap;
-          },
-          set: function (wordWrap) {
-              if (this._wordWrap !== wordWrap) {
-                  this._wordWrap = wordWrap;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextStyle.prototype, "wordWrapWidth", {
-          /** The width at which text will wrap, it needs wordWrap to be set to true. */
-          get: function () {
-              return this._wordWrapWidth;
-          },
-          set: function (wordWrapWidth) {
-              if (this._wordWrapWidth !== wordWrapWidth) {
-                  this._wordWrapWidth = wordWrapWidth;
-                  this.styleID++;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Generates a font style string to use for `TextMetrics.measureFont()`.
-       *
-       * @return Font style string, for passing to `TextMetrics.measureFont()`
-       */
-      TextStyle.prototype.toFontString = function () {
-          // build canvas api font setting from individual components. Convert a numeric this.fontSize to px
-          var fontSizeString = (typeof this.fontSize === 'number') ? this.fontSize + "px" : this.fontSize;
-          // Clean-up fontFamily property by quoting each font name
-          // this will support font names with spaces
-          var fontFamilies = this.fontFamily;
-          if (!Array.isArray(this.fontFamily)) {
-              fontFamilies = this.fontFamily.split(',');
-          }
-          for (var i = fontFamilies.length - 1; i >= 0; i--) {
-              // Trim any extra white-space
-              var fontFamily = fontFamilies[i].trim();
-              // Check if font already contains strings
-              if (!(/([\"\'])[^\'\"]+\1/).test(fontFamily) && genericFontFamilies.indexOf(fontFamily) < 0) {
-                  fontFamily = "\"" + fontFamily + "\"";
-              }
-              fontFamilies[i] = fontFamily;
-          }
-          return this.fontStyle + " " + this.fontVariant + " " + this.fontWeight + " " + fontSizeString + " " + fontFamilies.join(',');
-      };
-      return TextStyle;
-  }());
-  /**
-   * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.
-   * @private
-   * @param color
-   * @return The color as a string.
-   */
-  function getSingleColor(color) {
-      if (typeof color === 'number') {
-          return hex2string(color);
-      }
-      else if (typeof color === 'string') {
-          if (color.indexOf('0x') === 0) {
-              color = color.replace('0x', '#');
-          }
-      }
-      return color;
-  }
-  function getColor(color) {
-      if (!Array.isArray(color)) {
-          return getSingleColor(color);
-      }
-      else {
-          for (var i = 0; i < color.length; ++i) {
-              color[i] = getSingleColor(color[i]);
-          }
-          return color;
-      }
-  }
-  /**
-   * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.
-   * This version can also convert array of colors
-   * @private
-   * @param array1 - First array to compare
-   * @param array2 - Second array to compare
-   * @return Do the arrays contain the same values in the same order
-   */
-  function areArraysEqual(array1, array2) {
-      if (!Array.isArray(array1) || !Array.isArray(array2)) {
-          return false;
-      }
-      if (array1.length !== array2.length) {
-          return false;
-      }
-      for (var i = 0; i < array1.length; ++i) {
-          if (array1[i] !== array2[i]) {
-              return false;
-          }
-      }
-      return true;
-  }
-  /**
-   * Utility function to ensure that object properties are copied by value, and not by reference
-   * @private
-   * @param target - Target object to copy properties into
-   * @param source - Source object for the properties to copy
-   * @param propertyObj - Object containing properties names we want to loop over
-   */
-  function deepCopyProperties(target, source, propertyObj) {
-      for (var prop in propertyObj) {
-          if (Array.isArray(source[prop])) {
-              target[prop] = source[prop].slice();
-          }
-          else {
-              target[prop] = source[prop];
-          }
-      }
-  }
-
-  // Default settings used for all getContext calls
-  var contextSettings = {
-      // TextMetrics requires getImageData readback for measuring fonts.
-      willReadFrequently: true,
-  };
-  /**
-   * The TextMetrics object represents the measurement of a block of text with a specified style.
-   *
-   * ```js
-   * let style = new PIXI.TextStyle({fontFamily : 'Arial', fontSize: 24, fill : 0xff1010, align : 'center'})
-   * let textMetrics = PIXI.TextMetrics.measureText('Your text', style)
-   * ```
-   * @memberof PIXI
-   */
-  var TextMetrics = /** @class */ (function () {
-      /**
-       * @param text - the text that was measured
-       * @param style - the style that was measured
-       * @param width - the measured width of the text
-       * @param height - the measured height of the text
-       * @param lines - an array of the lines of text broken by new lines and wrapping if specified in style
-       * @param lineWidths - an array of the line widths for each line matched to `lines`
-       * @param lineHeight - the measured line height for this style
-       * @param maxLineWidth - the maximum line width for all measured lines
-       * @param {PIXI.IFontMetrics} fontProperties - the font properties object from TextMetrics.measureFont
-       */
-      function TextMetrics(text, style, width, height, lines, lineWidths, lineHeight, maxLineWidth, fontProperties) {
-          this.text = text;
-          this.style = style;
-          this.width = width;
-          this.height = height;
-          this.lines = lines;
-          this.lineWidths = lineWidths;
-          this.lineHeight = lineHeight;
-          this.maxLineWidth = maxLineWidth;
-          this.fontProperties = fontProperties;
-      }
-      /**
-       * Measures the supplied string of text and returns a Rectangle.
-       * @param text - The text to measure.
-       * @param style - The text style to use for measuring
-       * @param wordWrap - Override for if word-wrap should be applied to the text.
-       * @param canvas - optional specification of the canvas to use for measuring.
-       * @returns Measured width and height of the text.
-       */
-      TextMetrics.measureText = function (text, style, wordWrap, canvas) {
-          if (canvas === void 0) { canvas = TextMetrics._canvas; }
-          wordWrap = (wordWrap === undefined || wordWrap === null) ? style.wordWrap : wordWrap;
-          var font = style.toFontString();
-          var fontProperties = TextMetrics.measureFont(font);
-          // fallback in case UA disallow canvas data extraction
-          // (toDataURI, getImageData functions)
-          if (fontProperties.fontSize === 0) {
-              fontProperties.fontSize = style.fontSize;
-              fontProperties.ascent = style.fontSize;
-          }
-          var context = canvas.getContext('2d', contextSettings);
-          context.font = font;
-          var outputText = wordWrap ? TextMetrics.wordWrap(text, style, canvas) : text;
-          var lines = outputText.split(/(?:\r\n|\r|\n)/);
-          var lineWidths = new Array(lines.length);
-          var maxLineWidth = 0;
-          for (var i = 0; i < lines.length; i++) {
-              var lineWidth = context.measureText(lines[i]).width + ((lines[i].length - 1) * style.letterSpacing);
-              lineWidths[i] = lineWidth;
-              maxLineWidth = Math.max(maxLineWidth, lineWidth);
-          }
-          var width = maxLineWidth + style.strokeThickness;
-          if (style.dropShadow) {
-              width += style.dropShadowDistance;
-          }
-          var lineHeight = style.lineHeight || fontProperties.fontSize + style.strokeThickness;
-          var height = Math.max(lineHeight, fontProperties.fontSize + style.strokeThickness)
-              + ((lines.length - 1) * (lineHeight + style.leading));
-          if (style.dropShadow) {
-              height += style.dropShadowDistance;
-          }
-          return new TextMetrics(text, style, width, height, lines, lineWidths, lineHeight + style.leading, maxLineWidth, fontProperties);
-      };
-      /**
-       * Applies newlines to a string to have it optimally fit into the horizontal
-       * bounds set by the Text object's wordWrapWidth property.
-       * @param text - String to apply word wrapping to
-       * @param style - the style to use when wrapping
-       * @param canvas - optional specification of the canvas to use for measuring.
-       * @returns New string with new lines applied where required
-       */
-      TextMetrics.wordWrap = function (text, style, canvas) {
-          if (canvas === void 0) { canvas = TextMetrics._canvas; }
-          var context = canvas.getContext('2d', contextSettings);
-          var width = 0;
-          var line = '';
-          var lines = '';
-          var cache = Object.create(null);
-          var letterSpacing = style.letterSpacing, whiteSpace = style.whiteSpace;
-          // How to handle whitespaces
-          var collapseSpaces = TextMetrics.collapseSpaces(whiteSpace);
-          var collapseNewlines = TextMetrics.collapseNewlines(whiteSpace);
-          // whether or not spaces may be added to the beginning of lines
-          var canPrependSpaces = !collapseSpaces;
-          // There is letterSpacing after every char except the last one
-          // t_h_i_s_' '_i_s_' '_a_n_' '_e_x_a_m_p_l_e_' '_!
-          // so for convenience the above needs to be compared to width + 1 extra letterSpace
-          // t_h_i_s_' '_i_s_' '_a_n_' '_e_x_a_m_p_l_e_' '_!_
-          // ________________________________________________
-          // And then the final space is simply no appended to each line
-          var wordWrapWidth = style.wordWrapWidth + letterSpacing;
-          // break text into words, spaces and newline chars
-          var tokens = TextMetrics.tokenize(text);
-          for (var i = 0; i < tokens.length; i++) {
-              // get the word, space or newlineChar
-              var token = tokens[i];
-              // if word is a new line
-              if (TextMetrics.isNewline(token)) {
-                  // keep the new line
-                  if (!collapseNewlines) {
-                      lines += TextMetrics.addLine(line);
-                      canPrependSpaces = !collapseSpaces;
-                      line = '';
-                      width = 0;
-                      continue;
-                  }
-                  // if we should collapse new lines
-                  // we simply convert it into a space
-                  token = ' ';
-              }
-              // if we should collapse repeated whitespaces
-              if (collapseSpaces) {
-                  // check both this and the last tokens for spaces
-                  var currIsBreakingSpace = TextMetrics.isBreakingSpace(token);
-                  var lastIsBreakingSpace = TextMetrics.isBreakingSpace(line[line.length - 1]);
-                  if (currIsBreakingSpace && lastIsBreakingSpace) {
-                      continue;
-                  }
-              }
-              // get word width from cache if possible
-              var tokenWidth = TextMetrics.getFromCache(token, letterSpacing, cache, context);
-              // word is longer than desired bounds
-              if (tokenWidth > wordWrapWidth) {
-                  // if we are not already at the beginning of a line
-                  if (line !== '') {
-                      // start newlines for overflow words
-                      lines += TextMetrics.addLine(line);
-                      line = '';
-                      width = 0;
-                  }
-                  // break large word over multiple lines
-                  if (TextMetrics.canBreakWords(token, style.breakWords)) {
-                      // break word into characters
-                      var characters = TextMetrics.wordWrapSplit(token);
-                      // loop the characters
-                      for (var j = 0; j < characters.length; j++) {
-                          var char = characters[j];
-                          var k = 1;
-                          // we are not at the end of the token
-                          while (characters[j + k]) {
-                              var nextChar = characters[j + k];
-                              var lastChar = char[char.length - 1];
-                              // should not split chars
-                              if (!TextMetrics.canBreakChars(lastChar, nextChar, token, j, style.breakWords)) {
-                                  // combine chars & move forward one
-                                  char += nextChar;
-                              }
-                              else {
-                                  break;
-                              }
-                              k++;
-                          }
-                          j += char.length - 1;
-                          var characterWidth = TextMetrics.getFromCache(char, letterSpacing, cache, context);
-                          if (characterWidth + width > wordWrapWidth) {
-                              lines += TextMetrics.addLine(line);
-                              canPrependSpaces = false;
-                              line = '';
-                              width = 0;
-                          }
-                          line += char;
-                          width += characterWidth;
-                      }
-                  }
-                  // run word out of the bounds
-                  else {
-                      // if there are words in this line already
-                      // finish that line and start a new one
-                      if (line.length > 0) {
-                          lines += TextMetrics.addLine(line);
-                          line = '';
-                          width = 0;
-                      }
-                      var isLastToken = i === tokens.length - 1;
-                      // give it its own line if it's not the end
-                      lines += TextMetrics.addLine(token, !isLastToken);
-                      canPrependSpaces = false;
-                      line = '';
-                      width = 0;
-                  }
-              }
-              // word could fit
-              else {
-                  // word won't fit because of existing words
-                  // start a new line
-                  if (tokenWidth + width > wordWrapWidth) {
-                      // if its a space we don't want it
-                      canPrependSpaces = false;
-                      // add a new line
-                      lines += TextMetrics.addLine(line);
-                      // start a new line
-                      line = '';
-                      width = 0;
-                  }
-                  // don't add spaces to the beginning of lines
-                  if (line.length > 0 || !TextMetrics.isBreakingSpace(token) || canPrependSpaces) {
-                      // add the word to the current line
-                      line += token;
-                      // update width counter
-                      width += tokenWidth;
-                  }
-              }
-          }
-          lines += TextMetrics.addLine(line, false);
-          return lines;
-      };
-      /**
-       * Convienience function for logging each line added during the wordWrap method.
-       * @param line    - The line of text to add
-       * @param newLine - Add new line character to end
-       * @returns A formatted line
-       */
-      TextMetrics.addLine = function (line, newLine) {
-          if (newLine === void 0) { newLine = true; }
-          line = TextMetrics.trimRight(line);
-          line = (newLine) ? line + "\n" : line;
-          return line;
-      };
-      /**
-       * Gets & sets the widths of calculated characters in a cache object
-       * @param key            - The key
-       * @param letterSpacing  - The letter spacing
-       * @param cache          - The cache
-       * @param context        - The canvas context
-       * @returns The from cache.
-       */
-      TextMetrics.getFromCache = function (key, letterSpacing, cache, context) {
-          var width = cache[key];
-          if (typeof width !== 'number') {
-              var spacing = ((key.length) * letterSpacing);
-              width = context.measureText(key).width + spacing;
-              cache[key] = width;
-          }
-          return width;
-      };
-      /**
-       * Determines whether we should collapse breaking spaces.
-       * @param whiteSpace - The TextStyle property whiteSpace
-       * @returns Should collapse
-       */
-      TextMetrics.collapseSpaces = function (whiteSpace) {
-          return (whiteSpace === 'normal' || whiteSpace === 'pre-line');
-      };
-      /**
-       * Determines whether we should collapse newLine chars.
-       * @param whiteSpace - The white space
-       * @returns  should collapse
-       */
-      TextMetrics.collapseNewlines = function (whiteSpace) {
-          return (whiteSpace === 'normal');
-      };
-      /**
-       * Trims breaking whitespaces from string.
-       * @param  text - The text
-       * @returns Trimmed string
-       */
-      TextMetrics.trimRight = function (text) {
-          if (typeof text !== 'string') {
-              return '';
-          }
-          for (var i = text.length - 1; i >= 0; i--) {
-              var char = text[i];
-              if (!TextMetrics.isBreakingSpace(char)) {
-                  break;
-              }
-              text = text.slice(0, -1);
-          }
-          return text;
-      };
-      /**
-       * Determines if char is a newline.
-       * @param  char - The character
-       * @returns True if newline, False otherwise.
-       */
-      TextMetrics.isNewline = function (char) {
-          if (typeof char !== 'string') {
-              return false;
-          }
-          return (TextMetrics._newlines.indexOf(char.charCodeAt(0)) >= 0);
-      };
-      /**
-       * Determines if char is a breaking whitespace.
-       *
-       * It allows one to determine whether char should be a breaking whitespace
-       * For example certain characters in CJK langs or numbers.
-       * It must return a boolean.
-       * @param char - The character
-       * @param [_nextChar] - The next character
-       * @returns True if whitespace, False otherwise.
-       */
-      TextMetrics.isBreakingSpace = function (char, _nextChar) {
-          if (typeof char !== 'string') {
-              return false;
-          }
-          return (TextMetrics._breakingSpaces.indexOf(char.charCodeAt(0)) >= 0);
-      };
-      /**
-       * Splits a string into words, breaking-spaces and newLine characters
-       * @param  text - The text
-       * @returns  A tokenized array
-       */
-      TextMetrics.tokenize = function (text) {
-          var tokens = [];
-          var token = '';
-          if (typeof text !== 'string') {
-              return tokens;
-          }
-          for (var i = 0; i < text.length; i++) {
-              var char = text[i];
-              var nextChar = text[i + 1];
-              if (TextMetrics.isBreakingSpace(char, nextChar) || TextMetrics.isNewline(char)) {
-                  if (token !== '') {
-                      tokens.push(token);
-                      token = '';
-                  }
-                  tokens.push(char);
-                  continue;
-              }
-              token += char;
-          }
-          if (token !== '') {
-              tokens.push(token);
-          }
-          return tokens;
-      };
-      /**
-       * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
-       *
-       * It allows one to customise which words should break
-       * Examples are if the token is CJK or numbers.
-       * It must return a boolean.
-       * @param _token - The token
-       * @param  breakWords - The style attr break words
-       * @returns Whether to break word or not
-       */
-      TextMetrics.canBreakWords = function (_token, breakWords) {
-          return breakWords;
-      };
-      /**
-       * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
-       *
-       * It allows one to determine whether a pair of characters
-       * should be broken by newlines
-       * For example certain characters in CJK langs or numbers.
-       * It must return a boolean.
-       * @param _char - The character
-       * @param _nextChar - The next character
-       * @param _token - The token/word the characters are from
-       * @param _index - The index in the token of the char
-       * @param _breakWords - The style attr break words
-       * @returns whether to break word or not
-       */
-      TextMetrics.canBreakChars = function (_char, _nextChar, _token, _index, _breakWords) {
-          return true;
-      };
-      /**
-       * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
-       *
-       * It is called when a token (usually a word) has to be split into separate pieces
-       * in order to determine the point to break a word.
-       * It must return an array of characters.
-       * @example
-       * // Correctly splits emojis, eg "🤪🤪" will result in two element array, each with one emoji.
-       * TextMetrics.wordWrapSplit = (token) => [...token];
-       * @param  token - The token to split
-       * @returns The characters of the token
-       */
-      TextMetrics.wordWrapSplit = function (token) {
-          return token.split('');
-      };
-      /**
-       * Calculates the ascent, descent and fontSize of a given font-style
-       * @param font - String representing the style of the font
-       * @returns Font properties object
-       */
-      TextMetrics.measureFont = function (font) {
-          // as this method is used for preparing assets, don't recalculate things if we don't need to
-          if (TextMetrics._fonts[font]) {
-              return TextMetrics._fonts[font];
-          }
-          var properties = {
-              ascent: 0,
-              descent: 0,
-              fontSize: 0,
-          };
-          var canvas = TextMetrics._canvas;
-          var context = TextMetrics._context;
-          context.font = font;
-          var metricsString = TextMetrics.METRICS_STRING + TextMetrics.BASELINE_SYMBOL;
-          var width = Math.ceil(context.measureText(metricsString).width);
-          var baseline = Math.ceil(context.measureText(TextMetrics.BASELINE_SYMBOL).width);
-          var height = Math.ceil(TextMetrics.HEIGHT_MULTIPLIER * baseline);
-          baseline = baseline * TextMetrics.BASELINE_MULTIPLIER | 0;
-          canvas.width = width;
-          canvas.height = height;
-          context.fillStyle = '#f00';
-          context.fillRect(0, 0, width, height);
-          context.font = font;
-          context.textBaseline = 'alphabetic';
-          context.fillStyle = '#000';
-          context.fillText(metricsString, 0, baseline);
-          var imagedata = context.getImageData(0, 0, width, height).data;
-          var pixels = imagedata.length;
-          var line = width * 4;
-          var i = 0;
-          var idx = 0;
-          var stop = false;
-          // ascent. scan from top to bottom until we find a non red pixel
-          for (i = 0; i < baseline; ++i) {
-              for (var j = 0; j < line; j += 4) {
-                  if (imagedata[idx + j] !== 255) {
-                      stop = true;
-                      break;
-                  }
-              }
-              if (!stop) {
-                  idx += line;
-              }
-              else {
-                  break;
-              }
-          }
-          properties.ascent = baseline - i;
-          idx = pixels - line;
-          stop = false;
-          // descent. scan from bottom to top until we find a non red pixel
-          for (i = height; i > baseline; --i) {
-              for (var j = 0; j < line; j += 4) {
-                  if (imagedata[idx + j] !== 255) {
-                      stop = true;
-                      break;
-                  }
-              }
-              if (!stop) {
-                  idx -= line;
-              }
-              else {
-                  break;
-              }
-          }
-          properties.descent = i - baseline;
-          properties.fontSize = properties.ascent + properties.descent;
-          TextMetrics._fonts[font] = properties;
-          return properties;
-      };
-      /**
-       * Clear font metrics in metrics cache.
-       * @param {string} [font] - font name. If font name not set then clear cache for all fonts.
-       */
-      TextMetrics.clearMetrics = function (font) {
-          if (font === void 0) { font = ''; }
-          if (font) {
-              delete TextMetrics._fonts[font];
-          }
-          else {
-              TextMetrics._fonts = {};
-          }
-      };
-      Object.defineProperty(TextMetrics, "_canvas", {
-          /**
-           * Cached canvas element for measuring text
-           * TODO: this should be private, but isn't because of backward compat, will fix later.
-           * @ignore
-           */
-          get: function () {
-              if (!TextMetrics.__canvas) {
-                  var canvas = void 0;
-                  try {
-                      // OffscreenCanvas2D measureText can be up to 40% faster.
-                      var c = new OffscreenCanvas(0, 0);
-                      var context = c.getContext('2d', contextSettings);
-                      if (context && context.measureText) {
-                          TextMetrics.__canvas = c;
-                          return c;
-                      }
-                      canvas = settings.ADAPTER.createCanvas();
-                  }
-                  catch (ex) {
-                      canvas = settings.ADAPTER.createCanvas();
-                  }
-                  canvas.width = canvas.height = 10;
-                  TextMetrics.__canvas = canvas;
-              }
-              return TextMetrics.__canvas;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TextMetrics, "_context", {
-          /**
-           * TODO: this should be private, but isn't because of backward compat, will fix later.
-           * @ignore
-           */
-          get: function () {
-              if (!TextMetrics.__context) {
-                  TextMetrics.__context = TextMetrics._canvas.getContext('2d', contextSettings);
-              }
-              return TextMetrics.__context;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return TextMetrics;
-  }());
-  /**
-   * Internal return object for {@link PIXI.TextMetrics.measureFont `TextMetrics.measureFont`}.
-   * @typedef {object} FontMetrics
-   * @property {number} ascent - The ascent distance
-   * @property {number} descent - The descent distance
-   * @property {number} fontSize - Font size from ascent to descent
-   * @memberof PIXI.TextMetrics
-   * @private
-   */
-  /**
-   * Cache of {@see PIXI.TextMetrics.FontMetrics} objects.
-   * @memberof PIXI.TextMetrics
-   * @type {object}
-   * @private
-   */
-  TextMetrics._fonts = {};
-  /**
-   * String used for calculate font metrics.
-   * These characters are all tall to help calculate the height required for text.
-   * @static
-   * @memberof PIXI.TextMetrics
-   * @name METRICS_STRING
-   * @type {string}
-   * @default |ÉqÅ
-   */
-  TextMetrics.METRICS_STRING = '|ÉqÅ';
-  /**
-   * Baseline symbol for calculate font metrics.
-   * @static
-   * @memberof PIXI.TextMetrics
-   * @name BASELINE_SYMBOL
-   * @type {string}
-   * @default M
-   */
-  TextMetrics.BASELINE_SYMBOL = 'M';
-  /**
-   * Baseline multiplier for calculate font metrics.
-   * @static
-   * @memberof PIXI.TextMetrics
-   * @name BASELINE_MULTIPLIER
-   * @type {number}
-   * @default 1.4
-   */
-  TextMetrics.BASELINE_MULTIPLIER = 1.4;
-  /**
-   * Height multiplier for setting height of canvas to calculate font metrics.
-   * @static
-   * @memberof PIXI.TextMetrics
-   * @name HEIGHT_MULTIPLIER
-   * @type {number}
-   * @default 2.00
-   */
-  TextMetrics.HEIGHT_MULTIPLIER = 2.0;
-  /**
-   * Cache of new line chars.
-   * @memberof PIXI.TextMetrics
-   * @type {number[]}
-   * @private
-   */
-  TextMetrics._newlines = [
-      0x000A,
-      0x000D ];
-  /**
-   * Cache of breaking spaces.
-   * @memberof PIXI.TextMetrics
-   * @type {number[]}
-   * @private
-   */
-  TextMetrics._breakingSpaces = [
-      0x0009,
-      0x0020,
-      0x2000,
-      0x2001,
-      0x2002,
-      0x2003,
-      0x2004,
-      0x2005,
-      0x2006,
-      0x2008,
-      0x2009,
-      0x200A,
-      0x205F,
-      0x3000 ];
-  /**
-   * A number, or a string containing a number.
-   * @memberof PIXI
-   * @typedef {object} IFontMetrics
-   * @property {number} ascent - Font ascent
-   * @property {number} descent - Font descent
-   * @property {number} fontSize - Font size
-   */
-
-  var defaultDestroyOptions = {
-      texture: true,
-      children: false,
-      baseTexture: true,
-  };
-  /**
-   * A Text Object will create a line or multiple lines of text.
-   *
-   * The text is created using the [Canvas API](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API).
-   *
-   * The primary advantage of this class over BitmapText is that you have great control over the style of the text,
-   * which you can change at runtime.
-   *
-   * The primary disadvantages is that each piece of text has it's own texture, which can use more memory.
-   * When text changes, this texture has to be re-generated and re-uploaded to the GPU, taking up time.
-   *
-   * To split a line you can use '\n' in your text string, or, on the `style` object,
-   * change its `wordWrap` property to true and and give the `wordWrapWidth` property a value.
-   *
-   * A Text can be created directly from a string and a style object,
-   * which can be generated [here](https://pixijs.io/pixi-text-style).
-   *
-   * ```js
-   * let text = new PIXI.Text('This is a PixiJS text',{fontFamily : 'Arial', fontSize: 24, fill : 0xff1010, align : 'center'});
-   * ```
-   * @memberof PIXI
-   */
-  var Text = /** @class */ (function (_super) {
-      __extends$c(Text, _super);
-      /**
-       * @param text - The string that you would like the text to display
-       * @param {object|PIXI.TextStyle} [style] - The style parameters
-       * @param canvas - The canvas element for drawing text
-       */
-      function Text(text, style, canvas) {
-          var _this = this;
-          var ownCanvas = false;
-          if (!canvas) {
-              canvas = settings.ADAPTER.createCanvas();
-              ownCanvas = true;
-          }
-          canvas.width = 3;
-          canvas.height = 3;
-          var texture = Texture.from(canvas);
-          texture.orig = new Rectangle();
-          texture.trim = new Rectangle();
-          _this = _super.call(this, texture) || this;
-          _this._ownCanvas = ownCanvas;
-          _this.canvas = canvas;
-          _this.context = canvas.getContext('2d', {
-              // required for trimming to work without warnings
-              willReadFrequently: true,
-          });
-          _this._resolution = settings.RESOLUTION;
-          _this._autoResolution = true;
-          _this._text = null;
-          _this._style = null;
-          _this._styleListener = null;
-          _this._font = '';
-          _this.text = text;
-          _this.style = style;
-          _this.localStyleID = -1;
-          return _this;
-      }
-      /**
-       * Renders text to its canvas, and updates its texture.
-       *
-       * By default this is used internally to ensure the texture is correct before rendering,
-       * but it can be used called externally, for example from this class to 'pre-generate' the texture from a piece of text,
-       * and then shared across multiple Sprites.
-       * @param respectDirty - Whether to abort updating the text if the Text isn't dirty and the function is called.
-       */
-      Text.prototype.updateText = function (respectDirty) {
-          var style = this._style;
-          // check if style has changed..
-          if (this.localStyleID !== style.styleID) {
-              this.dirty = true;
-              this.localStyleID = style.styleID;
-          }
-          if (!this.dirty && respectDirty) {
-              return;
-          }
-          this._font = this._style.toFontString();
-          var context = this.context;
-          var measured = TextMetrics.measureText(this._text || ' ', this._style, this._style.wordWrap, this.canvas);
-          var width = measured.width;
-          var height = measured.height;
-          var lines = measured.lines;
-          var lineHeight = measured.lineHeight;
-          var lineWidths = measured.lineWidths;
-          var maxLineWidth = measured.maxLineWidth;
-          var fontProperties = measured.fontProperties;
-          this.canvas.width = Math.ceil(Math.ceil((Math.max(1, width) + (style.padding * 2))) * this._resolution);
-          this.canvas.height = Math.ceil(Math.ceil((Math.max(1, height) + (style.padding * 2))) * this._resolution);
-          context.scale(this._resolution, this._resolution);
-          context.clearRect(0, 0, this.canvas.width, this.canvas.height);
-          context.font = this._font;
-          context.lineWidth = style.strokeThickness;
-          context.textBaseline = style.textBaseline;
-          context.lineJoin = style.lineJoin;
-          context.miterLimit = style.miterLimit;
-          var linePositionX;
-          var linePositionY;
-          // require 2 passes if a shadow; the first to draw the drop shadow, the second to draw the text
-          var passesCount = style.dropShadow ? 2 : 1;
-          // For v4, we drew text at the colours of the drop shadow underneath the normal text. This gave the correct zIndex,
-          // but features such as alpha and shadowblur did not look right at all, since we were using actual text as a shadow.
-          //
-          // For v5.0.0, we moved over to just use the canvas API for drop shadows, which made them look much nicer and more
-          // visually please, but now because the stroke is drawn and then the fill, drop shadows would appear on both the fill
-          // and the stroke; and fill drop shadows would appear over the top of the stroke.
-          //
-          // For v5.1.1, the new route is to revert to v4 style of drawing text first to get the drop shadows underneath normal
-          // text, but instead drawing text in the correct location, we'll draw it off screen (-paddingY), and then adjust the
-          // drop shadow so only that appears on screen (+paddingY). Now we'll have the correct draw order of the shadow
-          // beneath the text, whilst also having the proper text shadow styling.
-          for (var i = 0; i < passesCount; ++i) {
-              var isShadowPass = style.dropShadow && i === 0;
-              // we only want the drop shadow, so put text way off-screen
-              var dsOffsetText = isShadowPass ? Math.ceil(Math.max(1, height) + (style.padding * 2)) : 0;
-              var dsOffsetShadow = dsOffsetText * this._resolution;
-              if (isShadowPass) {
-                  // On Safari, text with gradient and drop shadows together do not position correctly
-                  // if the scale of the canvas is not 1: https://bugs.webkit.org/show_bug.cgi?id=197689
-                  // Therefore we'll set the styles to be a plain black whilst generating this drop shadow
-                  context.fillStyle = 'black';
-                  context.strokeStyle = 'black';
-                  var dropShadowColor = style.dropShadowColor;
-                  var rgb = hex2rgb(typeof dropShadowColor === 'number' ? dropShadowColor : string2hex(dropShadowColor));
-                  var dropShadowBlur = style.dropShadowBlur * this._resolution;
-                  var dropShadowDistance = style.dropShadowDistance * this._resolution;
-                  context.shadowColor = "rgba(" + rgb[0] * 255 + "," + rgb[1] * 255 + "," + rgb[2] * 255 + "," + style.dropShadowAlpha + ")";
-                  context.shadowBlur = dropShadowBlur;
-                  context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;
-                  context.shadowOffsetY = (Math.sin(style.dropShadowAngle) * dropShadowDistance) + dsOffsetShadow;
-              }
-              else {
-                  // set canvas text styles
-                  context.fillStyle = this._generateFillStyle(style, lines, measured);
-                  // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
-                  //       the setter converts to string. See this thread for more details:
-                  //       https://github.com/microsoft/TypeScript/issues/2521
-                  context.strokeStyle = style.stroke;
-                  context.shadowColor = 'black';
-                  context.shadowBlur = 0;
-                  context.shadowOffsetX = 0;
-                  context.shadowOffsetY = 0;
-              }
-              var linePositionYShift = (lineHeight - fontProperties.fontSize) / 2;
-              if (!Text.nextLineHeightBehavior || lineHeight - fontProperties.fontSize < 0) {
-                  linePositionYShift = 0;
-              }
-              // draw lines line by line
-              for (var i_1 = 0; i_1 < lines.length; i_1++) {
-                  linePositionX = style.strokeThickness / 2;
-                  linePositionY = ((style.strokeThickness / 2) + (i_1 * lineHeight)) + fontProperties.ascent
-                      + linePositionYShift;
-                  if (style.align === 'right') {
-                      linePositionX += maxLineWidth - lineWidths[i_1];
-                  }
-                  else if (style.align === 'center') {
-                      linePositionX += (maxLineWidth - lineWidths[i_1]) / 2;
-                  }
-                  if (style.stroke && style.strokeThickness) {
-                      this.drawLetterSpacing(lines[i_1], linePositionX + style.padding, linePositionY + style.padding - dsOffsetText, true);
-                  }
-                  if (style.fill) {
-                      this.drawLetterSpacing(lines[i_1], linePositionX + style.padding, linePositionY + style.padding - dsOffsetText);
-                  }
-              }
-          }
-          this.updateTexture();
-      };
-      /**
-       * Render the text with letter-spacing.
-       * @param text - The text to draw
-       * @param x - Horizontal position to draw the text
-       * @param y - Vertical position to draw the text
-       * @param isStroke - Is this drawing for the outside stroke of the
-       *  text? If not, it's for the inside fill
-       */
-      Text.prototype.drawLetterSpacing = function (text, x, y, isStroke) {
-          if (isStroke === void 0) { isStroke = false; }
-          var style = this._style;
-          // letterSpacing of 0 means normal
-          var letterSpacing = style.letterSpacing;
-          // Checking that we can use moddern canvas2D api
-          // https://developer.chrome.com/origintrials/#/view_trial/3585991203293757441
-          // note: this is unstable API, Chrome less 94 use a `textLetterSpacing`, newest use a letterSpacing
-          // eslint-disable-next-line max-len
-          var supportLetterSpacing = Text.experimentalLetterSpacing
-              && ('letterSpacing' in CanvasRenderingContext2D.prototype
-                  || 'textLetterSpacing' in CanvasRenderingContext2D.prototype);
-          if (letterSpacing === 0 || supportLetterSpacing) {
-              if (supportLetterSpacing) {
-                  this.context.letterSpacing = letterSpacing;
-                  this.context.textLetterSpacing = letterSpacing;
-              }
-              if (isStroke) {
-                  this.context.strokeText(text, x, y);
-              }
-              else {
-                  this.context.fillText(text, x, y);
-              }
-              return;
-          }
-          var currentPosition = x;
-          // Using Array.from correctly splits characters whilst keeping emoji together.
-          // This is not supported on IE as it requires ES6, so regular text splitting occurs.
-          // This also doesn't account for emoji that are multiple emoji put together to make something else.
-          // Handling all of this would require a big library itself.
-          // https://medium.com/@giltayar/iterating-over-emoji-characters-the-es6-way-f06e4589516
-          // https://github.com/orling/grapheme-splitter
-          var stringArray = Array.from ? Array.from(text) : text.split('');
-          var previousWidth = this.context.measureText(text).width;
-          var currentWidth = 0;
-          for (var i = 0; i < stringArray.length; ++i) {
-              var currentChar = stringArray[i];
-              if (isStroke) {
-                  this.context.strokeText(currentChar, currentPosition, y);
-              }
-              else {
-                  this.context.fillText(currentChar, currentPosition, y);
-              }
-              var textStr = '';
-              for (var j = i + 1; j < stringArray.length; ++j) {
-                  textStr += stringArray[j];
-              }
-              currentWidth = this.context.measureText(textStr).width;
-              currentPosition += previousWidth - currentWidth + letterSpacing;
-              previousWidth = currentWidth;
-          }
-      };
-      /** Updates texture size based on canvas size. */
-      Text.prototype.updateTexture = function () {
-          var canvas = this.canvas;
-          if (this._style.trim) {
-              var trimmed = trimCanvas(canvas);
-              if (trimmed.data) {
-                  canvas.width = trimmed.width;
-                  canvas.height = trimmed.height;
-                  this.context.putImageData(trimmed.data, 0, 0);
-              }
-          }
-          var texture = this._texture;
-          var style = this._style;
-          var padding = style.trim ? 0 : style.padding;
-          var baseTexture = texture.baseTexture;
-          texture.trim.width = texture._frame.width = canvas.width / this._resolution;
-          texture.trim.height = texture._frame.height = canvas.height / this._resolution;
-          texture.trim.x = -padding;
-          texture.trim.y = -padding;
-          texture.orig.width = texture._frame.width - (padding * 2);
-          texture.orig.height = texture._frame.height - (padding * 2);
-          // call sprite onTextureUpdate to update scale if _width or _height were set
-          this._onTextureUpdate();
-          baseTexture.setRealSize(canvas.width, canvas.height, this._resolution);
-          texture.updateUvs();
-          this.dirty = false;
-      };
-      /**
-       * Renders the object using the WebGL renderer
-       * @param renderer - The renderer
-       */
-      Text.prototype._render = function (renderer) {
-          if (this._autoResolution && this._resolution !== renderer.resolution) {
-              this._resolution = renderer.resolution;
-              this.dirty = true;
-          }
-          this.updateText(true);
-          _super.prototype._render.call(this, renderer);
-      };
-      /** Updates the transform on all children of this container for rendering. */
-      Text.prototype.updateTransform = function () {
-          this.updateText(true);
-          _super.prototype.updateTransform.call(this);
-      };
-      Text.prototype.getBounds = function (skipUpdate, rect) {
-          this.updateText(true);
-          if (this._textureID === -1) {
-              // texture was updated: recalculate transforms
-              skipUpdate = false;
-          }
-          return _super.prototype.getBounds.call(this, skipUpdate, rect);
-      };
-      /**
-       * Gets the local bounds of the text object.
-       * @param rect - The output rectangle.
-       * @returns The bounds.
-       */
-      Text.prototype.getLocalBounds = function (rect) {
-          this.updateText(true);
-          return _super.prototype.getLocalBounds.call(this, rect);
-      };
-      /** Calculates the bounds of the Text as a rectangle. The bounds calculation takes the worldTransform into account. */
-      Text.prototype._calculateBounds = function () {
-          this.calculateVertices();
-          // if we have already done this on THIS frame.
-          this._bounds.addQuad(this.vertexData);
-      };
-      /**
-       * Generates the fill style. Can automatically generate a gradient based on the fill style being an array
-       * @param style - The style.
-       * @param lines - The lines of text.
-       * @param metrics
-       * @returns The fill style
-       */
-      Text.prototype._generateFillStyle = function (style, lines, metrics) {
-          // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
-          //       the setter converts to string. See this thread for more details:
-          //       https://github.com/microsoft/TypeScript/issues/2521
-          var fillStyle = style.fill;
-          if (!Array.isArray(fillStyle)) {
-              return fillStyle;
-          }
-          else if (fillStyle.length === 1) {
-              return fillStyle[0];
-          }
-          // the gradient will be evenly spaced out according to how large the array is.
-          // ['#FF0000', '#00FF00', '#0000FF'] would created stops at 0.25, 0.5 and 0.75
-          var gradient;
-          // a dropshadow will enlarge the canvas and result in the gradient being
-          // generated with the incorrect dimensions
-          var dropShadowCorrection = (style.dropShadow) ? style.dropShadowDistance : 0;
-          // should also take padding into account, padding can offset the gradient
-          var padding = style.padding || 0;
-          var width = (this.canvas.width / this._resolution) - dropShadowCorrection - (padding * 2);
-          var height = (this.canvas.height / this._resolution) - dropShadowCorrection - (padding * 2);
-          // make a copy of the style settings, so we can manipulate them later
-          var fill = fillStyle.slice();
-          var fillGradientStops = style.fillGradientStops.slice();
-          // wanting to evenly distribute the fills. So an array of 4 colours should give fills of 0.25, 0.5 and 0.75
-          if (!fillGradientStops.length) {
-              var lengthPlus1 = fill.length + 1;
-              for (var i = 1; i < lengthPlus1; ++i) {
-                  fillGradientStops.push(i / lengthPlus1);
-              }
-          }
-          // stop the bleeding of the last gradient on the line above to the top gradient of the this line
-          // by hard defining the first gradient colour at point 0, and last gradient colour at point 1
-          fill.unshift(fillStyle[0]);
-          fillGradientStops.unshift(0);
-          fill.push(fillStyle[fillStyle.length - 1]);
-          fillGradientStops.push(1);
-          if (style.fillGradientType === exports.TEXT_GRADIENT.LINEAR_VERTICAL) {
-              // start the gradient at the top center of the canvas, and end at the bottom middle of the canvas
-              gradient = this.context.createLinearGradient(width / 2, padding, width / 2, height + padding);
-              // we need to repeat the gradient so that each individual line of text has the same vertical gradient effect
-              // ['#FF0000', '#00FF00', '#0000FF'] over 2 lines would create stops at 0.125, 0.25, 0.375, 0.625, 0.75, 0.875
-              // Actual height of the text itself, not counting spacing for lineHeight/leading/dropShadow etc
-              var textHeight = metrics.fontProperties.fontSize + style.strokeThickness;
-              for (var i = 0; i < lines.length; i++) {
-                  var lastLineBottom = (metrics.lineHeight * (i - 1)) + textHeight;
-                  var thisLineTop = metrics.lineHeight * i;
-                  var thisLineGradientStart = thisLineTop;
-                  // Handle case where last & this line overlap
-                  if (i > 0 && lastLineBottom > thisLineTop) {
-                      thisLineGradientStart = (thisLineTop + lastLineBottom) / 2;
-                  }
-                  var thisLineBottom = thisLineTop + textHeight;
-                  var nextLineTop = metrics.lineHeight * (i + 1);
-                  var thisLineGradientEnd = thisLineBottom;
-                  // Handle case where this & next line overlap
-                  if (i + 1 < lines.length && nextLineTop < thisLineBottom) {
-                      thisLineGradientEnd = (thisLineBottom + nextLineTop) / 2;
-                  }
-                  // textHeight, but as a 0-1 size in global gradient stop space
-                  var gradStopLineHeight = (thisLineGradientEnd - thisLineGradientStart) / height;
-                  for (var j = 0; j < fill.length; j++) {
-                      // 0-1 stop point for the current line, multiplied to global space afterwards
-                      var lineStop = 0;
-                      if (typeof fillGradientStops[j] === 'number') {
-                          lineStop = fillGradientStops[j];
-                      }
-                      else {
-                          lineStop = j / fill.length;
-                      }
-                      var globalStop = Math.min(1, Math.max(0, (thisLineGradientStart / height) + (lineStop * gradStopLineHeight)));
-                      // There's potential for floating point precision issues at the seams between gradient repeats.
-                      globalStop = Number(globalStop.toFixed(5));
-                      gradient.addColorStop(globalStop, fill[j]);
-                  }
-              }
-          }
-          else {
-              // start the gradient at the center left of the canvas, and end at the center right of the canvas
-              gradient = this.context.createLinearGradient(padding, height / 2, width + padding, height / 2);
-              // can just evenly space out the gradients in this case, as multiple lines makes no difference
-              // to an even left to right gradient
-              var totalIterations = fill.length + 1;
-              var currentIteration = 1;
-              for (var i = 0; i < fill.length; i++) {
-                  var stop = void 0;
-                  if (typeof fillGradientStops[i] === 'number') {
-                      stop = fillGradientStops[i];
-                  }
-                  else {
-                      stop = currentIteration / totalIterations;
-                  }
-                  gradient.addColorStop(stop, fill[i]);
-                  currentIteration++;
-              }
-          }
-          return gradient;
-      };
-      /**
-       * Destroys this text object.
-       *
-       * Note* Unlike a Sprite, a Text object will automatically destroy its baseTexture and texture as
-       * the majority of the time the texture will not be shared with any other Sprites.
-       * @param options - Options parameter. A boolean will act as if all options
-       *  have been set to that value
-       * @param {boolean} [options.children=false] - if set to true, all the children will have their
-       *  destroy method called as well. 'options' will be passed on to those calls.
-       * @param {boolean} [options.texture=true] - Should it destroy the current texture of the sprite as well
-       * @param {boolean} [options.baseTexture=true] - Should it destroy the base texture of the sprite as well
-       */
-      Text.prototype.destroy = function (options) {
-          if (typeof options === 'boolean') {
-              options = { children: options };
-          }
-          options = Object.assign({}, defaultDestroyOptions, options);
-          _super.prototype.destroy.call(this, options);
-          // set canvas width and height to 0 to workaround memory leak in Safari < 13
-          // https://stackoverflow.com/questions/52532614/total-canvas-memory-use-exceeds-the-maximum-limit-safari-12
-          if (this._ownCanvas) {
-              this.canvas.height = this.canvas.width = 0;
-          }
-          // make sure to reset the context and canvas.. dont want this hanging around in memory!
-          this.context = null;
-          this.canvas = null;
-          this._style = null;
-      };
-      Object.defineProperty(Text.prototype, "width", {
-          /** The width of the Text, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              this.updateText(true);
-              return Math.abs(this.scale.x) * this._texture.orig.width;
-          },
-          set: function (value) {
-              this.updateText(true);
-              var s = sign(this.scale.x) || 1;
-              this.scale.x = s * value / this._texture.orig.width;
-              this._width = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Text.prototype, "height", {
-          /** The height of the Text, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              this.updateText(true);
-              return Math.abs(this.scale.y) * this._texture.orig.height;
-          },
-          set: function (value) {
-              this.updateText(true);
-              var s = sign(this.scale.y) || 1;
-              this.scale.y = s * value / this._texture.orig.height;
-              this._height = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Text.prototype, "style", {
-          /**
-           * Set the style of the text.
-           *
-           * Set up an event listener to listen for changes on the style object and mark the text as dirty.
-           */
-          get: function () {
-              // TODO: Can't have different types for getter and setter. The getter shouldn't have the ITextStyle
-              //       since the setter creates the TextStyle. See this thread for more details:
-              //       https://github.com/microsoft/TypeScript/issues/2521
-              return this._style;
-          },
-          set: function (style) {
-              style = style || {};
-              if (style instanceof TextStyle) {
-                  this._style = style;
-              }
-              else {
-                  this._style = new TextStyle(style);
-              }
-              this.localStyleID = -1;
-              this.dirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Text.prototype, "text", {
-          /** Set the copy for the text object. To split a line you can use '\n'. */
-          get: function () {
-              return this._text;
-          },
-          set: function (text) {
-              text = String(text === null || text === undefined ? '' : text);
-              if (this._text === text) {
-                  return;
-              }
-              this._text = text;
-              this.dirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Text.prototype, "resolution", {
-          /**
-           * The resolution / device pixel ratio of the canvas.
-           *
-           * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.
-           * @default 1
-           */
-          get: function () {
-              return this._resolution;
-          },
-          set: function (value) {
-              this._autoResolution = false;
-              if (this._resolution === value) {
-                  return;
-              }
-              this._resolution = value;
-              this.dirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * New behavior for `lineHeight` that's meant to mimic HTML text. A value of `true` will
-       * make sure the first baseline is offset by the `lineHeight` value if it is greater than `fontSize`.
-       * A value of `false` will use the legacy behavior and not change the baseline of the first line.
-       * In the next major release, we'll enable this by default.
-       */
-      Text.nextLineHeightBehavior = false;
-      /**
-       * New rendering behavior for letter-spacing which uses Chrome's new native API. This will
-       * lead to more accurate letter-spacing results because it does not try to manually draw
-       * each character. However, this Chrome API is experimental and may not serve all cases yet.
-       */
-      Text.experimentalLetterSpacing = false;
-      return Text;
-  }(Sprite));
-
-  /*!
-   * @pixi/prepare - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/prepare is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Default number of uploads per frame using prepare plugin.
-   * @static
-   * @memberof PIXI.settings
-   * @name UPLOADS_PER_FRAME
-   * @type {number}
-   * @default 4
-   */
-  settings.UPLOADS_PER_FRAME = 4;
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$b = function(d, b) {
-      extendStatics$b = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$b(d, b);
-  };
-
-  function __extends$b(d, b) {
-      extendStatics$b(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * CountLimiter limits the number of items handled by a {@link PIXI.BasePrepare} to a specified
-   * number of items per frame.
-   * @memberof PIXI
-   */
-  var CountLimiter = /** @class */ (function () {
-      /**
-       * @param maxItemsPerFrame - The maximum number of items that can be prepared each frame.
-       */
-      function CountLimiter(maxItemsPerFrame) {
-          this.maxItemsPerFrame = maxItemsPerFrame;
-          this.itemsLeft = 0;
-      }
-      /** Resets any counting properties to start fresh on a new frame. */
-      CountLimiter.prototype.beginFrame = function () {
-          this.itemsLeft = this.maxItemsPerFrame;
-      };
-      /**
-       * Checks to see if another item can be uploaded. This should only be called once per item.
-       * @returns If the item is allowed to be uploaded.
-       */
-      CountLimiter.prototype.allowedToUpload = function () {
-          return this.itemsLeft-- > 0;
-      };
-      return CountLimiter;
-  }());
-
-  /**
-   * Built-in hook to find multiple textures from objects like AnimatedSprites.
-   * @private
-   * @param item - Display object to check
-   * @param queue - Collection of items to upload
-   * @returns If a PIXI.Texture object was found.
-   */
-  function findMultipleBaseTextures(item, queue) {
-      var result = false;
-      // Objects with multiple textures
-      if (item && item._textures && item._textures.length) {
-          for (var i = 0; i < item._textures.length; i++) {
-              if (item._textures[i] instanceof Texture) {
-                  var baseTexture = item._textures[i].baseTexture;
-                  if (queue.indexOf(baseTexture) === -1) {
-                      queue.push(baseTexture);
-                      result = true;
-                  }
-              }
-          }
-      }
-      return result;
-  }
-  /**
-   * Built-in hook to find BaseTextures from Texture.
-   * @private
-   * @param item - Display object to check
-   * @param queue - Collection of items to upload
-   * @returns If a PIXI.Texture object was found.
-   */
-  function findBaseTexture(item, queue) {
-      if (item.baseTexture instanceof BaseTexture) {
-          var texture = item.baseTexture;
-          if (queue.indexOf(texture) === -1) {
-              queue.push(texture);
-          }
-          return true;
-      }
-      return false;
-  }
-  /**
-   * Built-in hook to find textures from objects.
-   * @private
-   * @param item - Display object to check
-   * @param queue - Collection of items to upload
-   * @returns If a PIXI.Texture object was found.
-   */
-  function findTexture(item, queue) {
-      if (item._texture && item._texture instanceof Texture) {
-          var texture = item._texture.baseTexture;
-          if (queue.indexOf(texture) === -1) {
-              queue.push(texture);
-          }
-          return true;
-      }
-      return false;
-  }
-  /**
-   * Built-in hook to draw PIXI.Text to its texture.
-   * @private
-   * @param _helper - Not used by this upload handler
-   * @param item - Item to check
-   * @returns If item was uploaded.
-   */
-  function drawText(_helper, item) {
-      if (item instanceof Text) {
-          // updating text will return early if it is not dirty
-          item.updateText(true);
-          return true;
-      }
-      return false;
-  }
-  /**
-   * Built-in hook to calculate a text style for a PIXI.Text object.
-   * @private
-   * @param _helper - Not used by this upload handler
-   * @param item - Item to check
-   * @returns If item was uploaded.
-   */
-  function calculateTextStyle(_helper, item) {
-      if (item instanceof TextStyle) {
-          var font = item.toFontString();
-          TextMetrics.measureFont(font);
-          return true;
-      }
-      return false;
-  }
-  /**
-   * Built-in hook to find Text objects.
-   * @private
-   * @param item - Display object to check
-   * @param queue - Collection of items to upload
-   * @returns if a PIXI.Text object was found.
-   */
-  function findText(item, queue) {
-      if (item instanceof Text) {
-          // push the text style to prepare it - this can be really expensive
-          if (queue.indexOf(item.style) === -1) {
-              queue.push(item.style);
-          }
-          // also push the text object so that we can render it (to canvas/texture) if needed
-          if (queue.indexOf(item) === -1) {
-              queue.push(item);
-          }
-          // also push the Text's texture for upload to GPU
-          var texture = item._texture.baseTexture;
-          if (queue.indexOf(texture) === -1) {
-              queue.push(texture);
-          }
-          return true;
-      }
-      return false;
-  }
-  /**
-   * Built-in hook to find TextStyle objects.
-   * @private
-   * @param item - Display object to check
-   * @param queue - Collection of items to upload
-   * @returns If a PIXI.TextStyle object was found.
-   */
-  function findTextStyle(item, queue) {
-      if (item instanceof TextStyle) {
-          if (queue.indexOf(item) === -1) {
-              queue.push(item);
-          }
-          return true;
-      }
-      return false;
-  }
-  /**
-   * The prepare manager provides functionality to upload content to the GPU.
-   *
-   * BasePrepare handles basic queuing functionality and is extended by
-   * {@link PIXI.Prepare} and {@link PIXI.CanvasPrepare}
-   * to provide preparation capabilities specific to their respective renderers.
-   * @example
-   * // Create a sprite
-   * const sprite = PIXI.Sprite.from('something.png');
-   *
-   * // Load object into GPU
-   * app.renderer.plugins.prepare.upload(sprite, () => {
-   *
-   *     //Texture(s) has been uploaded to GPU
-   *     app.stage.addChild(sprite);
-   *
-   * })
-   * @abstract
-   * @memberof PIXI
-   */
-  var BasePrepare = /** @class */ (function () {
-      /**
-       * @param {PIXI.AbstractRenderer} renderer - A reference to the current renderer
-       */
-      function BasePrepare(renderer) {
-          var _this = this;
-          this.limiter = new CountLimiter(settings.UPLOADS_PER_FRAME);
-          this.renderer = renderer;
-          this.uploadHookHelper = null;
-          this.queue = [];
-          this.addHooks = [];
-          this.uploadHooks = [];
-          this.completes = [];
-          this.ticking = false;
-          this.delayedTick = function () {
-              // unlikely, but in case we were destroyed between tick() and delayedTick()
-              if (!_this.queue) {
-                  return;
-              }
-              _this.prepareItems();
-          };
-          // hooks to find the correct texture
-          this.registerFindHook(findText);
-          this.registerFindHook(findTextStyle);
-          this.registerFindHook(findMultipleBaseTextures);
-          this.registerFindHook(findBaseTexture);
-          this.registerFindHook(findTexture);
-          // upload hooks
-          this.registerUploadHook(drawText);
-          this.registerUploadHook(calculateTextStyle);
-      }
-      /** @ignore */
-      BasePrepare.prototype.upload = function (item, done) {
-          var _this = this;
-          if (typeof item === 'function') {
-              done = item;
-              item = null;
-          }
-          if (done) {
-              deprecation('6.5.0', 'BasePrepare.upload callback is deprecated, use the return Promise instead.');
-          }
-          return new Promise(function (resolve) {
-              // If a display object, search for items
-              // that we could upload
-              if (item) {
-                  _this.add(item);
-              }
-              // TODO: remove done callback and just use resolve
-              var complete = function () {
-                  done === null || done === void 0 ? void 0 : done();
-                  resolve();
-              };
-              // Get the items for upload from the display
-              if (_this.queue.length) {
-                  _this.completes.push(complete);
-                  if (!_this.ticking) {
-                      _this.ticking = true;
-                      Ticker.system.addOnce(_this.tick, _this, exports.UPDATE_PRIORITY.UTILITY);
-                  }
-              }
-              else {
-                  complete();
-              }
-          });
-      };
-      /**
-       * Handle tick update
-       * @private
-       */
-      BasePrepare.prototype.tick = function () {
-          setTimeout(this.delayedTick, 0);
-      };
-      /**
-       * Actually prepare items. This is handled outside of the tick because it will take a while
-       * and we do NOT want to block the current animation frame from rendering.
-       * @private
-       */
-      BasePrepare.prototype.prepareItems = function () {
-          this.limiter.beginFrame();
-          // Upload the graphics
-          while (this.queue.length && this.limiter.allowedToUpload()) {
-              var item = this.queue[0];
-              var uploaded = false;
-              if (item && !item._destroyed) {
-                  for (var i = 0, len = this.uploadHooks.length; i < len; i++) {
-                      if (this.uploadHooks[i](this.uploadHookHelper, item)) {
-                          this.queue.shift();
-                          uploaded = true;
-                          break;
-                      }
-                  }
-              }
-              if (!uploaded) {
-                  this.queue.shift();
-              }
-          }
-          // We're finished
-          if (!this.queue.length) {
-              this.ticking = false;
-              var completes = this.completes.slice(0);
-              this.completes.length = 0;
-              for (var i = 0, len = completes.length; i < len; i++) {
-                  completes[i]();
-              }
-          }
-          else {
-              // if we are not finished, on the next rAF do this again
-              Ticker.system.addOnce(this.tick, this, exports.UPDATE_PRIORITY.UTILITY);
-          }
-      };
-      /**
-       * Adds hooks for finding items.
-       * @param {Function} addHook - Function call that takes two parameters: `item:*, queue:Array`
-       *          function must return `true` if it was able to add item to the queue.
-       * @returns Instance of plugin for chaining.
-       */
-      BasePrepare.prototype.registerFindHook = function (addHook) {
-          if (addHook) {
-              this.addHooks.push(addHook);
-          }
-          return this;
-      };
-      /**
-       * Adds hooks for uploading items.
-       * @param {Function} uploadHook - Function call that takes two parameters: `prepare:CanvasPrepare, item:*` and
-       *          function must return `true` if it was able to handle upload of item.
-       * @returns Instance of plugin for chaining.
-       */
-      BasePrepare.prototype.registerUploadHook = function (uploadHook) {
-          if (uploadHook) {
-              this.uploadHooks.push(uploadHook);
-          }
-          return this;
-      };
-      /**
-       * Manually add an item to the uploading queue.
-       * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text|*} item - Object to
-       *        add to the queue
-       * @returns Instance of plugin for chaining.
-       */
-      BasePrepare.prototype.add = function (item) {
-          // Add additional hooks for finding elements on special
-          // types of objects that
-          for (var i = 0, len = this.addHooks.length; i < len; i++) {
-              if (this.addHooks[i](item, this.queue)) {
-                  break;
-              }
-          }
-          // Get children recursively
-          if (item instanceof Container) {
-              for (var i = item.children.length - 1; i >= 0; i--) {
-                  this.add(item.children[i]);
-              }
-          }
-          return this;
-      };
-      /** Destroys the plugin, don't use after this. */
-      BasePrepare.prototype.destroy = function () {
-          if (this.ticking) {
-              Ticker.system.remove(this.tick, this);
-          }
-          this.ticking = false;
-          this.addHooks = null;
-          this.uploadHooks = null;
-          this.renderer = null;
-          this.completes = null;
-          this.queue = null;
-          this.limiter = null;
-          this.uploadHookHelper = null;
-      };
-      return BasePrepare;
-  }());
-
-  /**
-   * Built-in hook to upload PIXI.Texture objects to the GPU.
-   * @private
-   * @param renderer - instance of the webgl renderer
-   * @param item - Item to check
-   * @returns If item was uploaded.
-   */
-  function uploadBaseTextures(renderer, item) {
-      if (item instanceof BaseTexture) {
-          // if the texture already has a GL texture, then the texture has been prepared or rendered
-          // before now. If the texture changed, then the changer should be calling texture.update() which
-          // reuploads the texture without need for preparing it again
-          if (!item._glTextures[renderer.CONTEXT_UID]) {
-              renderer.texture.bind(item);
-          }
-          return true;
-      }
-      return false;
-  }
-  /**
-   * Built-in hook to upload PIXI.Graphics to the GPU.
-   * @private
-   * @param renderer - instance of the webgl renderer
-   * @param item - Item to check
-   * @returns If item was uploaded.
-   */
-  function uploadGraphics(renderer, item) {
-      if (!(item instanceof Graphics)) {
-          return false;
-      }
-      var geometry = item.geometry;
-      // update dirty graphics to get batches
-      item.finishPoly();
-      geometry.updateBatches();
-      var batches = geometry.batches;
-      // upload all textures found in styles
-      for (var i = 0; i < batches.length; i++) {
-          var texture = batches[i].style.texture;
-          if (texture) {
-              uploadBaseTextures(renderer, texture.baseTexture);
-          }
-      }
-      // if its not batchable - update vao for particular shader
-      if (!geometry.batchable) {
-          renderer.geometry.bind(geometry, item._resolveDirectShader(renderer));
-      }
-      return true;
-  }
-  /**
-   * Built-in hook to find graphics.
-   * @private
-   * @param item - Display object to check
-   * @param queue - Collection of items to upload
-   * @returns if a PIXI.Graphics object was found.
-   */
-  function findGraphics(item, queue) {
-      if (item instanceof Graphics) {
-          queue.push(item);
-          return true;
-      }
-      return false;
-  }
-  /**
-   * The prepare plugin provides renderer-specific plugins for pre-rendering DisplayObjects. These plugins are useful for
-   * asynchronously preparing and uploading to the GPU assets, textures, graphics waiting to be displayed.
-   *
-   * Do not instantiate this plugin directly. It is available from the `renderer.plugins` property.
-   * See {@link PIXI.CanvasRenderer#plugins} or {@link PIXI.Renderer#plugins}.
-   * @example
-   * // Create a new application
-   * const app = new PIXI.Application();
-   * document.body.appendChild(app.view);
-   *
-   * // Don't start rendering right away
-   * app.stop();
-   *
-   * // create a display object
-   * const rect = new PIXI.Graphics()
-   *     .beginFill(0x00ff00)
-   *     .drawRect(40, 40, 200, 200);
-   *
-   * // Add to the stage
-   * app.stage.addChild(rect);
-   *
-   * // Don't start rendering until the graphic is uploaded to the GPU
-   * app.renderer.plugins.prepare.upload(app.stage, () => {
-   *     app.start();
-   * });
-   * @memberof PIXI
-   */
-  var Prepare = /** @class */ (function (_super) {
-      __extends$b(Prepare, _super);
-      /**
-       * @param {PIXI.Renderer} renderer - A reference to the current renderer
-       */
-      function Prepare(renderer) {
-          var _this = _super.call(this, renderer) || this;
-          _this.uploadHookHelper = _this.renderer;
-          // Add textures and graphics to upload
-          _this.registerFindHook(findGraphics);
-          _this.registerUploadHook(uploadBaseTextures);
-          _this.registerUploadHook(uploadGraphics);
-          return _this;
-      }
-      /** @ignore */
-      Prepare.extension = {
-          name: 'prepare',
-          type: exports.ExtensionType.RendererPlugin,
-      };
-      return Prepare;
-  }(BasePrepare));
-
-  /**
-   * TimeLimiter limits the number of items handled by a {@link PIXI.BasePrepare} to a specified
-   * number of milliseconds per frame.
-   * @memberof PIXI
-   */
-  var TimeLimiter = /** @class */ (function () {
-      /** @param maxMilliseconds - The maximum milliseconds that can be spent preparing items each frame. */
-      function TimeLimiter(maxMilliseconds) {
-          this.maxMilliseconds = maxMilliseconds;
-          this.frameStart = 0;
-      }
-      /** Resets any counting properties to start fresh on a new frame. */
-      TimeLimiter.prototype.beginFrame = function () {
-          this.frameStart = Date.now();
-      };
-      /**
-       * Checks to see if another item can be uploaded. This should only be called once per item.
-       * @returns - If the item is allowed to be uploaded.
-       */
-      TimeLimiter.prototype.allowedToUpload = function () {
-          return Date.now() - this.frameStart < this.maxMilliseconds;
-      };
-      return TimeLimiter;
-  }());
-
-  /*!
-   * @pixi/spritesheet - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/spritesheet is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Utility class for maintaining reference to a collection
-   * of Textures on a single Spritesheet.
-   *
-   * To access a sprite sheet from your code you may pass its JSON data file to Pixi's loader:
-   *
-   * ```js
-   * PIXI.Loader.shared.add("images/spritesheet.json").load(setup);
-   *
-   * function setup() {
-   *   let sheet = PIXI.Loader.shared.resources["images/spritesheet.json"].spritesheet;
-   *   ...
-   * }
-   * ```
-   *
-   * Alternately, you may circumvent the loader by instantiating the Spritesheet directly:
-   * ```js
-   * const sheet = new PIXI.Spritesheet(texture, spritesheetData);
-   * await sheet.parse();
-   * console.log('Spritesheet ready to use!');
-   * ```
-   *
-   * With the `sheet.textures` you can create Sprite objects,`sheet.animations` can be used to create an AnimatedSprite.
-   *
-   * Sprite sheets can be packed using tools like {@link https://codeandweb.com/texturepacker|TexturePacker},
-   * {@link https://renderhjs.net/shoebox/|Shoebox} or {@link https://github.com/krzysztof-o/spritesheet.js|Spritesheet.js}.
-   * Default anchor points (see {@link PIXI.Texture#defaultAnchor}) and grouping of animation sprites are currently only
-   * supported by TexturePacker.
-   * @memberof PIXI
-   */
-  var Spritesheet = /** @class */ (function () {
-      /**
-       * @param texture - Reference to the source BaseTexture object.
-       * @param {object} data - Spritesheet image data.
-       * @param resolutionFilename - The filename to consider when determining
-       *        the resolution of the spritesheet. If not provided, the imageUrl will
-       *        be used on the BaseTexture.
-       */
-      function Spritesheet(texture, data, resolutionFilename) {
-          if (resolutionFilename === void 0) { resolutionFilename = null; }
-          /** For multi-packed spritesheets, this contains a reference to all the other spritesheets it depends on. */
-          this.linkedSheets = [];
-          this._texture = texture instanceof Texture ? texture : null;
-          this.baseTexture = texture instanceof BaseTexture ? texture : this._texture.baseTexture;
-          this.textures = {};
-          this.animations = {};
-          this.data = data;
-          var resource = this.baseTexture.resource;
-          this.resolution = this._updateResolution(resolutionFilename || (resource ? resource.url : null));
-          this._frames = this.data.frames;
-          this._frameKeys = Object.keys(this._frames);
-          this._batchIndex = 0;
-          this._callback = null;
-      }
-      /**
-       * Generate the resolution from the filename or fallback
-       * to the meta.scale field of the JSON data.
-       * @param resolutionFilename - The filename to use for resolving
-       *        the default resolution.
-       * @returns Resolution to use for spritesheet.
-       */
-      Spritesheet.prototype._updateResolution = function (resolutionFilename) {
-          if (resolutionFilename === void 0) { resolutionFilename = null; }
-          var scale = this.data.meta.scale;
-          // Use a defaultValue of `null` to check if a url-based resolution is set
-          var resolution = getResolutionOfUrl(resolutionFilename, null);
-          // No resolution found via URL
-          if (resolution === null) {
-              // Use the scale value or default to 1
-              resolution = scale !== undefined ? parseFloat(scale) : 1;
-          }
-          // For non-1 resolutions, update baseTexture
-          if (resolution !== 1) {
-              this.baseTexture.setResolution(resolution);
-          }
-          return resolution;
-      };
-      /** @ignore */
-      Spritesheet.prototype.parse = function (callback) {
-          var _this = this;
-          if (callback) {
-              deprecation('6.5.0', 'Spritesheet.parse callback is deprecated, use the return Promise instead.');
-          }
-          return new Promise(function (resolve) {
-              _this._callback = function (textures) {
-                  callback === null || callback === void 0 ? void 0 : callback(textures);
-                  resolve(textures);
-              };
-              _this._batchIndex = 0;
-              if (_this._frameKeys.length <= Spritesheet.BATCH_SIZE) {
-                  _this._processFrames(0);
-                  _this._processAnimations();
-                  _this._parseComplete();
-              }
-              else {
-                  _this._nextBatch();
-              }
-          });
-      };
-      /**
-       * Process a batch of frames
-       * @param initialFrameIndex - The index of frame to start.
-       */
-      Spritesheet.prototype._processFrames = function (initialFrameIndex) {
-          var frameIndex = initialFrameIndex;
-          var maxFrames = Spritesheet.BATCH_SIZE;
-          while (frameIndex - initialFrameIndex < maxFrames && frameIndex < this._frameKeys.length) {
-              var i = this._frameKeys[frameIndex];
-              var data = this._frames[i];
-              var rect = data.frame;
-              if (rect) {
-                  var frame = null;
-                  var trim = null;
-                  var sourceSize = data.trimmed !== false && data.sourceSize
-                      ? data.sourceSize : data.frame;
-                  var orig = new Rectangle(0, 0, Math.floor(sourceSize.w) / this.resolution, Math.floor(sourceSize.h) / this.resolution);
-                  if (data.rotated) {
-                      frame = new Rectangle(Math.floor(rect.x) / this.resolution, Math.floor(rect.y) / this.resolution, Math.floor(rect.h) / this.resolution, Math.floor(rect.w) / this.resolution);
-                  }
-                  else {
-                      frame = new Rectangle(Math.floor(rect.x) / this.resolution, Math.floor(rect.y) / this.resolution, Math.floor(rect.w) / this.resolution, Math.floor(rect.h) / this.resolution);
-                  }
-                  //  Check to see if the sprite is trimmed
-                  if (data.trimmed !== false && data.spriteSourceSize) {
-                      trim = new Rectangle(Math.floor(data.spriteSourceSize.x) / this.resolution, Math.floor(data.spriteSourceSize.y) / this.resolution, Math.floor(rect.w) / this.resolution, Math.floor(rect.h) / this.resolution);
-                  }
-                  this.textures[i] = new Texture(this.baseTexture, frame, orig, trim, data.rotated ? 2 : 0, data.anchor);
-                  // lets also add the frame to pixi's global cache for 'from' and 'fromLoader' functions
-                  Texture.addToCache(this.textures[i], i);
-              }
-              frameIndex++;
-          }
-      };
-      /** Parse animations config. */
-      Spritesheet.prototype._processAnimations = function () {
-          var animations = this.data.animations || {};
-          for (var animName in animations) {
-              this.animations[animName] = [];
-              for (var i = 0; i < animations[animName].length; i++) {
-                  var frameName = animations[animName][i];
-                  this.animations[animName].push(this.textures[frameName]);
-              }
-          }
-      };
-      /** The parse has completed. */
-      Spritesheet.prototype._parseComplete = function () {
-          var callback = this._callback;
-          this._callback = null;
-          this._batchIndex = 0;
-          callback.call(this, this.textures);
-      };
-      /** Begin the next batch of textures. */
-      Spritesheet.prototype._nextBatch = function () {
-          var _this = this;
-          this._processFrames(this._batchIndex * Spritesheet.BATCH_SIZE);
-          this._batchIndex++;
-          setTimeout(function () {
-              if (_this._batchIndex * Spritesheet.BATCH_SIZE < _this._frameKeys.length) {
-                  _this._nextBatch();
-              }
-              else {
-                  _this._processAnimations();
-                  _this._parseComplete();
-              }
-          }, 0);
-      };
-      /**
-       * Destroy Spritesheet and don't use after this.
-       * @param {boolean} [destroyBase=false] - Whether to destroy the base texture as well
-       */
-      Spritesheet.prototype.destroy = function (destroyBase) {
-          var _a;
-          if (destroyBase === void 0) { destroyBase = false; }
-          for (var i in this.textures) {
-              this.textures[i].destroy();
-          }
-          this._frames = null;
-          this._frameKeys = null;
-          this.data = null;
-          this.textures = null;
-          if (destroyBase) {
-              (_a = this._texture) === null || _a === void 0 ? void 0 : _a.destroy();
-              this.baseTexture.destroy();
-          }
-          this._texture = null;
-          this.baseTexture = null;
-          this.linkedSheets = [];
-      };
-      /** The maximum number of Textures to build per process. */
-      Spritesheet.BATCH_SIZE = 1000;
-      return Spritesheet;
-  }());
-  /**
-   * Reference to Spritesheet object created.
-   * @member {PIXI.Spritesheet} spritesheet
-   * @memberof PIXI.LoaderResource
-   * @instance
-   */
-  /**
-   * Dictionary of textures from Spritesheet.
-   * @member {Object<string, PIXI.Texture>} textures
-   * @memberof PIXI.LoaderResource
-   * @instance
-   */
-
-  /**
-   * {@link PIXI.Loader} middleware for loading texture atlases that have been created with
-   * TexturePacker or similar JSON-based spritesheet.
-   *
-   * This middleware automatically generates Texture resources.
-   *
-   * If you're using Webpack or other bundlers and plan on bundling the atlas' JSON,
-   * use the {@link PIXI.Spritesheet} class to directly parse the JSON.
-   *
-   * The Loader's image Resource name is automatically appended with `"_image"`.
-   * If a Resource with this name is already loaded, the Loader will skip parsing the
-   * Spritesheet. The code below will generate an internal Loader Resource called `"myatlas_image"`.
-   * @example
-   * loader.add('myatlas', 'path/to/myatlas.json');
-   * loader.load(() => {
-   *   loader.resources.myatlas; // atlas JSON resource
-   *   loader.resources.myatlas_image; // atlas Image resource
-   * });
-   * @memberof PIXI
-   */
-  var SpritesheetLoader = /** @class */ (function () {
-      function SpritesheetLoader() {
-      }
-      /**
-       * Called after a resource is loaded.
-       * @see PIXI.Loader.loaderMiddleware
-       * @param resource
-       * @param next
-       */
-      SpritesheetLoader.use = function (resource, next) {
-          var _a, _b;
-          // because this is middleware, it execute in loader context. `this` = loader
-          var loader = this;
-          var imageResourceName = resource.name + "_image";
-          // skip if no data, its not json, it isn't spritesheet data, or the image resource already exists
-          if (!resource.data
-              || resource.type !== exports.LoaderResource.TYPE.JSON
-              || !resource.data.frames
-              || loader.resources[imageResourceName]) {
-              next();
-              return;
-          }
-          // Check and add the multi atlas
-          // Heavily influenced and based on https://github.com/rocket-ua/pixi-tps-loader/blob/master/src/ResourceLoader.js
-          // eslint-disable-next-line camelcase
-          var multiPacks = (_b = (_a = resource.data) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.related_multi_packs;
-          if (Array.isArray(multiPacks)) {
-              var _loop_1 = function (item) {
-                  if (typeof item !== 'string') {
-                      return "continue";
-                  }
-                  var itemName = item.replace('.json', '');
-                  var itemUrl = url.resolve(resource.url.replace(loader.baseUrl, ''), item);
-                  // Check if the file wasn't already added as multipacks are redundant
-                  if (loader.resources[itemName]
-                      || Object.values(loader.resources).some(function (r) { return url.format(url.parse(r.url)) === itemUrl; })) {
-                      return "continue";
-                  }
-                  var options = {
-                      crossOrigin: resource.crossOrigin,
-                      loadType: exports.LoaderResource.LOAD_TYPE.XHR,
-                      xhrType: exports.LoaderResource.XHR_RESPONSE_TYPE.JSON,
-                      parentResource: resource,
-                      metadata: resource.metadata
-                  };
-                  loader.add(itemName, itemUrl, options);
-              };
-              for (var _i = 0, multiPacks_1 = multiPacks; _i < multiPacks_1.length; _i++) {
-                  var item = multiPacks_1[_i];
-                  _loop_1(item);
-              }
-          }
-          var loadOptions = {
-              crossOrigin: resource.crossOrigin,
-              metadata: resource.metadata.imageMetadata,
-              parentResource: resource,
-          };
-          var resourcePath = SpritesheetLoader.getResourcePath(resource, loader.baseUrl);
-          // load the image for this sheet
-          loader.add(imageResourceName, resourcePath, loadOptions, function onImageLoad(res) {
-              if (res.error) {
-                  next(res.error);
-                  return;
-              }
-              var spritesheet = new Spritesheet(res.texture, resource.data, resource.url);
-              spritesheet.parse().then(function () {
-                  resource.spritesheet = spritesheet;
-                  resource.textures = spritesheet.textures;
-                  next();
-              });
-          });
-      };
-      /**
-       * Get the spritesheets root path
-       * @param resource - Resource to check path
-       * @param baseUrl - Base root url
-       */
-      SpritesheetLoader.getResourcePath = function (resource, baseUrl) {
-          // Prepend url path unless the resource image is a data url
-          if (resource.isDataUrl) {
-              return resource.data.meta.image;
-          }
-          return url.resolve(resource.url.replace(baseUrl, ''), resource.data.meta.image);
-      };
-      /** @ignore */
-      SpritesheetLoader.extension = exports.ExtensionType.Loader;
-      return SpritesheetLoader;
-  }());
-
-  /*!
-   * @pixi/sprite-tiling - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/sprite-tiling is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$a = function(d, b) {
-      extendStatics$a = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$a(d, b);
-  };
-
-  function __extends$a(d, b) {
-      extendStatics$a(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var tempPoint$1 = new Point();
-  /**
-   * A tiling sprite is a fast way of rendering a tiling image.
-   * @memberof PIXI
-   */
-  var TilingSprite = /** @class */ (function (_super) {
-      __extends$a(TilingSprite, _super);
-      /**
-       * @param texture - The texture of the tiling sprite.
-       * @param width - The width of the tiling sprite.
-       * @param height - The height of the tiling sprite.
-       */
-      function TilingSprite(texture, width, height) {
-          if (width === void 0) { width = 100; }
-          if (height === void 0) { height = 100; }
-          var _this = _super.call(this, texture) || this;
-          _this.tileTransform = new Transform();
-          // The width of the tiling sprite
-          _this._width = width;
-          // The height of the tiling sprite
-          _this._height = height;
-          _this.uvMatrix = _this.texture.uvMatrix || new TextureMatrix(texture);
-          /**
-           * Plugin that is responsible for rendering this element.
-           * Allows to customize the rendering process without overriding '_render' method.
-           * @default 'tilingSprite'
-           */
-          _this.pluginName = 'tilingSprite';
-          _this.uvRespectAnchor = false;
-          return _this;
-      }
-      Object.defineProperty(TilingSprite.prototype, "clampMargin", {
-          /**
-           * Changes frame clamping in corresponding textureTransform, shortcut
-           * Change to -0.5 to add a pixel to the edge, recommended for transparent trimmed textures in atlas
-           * @default 0.5
-           * @member {number}
-           */
-          get: function () {
-              return this.uvMatrix.clampMargin;
-          },
-          set: function (value) {
-              this.uvMatrix.clampMargin = value;
-              this.uvMatrix.update(true);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TilingSprite.prototype, "tileScale", {
-          /** The scaling of the image that is being tiled. */
-          get: function () {
-              return this.tileTransform.scale;
-          },
-          set: function (value) {
-              this.tileTransform.scale.copyFrom(value);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TilingSprite.prototype, "tilePosition", {
-          /** The offset of the image that is being tiled. */
-          get: function () {
-              return this.tileTransform.position;
-          },
-          set: function (value) {
-              this.tileTransform.position.copyFrom(value);
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * @protected
-       */
-      TilingSprite.prototype._onTextureUpdate = function () {
-          if (this.uvMatrix) {
-              this.uvMatrix.texture = this._texture;
-          }
-          this._cachedTint = 0xFFFFFF;
-      };
-      /**
-       * Renders the object using the WebGL renderer
-       * @param renderer - The renderer
-       */
-      TilingSprite.prototype._render = function (renderer) {
-          // tweak our texture temporarily..
-          var texture = this._texture;
-          if (!texture || !texture.valid) {
-              return;
-          }
-          this.tileTransform.updateLocalTransform();
-          this.uvMatrix.update();
-          renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);
-          renderer.plugins[this.pluginName].render(this);
-      };
-      /** Updates the bounds of the tiling sprite. */
-      TilingSprite.prototype._calculateBounds = function () {
-          var minX = this._width * -this._anchor._x;
-          var minY = this._height * -this._anchor._y;
-          var maxX = this._width * (1 - this._anchor._x);
-          var maxY = this._height * (1 - this._anchor._y);
-          this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);
-      };
-      /**
-       * Gets the local bounds of the sprite object.
-       * @param rect - Optional output rectangle.
-       * @returns The bounds.
-       */
-      TilingSprite.prototype.getLocalBounds = function (rect) {
-          // we can do a fast local bounds if the sprite has no children!
-          if (this.children.length === 0) {
-              this._bounds.minX = this._width * -this._anchor._x;
-              this._bounds.minY = this._height * -this._anchor._y;
-              this._bounds.maxX = this._width * (1 - this._anchor._x);
-              this._bounds.maxY = this._height * (1 - this._anchor._y);
-              if (!rect) {
-                  if (!this._localBoundsRect) {
-                      this._localBoundsRect = new Rectangle();
-                  }
-                  rect = this._localBoundsRect;
-              }
-              return this._bounds.getRectangle(rect);
-          }
-          return _super.prototype.getLocalBounds.call(this, rect);
-      };
-      /**
-       * Checks if a point is inside this tiling sprite.
-       * @param point - The point to check.
-       * @returns Whether or not the sprite contains the point.
-       */
-      TilingSprite.prototype.containsPoint = function (point) {
-          this.worldTransform.applyInverse(point, tempPoint$1);
-          var width = this._width;
-          var height = this._height;
-          var x1 = -width * this.anchor._x;
-          if (tempPoint$1.x >= x1 && tempPoint$1.x < x1 + width) {
-              var y1 = -height * this.anchor._y;
-              if (tempPoint$1.y >= y1 && tempPoint$1.y < y1 + height) {
-                  return true;
-              }
-          }
-          return false;
-      };
-      /**
-       * Destroys this sprite and optionally its texture and children
-       * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-       *  have been set to that value
-       * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
-       *      method called as well. 'options' will be passed on to those calls.
-       * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well
-       * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well
-       */
-      TilingSprite.prototype.destroy = function (options) {
-          _super.prototype.destroy.call(this, options);
-          this.tileTransform = null;
-          this.uvMatrix = null;
-      };
-      /**
-       * Helper function that creates a new tiling sprite based on the source you provide.
-       * The source can be - frame id, image url, video url, canvas element, video element, base texture
-       * @static
-       * @param {string|PIXI.Texture|HTMLCanvasElement|HTMLVideoElement} source - Source to create texture from
-       * @param {object} options - See {@link PIXI.BaseTexture}'s constructor for options.
-       * @param {number} options.width - required width of the tiling sprite
-       * @param {number} options.height - required height of the tiling sprite
-       * @returns {PIXI.TilingSprite} The newly created texture
-       */
-      TilingSprite.from = function (source, options) {
-          var texture = (source instanceof Texture)
-              ? source
-              : Texture.from(source, options);
-          return new TilingSprite(texture, options.width, options.height);
-      };
-      Object.defineProperty(TilingSprite.prototype, "width", {
-          /** The width of the sprite, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              return this._width;
-          },
-          set: function (value) {
-              this._width = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(TilingSprite.prototype, "height", {
-          /** The height of the TilingSprite, setting this will actually modify the scale to achieve the value set. */
-          get: function () {
-              return this._height;
-          },
-          set: function (value) {
-              this._height = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return TilingSprite;
-  }(Sprite));
-
-  var fragmentSimpleSrc = "#version 100\n#define SHADER_NAME Tiling-Sprite-Simple-100\n\nprecision lowp float;\n\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\n\nvoid main(void)\n{\n    vec4 texSample = texture2D(uSampler, vTextureCoord);\n    gl_FragColor = texSample * uColor;\n}\n";
-
-  var gl1VertexSrc = "#version 100\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n";
-
-  var gl1FragmentSrc = "#version 100\n#ifdef GL_EXT_shader_texture_lod\n    #extension GL_EXT_shader_texture_lod : enable\n#endif\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\nuniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;\n\nvoid main(void)\n{\n    vec2 coord = vTextureCoord + ceil(uClampOffset - vTextureCoord);\n    coord = (uMapCoord * vec3(coord, 1.0)).xy;\n    vec2 unclamped = coord;\n    coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);\n\n    #ifdef GL_EXT_shader_texture_lod\n        vec4 texSample = unclamped == coord\n            ? texture2D(uSampler, coord) \n            : texture2DLodEXT(uSampler, coord, 0);\n    #else\n        vec4 texSample = texture2D(uSampler, coord);\n    #endif\n\n    gl_FragColor = texSample * uColor;\n}\n";
-
-  var gl2VertexSrc = "#version 300 es\n#define SHADER_NAME Tiling-Sprite-300\n\nprecision lowp float;\n\nin vec2 aVertexPosition;\nin vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTransform;\n\nout vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTransform * vec3(aTextureCoord, 1.0)).xy;\n}\n";
-
-  var gl2FragmentSrc = "#version 300 es\n#define SHADER_NAME Tiling-Sprite-100\n\nprecision lowp float;\n\nin vec2 vTextureCoord;\n\nout vec4 fragmentColor;\n\nuniform sampler2D uSampler;\nuniform vec4 uColor;\nuniform mat3 uMapCoord;\nuniform vec4 uClampFrame;\nuniform vec2 uClampOffset;\n\nvoid main(void)\n{\n    vec2 coord = vTextureCoord + ceil(uClampOffset - vTextureCoord);\n    coord = (uMapCoord * vec3(coord, 1.0)).xy;\n    vec2 unclamped = coord;\n    coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);\n\n    vec4 texSample = texture(uSampler, coord, unclamped == coord ? 0.0f : -32.0f);// lod-bias very negative to force lod 0\n\n    fragmentColor = texSample * uColor;\n}\n";
-
-  var tempMat = new Matrix();
-  /**
-   * WebGL renderer plugin for tiling sprites
-   * @class
-   * @memberof PIXI
-   * @extends PIXI.ObjectRenderer
-   */
-  var TilingSpriteRenderer = /** @class */ (function (_super) {
-      __extends$a(TilingSpriteRenderer, _super);
-      /**
-       * constructor for renderer
-       * @param {PIXI.Renderer} renderer - The renderer this tiling awesomeness works for.
-       */
-      function TilingSpriteRenderer(renderer) {
-          var _this = _super.call(this, renderer) || this;
-          // WebGL version is not available during initialization!
-          renderer.runners.contextChange.add(_this);
-          _this.quad = new QuadUv();
-          /**
-           * The WebGL state in which this renderer will work.
-           * @member {PIXI.State}
-           * @readonly
-           */
-          _this.state = State.for2d();
-          return _this;
-      }
-      /** Creates shaders when context is initialized. */
-      TilingSpriteRenderer.prototype.contextChange = function () {
-          var renderer = this.renderer;
-          var uniforms = { globals: renderer.globalUniforms };
-          this.simpleShader = Shader.from(gl1VertexSrc, fragmentSimpleSrc, uniforms);
-          this.shader = renderer.context.webGLVersion > 1
-              ? Shader.from(gl2VertexSrc, gl2FragmentSrc, uniforms)
-              : Shader.from(gl1VertexSrc, gl1FragmentSrc, uniforms);
-      };
-      /**
-       * @param {PIXI.TilingSprite} ts - tilingSprite to be rendered
-       */
-      TilingSpriteRenderer.prototype.render = function (ts) {
-          var renderer = this.renderer;
-          var quad = this.quad;
-          var vertices = quad.vertices;
-          vertices[0] = vertices[6] = (ts._width) * -ts.anchor.x;
-          vertices[1] = vertices[3] = ts._height * -ts.anchor.y;
-          vertices[2] = vertices[4] = (ts._width) * (1.0 - ts.anchor.x);
-          vertices[5] = vertices[7] = ts._height * (1.0 - ts.anchor.y);
-          var anchorX = ts.uvRespectAnchor ? ts.anchor.x : 0;
-          var anchorY = ts.uvRespectAnchor ? ts.anchor.y : 0;
-          vertices = quad.uvs;
-          vertices[0] = vertices[6] = -anchorX;
-          vertices[1] = vertices[3] = -anchorY;
-          vertices[2] = vertices[4] = 1.0 - anchorX;
-          vertices[5] = vertices[7] = 1.0 - anchorY;
-          quad.invalidate();
-          var tex = ts._texture;
-          var baseTex = tex.baseTexture;
-          var premultiplied = baseTex.alphaMode > 0;
-          var lt = ts.tileTransform.localTransform;
-          var uv = ts.uvMatrix;
-          var isSimple = baseTex.isPowerOfTwo
-              && tex.frame.width === baseTex.width && tex.frame.height === baseTex.height;
-          // auto, force repeat wrapMode for big tiling textures
-          if (isSimple) {
-              if (!baseTex._glTextures[renderer.CONTEXT_UID]) {
-                  if (baseTex.wrapMode === exports.WRAP_MODES.CLAMP) {
-                      baseTex.wrapMode = exports.WRAP_MODES.REPEAT;
-                  }
-              }
-              else {
-                  isSimple = baseTex.wrapMode !== exports.WRAP_MODES.CLAMP;
-              }
-          }
-          var shader = isSimple ? this.simpleShader : this.shader;
-          var w = tex.width;
-          var h = tex.height;
-          var W = ts._width;
-          var H = ts._height;
-          tempMat.set(lt.a * w / W, lt.b * w / H, lt.c * h / W, lt.d * h / H, lt.tx / W, lt.ty / H);
-          // that part is the same as above:
-          // tempMat.identity();
-          // tempMat.scale(tex.width, tex.height);
-          // tempMat.prepend(lt);
-          // tempMat.scale(1.0 / ts._width, 1.0 / ts._height);
-          tempMat.invert();
-          if (isSimple) {
-              tempMat.prepend(uv.mapCoord);
-          }
-          else {
-              shader.uniforms.uMapCoord = uv.mapCoord.toArray(true);
-              shader.uniforms.uClampFrame = uv.uClampFrame;
-              shader.uniforms.uClampOffset = uv.uClampOffset;
-          }
-          shader.uniforms.uTransform = tempMat.toArray(true);
-          shader.uniforms.uColor = premultiplyTintToRgba(ts.tint, ts.worldAlpha, shader.uniforms.uColor, premultiplied);
-          shader.uniforms.translationMatrix = ts.transform.worldTransform.toArray(true);
-          shader.uniforms.uSampler = tex;
-          renderer.shader.bind(shader);
-          renderer.geometry.bind(quad);
-          this.state.blendMode = correctBlendMode(ts.blendMode, premultiplied);
-          renderer.state.set(this.state);
-          renderer.geometry.draw(this.renderer.gl.TRIANGLES, 6, 0);
-      };
-      /** @ignore */
-      TilingSpriteRenderer.extension = {
-          name: 'tilingSprite',
-          type: exports.ExtensionType.RendererPlugin,
-      };
-      return TilingSpriteRenderer;
-  }(ObjectRenderer));
-
-  /*!
-   * @pixi/mesh - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/mesh is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$9 = function(d, b) {
-      extendStatics$9 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$9(d, b);
-  };
-
-  function __extends$9(d, b) {
-      extendStatics$9(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * Class controls cache for UV mapping from Texture normal space to BaseTexture normal space.
-   * @memberof PIXI
-   */
-  var MeshBatchUvs = /** @class */ (function () {
-      /**
-       * @param uvBuffer - Buffer with normalized uv's
-       * @param uvMatrix - Material UV matrix
-       */
-      function MeshBatchUvs(uvBuffer, uvMatrix) {
-          this.uvBuffer = uvBuffer;
-          this.uvMatrix = uvMatrix;
-          this.data = null;
-          this._bufferUpdateId = -1;
-          this._textureUpdateId = -1;
-          this._updateID = 0;
-      }
-      /**
-       * Updates
-       * @param forceUpdate - force the update
-       */
-      MeshBatchUvs.prototype.update = function (forceUpdate) {
-          if (!forceUpdate
-              && this._bufferUpdateId === this.uvBuffer._updateID
-              && this._textureUpdateId === this.uvMatrix._updateID) {
-              return;
-          }
-          this._bufferUpdateId = this.uvBuffer._updateID;
-          this._textureUpdateId = this.uvMatrix._updateID;
-          var data = this.uvBuffer.data;
-          if (!this.data || this.data.length !== data.length) {
-              this.data = new Float32Array(data.length);
-          }
-          this.uvMatrix.multiplyUvs(data, this.data);
-          this._updateID++;
-      };
-      return MeshBatchUvs;
-  }());
-
-  var tempPoint = new Point();
-  var tempPolygon = new Polygon();
-  /**
-   * Base mesh class.
-   *
-   * This class empowers you to have maximum flexibility to render any kind of WebGL visuals you can think of.
-   * This class assumes a certain level of WebGL knowledge.
-   * If you know a bit this should abstract enough away to make your life easier!
-   *
-   * Pretty much ALL WebGL can be broken down into the following:
-   * - Geometry - The structure and data for the mesh. This can include anything from positions, uvs, normals, colors etc..
-   * - Shader - This is the shader that PixiJS will render the geometry with (attributes in the shader must match the geometry)
-   * - State - This is the state of WebGL required to render the mesh.
-   *
-   * Through a combination of the above elements you can render anything you want, 2D or 3D!
-   * @memberof PIXI
-   */
-  var Mesh = /** @class */ (function (_super) {
-      __extends$9(Mesh, _super);
-      /**
-       * @param geometry - The geometry the mesh will use.
-       * @param {PIXI.MeshMaterial} shader - The shader the mesh will use.
-       * @param state - The state that the WebGL context is required to be in to render the mesh
-       *        if no state is provided, uses {@link PIXI.State.for2d} to create a 2D state for PixiJS.
-       * @param drawMode - The drawMode, can be any of the {@link PIXI.DRAW_MODES} constants.
-       */
-      function Mesh(geometry, shader, state, drawMode) {
-          if (drawMode === void 0) { drawMode = exports.DRAW_MODES.TRIANGLES; }
-          var _this = _super.call(this) || this;
-          _this.geometry = geometry;
-          _this.shader = shader;
-          _this.state = state || State.for2d();
-          _this.drawMode = drawMode;
-          _this.start = 0;
-          _this.size = 0;
-          _this.uvs = null;
-          _this.indices = null;
-          _this.vertexData = new Float32Array(1);
-          _this.vertexDirty = -1;
-          _this._transformID = -1;
-          _this._roundPixels = settings.ROUND_PIXELS;
-          _this.batchUvs = null;
-          return _this;
-      }
-      Object.defineProperty(Mesh.prototype, "geometry", {
-          /**
-           * Includes vertex positions, face indices, normals, colors, UVs, and
-           * custom attributes within buffers, reducing the cost of passing all
-           * this data to the GPU. Can be shared between multiple Mesh objects.
-           */
-          get: function () {
-              return this._geometry;
-          },
-          set: function (value) {
-              if (this._geometry === value) {
-                  return;
-              }
-              if (this._geometry) {
-                  this._geometry.refCount--;
-                  if (this._geometry.refCount === 0) {
-                      this._geometry.dispose();
-                  }
-              }
-              this._geometry = value;
-              if (this._geometry) {
-                  this._geometry.refCount++;
-              }
-              this.vertexDirty = -1;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Mesh.prototype, "uvBuffer", {
-          /**
-           * To change mesh uv's, change its uvBuffer data and increment its _updateID.
-           * @readonly
-           */
-          get: function () {
-              return this.geometry.buffers[1];
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Mesh.prototype, "verticesBuffer", {
-          /**
-           * To change mesh vertices, change its uvBuffer data and increment its _updateID.
-           * Incrementing _updateID is optional because most of Mesh objects do it anyway.
-           * @readonly
-           */
-          get: function () {
-              return this.geometry.buffers[0];
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Mesh.prototype, "material", {
-          get: function () {
-              return this.shader;
-          },
-          /** Alias for {@link PIXI.Mesh#shader}. */
-          set: function (value) {
-              this.shader = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Mesh.prototype, "blendMode", {
-          get: function () {
-              return this.state.blendMode;
-          },
-          /**
-           * The blend mode to be applied to the Mesh. Apply a value of
-           * `PIXI.BLEND_MODES.NORMAL` to reset the blend mode.
-           * @default PIXI.BLEND_MODES.NORMAL;
-           */
-          set: function (value) {
-              this.state.blendMode = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Mesh.prototype, "roundPixels", {
-          get: function () {
-              return this._roundPixels;
-          },
-          /**
-           * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
-           * Advantages can include sharper image quality (like text) and faster rendering on canvas.
-           * The main disadvantage is movement of objects may appear less smooth.
-           * To set the global default, change {@link PIXI.settings.ROUND_PIXELS}
-           * @default false
-           */
-          set: function (value) {
-              if (this._roundPixels !== value) {
-                  this._transformID = -1;
-              }
-              this._roundPixels = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Mesh.prototype, "tint", {
-          /**
-           * The multiply tint applied to the Mesh. This is a hex value. A value of
-           * `0xFFFFFF` will remove any tint effect.
-           *
-           * Null for non-MeshMaterial shaders
-           * @default 0xFFFFFF
-           */
-          get: function () {
-              return 'tint' in this.shader ? this.shader.tint : null;
-          },
-          set: function (value) {
-              this.shader.tint = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Mesh.prototype, "texture", {
-          /** The texture that the Mesh uses. Null for non-MeshMaterial shaders */
-          get: function () {
-              return 'texture' in this.shader ? this.shader.texture : null;
-          },
-          set: function (value) {
-              this.shader.texture = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Standard renderer draw.
-       * @param renderer - Instance to renderer.
-       */
-      Mesh.prototype._render = function (renderer) {
-          // set properties for batching..
-          // TODO could use a different way to grab verts?
-          var vertices = this.geometry.buffers[0].data;
-          var shader = this.shader;
-          // TODO benchmark check for attribute size..
-          if (shader.batchable
-              && this.drawMode === exports.DRAW_MODES.TRIANGLES
-              && vertices.length < Mesh.BATCHABLE_SIZE * 2) {
-              this._renderToBatch(renderer);
-          }
-          else {
-              this._renderDefault(renderer);
-          }
-      };
-      /**
-       * Standard non-batching way of rendering.
-       * @param renderer - Instance to renderer.
-       */
-      Mesh.prototype._renderDefault = function (renderer) {
-          var shader = this.shader;
-          shader.alpha = this.worldAlpha;
-          if (shader.update) {
-              shader.update();
-          }
-          renderer.batch.flush();
-          // bind and sync uniforms..
-          shader.uniforms.translationMatrix = this.transform.worldTransform.toArray(true);
-          renderer.shader.bind(shader);
-          // set state..
-          renderer.state.set(this.state);
-          // bind the geometry...
-          renderer.geometry.bind(this.geometry, shader);
-          // then render it
-          renderer.geometry.draw(this.drawMode, this.size, this.start, this.geometry.instanceCount);
-      };
-      /**
-       * Rendering by using the Batch system.
-       * @param renderer - Instance to renderer.
-       */
-      Mesh.prototype._renderToBatch = function (renderer) {
-          var geometry = this.geometry;
-          var shader = this.shader;
-          if (shader.uvMatrix) {
-              shader.uvMatrix.update();
-              this.calculateUvs();
-          }
-          // set properties for batching..
-          this.calculateVertices();
-          this.indices = geometry.indexBuffer.data;
-          this._tintRGB = shader._tintRGB;
-          this._texture = shader.texture;
-          var pluginName = this.material.pluginName;
-          renderer.batch.setObjectRenderer(renderer.plugins[pluginName]);
-          renderer.plugins[pluginName].render(this);
-      };
-      /** Updates vertexData field based on transform and vertices. */
-      Mesh.prototype.calculateVertices = function () {
-          var geometry = this.geometry;
-          var verticesBuffer = geometry.buffers[0];
-          var vertices = verticesBuffer.data;
-          var vertexDirtyId = verticesBuffer._updateID;
-          if (vertexDirtyId === this.vertexDirty && this._transformID === this.transform._worldID) {
-              return;
-          }
-          this._transformID = this.transform._worldID;
-          if (this.vertexData.length !== vertices.length) {
-              this.vertexData = new Float32Array(vertices.length);
-          }
-          var wt = this.transform.worldTransform;
-          var a = wt.a;
-          var b = wt.b;
-          var c = wt.c;
-          var d = wt.d;
-          var tx = wt.tx;
-          var ty = wt.ty;
-          var vertexData = this.vertexData;
-          for (var i = 0; i < vertexData.length / 2; i++) {
-              var x = vertices[(i * 2)];
-              var y = vertices[(i * 2) + 1];
-              vertexData[(i * 2)] = (a * x) + (c * y) + tx;
-              vertexData[(i * 2) + 1] = (b * x) + (d * y) + ty;
-          }
-          if (this._roundPixels) {
-              var resolution = settings.RESOLUTION;
-              for (var i = 0; i < vertexData.length; ++i) {
-                  vertexData[i] = Math.round((vertexData[i] * resolution | 0) / resolution);
-              }
-          }
-          this.vertexDirty = vertexDirtyId;
-      };
-      /** Updates uv field based on from geometry uv's or batchUvs. */
-      Mesh.prototype.calculateUvs = function () {
-          var geomUvs = this.geometry.buffers[1];
-          var shader = this.shader;
-          if (!shader.uvMatrix.isSimple) {
-              if (!this.batchUvs) {
-                  this.batchUvs = new MeshBatchUvs(geomUvs, shader.uvMatrix);
-              }
-              this.batchUvs.update();
-              this.uvs = this.batchUvs.data;
-          }
-          else {
-              this.uvs = geomUvs.data;
-          }
-      };
-      /**
-       * Updates the bounds of the mesh as a rectangle. The bounds calculation takes the worldTransform into account.
-       * there must be a aVertexPosition attribute present in the geometry for bounds to be calculated correctly.
-       */
-      Mesh.prototype._calculateBounds = function () {
-          this.calculateVertices();
-          this._bounds.addVertexData(this.vertexData, 0, this.vertexData.length);
-      };
-      /**
-       * Tests if a point is inside this mesh. Works only for PIXI.DRAW_MODES.TRIANGLES.
-       * @param point - The point to test.
-       * @returns - The result of the test.
-       */
-      Mesh.prototype.containsPoint = function (point) {
-          if (!this.getBounds().contains(point.x, point.y)) {
-              return false;
-          }
-          this.worldTransform.applyInverse(point, tempPoint);
-          var vertices = this.geometry.getBuffer('aVertexPosition').data;
-          var points = tempPolygon.points;
-          var indices = this.geometry.getIndex().data;
-          var len = indices.length;
-          var step = this.drawMode === 4 ? 3 : 1;
-          for (var i = 0; i + 2 < len; i += step) {
-              var ind0 = indices[i] * 2;
-              var ind1 = indices[i + 1] * 2;
-              var ind2 = indices[i + 2] * 2;
-              points[0] = vertices[ind0];
-              points[1] = vertices[ind0 + 1];
-              points[2] = vertices[ind1];
-              points[3] = vertices[ind1 + 1];
-              points[4] = vertices[ind2];
-              points[5] = vertices[ind2 + 1];
-              if (tempPolygon.contains(tempPoint.x, tempPoint.y)) {
-                  return true;
-              }
-          }
-          return false;
-      };
-      Mesh.prototype.destroy = function (options) {
-          _super.prototype.destroy.call(this, options);
-          if (this._cachedTexture) {
-              this._cachedTexture.destroy();
-              this._cachedTexture = null;
-          }
-          this.geometry = null;
-          this.shader = null;
-          this.state = null;
-          this.uvs = null;
-          this.indices = null;
-          this.vertexData = null;
-      };
-      /** The maximum number of vertices to consider batchable. Generally, the complexity of the geometry. */
-      Mesh.BATCHABLE_SIZE = 100;
-      return Mesh;
-  }(Container));
-
-  var fragment$5 = "varying vec2 vTextureCoord;\nuniform vec4 uColor;\n\nuniform sampler2D uSampler;\n\nvoid main(void)\n{\n    gl_FragColor = texture2D(uSampler, vTextureCoord) * uColor;\n}\n";
-
-  var vertex$2 = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform mat3 translationMatrix;\nuniform mat3 uTextureMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n\n    vTextureCoord = (uTextureMatrix * vec3(aTextureCoord, 1.0)).xy;\n}\n";
-
-  /**
-   * Slightly opinionated default shader for PixiJS 2D objects.
-   * @memberof PIXI
-   */
-  var MeshMaterial = /** @class */ (function (_super) {
-      __extends$9(MeshMaterial, _super);
-      /**
-       * @param uSampler - Texture that material uses to render.
-       * @param options - Additional options
-       * @param {number} [options.alpha=1] - Default alpha.
-       * @param {number} [options.tint=0xFFFFFF] - Default tint.
-       * @param {string} [options.pluginName='batch'] - Renderer plugin for batching.
-       * @param {PIXI.Program} [options.program=0xFFFFFF] - Custom program.
-       * @param {object} [options.uniforms] - Custom uniforms.
-       */
-      function MeshMaterial(uSampler, options) {
-          var _this = this;
-          var uniforms = {
-              uSampler: uSampler,
-              alpha: 1,
-              uTextureMatrix: Matrix.IDENTITY,
-              uColor: new Float32Array([1, 1, 1, 1]),
-          };
-          // Set defaults
-          options = Object.assign({
-              tint: 0xFFFFFF,
-              alpha: 1,
-              pluginName: 'batch',
-          }, options);
-          if (options.uniforms) {
-              Object.assign(uniforms, options.uniforms);
-          }
-          _this = _super.call(this, options.program || Program.from(vertex$2, fragment$5), uniforms) || this;
-          _this._colorDirty = false;
-          _this.uvMatrix = new TextureMatrix(uSampler);
-          _this.batchable = options.program === undefined;
-          _this.pluginName = options.pluginName;
-          _this.tint = options.tint;
-          _this.alpha = options.alpha;
-          return _this;
-      }
-      Object.defineProperty(MeshMaterial.prototype, "texture", {
-          /** Reference to the texture being rendered. */
-          get: function () {
-              return this.uniforms.uSampler;
-          },
-          set: function (value) {
-              if (this.uniforms.uSampler !== value) {
-                  if (!this.uniforms.uSampler.baseTexture.alphaMode !== !value.baseTexture.alphaMode) {
-                      this._colorDirty = true;
-                  }
-                  this.uniforms.uSampler = value;
-                  this.uvMatrix.texture = value;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(MeshMaterial.prototype, "alpha", {
-          get: function () {
-              return this._alpha;
-          },
-          /**
-           * This gets automatically set by the object using this.
-           * @default 1
-           */
-          set: function (value) {
-              if (value === this._alpha)
-                  { return; }
-              this._alpha = value;
-              this._colorDirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(MeshMaterial.prototype, "tint", {
-          get: function () {
-              return this._tint;
-          },
-          /**
-           * Multiply tint for the material.
-           * @default 0xFFFFFF
-           */
-          set: function (value) {
-              if (value === this._tint)
-                  { return; }
-              this._tint = value;
-              this._tintRGB = (value >> 16) + (value & 0xff00) + ((value & 0xff) << 16);
-              this._colorDirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Gets called automatically by the Mesh. Intended to be overridden for custom {@link MeshMaterial} objects. */
-      MeshMaterial.prototype.update = function () {
-          if (this._colorDirty) {
-              this._colorDirty = false;
-              var baseTexture = this.texture.baseTexture;
-              premultiplyTintToRgba(this._tint, this._alpha, this.uniforms.uColor, baseTexture.alphaMode);
-          }
-          if (this.uvMatrix.update()) {
-              this.uniforms.uTextureMatrix = this.uvMatrix.mapCoord;
-          }
-      };
-      return MeshMaterial;
-  }(Shader));
-
-  /**
-   * Standard 2D geometry used in PixiJS.
-   *
-   * Geometry can be defined without passing in a style or data if required.
-   *
-   * ```js
-   * const geometry = new PIXI.Geometry();
-   *
-   * geometry.addAttribute('positions', [0, 0, 100, 0, 100, 100, 0, 100], 2);
-   * geometry.addAttribute('uvs', [0,0,1,0,1,1,0,1], 2);
-   * geometry.addIndex([0,1,2,1,3,2]);
-   *
-   * ```
-   * @memberof PIXI
-   */
-  var MeshGeometry = /** @class */ (function (_super) {
-      __extends$9(MeshGeometry, _super);
-      /**
-       * @param {Float32Array|number[]} [vertices] - Positional data on geometry.
-       * @param {Float32Array|number[]} [uvs] - Texture UVs.
-       * @param {Uint16Array|number[]} [index] - IndexBuffer
-       */
-      function MeshGeometry(vertices, uvs, index) {
-          var _this = _super.call(this) || this;
-          var verticesBuffer = new Buffer(vertices);
-          var uvsBuffer = new Buffer(uvs, true);
-          var indexBuffer = new Buffer(index, true, true);
-          _this.addAttribute('aVertexPosition', verticesBuffer, 2, false, exports.TYPES.FLOAT)
-              .addAttribute('aTextureCoord', uvsBuffer, 2, false, exports.TYPES.FLOAT)
-              .addIndex(indexBuffer);
-          _this._updateId = -1;
-          return _this;
-      }
-      Object.defineProperty(MeshGeometry.prototype, "vertexDirtyId", {
-          /**
-           * If the vertex position is updated.
-           * @readonly
-           * @private
-           */
-          get: function () {
-              return this.buffers[0]._updateID;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return MeshGeometry;
-  }(Geometry));
-
-  /*!
-   * @pixi/text-bitmap - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/text-bitmap is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$8 = function(d, b) {
-      extendStatics$8 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$8(d, b);
-  };
-
-  function __extends$8(d, b) {
-      extendStatics$8(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /* eslint-disable max-len */
-  /**
-   * Normalized parsed data from .fnt files.
-   * @memberof PIXI
-   */
-  var BitmapFontData = /** @class */ (function () {
-      function BitmapFontData() {
-          this.info = [];
-          this.common = [];
-          this.page = [];
-          this.char = [];
-          this.kerning = [];
-          this.distanceField = [];
-      }
-      return BitmapFontData;
-  }());
-
-  /**
-   * BitmapFont format that's Text-based.
-   * @private
-   */
-  var TextFormat = /** @class */ (function () {
-      function TextFormat() {
-      }
-      /**
-       * Check if resource refers to txt font data.
-       * @param data
-       * @returns - True if resource could be treated as font data, false otherwise.
-       */
-      TextFormat.test = function (data) {
-          return typeof data === 'string' && data.indexOf('info face=') === 0;
-      };
-      /**
-       * Convert text font data to a javascript object.
-       * @param txt - Raw string data to be converted
-       * @returns - Parsed font data
-       */
-      TextFormat.parse = function (txt) {
-          // Retrieve data item
-          var items = txt.match(/^[a-z]+\s+.+$/gm);
-          var rawData = {
-              info: [],
-              common: [],
-              page: [],
-              char: [],
-              chars: [],
-              kerning: [],
-              kernings: [],
-              distanceField: [],
-          };
-          for (var i in items) {
-              // Extract item name
-              var name = items[i].match(/^[a-z]+/gm)[0];
-              // Extract item attribute list as string ex.: "width=10"
-              var attributeList = items[i].match(/[a-zA-Z]+=([^\s"']+|"([^"]*)")/gm);
-              // Convert attribute list into an object
-              var itemData = {};
-              for (var i_1 in attributeList) {
-                  // Split key-value pairs
-                  var split = attributeList[i_1].split('=');
-                  var key = split[0];
-                  // Remove eventual quotes from value
-                  var strValue = split[1].replace(/"/gm, '');
-                  // Try to convert value into float
-                  var floatValue = parseFloat(strValue);
-                  // Use string value case float value is NaN
-                  var value = isNaN(floatValue) ? strValue : floatValue;
-                  itemData[key] = value;
-              }
-              // Push current item to the resulting data
-              rawData[name].push(itemData);
-          }
-          var font = new BitmapFontData();
-          rawData.info.forEach(function (info) { return font.info.push({
-              face: info.face,
-              size: parseInt(info.size, 10),
-          }); });
-          rawData.common.forEach(function (common) { return font.common.push({
-              lineHeight: parseInt(common.lineHeight, 10),
-          }); });
-          rawData.page.forEach(function (page) { return font.page.push({
-              id: parseInt(page.id, 10),
-              file: page.file,
-          }); });
-          rawData.char.forEach(function (char) { return font.char.push({
-              id: parseInt(char.id, 10),
-              page: parseInt(char.page, 10),
-              x: parseInt(char.x, 10),
-              y: parseInt(char.y, 10),
-              width: parseInt(char.width, 10),
-              height: parseInt(char.height, 10),
-              xoffset: parseInt(char.xoffset, 10),
-              yoffset: parseInt(char.yoffset, 10),
-              xadvance: parseInt(char.xadvance, 10),
-          }); });
-          rawData.kerning.forEach(function (kerning) { return font.kerning.push({
-              first: parseInt(kerning.first, 10),
-              second: parseInt(kerning.second, 10),
-              amount: parseInt(kerning.amount, 10),
-          }); });
-          rawData.distanceField.forEach(function (df) { return font.distanceField.push({
-              distanceRange: parseInt(df.distanceRange, 10),
-              fieldType: df.fieldType,
-          }); });
-          return font;
-      };
-      return TextFormat;
-  }());
-
-  /**
-   * BitmapFont format that's XML-based.
-   * @private
-   */
-  var XMLFormat = /** @class */ (function () {
-      function XMLFormat() {
-      }
-      /**
-       * Check if resource refers to xml font data.
-       * @param data
-       * @returns - True if resource could be treated as font data, false otherwise.
-       */
-      XMLFormat.test = function (data) {
-          return data instanceof XMLDocument
-              && data.getElementsByTagName('page').length
-              && data.getElementsByTagName('info')[0].getAttribute('face') !== null;
-      };
-      /**
-       * Convert the XML into BitmapFontData that we can use.
-       * @param xml
-       * @returns - Data to use for BitmapFont
-       */
-      XMLFormat.parse = function (xml) {
-          var data = new BitmapFontData();
-          var info = xml.getElementsByTagName('info');
-          var common = xml.getElementsByTagName('common');
-          var page = xml.getElementsByTagName('page');
-          var char = xml.getElementsByTagName('char');
-          var kerning = xml.getElementsByTagName('kerning');
-          var distanceField = xml.getElementsByTagName('distanceField');
-          for (var i = 0; i < info.length; i++) {
-              data.info.push({
-                  face: info[i].getAttribute('face'),
-                  size: parseInt(info[i].getAttribute('size'), 10),
-              });
-          }
-          for (var i = 0; i < common.length; i++) {
-              data.common.push({
-                  lineHeight: parseInt(common[i].getAttribute('lineHeight'), 10),
-              });
-          }
-          for (var i = 0; i < page.length; i++) {
-              data.page.push({
-                  id: parseInt(page[i].getAttribute('id'), 10) || 0,
-                  file: page[i].getAttribute('file'),
-              });
-          }
-          for (var i = 0; i < char.length; i++) {
-              var letter = char[i];
-              data.char.push({
-                  id: parseInt(letter.getAttribute('id'), 10),
-                  page: parseInt(letter.getAttribute('page'), 10) || 0,
-                  x: parseInt(letter.getAttribute('x'), 10),
-                  y: parseInt(letter.getAttribute('y'), 10),
-                  width: parseInt(letter.getAttribute('width'), 10),
-                  height: parseInt(letter.getAttribute('height'), 10),
-                  xoffset: parseInt(letter.getAttribute('xoffset'), 10),
-                  yoffset: parseInt(letter.getAttribute('yoffset'), 10),
-                  xadvance: parseInt(letter.getAttribute('xadvance'), 10),
-              });
-          }
-          for (var i = 0; i < kerning.length; i++) {
-              data.kerning.push({
-                  first: parseInt(kerning[i].getAttribute('first'), 10),
-                  second: parseInt(kerning[i].getAttribute('second'), 10),
-                  amount: parseInt(kerning[i].getAttribute('amount'), 10),
-              });
-          }
-          for (var i = 0; i < distanceField.length; i++) {
-              data.distanceField.push({
-                  fieldType: distanceField[i].getAttribute('fieldType'),
-                  distanceRange: parseInt(distanceField[i].getAttribute('distanceRange'), 10),
-              });
-          }
-          return data;
-      };
-      return XMLFormat;
-  }());
-
-  /**
-   * BitmapFont format that's XML-based.
-   * @private
-   */
-  var XMLStringFormat = /** @class */ (function () {
-      function XMLStringFormat() {
-      }
-      /**
-       * Check if resource refers to text xml font data.
-       * @param data
-       * @returns - True if resource could be treated as font data, false otherwise.
-       */
-      XMLStringFormat.test = function (data) {
-          if (typeof data === 'string' && data.indexOf('<font>') > -1) {
-              var xml = new globalThis.DOMParser().parseFromString(data, 'text/xml');
-              return XMLFormat.test(xml);
-          }
-          return false;
-      };
-      /**
-       * Convert the text XML into BitmapFontData that we can use.
-       * @param xmlTxt
-       * @returns - Data to use for BitmapFont
-       */
-      XMLStringFormat.parse = function (xmlTxt) {
-          var xml = new globalThis.DOMParser().parseFromString(xmlTxt, 'text/xml');
-          return XMLFormat.parse(xml);
-      };
-      return XMLStringFormat;
-  }());
-
-  // Registered formats, maybe make this extensible in the future?
-  var formats = [
-      TextFormat,
-      XMLFormat,
-      XMLStringFormat ];
-  /**
-   * Auto-detect BitmapFont parsing format based on data.
-   * @private
-   * @param {any} data - Data to detect format
-   * @returns {any} Format or null
-   */
-  function autoDetectFormat(data) {
-      for (var i = 0; i < formats.length; i++) {
-          if (formats[i].test(data)) {
-              return formats[i];
-          }
-      }
-      return null;
-  }
-
-  // TODO: Prevent code duplication b/w generateFillStyle & Text#generateFillStyle
-  /**
-   * Generates the fill style. Can automatically generate a gradient based on the fill style being an array
-   * @private
-   * @param canvas
-   * @param context
-   * @param {object} style - The style.
-   * @param resolution
-   * @param {string[]} lines - The lines of text.
-   * @param metrics
-   * @returns {string|number|CanvasGradient} The fill style
-   */
-  function generateFillStyle(canvas, context, style, resolution, lines, metrics) {
-      // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as
-      //       the setter converts to string. See this thread for more details:
-      //       https://github.com/microsoft/TypeScript/issues/2521
-      var fillStyle = style.fill;
-      if (!Array.isArray(fillStyle)) {
-          return fillStyle;
-      }
-      else if (fillStyle.length === 1) {
-          return fillStyle[0];
-      }
-      // the gradient will be evenly spaced out according to how large the array is.
-      // ['#FF0000', '#00FF00', '#0000FF'] would created stops at 0.25, 0.5 and 0.75
-      var gradient;
-      // a dropshadow will enlarge the canvas and result in the gradient being
-      // generated with the incorrect dimensions
-      var dropShadowCorrection = (style.dropShadow) ? style.dropShadowDistance : 0;
-      // should also take padding into account, padding can offset the gradient
-      var padding = style.padding || 0;
-      var width = (canvas.width / resolution) - dropShadowCorrection - (padding * 2);
-      var height = (canvas.height / resolution) - dropShadowCorrection - (padding * 2);
-      // make a copy of the style settings, so we can manipulate them later
-      var fill = fillStyle.slice();
-      var fillGradientStops = style.fillGradientStops.slice();
-      // wanting to evenly distribute the fills. So an array of 4 colours should give fills of 0.25, 0.5 and 0.75
-      if (!fillGradientStops.length) {
-          var lengthPlus1 = fill.length + 1;
-          for (var i = 1; i < lengthPlus1; ++i) {
-              fillGradientStops.push(i / lengthPlus1);
-          }
-      }
-      // stop the bleeding of the last gradient on the line above to the top gradient of the this line
-      // by hard defining the first gradient colour at point 0, and last gradient colour at point 1
-      fill.unshift(fillStyle[0]);
-      fillGradientStops.unshift(0);
-      fill.push(fillStyle[fillStyle.length - 1]);
-      fillGradientStops.push(1);
-      if (style.fillGradientType === exports.TEXT_GRADIENT.LINEAR_VERTICAL) {
-          // start the gradient at the top center of the canvas, and end at the bottom middle of the canvas
-          gradient = context.createLinearGradient(width / 2, padding, width / 2, height + padding);
-          // we need to repeat the gradient so that each individual line of text has the same vertical gradient effect
-          // ['#FF0000', '#00FF00', '#0000FF'] over 2 lines would create stops at 0.125, 0.25, 0.375, 0.625, 0.75, 0.875
-          // There's potential for floating point precision issues at the seams between gradient repeats.
-          // The loop below generates the stops in order, so track the last generated one to prevent
-          // floating point precision from making us go the teeniest bit backwards, resulting in
-          // the first and last colors getting swapped.
-          var lastIterationStop = 0;
-          // Actual height of the text itself, not counting spacing for lineHeight/leading/dropShadow etc
-          var textHeight = metrics.fontProperties.fontSize + style.strokeThickness;
-          // textHeight, but as a 0-1 size in global gradient stop space
-          var gradStopLineHeight = textHeight / height;
-          for (var i = 0; i < lines.length; i++) {
-              var thisLineTop = metrics.lineHeight * i;
-              for (var j = 0; j < fill.length; j++) {
-                  // 0-1 stop point for the current line, multiplied to global space afterwards
-                  var lineStop = 0;
-                  if (typeof fillGradientStops[j] === 'number') {
-                      lineStop = fillGradientStops[j];
-                  }
-                  else {
-                      lineStop = j / fill.length;
-                  }
-                  var globalStop = (thisLineTop / height) + (lineStop * gradStopLineHeight);
-                  // Prevent color stop generation going backwards from floating point imprecision
-                  var clampedStop = Math.max(lastIterationStop, globalStop);
-                  clampedStop = Math.min(clampedStop, 1); // Cap at 1 as well for safety's sake to avoid a possible throw.
-                  gradient.addColorStop(clampedStop, fill[j]);
-                  lastIterationStop = clampedStop;
-              }
-          }
-      }
-      else {
-          // start the gradient at the center left of the canvas, and end at the center right of the canvas
-          gradient = context.createLinearGradient(padding, height / 2, width + padding, height / 2);
-          // can just evenly space out the gradients in this case, as multiple lines makes no difference
-          // to an even left to right gradient
-          var totalIterations = fill.length + 1;
-          var currentIteration = 1;
-          for (var i = 0; i < fill.length; i++) {
-              var stop = void 0;
-              if (typeof fillGradientStops[i] === 'number') {
-                  stop = fillGradientStops[i];
-              }
-              else {
-                  stop = currentIteration / totalIterations;
-              }
-              gradient.addColorStop(stop, fill[i]);
-              currentIteration++;
-          }
-      }
-      return gradient;
-  }
-
-  // TODO: Prevent code duplication b/w drawGlyph & Text#updateText
-  /**
-   * Draws the glyph `metrics.text` on the given canvas.
-   *
-   * Ignored because not directly exposed.
-   * @ignore
-   * @param {HTMLCanvasElement} canvas
-   * @param {CanvasRenderingContext2D} context
-   * @param {TextMetrics} metrics
-   * @param {number} x
-   * @param {number} y
-   * @param {number} resolution
-   * @param {TextStyle} style
-   */
-  function drawGlyph(canvas, context, metrics, x, y, resolution, style) {
-      var char = metrics.text;
-      var fontProperties = metrics.fontProperties;
-      context.translate(x, y);
-      context.scale(resolution, resolution);
-      var tx = style.strokeThickness / 2;
-      var ty = -(style.strokeThickness / 2);
-      context.font = style.toFontString();
-      context.lineWidth = style.strokeThickness;
-      context.textBaseline = style.textBaseline;
-      context.lineJoin = style.lineJoin;
-      context.miterLimit = style.miterLimit;
-      // set canvas text styles
-      context.fillStyle = generateFillStyle(canvas, context, style, resolution, [char], metrics);
-      context.strokeStyle = style.stroke;
-      if (style.dropShadow) {
-          var dropShadowColor = style.dropShadowColor;
-          var rgb = hex2rgb(typeof dropShadowColor === 'number' ? dropShadowColor : string2hex(dropShadowColor));
-          var dropShadowBlur = style.dropShadowBlur * resolution;
-          var dropShadowDistance = style.dropShadowDistance * resolution;
-          context.shadowColor = "rgba(" + rgb[0] * 255 + "," + rgb[1] * 255 + "," + rgb[2] * 255 + "," + style.dropShadowAlpha + ")";
-          context.shadowBlur = dropShadowBlur;
-          context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;
-          context.shadowOffsetY = Math.sin(style.dropShadowAngle) * dropShadowDistance;
-      }
-      else {
-          context.shadowColor = 'black';
-          context.shadowBlur = 0;
-          context.shadowOffsetX = 0;
-          context.shadowOffsetY = 0;
-      }
-      if (style.stroke && style.strokeThickness) {
-          context.strokeText(char, tx, ty + metrics.lineHeight - fontProperties.descent);
-      }
-      if (style.fill) {
-          context.fillText(char, tx, ty + metrics.lineHeight - fontProperties.descent);
-      }
-      context.setTransform(1, 0, 0, 1, 0, 0); // defaults needed for older browsers (e.g. Opera 29)
-      context.fillStyle = 'rgba(0, 0, 0, 0)';
-  }
-
-  /**
-   * Ponyfill for IE because it doesn't support `Array.from`
-   * @param text
-   * @private
-   */
-  function splitTextToCharacters(text) {
-      return Array.from ? Array.from(text) : text.split('');
-  }
-
-  /**
-   * Processes the passed character set data and returns a flattened array of all the characters.
-   *
-   * Ignored because not directly exposed.
-   * @ignore
-   * @param {string | string[] | string[][] } chars
-   * @returns {string[]} the flattened array of characters
-   */
-  function resolveCharacters(chars) {
-      // Split the chars string into individual characters
-      if (typeof chars === 'string') {
-          chars = [chars];
-      }
-      // Handle an array of characters+ranges
-      var result = [];
-      for (var i = 0, j = chars.length; i < j; i++) {
-          var item = chars[i];
-          // Handle range delimited by start/end chars
-          if (Array.isArray(item)) {
-              if (item.length !== 2) {
-                  throw new Error("[BitmapFont]: Invalid character range length, expecting 2 got " + item.length + ".");
-              }
-              var startCode = item[0].charCodeAt(0);
-              var endCode = item[1].charCodeAt(0);
-              if (endCode < startCode) {
-                  throw new Error('[BitmapFont]: Invalid character range.');
-              }
-              for (var i_1 = startCode, j_1 = endCode; i_1 <= j_1; i_1++) {
-                  result.push(String.fromCharCode(i_1));
-              }
-          }
-          // Handle a character set string
-          else {
-              result.push.apply(result, splitTextToCharacters(item));
-          }
-      }
-      if (result.length === 0) {
-          throw new Error('[BitmapFont]: Empty set when resolving characters.');
-      }
-      return result;
-  }
-
-  /**
-   * Ponyfill for IE because it doesn't support `codePointAt`
-   * @param str
-   * @private
-   */
-  function extractCharCode(str) {
-      return str.codePointAt ? str.codePointAt(0) : str.charCodeAt(0);
-  }
-
-  /**
-   * BitmapFont represents a typeface available for use with the BitmapText class. Use the `install`
-   * method for adding a font to be used.
-   * @memberof PIXI
-   */
-  var BitmapFont = /** @class */ (function () {
-      /**
-       * @param data
-       * @param textures
-       * @param ownsTextures - Setting to `true` will destroy page textures
-       *        when the font is uninstalled.
-       */
-      function BitmapFont(data, textures, ownsTextures) {
-          var _a, _b;
-          var info = data.info[0];
-          var common = data.common[0];
-          var page = data.page[0];
-          var distanceField = data.distanceField[0];
-          var res = getResolutionOfUrl(page.file);
-          var pageTextures = {};
-          this._ownsTextures = ownsTextures;
-          this.font = info.face;
-          this.size = info.size;
-          this.lineHeight = common.lineHeight / res;
-          this.chars = {};
-          this.pageTextures = pageTextures;
-          // Convert the input Texture, Textures or object
-          // into a page Texture lookup by "id"
-          for (var i = 0; i < data.page.length; i++) {
-              var _c = data.page[i], id = _c.id, file = _c.file;
-              pageTextures[id] = textures instanceof Array
-                  ? textures[i] : textures[file];
-              // only MSDF and SDF fonts need no-premultiplied-alpha
-              if ((distanceField === null || distanceField === void 0 ? void 0 : distanceField.fieldType) && distanceField.fieldType !== 'none') {
-                  pageTextures[id].baseTexture.alphaMode = exports.ALPHA_MODES.NO_PREMULTIPLIED_ALPHA;
-                  pageTextures[id].baseTexture.mipmap = exports.MIPMAP_MODES.OFF;
-              }
-          }
-          // parse letters
-          for (var i = 0; i < data.char.length; i++) {
-              var _d = data.char[i], id = _d.id, page_1 = _d.page;
-              var _e = data.char[i], x = _e.x, y = _e.y, width = _e.width, height = _e.height, xoffset = _e.xoffset, yoffset = _e.yoffset, xadvance = _e.xadvance;
-              x /= res;
-              y /= res;
-              width /= res;
-              height /= res;
-              xoffset /= res;
-              yoffset /= res;
-              xadvance /= res;
-              var rect = new Rectangle(x + (pageTextures[page_1].frame.x / res), y + (pageTextures[page_1].frame.y / res), width, height);
-              this.chars[id] = {
-                  xOffset: xoffset,
-                  yOffset: yoffset,
-                  xAdvance: xadvance,
-                  kerning: {},
-                  texture: new Texture(pageTextures[page_1].baseTexture, rect),
-                  page: page_1,
-              };
-          }
-          // parse kernings
-          for (var i = 0; i < data.kerning.length; i++) {
-              var _f = data.kerning[i], first = _f.first, second = _f.second, amount = _f.amount;
-              first /= res;
-              second /= res;
-              amount /= res;
-              if (this.chars[second]) {
-                  this.chars[second].kerning[first] = amount;
-              }
-          }
-          // Store distance field information
-          this.distanceFieldRange = distanceField === null || distanceField === void 0 ? void 0 : distanceField.distanceRange;
-          this.distanceFieldType = (_b = (_a = distanceField === null || distanceField === void 0 ? void 0 : distanceField.fieldType) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : 'none';
-      }
-      /** Remove references to created glyph textures. */
-      BitmapFont.prototype.destroy = function () {
-          for (var id in this.chars) {
-              this.chars[id].texture.destroy();
-              this.chars[id].texture = null;
-          }
-          for (var id in this.pageTextures) {
-              if (this._ownsTextures) {
-                  this.pageTextures[id].destroy(true);
-              }
-              this.pageTextures[id] = null;
-          }
-          // Set readonly null.
-          this.chars = null;
-          this.pageTextures = null;
-      };
-      /**
-       * Register a new bitmap font.
-       * @param data - The
-       *        characters map that could be provided as xml or raw string.
-       * @param textures - List of textures for each page.
-       * @param ownsTextures - Set to `true` to destroy page textures
-       *        when the font is uninstalled. By default fonts created with
-       *        `BitmapFont.from` or from the `BitmapFontLoader` are `true`.
-       * @returns {PIXI.BitmapFont} Result font object with font, size, lineHeight
-       *         and char fields.
-       */
-      BitmapFont.install = function (data, textures, ownsTextures) {
-          var fontData;
-          if (data instanceof BitmapFontData) {
-              fontData = data;
-          }
-          else {
-              var format = autoDetectFormat(data);
-              if (!format) {
-                  throw new Error('Unrecognized data format for font.');
-              }
-              fontData = format.parse(data);
-          }
-          // Single texture, convert to list
-          if (textures instanceof Texture) {
-              textures = [textures];
-          }
-          var font = new BitmapFont(fontData, textures, ownsTextures);
-          BitmapFont.available[font.font] = font;
-          return font;
-      };
-      /**
-       * Remove bitmap font by name.
-       * @param name - Name of the font to uninstall.
-       */
-      BitmapFont.uninstall = function (name) {
-          var font = BitmapFont.available[name];
-          if (!font) {
-              throw new Error("No font found named '" + name + "'");
-          }
-          font.destroy();
-          delete BitmapFont.available[name];
-      };
-      /**
-       * Generates a bitmap-font for the given style and character set. This does not support
-       * kernings yet. With `style` properties, only the following non-layout properties are used:
-       *
-       * - {@link PIXI.TextStyle#dropShadow|dropShadow}
-       * - {@link PIXI.TextStyle#dropShadowDistance|dropShadowDistance}
-       * - {@link PIXI.TextStyle#dropShadowColor|dropShadowColor}
-       * - {@link PIXI.TextStyle#dropShadowBlur|dropShadowBlur}
-       * - {@link PIXI.TextStyle#dropShadowAngle|dropShadowAngle}
-       * - {@link PIXI.TextStyle#fill|fill}
-       * - {@link PIXI.TextStyle#fillGradientStops|fillGradientStops}
-       * - {@link PIXI.TextStyle#fillGradientType|fillGradientType}
-       * - {@link PIXI.TextStyle#fontFamily|fontFamily}
-       * - {@link PIXI.TextStyle#fontSize|fontSize}
-       * - {@link PIXI.TextStyle#fontVariant|fontVariant}
-       * - {@link PIXI.TextStyle#fontWeight|fontWeight}
-       * - {@link PIXI.TextStyle#lineJoin|lineJoin}
-       * - {@link PIXI.TextStyle#miterLimit|miterLimit}
-       * - {@link PIXI.TextStyle#stroke|stroke}
-       * - {@link PIXI.TextStyle#strokeThickness|strokeThickness}
-       * - {@link PIXI.TextStyle#textBaseline|textBaseline}
-       * @param name - The name of the custom font to use with BitmapText.
-       * @param textStyle - Style options to render with BitmapFont.
-       * @param options - Setup options for font or name of the font.
-       * @param {string|string[]|string[][]} [options.chars=PIXI.BitmapFont.ALPHANUMERIC] - characters included
-       *      in the font set. You can also use ranges. For example, `[['a', 'z'], ['A', 'Z'], "!@#$%^&*()~{}[] "]`.
-       *      Don't forget to include spaces ' ' in your character set!
-       * @param {number} [options.resolution=1] - Render resolution for glyphs.
-       * @param {number} [options.textureWidth=512] - Optional width of atlas, smaller values to reduce memory.
-       * @param {number} [options.textureHeight=512] - Optional height of atlas, smaller values to reduce memory.
-       * @param {number} [options.padding=4] - Padding between glyphs on texture atlas.
-       * @returns Font generated by style options.
-       * @example
-       * PIXI.BitmapFont.from("TitleFont", {
-       *     fontFamily: "Arial",
-       *     fontSize: 12,
-       *     strokeThickness: 2,
-       *     fill: "purple"
-       * });
-       *
-       * const title = new PIXI.BitmapText("This is the title", { fontName: "TitleFont" });
-       */
-      BitmapFont.from = function (name, textStyle, options) {
-          if (!name) {
-              throw new Error('[BitmapFont] Property `name` is required.');
-          }
-          var _a = Object.assign({}, BitmapFont.defaultOptions, options), chars = _a.chars, padding = _a.padding, resolution = _a.resolution, textureWidth = _a.textureWidth, textureHeight = _a.textureHeight;
-          var charsList = resolveCharacters(chars);
-          var style = textStyle instanceof TextStyle ? textStyle : new TextStyle(textStyle);
-          var lineWidth = textureWidth;
-          var fontData = new BitmapFontData();
-          fontData.info[0] = {
-              face: style.fontFamily,
-              size: style.fontSize,
-          };
-          fontData.common[0] = {
-              lineHeight: style.fontSize,
-          };
-          var positionX = 0;
-          var positionY = 0;
-          var canvas;
-          var context;
-          var baseTexture;
-          var maxCharHeight = 0;
-          var textures = [];
-          for (var i = 0; i < charsList.length; i++) {
-              if (!canvas) {
-                  canvas = settings.ADAPTER.createCanvas();
-                  canvas.width = textureWidth;
-                  canvas.height = textureHeight;
-                  context = canvas.getContext('2d');
-                  baseTexture = new BaseTexture(canvas, { resolution: resolution });
-                  textures.push(new Texture(baseTexture));
-                  fontData.page.push({
-                      id: textures.length - 1,
-                      file: '',
-                  });
-              }
-              // Measure glyph dimensions
-              var character = charsList[i];
-              var metrics = TextMetrics.measureText(character, style, false, canvas);
-              var width = metrics.width;
-              var height = Math.ceil(metrics.height);
-              // This is ugly - but italics are given more space so they don't overlap
-              var textureGlyphWidth = Math.ceil((style.fontStyle === 'italic' ? 2 : 1) * width);
-              // Can't fit char anymore: next canvas please!
-              if (positionY >= textureHeight - (height * resolution)) {
-                  if (positionY === 0) {
-                      // We don't want user debugging an infinite loop (or do we? :)
-                      throw new Error("[BitmapFont] textureHeight " + textureHeight + "px is too small "
-                          + ("(fontFamily: '" + style.fontFamily + "', fontSize: " + style.fontSize + "px, char: '" + character + "')"));
-                  }
-                  --i;
-                  // Create new atlas once current has filled up
-                  canvas = null;
-                  context = null;
-                  baseTexture = null;
-                  positionY = 0;
-                  positionX = 0;
-                  maxCharHeight = 0;
-                  continue;
-              }
-              maxCharHeight = Math.max(height + metrics.fontProperties.descent, maxCharHeight);
-              // Wrap line once full row has been rendered
-              if ((textureGlyphWidth * resolution) + positionX >= lineWidth) {
-                  if (positionX === 0) {
-                      // Avoid infinite loop (There can be some very wide char like '\uFDFD'!)
-                      throw new Error("[BitmapFont] textureWidth " + textureWidth + "px is too small "
-                          + ("(fontFamily: '" + style.fontFamily + "', fontSize: " + style.fontSize + "px, char: '" + character + "')"));
-                  }
-                  --i;
-                  positionY += maxCharHeight * resolution;
-                  positionY = Math.ceil(positionY);
-                  positionX = 0;
-                  maxCharHeight = 0;
-                  continue;
-              }
-              drawGlyph(canvas, context, metrics, positionX, positionY, resolution, style);
-              // Unique (numeric) ID mapping to this glyph
-              var id = extractCharCode(metrics.text);
-              // Create a texture holding just the glyph
-              fontData.char.push({
-                  id: id,
-                  page: textures.length - 1,
-                  x: positionX / resolution,
-                  y: positionY / resolution,
-                  width: textureGlyphWidth,
-                  height: height,
-                  xoffset: 0,
-                  yoffset: 0,
-                  xadvance: Math.ceil(width
-                      - (style.dropShadow ? style.dropShadowDistance : 0)
-                      - (style.stroke ? style.strokeThickness : 0)),
-              });
-              positionX += (textureGlyphWidth + (2 * padding)) * resolution;
-              positionX = Math.ceil(positionX);
-          }
-          if (!(options === null || options === void 0 ? void 0 : options.skipKerning)) {
-              // Brute-force kerning info, this can be expensive b/c it's an O(n²),
-              // but we're using measureText which is native and fast.
-              for (var i = 0, len = charsList.length; i < len; i++) {
-                  var first = charsList[i];
-                  for (var j = 0; j < len; j++) {
-                      var second = charsList[j];
-                      var c1 = context.measureText(first).width;
-                      var c2 = context.measureText(second).width;
-                      var total = context.measureText(first + second).width;
-                      var amount = total - (c1 + c2);
-                      if (amount) {
-                          fontData.kerning.push({
-                              first: extractCharCode(first),
-                              second: extractCharCode(second),
-                              amount: amount,
-                          });
-                      }
-                  }
-              }
-          }
-          var font = new BitmapFont(fontData, textures, true);
-          // Make it easier to replace a font
-          if (BitmapFont.available[name] !== undefined) {
-              BitmapFont.uninstall(name);
-          }
-          BitmapFont.available[name] = font;
-          return font;
-      };
-      /**
-       * This character set includes all the letters in the alphabet (both lower- and upper- case).
-       * @type {string[][]}
-       * @example
-       * BitmapFont.from("ExampleFont", style, { chars: BitmapFont.ALPHA })
-       */
-      BitmapFont.ALPHA = [['a', 'z'], ['A', 'Z'], ' '];
-      /**
-       * This character set includes all decimal digits (from 0 to 9).
-       * @type {string[][]}
-       * @example
-       * BitmapFont.from("ExampleFont", style, { chars: BitmapFont.NUMERIC })
-       */
-      BitmapFont.NUMERIC = [['0', '9']];
-      /**
-       * This character set is the union of `BitmapFont.ALPHA` and `BitmapFont.NUMERIC`.
-       * @type {string[][]}
-       */
-      BitmapFont.ALPHANUMERIC = [['a', 'z'], ['A', 'Z'], ['0', '9'], ' '];
-      /**
-       * This character set consists of all the ASCII table.
-       * @member {string[][]}
-       * @see http://www.asciitable.com/
-       */
-      BitmapFont.ASCII = [[' ', '~']];
-      /**
-       * Collection of default options when using `BitmapFont.from`.
-       * @property {number} [resolution=1] -
-       * @property {number} [textureWidth=512] -
-       * @property {number} [textureHeight=512] -
-       * @property {number} [padding=4] -
-       * @property {string|string[]|string[][]} chars = PIXI.BitmapFont.ALPHANUMERIC
-       */
-      BitmapFont.defaultOptions = {
-          resolution: 1,
-          textureWidth: 512,
-          textureHeight: 512,
-          padding: 4,
-          chars: BitmapFont.ALPHANUMERIC,
-      };
-      /** Collection of available/installed fonts. */
-      BitmapFont.available = {};
-      return BitmapFont;
-  }());
-
-  var msdfFrag = "// Pixi texture info\r\nvarying vec2 vTextureCoord;\r\nuniform sampler2D uSampler;\r\n\r\n// Tint\r\nuniform vec4 uColor;\r\n\r\n// on 2D applications fwidth is screenScale / glyphAtlasScale * distanceFieldRange\r\nuniform float uFWidth;\r\n\r\nvoid main(void) {\r\n\r\n  // To stack MSDF and SDF we need a non-pre-multiplied-alpha texture.\r\n  vec4 texColor = texture2D(uSampler, vTextureCoord);\r\n\r\n  // MSDF\r\n  float median = texColor.r + texColor.g + texColor.b -\r\n                  min(texColor.r, min(texColor.g, texColor.b)) -\r\n                  max(texColor.r, max(texColor.g, texColor.b));\r\n  // SDF\r\n  median = min(median, texColor.a);\r\n\r\n  float screenPxDistance = uFWidth * (median - 0.5);\r\n  float alpha = clamp(screenPxDistance + 0.5, 0.0, 1.0);\r\n  if (median < 0.01) {\r\n    alpha = 0.0;\r\n  } else if (median > 0.99) {\r\n    alpha = 1.0;\r\n  }\r\n\r\n  // NPM Textures, NPM outputs\r\n  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);\r\n\r\n}\r\n";
-
-  var msdfVert = "// Mesh material default fragment\r\nattribute vec2 aVertexPosition;\r\nattribute vec2 aTextureCoord;\r\n\r\nuniform mat3 projectionMatrix;\r\nuniform mat3 translationMatrix;\r\nuniform mat3 uTextureMatrix;\r\n\r\nvarying vec2 vTextureCoord;\r\n\r\nvoid main(void)\r\n{\r\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\r\n\r\n    vTextureCoord = (uTextureMatrix * vec3(aTextureCoord, 1.0)).xy;\r\n}\r\n";
-
-  // If we ever need more than two pools, please make a Dict or something better.
-  var pageMeshDataDefaultPageMeshData = [];
-  var pageMeshDataMSDFPageMeshData = [];
-  var charRenderDataPool = [];
-  /**
-   * A BitmapText object will create a line or multiple lines of text using bitmap font.
-   *
-   * The primary advantage of this class over Text is that all of your textures are pre-generated and loading,
-   * meaning that rendering is fast, and changing text has no performance implications.
-   *
-   * Supporting character sets other than latin, such as CJK languages, may be impractical due to the number of characters.
-   *
-   * To split a line you can use '\n', '\r' or '\r\n' in your string.
-   *
-   * PixiJS can auto-generate fonts on-the-fly using BitmapFont or use fnt files provided by:
-   * http://www.angelcode.com/products/bmfont/ for Windows or
-   * http://www.bmglyph.com/ for Mac.
-   *
-   * You can also use SDF, MSDF and MTSDF BitmapFonts for vector-like scaling appearance provided by:
-   * https://github.com/soimy/msdf-bmfont-xml for SDF and MSDF fnt files or
-   * https://github.com/Chlumsky/msdf-atlas-gen for SDF, MSDF and MTSDF json files
-   *
-   * A BitmapText can only be created when the font is loaded.
-   *
-   * ```js
-   * // in this case the font is in a file called 'desyrel.fnt'
-   * let bitmapText = new PIXI.BitmapText("text using a fancy font!", {
-   *   fontName: "Desyrel",
-   *   fontSize: 35,
-   *   align: "right"
-   * });
-   * ```
-   * @memberof PIXI
-   */
-  var BitmapText = /** @class */ (function (_super) {
-      __extends$8(BitmapText, _super);
-      /**
-       * @param text - A string that you would like the text to display.
-       * @param style - The style parameters.
-       * @param {string} style.fontName - The installed BitmapFont name.
-       * @param {number} [style.fontSize] - The size of the font in pixels, e.g. 24. If undefined,
-       *.     this will default to the BitmapFont size.
-       * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center', 'right' or 'justify'),
-       *      does not affect single line text.
-       * @param {number} [style.tint=0xFFFFFF] - The tint color.
-       * @param {number} [style.letterSpacing=0] - The amount of spacing between letters.
-       * @param {number} [style.maxWidth=0] - The max width of the text before line wrapping.
-       */
-      function BitmapText(text, style) {
-          if (style === void 0) { style = {}; }
-          var _this = _super.call(this) || this;
-          /**
-           * Private tracker for the current tint.
-           * @private
-           */
-          _this._tint = 0xFFFFFF;
-          // Apply the defaults
-          var _a = Object.assign({}, BitmapText.styleDefaults, style), align = _a.align, tint = _a.tint, maxWidth = _a.maxWidth, letterSpacing = _a.letterSpacing, fontName = _a.fontName, fontSize = _a.fontSize;
-          if (!BitmapFont.available[fontName]) {
-              throw new Error("Missing BitmapFont \"" + fontName + "\"");
-          }
-          _this._activePagesMeshData = [];
-          _this._textWidth = 0;
-          _this._textHeight = 0;
-          _this._align = align;
-          _this._tint = tint;
-          _this._font = undefined;
-          _this._fontName = fontName;
-          _this._fontSize = fontSize;
-          _this.text = text;
-          _this._maxWidth = maxWidth;
-          _this._maxLineHeight = 0;
-          _this._letterSpacing = letterSpacing;
-          _this._anchor = new ObservablePoint(function () { _this.dirty = true; }, _this, 0, 0);
-          _this._roundPixels = settings.ROUND_PIXELS;
-          _this.dirty = true;
-          _this._resolution = settings.RESOLUTION;
-          _this._autoResolution = true;
-          _this._textureCache = {};
-          return _this;
-      }
-      /** Renders text and updates it when needed. This should only be called if the BitmapFont is regenerated. */
-      BitmapText.prototype.updateText = function () {
-          var _a;
-          var data = BitmapFont.available[this._fontName];
-          var fontSize = this.fontSize;
-          var scale = fontSize / data.size;
-          var pos = new Point();
-          var chars = [];
-          var lineWidths = [];
-          var lineSpaces = [];
-          var text = this._text.replace(/(?:\r\n|\r)/g, '\n') || ' ';
-          var charsInput = splitTextToCharacters(text);
-          var maxWidth = this._maxWidth * data.size / fontSize;
-          var pageMeshDataPool = data.distanceFieldType === 'none'
-              ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;
-          var prevCharCode = null;
-          var lastLineWidth = 0;
-          var maxLineWidth = 0;
-          var line = 0;
-          var lastBreakPos = -1;
-          var lastBreakWidth = 0;
-          var spacesRemoved = 0;
-          var maxLineHeight = 0;
-          var spaceCount = 0;
-          for (var i = 0; i < charsInput.length; i++) {
-              var char = charsInput[i];
-              var charCode = extractCharCode(char);
-              if ((/(?:\s)/).test(char)) {
-                  lastBreakPos = i;
-                  lastBreakWidth = lastLineWidth;
-                  spaceCount++;
-              }
-              if (char === '\r' || char === '\n') {
-                  lineWidths.push(lastLineWidth);
-                  lineSpaces.push(-1);
-                  maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
-                  ++line;
-                  ++spacesRemoved;
-                  pos.x = 0;
-                  pos.y += data.lineHeight;
-                  prevCharCode = null;
-                  spaceCount = 0;
-                  continue;
-              }
-              var charData = data.chars[charCode];
-              if (!charData) {
-                  continue;
-              }
-              if (prevCharCode && charData.kerning[prevCharCode]) {
-                  pos.x += charData.kerning[prevCharCode];
-              }
-              var charRenderData = charRenderDataPool.pop() || {
-                  texture: Texture.EMPTY,
-                  line: 0,
-                  charCode: 0,
-                  prevSpaces: 0,
-                  position: new Point(),
-              };
-              charRenderData.texture = charData.texture;
-              charRenderData.line = line;
-              charRenderData.charCode = charCode;
-              charRenderData.position.x = pos.x + charData.xOffset + (this._letterSpacing / 2);
-              charRenderData.position.y = pos.y + charData.yOffset;
-              charRenderData.prevSpaces = spaceCount;
-              chars.push(charRenderData);
-              lastLineWidth = charRenderData.position.x
-                  + Math.max(charData.xAdvance - charData.xOffset, charData.texture.orig.width);
-              pos.x += charData.xAdvance + this._letterSpacing;
-              maxLineHeight = Math.max(maxLineHeight, (charData.yOffset + charData.texture.height));
-              prevCharCode = charCode;
-              if (lastBreakPos !== -1 && maxWidth > 0 && pos.x > maxWidth) {
-                  ++spacesRemoved;
-                  removeItems(chars, 1 + lastBreakPos - spacesRemoved, 1 + i - lastBreakPos);
-                  i = lastBreakPos;
-                  lastBreakPos = -1;
-                  lineWidths.push(lastBreakWidth);
-                  lineSpaces.push(chars.length > 0 ? chars[chars.length - 1].prevSpaces : 0);
-                  maxLineWidth = Math.max(maxLineWidth, lastBreakWidth);
-                  line++;
-                  pos.x = 0;
-                  pos.y += data.lineHeight;
-                  prevCharCode = null;
-                  spaceCount = 0;
-              }
-          }
-          var lastChar = charsInput[charsInput.length - 1];
-          if (lastChar !== '\r' && lastChar !== '\n') {
-              if ((/(?:\s)/).test(lastChar)) {
-                  lastLineWidth = lastBreakWidth;
-              }
-              lineWidths.push(lastLineWidth);
-              maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
-              lineSpaces.push(-1);
-          }
-          var lineAlignOffsets = [];
-          for (var i = 0; i <= line; i++) {
-              var alignOffset = 0;
-              if (this._align === 'right') {
-                  alignOffset = maxLineWidth - lineWidths[i];
-              }
-              else if (this._align === 'center') {
-                  alignOffset = (maxLineWidth - lineWidths[i]) / 2;
-              }
-              else if (this._align === 'justify') {
-                  alignOffset = lineSpaces[i] < 0 ? 0 : (maxLineWidth - lineWidths[i]) / lineSpaces[i];
-              }
-              lineAlignOffsets.push(alignOffset);
-          }
-          var lenChars = chars.length;
-          var pagesMeshData = {};
-          var newPagesMeshData = [];
-          var activePagesMeshData = this._activePagesMeshData;
-          pageMeshDataPool.push.apply(pageMeshDataPool, activePagesMeshData);
-          for (var i = 0; i < lenChars; i++) {
-              var texture = chars[i].texture;
-              var baseTextureUid = texture.baseTexture.uid;
-              if (!pagesMeshData[baseTextureUid]) {
-                  var pageMeshData = pageMeshDataPool.pop();
-                  if (!pageMeshData) {
-                      var geometry = new MeshGeometry();
-                      var material = void 0;
-                      var meshBlendMode = void 0;
-                      if (data.distanceFieldType === 'none') {
-                          material = new MeshMaterial(Texture.EMPTY);
-                          meshBlendMode = exports.BLEND_MODES.NORMAL;
-                      }
-                      else {
-                          material = new MeshMaterial(Texture.EMPTY, { program: Program.from(msdfVert, msdfFrag), uniforms: { uFWidth: 0 } });
-                          meshBlendMode = exports.BLEND_MODES.NORMAL_NPM;
-                      }
-                      var mesh = new Mesh(geometry, material);
-                      mesh.blendMode = meshBlendMode;
-                      pageMeshData = {
-                          index: 0,
-                          indexCount: 0,
-                          vertexCount: 0,
-                          uvsCount: 0,
-                          total: 0,
-                          mesh: mesh,
-                          vertices: null,
-                          uvs: null,
-                          indices: null,
-                      };
-                  }
-                  // reset data..
-                  pageMeshData.index = 0;
-                  pageMeshData.indexCount = 0;
-                  pageMeshData.vertexCount = 0;
-                  pageMeshData.uvsCount = 0;
-                  pageMeshData.total = 0;
-                  // TODO need to get page texture here somehow..
-                  var _textureCache = this._textureCache;
-                  _textureCache[baseTextureUid] = _textureCache[baseTextureUid] || new Texture(texture.baseTexture);
-                  pageMeshData.mesh.texture = _textureCache[baseTextureUid];
-                  pageMeshData.mesh.tint = this._tint;
-                  newPagesMeshData.push(pageMeshData);
-                  pagesMeshData[baseTextureUid] = pageMeshData;
-              }
-              pagesMeshData[baseTextureUid].total++;
-          }
-          // lets find any previously active pageMeshDatas that are no longer required for
-          // the updated text (if any), removed and return them to the pool.
-          for (var i = 0; i < activePagesMeshData.length; i++) {
-              if (newPagesMeshData.indexOf(activePagesMeshData[i]) === -1) {
-                  this.removeChild(activePagesMeshData[i].mesh);
-              }
-          }
-          // next lets add any new meshes, that have not yet been added to this BitmapText
-          // we only add if its not already a child of this BitmapObject
-          for (var i = 0; i < newPagesMeshData.length; i++) {
-              if (newPagesMeshData[i].mesh.parent !== this) {
-                  this.addChild(newPagesMeshData[i].mesh);
-              }
-          }
-          // active page mesh datas are set to be the new pages added.
-          this._activePagesMeshData = newPagesMeshData;
-          for (var i in pagesMeshData) {
-              var pageMeshData = pagesMeshData[i];
-              var total = pageMeshData.total;
-              // lets only allocate new buffers if we can fit the new text in the current ones..
-              // unless that is, we will be batching. Currently batching dose not respect the size property of mesh
-              if (!(((_a = pageMeshData.indices) === null || _a === void 0 ? void 0 : _a.length) > 6 * total) || pageMeshData.vertices.length < Mesh.BATCHABLE_SIZE * 2) {
-                  pageMeshData.vertices = new Float32Array(4 * 2 * total);
-                  pageMeshData.uvs = new Float32Array(4 * 2 * total);
-                  pageMeshData.indices = new Uint16Array(6 * total);
-              }
-              else {
-                  var total_1 = pageMeshData.total;
-                  var vertices = pageMeshData.vertices;
-                  // Clear the garbage at the end of the vertices buffer. This will prevent the bounds miscalculation.
-                  for (var i_1 = total_1 * 4 * 2; i_1 < vertices.length; i_1++) {
-                      vertices[i_1] = 0;
-                  }
-              }
-              // as a buffer maybe bigger than the current word, we set the size of the meshMaterial
-              // to match the number of letters needed
-              pageMeshData.mesh.size = 6 * total;
-          }
-          for (var i = 0; i < lenChars; i++) {
-              var char = chars[i];
-              var offset = char.position.x + (lineAlignOffsets[char.line] * (this._align === 'justify' ? char.prevSpaces : 1));
-              if (this._roundPixels) {
-                  offset = Math.round(offset);
-              }
-              var xPos = offset * scale;
-              var yPos = char.position.y * scale;
-              var texture = char.texture;
-              var pageMesh = pagesMeshData[texture.baseTexture.uid];
-              var textureFrame = texture.frame;
-              var textureUvs = texture._uvs;
-              var index = pageMesh.index++;
-              pageMesh.indices[(index * 6) + 0] = 0 + (index * 4);
-              pageMesh.indices[(index * 6) + 1] = 1 + (index * 4);
-              pageMesh.indices[(index * 6) + 2] = 2 + (index * 4);
-              pageMesh.indices[(index * 6) + 3] = 0 + (index * 4);
-              pageMesh.indices[(index * 6) + 4] = 2 + (index * 4);
-              pageMesh.indices[(index * 6) + 5] = 3 + (index * 4);
-              pageMesh.vertices[(index * 8) + 0] = xPos;
-              pageMesh.vertices[(index * 8) + 1] = yPos;
-              pageMesh.vertices[(index * 8) + 2] = xPos + (textureFrame.width * scale);
-              pageMesh.vertices[(index * 8) + 3] = yPos;
-              pageMesh.vertices[(index * 8) + 4] = xPos + (textureFrame.width * scale);
-              pageMesh.vertices[(index * 8) + 5] = yPos + (textureFrame.height * scale);
-              pageMesh.vertices[(index * 8) + 6] = xPos;
-              pageMesh.vertices[(index * 8) + 7] = yPos + (textureFrame.height * scale);
-              pageMesh.uvs[(index * 8) + 0] = textureUvs.x0;
-              pageMesh.uvs[(index * 8) + 1] = textureUvs.y0;
-              pageMesh.uvs[(index * 8) + 2] = textureUvs.x1;
-              pageMesh.uvs[(index * 8) + 3] = textureUvs.y1;
-              pageMesh.uvs[(index * 8) + 4] = textureUvs.x2;
-              pageMesh.uvs[(index * 8) + 5] = textureUvs.y2;
-              pageMesh.uvs[(index * 8) + 6] = textureUvs.x3;
-              pageMesh.uvs[(index * 8) + 7] = textureUvs.y3;
-          }
-          this._textWidth = maxLineWidth * scale;
-          this._textHeight = (pos.y + data.lineHeight) * scale;
-          for (var i in pagesMeshData) {
-              var pageMeshData = pagesMeshData[i];
-              // apply anchor
-              if (this.anchor.x !== 0 || this.anchor.y !== 0) {
-                  var vertexCount = 0;
-                  var anchorOffsetX = this._textWidth * this.anchor.x;
-                  var anchorOffsetY = this._textHeight * this.anchor.y;
-                  for (var i_2 = 0; i_2 < pageMeshData.total; i_2++) {
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetX;
-                      pageMeshData.vertices[vertexCount++] -= anchorOffsetY;
-                  }
-              }
-              this._maxLineHeight = maxLineHeight * scale;
-              var vertexBuffer = pageMeshData.mesh.geometry.getBuffer('aVertexPosition');
-              var textureBuffer = pageMeshData.mesh.geometry.getBuffer('aTextureCoord');
-              var indexBuffer = pageMeshData.mesh.geometry.getIndex();
-              vertexBuffer.data = pageMeshData.vertices;
-              textureBuffer.data = pageMeshData.uvs;
-              indexBuffer.data = pageMeshData.indices;
-              vertexBuffer.update();
-              textureBuffer.update();
-              indexBuffer.update();
-          }
-          for (var i = 0; i < chars.length; i++) {
-              charRenderDataPool.push(chars[i]);
-          }
-          this._font = data;
-          this.dirty = false;
-      };
-      BitmapText.prototype.updateTransform = function () {
-          this.validate();
-          this.containerUpdateTransform();
-      };
-      BitmapText.prototype._render = function (renderer) {
-          if (this._autoResolution && this._resolution !== renderer.resolution) {
-              this._resolution = renderer.resolution;
-              this.dirty = true;
-          }
-          // Update the uniform
-          var _a = BitmapFont.available[this._fontName], distanceFieldRange = _a.distanceFieldRange, distanceFieldType = _a.distanceFieldType, size = _a.size;
-          if (distanceFieldType !== 'none') {
-              // Inject the shader code with the correct value
-              var _b = this.worldTransform, a = _b.a, b = _b.b, c = _b.c, d = _b.d;
-              var dx = Math.sqrt((a * a) + (b * b));
-              var dy = Math.sqrt((c * c) + (d * d));
-              var worldScale = (Math.abs(dx) + Math.abs(dy)) / 2;
-              var fontScale = this.fontSize / size;
-              for (var _i = 0, _c = this._activePagesMeshData; _i < _c.length; _i++) {
-                  var mesh = _c[_i];
-                  mesh.mesh.shader.uniforms.uFWidth = worldScale * distanceFieldRange * fontScale * this._resolution;
-              }
-          }
-          _super.prototype._render.call(this, renderer);
-      };
-      /**
-       * Validates text before calling parent's getLocalBounds
-       * @returns - The rectangular bounding area
-       */
-      BitmapText.prototype.getLocalBounds = function () {
-          this.validate();
-          return _super.prototype.getLocalBounds.call(this);
-      };
-      /**
-       * Updates text when needed
-       * @private
-       */
-      BitmapText.prototype.validate = function () {
-          var font = BitmapFont.available[this._fontName];
-          if (!font) {
-              throw new Error("Missing BitmapFont \"" + this._fontName + "\"");
-          }
-          if (this._font !== font) {
-              this.dirty = true;
-          }
-          if (this.dirty) {
-              this.updateText();
-          }
-      };
-      Object.defineProperty(BitmapText.prototype, "tint", {
-          /**
-           * The tint of the BitmapText object.
-           * @default 0xffffff
-           */
-          get: function () {
-              return this._tint;
-          },
-          set: function (value) {
-              if (this._tint === value)
-                  { return; }
-              this._tint = value;
-              for (var i = 0; i < this._activePagesMeshData.length; i++) {
-                  this._activePagesMeshData[i].mesh.tint = value;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "align", {
-          /**
-           * The alignment of the BitmapText object.
-           * @member {string}
-           * @default 'left'
-           */
-          get: function () {
-              return this._align;
-          },
-          set: function (value) {
-              if (this._align !== value) {
-                  this._align = value;
-                  this.dirty = true;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "fontName", {
-          /** The name of the BitmapFont. */
-          get: function () {
-              return this._fontName;
-          },
-          set: function (value) {
-              if (!BitmapFont.available[value]) {
-                  throw new Error("Missing BitmapFont \"" + value + "\"");
-              }
-              if (this._fontName !== value) {
-                  this._fontName = value;
-                  this.dirty = true;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "fontSize", {
-          /** The size of the font to display. */
-          get: function () {
-              var _a;
-              return (_a = this._fontSize) !== null && _a !== void 0 ? _a : BitmapFont.available[this._fontName].size;
-          },
-          set: function (value) {
-              if (this._fontSize !== value) {
-                  this._fontSize = value;
-                  this.dirty = true;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "anchor", {
-          /**
-           * The anchor sets the origin point of the text.
-           *
-           * The default is `(0,0)`, this means the text's origin is the top left.
-           *
-           * Setting the anchor to `(0.5,0.5)` means the text's origin is centered.
-           *
-           * Setting the anchor to `(1,1)` would mean the text's origin point will be the bottom right corner.
-           */
-          get: function () {
-              return this._anchor;
-          },
-          set: function (value) {
-              if (typeof value === 'number') {
-                  this._anchor.set(value);
-              }
-              else {
-                  this._anchor.copyFrom(value);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "text", {
-          /** The text of the BitmapText object. */
-          get: function () {
-              return this._text;
-          },
-          set: function (text) {
-              text = String(text === null || text === undefined ? '' : text);
-              if (this._text === text) {
-                  return;
-              }
-              this._text = text;
-              this.dirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "maxWidth", {
-          /**
-           * The max width of this bitmap text in pixels. If the text provided is longer than the
-           * value provided, line breaks will be automatically inserted in the last whitespace.
-           * Disable by setting the value to 0.
-           */
-          get: function () {
-              return this._maxWidth;
-          },
-          set: function (value) {
-              if (this._maxWidth === value) {
-                  return;
-              }
-              this._maxWidth = value;
-              this.dirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "maxLineHeight", {
-          /**
-           * The max line height. This is useful when trying to use the total height of the Text,
-           * i.e. when trying to vertically align.
-           * @readonly
-           */
-          get: function () {
-              this.validate();
-              return this._maxLineHeight;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "textWidth", {
-          /**
-           * The width of the overall text, different from fontSize,
-           * which is defined in the style object.
-           * @readonly
-           */
-          get: function () {
-              this.validate();
-              return this._textWidth;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "letterSpacing", {
-          /** Additional space between characters. */
-          get: function () {
-              return this._letterSpacing;
-          },
-          set: function (value) {
-              if (this._letterSpacing !== value) {
-                  this._letterSpacing = value;
-                  this.dirty = true;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "roundPixels", {
-          /**
-           * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.
-           * Advantages can include sharper image quality (like text) and faster rendering on canvas.
-           * The main disadvantage is movement of objects may appear less smooth.
-           * To set the global default, change {@link PIXI.settings.ROUND_PIXELS}
-           * @default PIXI.settings.ROUND_PIXELS
-           */
-          get: function () {
-              return this._roundPixels;
-          },
-          set: function (value) {
-              if (value !== this._roundPixels) {
-                  this._roundPixels = value;
-                  this.dirty = true;
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "textHeight", {
-          /**
-           * The height of the overall text, different from fontSize,
-           * which is defined in the style object.
-           * @readonly
-           */
-          get: function () {
-              this.validate();
-              return this._textHeight;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BitmapText.prototype, "resolution", {
-          /**
-           * The resolution / device pixel ratio of the canvas.
-           *
-           * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.
-           * @default 1
-           */
-          get: function () {
-              return this._resolution;
-          },
-          set: function (value) {
-              this._autoResolution = false;
-              if (this._resolution === value) {
-                  return;
-              }
-              this._resolution = value;
-              this.dirty = true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      BitmapText.prototype.destroy = function (options) {
-          var _textureCache = this._textureCache;
-          var data = BitmapFont.available[this._fontName];
-          var pageMeshDataPool = data.distanceFieldType === 'none'
-              ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;
-          pageMeshDataPool.push.apply(pageMeshDataPool, this._activePagesMeshData);
-          for (var _i = 0, _a = this._activePagesMeshData; _i < _a.length; _i++) {
-              var pageMeshData = _a[_i];
-              this.removeChild(pageMeshData.mesh);
-          }
-          this._activePagesMeshData = [];
-          // Release references to any cached textures in page pool
-          pageMeshDataPool
-              .filter(function (page) { return _textureCache[page.mesh.texture.baseTexture.uid]; })
-              .forEach(function (page) {
-              page.mesh.texture = Texture.EMPTY;
-          });
-          for (var id in _textureCache) {
-              var texture = _textureCache[id];
-              texture.destroy();
-              delete _textureCache[id];
-          }
-          this._font = null;
-          this._textureCache = null;
-          _super.prototype.destroy.call(this, options);
-      };
-      BitmapText.styleDefaults = {
-          align: 'left',
-          tint: 0xFFFFFF,
-          maxWidth: 0,
-          letterSpacing: 0,
-      };
-      return BitmapText;
-  }(Container));
-
-  /**
-   * {@link PIXI.Loader Loader} middleware for loading
-   * bitmap-based fonts suitable for using with {@link PIXI.BitmapText}.
-   * @memberof PIXI
-   */
-  var BitmapFontLoader = /** @class */ (function () {
-      function BitmapFontLoader() {
-      }
-      /**
-       * Called when the plugin is installed.
-       * @see PIXI.extensions.add
-       */
-      BitmapFontLoader.add = function () {
-          exports.LoaderResource.setExtensionXhrType('fnt', exports.LoaderResource.XHR_RESPONSE_TYPE.TEXT);
-      };
-      /**
-       * Called after a resource is loaded.
-       * @see PIXI.Loader.loaderMiddleware
-       * @param this
-       * @param {PIXI.LoaderResource} resource
-       * @param {Function} next
-       */
-      BitmapFontLoader.use = function (resource, next) {
-          var format = autoDetectFormat(resource.data);
-          // Resource was not recognised as any of the expected font data format
-          if (!format) {
-              next();
-              return;
-          }
-          var baseUrl = BitmapFontLoader.getBaseUrl(this, resource);
-          var data = format.parse(resource.data);
-          var textures = {};
-          // Handle completed, when the number of textures
-          // load is the same number as references in the fnt file
-          var completed = function (page) {
-              textures[page.metadata.pageFile] = page.texture;
-              if (Object.keys(textures).length === data.page.length) {
-                  resource.bitmapFont = BitmapFont.install(data, textures, true);
-                  next();
-              }
-          };
-          for (var i = 0; i < data.page.length; ++i) {
-              var pageFile = data.page[i].file;
-              var url = baseUrl + pageFile;
-              var exists = false;
-              // incase the image is loaded outside
-              // using the same loader, resource will be available
-              for (var name in this.resources) {
-                  var bitmapResource = this.resources[name];
-                  if (bitmapResource.url === url) {
-                      bitmapResource.metadata.pageFile = pageFile;
-                      if (bitmapResource.texture) {
-                          completed(bitmapResource);
-                      }
-                      else {
-                          bitmapResource.onAfterMiddleware.add(completed);
-                      }
-                      exists = true;
-                      break;
-                  }
-              }
-              // texture is not loaded, we'll attempt to add
-              // it to the load and add the texture to the list
-              if (!exists) {
-                  // Standard loading options for images
-                  var options = {
-                      crossOrigin: resource.crossOrigin,
-                      loadType: exports.LoaderResource.LOAD_TYPE.IMAGE,
-                      metadata: Object.assign({ pageFile: pageFile }, resource.metadata.imageMetadata),
-                      parentResource: resource,
-                  };
-                  this.add(url, options, completed);
-              }
-          }
-      };
-      /**
-       * Get folder path from a resource.
-       * @param loader
-       * @param resource
-       */
-      BitmapFontLoader.getBaseUrl = function (loader, resource) {
-          var resUrl = !resource.isDataUrl ? BitmapFontLoader.dirname(resource.url) : '';
-          if (resource.isDataUrl) {
-              if (resUrl === '.') {
-                  resUrl = '';
-              }
-              if (loader.baseUrl && resUrl) {
-                  // if baseurl has a trailing slash then add one to resUrl so the replace works below
-                  if (loader.baseUrl.charAt(loader.baseUrl.length - 1) === '/') {
-                      resUrl += '/';
-                  }
-              }
-          }
-          // remove baseUrl from resUrl
-          resUrl = resUrl.replace(loader.baseUrl, '');
-          // if there is an resUrl now, it needs a trailing slash. Ensure that it does if the string isn't empty.
-          if (resUrl && resUrl.charAt(resUrl.length - 1) !== '/') {
-              resUrl += '/';
-          }
-          return resUrl;
-      };
-      /**
-       * Replacement for NodeJS's path.dirname
-       * @param {string} url - Path to get directory for
-       */
-      BitmapFontLoader.dirname = function (url) {
-          var dir = url
-              .replace(/\\/g, '/') // convert windows notation to UNIX notation, URL-safe because it's a forbidden character
-              .replace(/\/$/, '') // replace trailing slash
-              .replace(/\/[^\/]*$/, ''); // remove everything after the last
-          // File request is relative, use current directory
-          if (dir === url) {
-              return '.';
-          }
-          // Started with a slash
-          else if (dir === '') {
-              return '/';
-          }
-          return dir;
-      };
-      /** @ignore */
-      BitmapFontLoader.extension = exports.ExtensionType.Loader;
-      return BitmapFontLoader;
-  }());
-
-  /*!
-   * @pixi/filter-alpha - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/filter-alpha is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$7 = function(d, b) {
-      extendStatics$7 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$7(d, b);
-  };
-
-  function __extends$7(d, b) {
-      extendStatics$7(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var fragment$4 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform float uAlpha;\n\nvoid main(void)\n{\n   gl_FragColor = texture2D(uSampler, vTextureCoord) * uAlpha;\n}\n";
-
-  /**
-   * Simplest filter - applies alpha.
-   *
-   * Use this instead of Container's alpha property to avoid visual layering of individual elements.
-   * AlphaFilter applies alpha evenly across the entire display object and any opaque elements it contains.
-   * If elements are not opaque, they will blend with each other anyway.
-   *
-   * Very handy if you want to use common features of all filters:
-   *
-   * 1. Assign a blendMode to this filter, blend all elements inside display object with background.
-   *
-   * 2. To use clipping in display coordinates, assign a filterArea to the same container that has this filter.
-   * @memberof PIXI.filters
-   */
-  var AlphaFilter = /** @class */ (function (_super) {
-      __extends$7(AlphaFilter, _super);
-      /**
-       * @param alpha - Amount of alpha from 0 to 1, where 0 is transparent
-       */
-      function AlphaFilter(alpha) {
-          if (alpha === void 0) { alpha = 1.0; }
-          var _this = _super.call(this, defaultVertex$1, fragment$4, { uAlpha: 1 }) || this;
-          _this.alpha = alpha;
-          return _this;
-      }
-      Object.defineProperty(AlphaFilter.prototype, "alpha", {
-          /**
-           * Coefficient for alpha multiplication
-           * @default 1
-           */
-          get: function () {
-              return this.uniforms.uAlpha;
-          },
-          set: function (value) {
-              this.uniforms.uAlpha = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return AlphaFilter;
-  }(Filter));
-
-  /*!
-   * @pixi/filter-blur - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/filter-blur is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$6 = function(d, b) {
-      extendStatics$6 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$6(d, b);
-  };
-
-  function __extends$6(d, b) {
-      extendStatics$6(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var vertTemplate = "\n    attribute vec2 aVertexPosition;\n\n    uniform mat3 projectionMatrix;\n\n    uniform float strength;\n\n    varying vec2 vBlurTexCoords[%size%];\n\n    uniform vec4 inputSize;\n    uniform vec4 outputFrame;\n\n    vec4 filterVertexPosition( void )\n    {\n        vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n        return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n    }\n\n    vec2 filterTextureCoord( void )\n    {\n        return aVertexPosition * (outputFrame.zw * inputSize.zw);\n    }\n\n    void main(void)\n    {\n        gl_Position = filterVertexPosition();\n\n        vec2 textureCoord = filterTextureCoord();\n        %blur%\n    }";
-  function generateBlurVertSource(kernelSize, x) {
-      var halfLength = Math.ceil(kernelSize / 2);
-      var vertSource = vertTemplate;
-      var blurLoop = '';
-      var template;
-      if (x) {
-          template = 'vBlurTexCoords[%index%] =  textureCoord + vec2(%sampleIndex% * strength, 0.0);';
-      }
-      else {
-          template = 'vBlurTexCoords[%index%] =  textureCoord + vec2(0.0, %sampleIndex% * strength);';
-      }
-      for (var i = 0; i < kernelSize; i++) {
-          var blur = template.replace('%index%', i.toString());
-          blur = blur.replace('%sampleIndex%', i - (halfLength - 1) + ".0");
-          blurLoop += blur;
-          blurLoop += '\n';
-      }
-      vertSource = vertSource.replace('%blur%', blurLoop);
-      vertSource = vertSource.replace('%size%', kernelSize.toString());
-      return vertSource;
-  }
-
-  var GAUSSIAN_VALUES = {
-      5: [0.153388, 0.221461, 0.250301],
-      7: [0.071303, 0.131514, 0.189879, 0.214607],
-      9: [0.028532, 0.067234, 0.124009, 0.179044, 0.20236],
-      11: [0.0093, 0.028002, 0.065984, 0.121703, 0.175713, 0.198596],
-      13: [0.002406, 0.009255, 0.027867, 0.065666, 0.121117, 0.174868, 0.197641],
-      15: [0.000489, 0.002403, 0.009246, 0.02784, 0.065602, 0.120999, 0.174697, 0.197448],
-  };
-  var fragTemplate = [
-      'varying vec2 vBlurTexCoords[%size%];',
-      'uniform sampler2D uSampler;',
-      'void main(void)',
-      '{',
-      '    gl_FragColor = vec4(0.0);',
-      '    %blur%',
-      '}' ].join('\n');
-  function generateBlurFragSource(kernelSize) {
-      var kernel = GAUSSIAN_VALUES[kernelSize];
-      var halfLength = kernel.length;
-      var fragSource = fragTemplate;
-      var blurLoop = '';
-      var template = 'gl_FragColor += texture2D(uSampler, vBlurTexCoords[%index%]) * %value%;';
-      var value;
-      for (var i = 0; i < kernelSize; i++) {
-          var blur = template.replace('%index%', i.toString());
-          value = i;
-          if (i >= halfLength) {
-              value = kernelSize - i - 1;
-          }
-          blur = blur.replace('%value%', kernel[value].toString());
-          blurLoop += blur;
-          blurLoop += '\n';
-      }
-      fragSource = fragSource.replace('%blur%', blurLoop);
-      fragSource = fragSource.replace('%size%', kernelSize.toString());
-      return fragSource;
-  }
-
-  /**
-   * The BlurFilterPass applies a horizontal or vertical Gaussian blur to an object.
-   * @memberof PIXI.filters
-   */
-  var BlurFilterPass = /** @class */ (function (_super) {
-      __extends$6(BlurFilterPass, _super);
-      /**
-       * @param horizontal - Do pass along the x-axis (`true`) or y-axis (`false`).
-       * @param strength - The strength of the blur filter.
-       * @param quality - The quality of the blur filter.
-       * @param resolution - The resolution of the blur filter.
-       * @param kernelSize - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.
-       */
-      function BlurFilterPass(horizontal, strength, quality, resolution, kernelSize) {
-          if (strength === void 0) { strength = 8; }
-          if (quality === void 0) { quality = 4; }
-          if (resolution === void 0) { resolution = settings.FILTER_RESOLUTION; }
-          if (kernelSize === void 0) { kernelSize = 5; }
-          var _this = this;
-          var vertSrc = generateBlurVertSource(kernelSize, horizontal);
-          var fragSrc = generateBlurFragSource(kernelSize);
-          _this = _super.call(this, 
-          // vertex shader
-          vertSrc, 
-          // fragment shader
-          fragSrc) || this;
-          _this.horizontal = horizontal;
-          _this.resolution = resolution;
-          _this._quality = 0;
-          _this.quality = quality;
-          _this.blur = strength;
-          return _this;
-      }
-      /**
-       * Applies the filter.
-       * @param filterManager - The manager.
-       * @param input - The input target.
-       * @param output - The output target.
-       * @param clearMode - How to clear
-       */
-      BlurFilterPass.prototype.apply = function (filterManager, input, output, clearMode) {
-          if (output) {
-              if (this.horizontal) {
-                  this.uniforms.strength = (1 / output.width) * (output.width / input.width);
-              }
-              else {
-                  this.uniforms.strength = (1 / output.height) * (output.height / input.height);
-              }
-          }
-          else {
-              if (this.horizontal) // eslint-disable-line
-               {
-                  this.uniforms.strength = (1 / filterManager.renderer.width) * (filterManager.renderer.width / input.width);
-              }
-              else {
-                  this.uniforms.strength = (1 / filterManager.renderer.height) * (filterManager.renderer.height / input.height); // eslint-disable-line
-              }
-          }
-          // screen space!
-          this.uniforms.strength *= this.strength;
-          this.uniforms.strength /= this.passes;
-          if (this.passes === 1) {
-              filterManager.applyFilter(this, input, output, clearMode);
-          }
-          else {
-              var renderTarget = filterManager.getFilterTexture();
-              var renderer = filterManager.renderer;
-              var flip = input;
-              var flop = renderTarget;
-              this.state.blend = false;
-              filterManager.applyFilter(this, flip, flop, exports.CLEAR_MODES.CLEAR);
-              for (var i = 1; i < this.passes - 1; i++) {
-                  filterManager.bindAndClear(flip, exports.CLEAR_MODES.BLIT);
-                  this.uniforms.uSampler = flop;
-                  var temp = flop;
-                  flop = flip;
-                  flip = temp;
-                  renderer.shader.bind(this);
-                  renderer.geometry.draw(5);
-              }
-              this.state.blend = true;
-              filterManager.applyFilter(this, flop, output, clearMode);
-              filterManager.returnFilterTexture(renderTarget);
-          }
-      };
-      Object.defineProperty(BlurFilterPass.prototype, "blur", {
-          /**
-           * Sets the strength of both the blur.
-           * @default 16
-           */
-          get: function () {
-              return this.strength;
-          },
-          set: function (value) {
-              this.padding = 1 + (Math.abs(value) * 2);
-              this.strength = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BlurFilterPass.prototype, "quality", {
-          /**
-           * Sets the quality of the blur by modifying the number of passes. More passes means higher
-           * quality bluring but the lower the performance.
-           * @default 4
-           */
-          get: function () {
-              return this._quality;
-          },
-          set: function (value) {
-              this._quality = value;
-              this.passes = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return BlurFilterPass;
-  }(Filter));
-
-  /**
-   * The BlurFilter applies a Gaussian blur to an object.
-   *
-   * The strength of the blur can be set for the x-axis and y-axis separately.
-   * @memberof PIXI.filters
-   */
-  var BlurFilter = /** @class */ (function (_super) {
-      __extends$6(BlurFilter, _super);
-      /**
-       * @param strength - The strength of the blur filter.
-       * @param quality - The quality of the blur filter.
-       * @param [resolution=PIXI.settings.FILTER_RESOLUTION] - The resolution of the blur filter.
-       * @param kernelSize - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.
-       */
-      function BlurFilter(strength, quality, resolution, kernelSize) {
-          if (strength === void 0) { strength = 8; }
-          if (quality === void 0) { quality = 4; }
-          if (resolution === void 0) { resolution = settings.FILTER_RESOLUTION; }
-          if (kernelSize === void 0) { kernelSize = 5; }
-          var _this = _super.call(this) || this;
-          _this.blurXFilter = new BlurFilterPass(true, strength, quality, resolution, kernelSize);
-          _this.blurYFilter = new BlurFilterPass(false, strength, quality, resolution, kernelSize);
-          _this.resolution = resolution;
-          _this.quality = quality;
-          _this.blur = strength;
-          _this.repeatEdgePixels = false;
-          return _this;
-      }
-      /**
-       * Applies the filter.
-       * @param filterManager - The manager.
-       * @param input - The input target.
-       * @param output - The output target.
-       * @param clearMode - How to clear
-       */
-      BlurFilter.prototype.apply = function (filterManager, input, output, clearMode) {
-          var xStrength = Math.abs(this.blurXFilter.strength);
-          var yStrength = Math.abs(this.blurYFilter.strength);
-          if (xStrength && yStrength) {
-              var renderTarget = filterManager.getFilterTexture();
-              this.blurXFilter.apply(filterManager, input, renderTarget, exports.CLEAR_MODES.CLEAR);
-              this.blurYFilter.apply(filterManager, renderTarget, output, clearMode);
-              filterManager.returnFilterTexture(renderTarget);
-          }
-          else if (yStrength) {
-              this.blurYFilter.apply(filterManager, input, output, clearMode);
-          }
-          else {
-              this.blurXFilter.apply(filterManager, input, output, clearMode);
-          }
-      };
-      BlurFilter.prototype.updatePadding = function () {
-          if (this._repeatEdgePixels) {
-              this.padding = 0;
-          }
-          else {
-              this.padding = Math.max(Math.abs(this.blurXFilter.strength), Math.abs(this.blurYFilter.strength)) * 2;
-          }
-      };
-      Object.defineProperty(BlurFilter.prototype, "blur", {
-          /**
-           * Sets the strength of both the blurX and blurY properties simultaneously
-           * @default 2
-           */
-          get: function () {
-              return this.blurXFilter.blur;
-          },
-          set: function (value) {
-              this.blurXFilter.blur = this.blurYFilter.blur = value;
-              this.updatePadding();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BlurFilter.prototype, "quality", {
-          /**
-           * Sets the number of passes for blur. More passes means higher quality bluring.
-           * @default 1
-           */
-          get: function () {
-              return this.blurXFilter.quality;
-          },
-          set: function (value) {
-              this.blurXFilter.quality = this.blurYFilter.quality = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BlurFilter.prototype, "blurX", {
-          /**
-           * Sets the strength of the blurX property
-           * @default 2
-           */
-          get: function () {
-              return this.blurXFilter.blur;
-          },
-          set: function (value) {
-              this.blurXFilter.blur = value;
-              this.updatePadding();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BlurFilter.prototype, "blurY", {
-          /**
-           * Sets the strength of the blurY property
-           * @default 2
-           */
-          get: function () {
-              return this.blurYFilter.blur;
-          },
-          set: function (value) {
-              this.blurYFilter.blur = value;
-              this.updatePadding();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BlurFilter.prototype, "blendMode", {
-          /**
-           * Sets the blendmode of the filter
-           * @default PIXI.BLEND_MODES.NORMAL
-           */
-          get: function () {
-              return this.blurYFilter.blendMode;
-          },
-          set: function (value) {
-              this.blurYFilter.blendMode = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(BlurFilter.prototype, "repeatEdgePixels", {
-          /**
-           * If set to true the edge of the target will be clamped
-           * @default false
-           */
-          get: function () {
-              return this._repeatEdgePixels;
-          },
-          set: function (value) {
-              this._repeatEdgePixels = value;
-              this.updatePadding();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return BlurFilter;
-  }(Filter));
-
-  /*!
-   * @pixi/filter-color-matrix - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/filter-color-matrix is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$5 = function(d, b) {
-      extendStatics$5 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$5(d, b);
-  };
-
-  function __extends$5(d, b) {
-      extendStatics$5(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var fragment$3 = "varying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float m[20];\nuniform float uAlpha;\n\nvoid main(void)\n{\n    vec4 c = texture2D(uSampler, vTextureCoord);\n\n    if (uAlpha == 0.0) {\n        gl_FragColor = c;\n        return;\n    }\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (c.a > 0.0) {\n      c.rgb /= c.a;\n    }\n\n    vec4 result;\n\n    result.r = (m[0] * c.r);\n        result.r += (m[1] * c.g);\n        result.r += (m[2] * c.b);\n        result.r += (m[3] * c.a);\n        result.r += m[4];\n\n    result.g = (m[5] * c.r);\n        result.g += (m[6] * c.g);\n        result.g += (m[7] * c.b);\n        result.g += (m[8] * c.a);\n        result.g += m[9];\n\n    result.b = (m[10] * c.r);\n       result.b += (m[11] * c.g);\n       result.b += (m[12] * c.b);\n       result.b += (m[13] * c.a);\n       result.b += m[14];\n\n    result.a = (m[15] * c.r);\n       result.a += (m[16] * c.g);\n       result.a += (m[17] * c.b);\n       result.a += (m[18] * c.a);\n       result.a += m[19];\n\n    vec3 rgb = mix(c.rgb, result.rgb, uAlpha);\n\n    // Premultiply alpha again.\n    rgb *= result.a;\n\n    gl_FragColor = vec4(rgb, result.a);\n}\n";
-
-  /**
-   * The ColorMatrixFilter class lets you apply a 5x4 matrix transformation on the RGBA
-   * color and alpha values of every pixel on your displayObject to produce a result
-   * with a new set of RGBA color and alpha values. It's pretty powerful!
-   *
-   * ```js
-   *  let colorMatrix = new PIXI.filters.ColorMatrixFilter();
-   *  container.filters = [colorMatrix];
-   *  colorMatrix.contrast(2);
-   * ```
-   * @author Clément Chenebault <clement@goodboydigital.com>
-   * @memberof PIXI.filters
-   */
-  var ColorMatrixFilter = /** @class */ (function (_super) {
-      __extends$5(ColorMatrixFilter, _super);
-      function ColorMatrixFilter() {
-          var _this = this;
-          var uniforms = {
-              m: new Float32Array([1, 0, 0, 0, 0,
-                  0, 1, 0, 0, 0,
-                  0, 0, 1, 0, 0,
-                  0, 0, 0, 1, 0]),
-              uAlpha: 1,
-          };
-          _this = _super.call(this, defaultFilterVertex, fragment$3, uniforms) || this;
-          _this.alpha = 1;
-          return _this;
-      }
-      /**
-       * Transforms current matrix and set the new one
-       * @param {number[]} matrix - 5x4 matrix
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype._loadMatrix = function (matrix, multiply) {
-          if (multiply === void 0) { multiply = false; }
-          var newMatrix = matrix;
-          if (multiply) {
-              this._multiply(newMatrix, this.uniforms.m, matrix);
-              newMatrix = this._colorMatrix(newMatrix);
-          }
-          // set the new matrix
-          this.uniforms.m = newMatrix;
-      };
-      /**
-       * Multiplies two mat5's
-       * @private
-       * @param out - 5x4 matrix the receiving matrix
-       * @param a - 5x4 matrix the first operand
-       * @param b - 5x4 matrix the second operand
-       * @returns {number[]} 5x4 matrix
-       */
-      ColorMatrixFilter.prototype._multiply = function (out, a, b) {
-          // Red Channel
-          out[0] = (a[0] * b[0]) + (a[1] * b[5]) + (a[2] * b[10]) + (a[3] * b[15]);
-          out[1] = (a[0] * b[1]) + (a[1] * b[6]) + (a[2] * b[11]) + (a[3] * b[16]);
-          out[2] = (a[0] * b[2]) + (a[1] * b[7]) + (a[2] * b[12]) + (a[3] * b[17]);
-          out[3] = (a[0] * b[3]) + (a[1] * b[8]) + (a[2] * b[13]) + (a[3] * b[18]);
-          out[4] = (a[0] * b[4]) + (a[1] * b[9]) + (a[2] * b[14]) + (a[3] * b[19]) + a[4];
-          // Green Channel
-          out[5] = (a[5] * b[0]) + (a[6] * b[5]) + (a[7] * b[10]) + (a[8] * b[15]);
-          out[6] = (a[5] * b[1]) + (a[6] * b[6]) + (a[7] * b[11]) + (a[8] * b[16]);
-          out[7] = (a[5] * b[2]) + (a[6] * b[7]) + (a[7] * b[12]) + (a[8] * b[17]);
-          out[8] = (a[5] * b[3]) + (a[6] * b[8]) + (a[7] * b[13]) + (a[8] * b[18]);
-          out[9] = (a[5] * b[4]) + (a[6] * b[9]) + (a[7] * b[14]) + (a[8] * b[19]) + a[9];
-          // Blue Channel
-          out[10] = (a[10] * b[0]) + (a[11] * b[5]) + (a[12] * b[10]) + (a[13] * b[15]);
-          out[11] = (a[10] * b[1]) + (a[11] * b[6]) + (a[12] * b[11]) + (a[13] * b[16]);
-          out[12] = (a[10] * b[2]) + (a[11] * b[7]) + (a[12] * b[12]) + (a[13] * b[17]);
-          out[13] = (a[10] * b[3]) + (a[11] * b[8]) + (a[12] * b[13]) + (a[13] * b[18]);
-          out[14] = (a[10] * b[4]) + (a[11] * b[9]) + (a[12] * b[14]) + (a[13] * b[19]) + a[14];
-          // Alpha Channel
-          out[15] = (a[15] * b[0]) + (a[16] * b[5]) + (a[17] * b[10]) + (a[18] * b[15]);
-          out[16] = (a[15] * b[1]) + (a[16] * b[6]) + (a[17] * b[11]) + (a[18] * b[16]);
-          out[17] = (a[15] * b[2]) + (a[16] * b[7]) + (a[17] * b[12]) + (a[18] * b[17]);
-          out[18] = (a[15] * b[3]) + (a[16] * b[8]) + (a[17] * b[13]) + (a[18] * b[18]);
-          out[19] = (a[15] * b[4]) + (a[16] * b[9]) + (a[17] * b[14]) + (a[18] * b[19]) + a[19];
-          return out;
-      };
-      /**
-       * Create a Float32 Array and normalize the offset component to 0-1
-       * @param {number[]} matrix - 5x4 matrix
-       * @returns {number[]} 5x4 matrix with all values between 0-1
-       */
-      ColorMatrixFilter.prototype._colorMatrix = function (matrix) {
-          // Create a Float32 Array and normalize the offset component to 0-1
-          var m = new Float32Array(matrix);
-          m[4] /= 255;
-          m[9] /= 255;
-          m[14] /= 255;
-          m[19] /= 255;
-          return m;
-      };
-      /**
-       * Adjusts brightness
-       * @param b - value of the brigthness (0-1, where 0 is black)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.brightness = function (b, multiply) {
-          var matrix = [
-              b, 0, 0, 0, 0,
-              0, b, 0, 0, 0,
-              0, 0, b, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Sets each channel on the diagonal of the color matrix.
-       * This can be used to achieve a tinting effect on Containers similar to the tint field of some
-       * display objects like Sprite, Text, Graphics, and Mesh.
-       * @param color - Color of the tint. This is a hex value.
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.tint = function (color, multiply) {
-          var r = (color >> 16) & 0xff;
-          var g = (color >> 8) & 0xff;
-          var b = color & 0xff;
-          var matrix = [
-              r / 255, 0, 0, 0, 0,
-              0, g / 255, 0, 0, 0,
-              0, 0, b / 255, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Set the matrices in grey scales
-       * @param scale - value of the grey (0-1, where 0 is black)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.greyscale = function (scale, multiply) {
-          var matrix = [
-              scale, scale, scale, 0, 0,
-              scale, scale, scale, 0, 0,
-              scale, scale, scale, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Set the black and white matrice.
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.blackAndWhite = function (multiply) {
-          var matrix = [
-              0.3, 0.6, 0.1, 0, 0,
-              0.3, 0.6, 0.1, 0, 0,
-              0.3, 0.6, 0.1, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Set the hue property of the color
-       * @param rotation - in degrees
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.hue = function (rotation, multiply) {
-          rotation = (rotation || 0) / 180 * Math.PI;
-          var cosR = Math.cos(rotation);
-          var sinR = Math.sin(rotation);
-          var sqrt = Math.sqrt;
-          /* a good approximation for hue rotation
-           This matrix is far better than the versions with magic luminance constants
-           formerly used here, but also used in the starling framework (flash) and known from this
-           old part of the internet: quasimondo.com/archives/000565.php
-
-           This new matrix is based on rgb cube rotation in space. Look here for a more descriptive
-           implementation as a shader not a general matrix:
-           https://github.com/evanw/glfx.js/blob/58841c23919bd59787effc0333a4897b43835412/src/filters/adjust/huesaturation.js
-
-           This is the source for the code:
-           see http://stackoverflow.com/questions/8507885/shift-hue-of-an-rgb-color/8510751#8510751
-           */
-          var w = 1 / 3;
-          var sqrW = sqrt(w); // weight is
-          var a00 = cosR + ((1.0 - cosR) * w);
-          var a01 = (w * (1.0 - cosR)) - (sqrW * sinR);
-          var a02 = (w * (1.0 - cosR)) + (sqrW * sinR);
-          var a10 = (w * (1.0 - cosR)) + (sqrW * sinR);
-          var a11 = cosR + (w * (1.0 - cosR));
-          var a12 = (w * (1.0 - cosR)) - (sqrW * sinR);
-          var a20 = (w * (1.0 - cosR)) - (sqrW * sinR);
-          var a21 = (w * (1.0 - cosR)) + (sqrW * sinR);
-          var a22 = cosR + (w * (1.0 - cosR));
-          var matrix = [
-              a00, a01, a02, 0, 0,
-              a10, a11, a12, 0, 0,
-              a20, a21, a22, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Set the contrast matrix, increase the separation between dark and bright
-       * Increase contrast : shadows darker and highlights brighter
-       * Decrease contrast : bring the shadows up and the highlights down
-       * @param amount - value of the contrast (0-1)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.contrast = function (amount, multiply) {
-          var v = (amount || 0) + 1;
-          var o = -0.5 * (v - 1);
-          var matrix = [
-              v, 0, 0, 0, o,
-              0, v, 0, 0, o,
-              0, 0, v, 0, o,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Set the saturation matrix, increase the separation between colors
-       * Increase saturation : increase contrast, brightness, and sharpness
-       * @param amount - The saturation amount (0-1)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.saturate = function (amount, multiply) {
-          if (amount === void 0) { amount = 0; }
-          var x = (amount * 2 / 3) + 1;
-          var y = ((x - 1) * -0.5);
-          var matrix = [
-              x, y, y, 0, 0,
-              y, x, y, 0, 0,
-              y, y, x, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /** Desaturate image (remove color) Call the saturate function */
-      ColorMatrixFilter.prototype.desaturate = function () {
-          this.saturate(-1);
-      };
-      /**
-       * Negative image (inverse of classic rgb matrix)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.negative = function (multiply) {
-          var matrix = [
-              -1, 0, 0, 1, 0,
-              0, -1, 0, 1, 0,
-              0, 0, -1, 1, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Sepia image
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.sepia = function (multiply) {
-          var matrix = [
-              0.393, 0.7689999, 0.18899999, 0, 0,
-              0.349, 0.6859999, 0.16799999, 0, 0,
-              0.272, 0.5339999, 0.13099999, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Color motion picture process invented in 1916 (thanks Dominic Szablewski)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.technicolor = function (multiply) {
-          var matrix = [
-              1.9125277891456083, -0.8545344976951645, -0.09155508482755585, 0, 11.793603434377337,
-              -0.3087833385928097, 1.7658908555458428, -0.10601743074722245, 0, -70.35205161461398,
-              -0.231103377548616, -0.7501899197440212, 1.847597816108189, 0, 30.950940869491138,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Polaroid filter
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.polaroid = function (multiply) {
-          var matrix = [
-              1.438, -0.062, -0.062, 0, 0,
-              -0.122, 1.378, -0.122, 0, 0,
-              -0.016, -0.016, 1.483, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Filter who transforms : Red -> Blue and Blue -> Red
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.toBGR = function (multiply) {
-          var matrix = [
-              0, 0, 1, 0, 0,
-              0, 1, 0, 0, 0,
-              1, 0, 0, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Color reversal film introduced by Eastman Kodak in 1935. (thanks Dominic Szablewski)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.kodachrome = function (multiply) {
-          var matrix = [
-              1.1285582396593525, -0.3967382283601348, -0.03992559172921793, 0, 63.72958762196502,
-              -0.16404339962244616, 1.0835251566291304, -0.05498805115633132, 0, 24.732407896706203,
-              -0.16786010706155763, -0.5603416277695248, 1.6014850761964943, 0, 35.62982807460946,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Brown delicious browni filter (thanks Dominic Szablewski)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.browni = function (multiply) {
-          var matrix = [
-              0.5997023498159715, 0.34553243048391263, -0.2708298674538042, 0, 47.43192855600873,
-              -0.037703249837783157, 0.8609577587992641, 0.15059552388459913, 0, -36.96841498319127,
-              0.24113635128153335, -0.07441037908422492, 0.44972182064877153, 0, -7.562075277591283,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Vintage filter (thanks Dominic Szablewski)
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.vintage = function (multiply) {
-          var matrix = [
-              0.6279345635605994, 0.3202183420819367, -0.03965408211312453, 0, 9.651285835294123,
-              0.02578397704808868, 0.6441188644374771, 0.03259127616149294, 0, 7.462829176470591,
-              0.0466055556782719, -0.0851232987247891, 0.5241648018700465, 0, 5.159190588235296,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * We don't know exactly what it does, kind of gradient map, but funny to play with!
-       * @param desaturation - Tone values.
-       * @param toned - Tone values.
-       * @param lightColor - Tone values, example: `0xFFE580`
-       * @param darkColor - Tone values, example: `0xFFE580`
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.colorTone = function (desaturation, toned, lightColor, darkColor, multiply) {
-          desaturation = desaturation || 0.2;
-          toned = toned || 0.15;
-          lightColor = lightColor || 0xFFE580;
-          darkColor = darkColor || 0x338000;
-          var lR = ((lightColor >> 16) & 0xFF) / 255;
-          var lG = ((lightColor >> 8) & 0xFF) / 255;
-          var lB = (lightColor & 0xFF) / 255;
-          var dR = ((darkColor >> 16) & 0xFF) / 255;
-          var dG = ((darkColor >> 8) & 0xFF) / 255;
-          var dB = (darkColor & 0xFF) / 255;
-          var matrix = [
-              0.3, 0.59, 0.11, 0, 0,
-              lR, lG, lB, desaturation, 0,
-              dR, dG, dB, toned, 0,
-              lR - dR, lG - dG, lB - dB, 0, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Night effect
-       * @param intensity - The intensity of the night effect.
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.night = function (intensity, multiply) {
-          intensity = intensity || 0.1;
-          var matrix = [
-              intensity * (-2.0), -intensity, 0, 0, 0,
-              -intensity, 0, intensity, 0, 0,
-              0, intensity, intensity * 2.0, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * Predator effect
-       *
-       * Erase the current matrix by setting a new indepent one
-       * @param amount - how much the predator feels his future victim
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.predator = function (amount, multiply) {
-          var matrix = [
-              // row 1
-              11.224130630493164 * amount,
-              -4.794486999511719 * amount,
-              -2.8746118545532227 * amount,
-              0 * amount,
-              0.40342438220977783 * amount,
-              // row 2
-              -3.6330697536468506 * amount,
-              9.193157196044922 * amount,
-              -2.951810836791992 * amount,
-              0 * amount,
-              -1.316135048866272 * amount,
-              // row 3
-              -3.2184197902679443 * amount,
-              -4.2375030517578125 * amount,
-              7.476448059082031 * amount,
-              0 * amount,
-              0.8044459223747253 * amount,
-              // row 4
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /**
-       * LSD effect
-       *
-       * Multiply the current matrix
-       * @param multiply - if true, current matrix and matrix are multiplied. If false,
-       *  just set the current matrix with @param matrix
-       */
-      ColorMatrixFilter.prototype.lsd = function (multiply) {
-          var matrix = [
-              2, -0.4, 0.5, 0, 0,
-              -0.5, 2, -0.4, 0, 0,
-              -0.4, -0.5, 3, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, multiply);
-      };
-      /** Erase the current matrix by setting the default one. */
-      ColorMatrixFilter.prototype.reset = function () {
-          var matrix = [
-              1, 0, 0, 0, 0,
-              0, 1, 0, 0, 0,
-              0, 0, 1, 0, 0,
-              0, 0, 0, 1, 0 ];
-          this._loadMatrix(matrix, false);
-      };
-      Object.defineProperty(ColorMatrixFilter.prototype, "matrix", {
-          /**
-           * The matrix of the color matrix filter
-           * @member {number[]}
-           * @default [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]
-           */
-          get: function () {
-              return this.uniforms.m;
-          },
-          set: function (value) {
-              this.uniforms.m = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(ColorMatrixFilter.prototype, "alpha", {
-          /**
-           * The opacity value to use when mixing the original and resultant colors.
-           *
-           * When the value is 0, the original color is used without modification.
-           * When the value is 1, the result color is used.
-           * When in the range (0, 1) the color is interpolated between the original and result by this amount.
-           * @default 1
-           */
-          get: function () {
-              return this.uniforms.uAlpha;
-          },
-          set: function (value) {
-              this.uniforms.uAlpha = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return ColorMatrixFilter;
-  }(Filter));
-  // Americanized alias
-  ColorMatrixFilter.prototype.grayscale = ColorMatrixFilter.prototype.greyscale;
-
-  /*!
-   * @pixi/filter-displacement - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/filter-displacement is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$4 = function(d, b) {
-      extendStatics$4 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$4(d, b);
-  };
-
-  function __extends$4(d, b) {
-      extendStatics$4(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var fragment$2 = "varying vec2 vFilterCoord;\nvarying vec2 vTextureCoord;\n\nuniform vec2 scale;\nuniform mat2 rotation;\nuniform sampler2D uSampler;\nuniform sampler2D mapSampler;\n\nuniform highp vec4 inputSize;\nuniform vec4 inputClamp;\n\nvoid main(void)\n{\n  vec4 map =  texture2D(mapSampler, vFilterCoord);\n\n  map -= 0.5;\n  map.xy = scale * inputSize.zw * (rotation * map.xy);\n\n  gl_FragColor = texture2D(uSampler, clamp(vec2(vTextureCoord.x + map.x, vTextureCoord.y + map.y), inputClamp.xy, inputClamp.zw));\n}\n";
-
-  var vertex$1 = "attribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\nuniform mat3 filterMatrix;\n\nvarying vec2 vTextureCoord;\nvarying vec2 vFilterCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aVertexPosition * (outputFrame.zw * inputSize.zw);\n}\n\nvoid main(void)\n{\n\tgl_Position = filterVertexPosition();\n\tvTextureCoord = filterTextureCoord();\n\tvFilterCoord = ( filterMatrix * vec3( vTextureCoord, 1.0)  ).xy;\n}\n";
-
-  /**
-   * The DisplacementFilter class uses the pixel values from the specified texture
-   * (called the displacement map) to perform a displacement of an object.
-   *
-   * You can use this filter to apply all manor of crazy warping effects.
-   * Currently the `r` property of the texture is used to offset the `x`
-   * and the `g` property of the texture is used to offset the `y`.
-   *
-   * The way it works is it uses the values of the displacement map to look up the
-   * correct pixels to output. This means it's not technically moving the original.
-   * Instead, it's starting at the output and asking "which pixel from the original goes here".
-   * For example, if a displacement map pixel has `red = 1` and the filter scale is `20`,
-   * this filter will output the pixel approximately 20 pixels to the right of the original.
-   * @memberof PIXI.filters
-   */
-  var DisplacementFilter = /** @class */ (function (_super) {
-      __extends$4(DisplacementFilter, _super);
-      /**
-       * @param {PIXI.Sprite} sprite - The sprite used for the displacement map. (make sure its added to the scene!)
-       * @param scale - The scale of the displacement
-       */
-      function DisplacementFilter(sprite, scale) {
-          var _this = this;
-          var maskMatrix = new Matrix();
-          sprite.renderable = false;
-          _this = _super.call(this, vertex$1, fragment$2, {
-              mapSampler: sprite._texture,
-              filterMatrix: maskMatrix,
-              scale: { x: 1, y: 1 },
-              rotation: new Float32Array([1, 0, 0, 1]),
-          }) || this;
-          _this.maskSprite = sprite;
-          _this.maskMatrix = maskMatrix;
-          if (scale === null || scale === undefined) {
-              scale = 20;
-          }
-          /**
-           * scaleX, scaleY for displacements
-           * @member {PIXI.Point}
-           */
-          _this.scale = new Point(scale, scale);
-          return _this;
-      }
-      /**
-       * Applies the filter.
-       * @param filterManager - The manager.
-       * @param input - The input target.
-       * @param output - The output target.
-       * @param clearMode - clearMode.
-       */
-      DisplacementFilter.prototype.apply = function (filterManager, input, output, clearMode) {
-          // fill maskMatrix with _normalized sprite texture coords_
-          this.uniforms.filterMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, this.maskSprite);
-          this.uniforms.scale.x = this.scale.x;
-          this.uniforms.scale.y = this.scale.y;
-          // Extract rotation from world transform
-          var wt = this.maskSprite.worldTransform;
-          var lenX = Math.sqrt((wt.a * wt.a) + (wt.b * wt.b));
-          var lenY = Math.sqrt((wt.c * wt.c) + (wt.d * wt.d));
-          if (lenX !== 0 && lenY !== 0) {
-              this.uniforms.rotation[0] = wt.a / lenX;
-              this.uniforms.rotation[1] = wt.b / lenX;
-              this.uniforms.rotation[2] = wt.c / lenY;
-              this.uniforms.rotation[3] = wt.d / lenY;
-          }
-          // draw the filter...
-          filterManager.applyFilter(this, input, output, clearMode);
-      };
-      Object.defineProperty(DisplacementFilter.prototype, "map", {
-          /** The texture used for the displacement map. Must be power of 2 sized texture. */
-          get: function () {
-              return this.uniforms.mapSampler;
-          },
-          set: function (value) {
-              this.uniforms.mapSampler = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return DisplacementFilter;
-  }(Filter));
-
-  /*!
-   * @pixi/filter-fxaa - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/filter-fxaa is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$3 = function(d, b) {
-      extendStatics$3 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$3(d, b);
-  };
-
-  function __extends$3(d, b) {
-      extendStatics$3(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var vertex = "\nattribute vec2 aVertexPosition;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nvarying vec2 vFragCoord;\n\nuniform vec4 inputSize;\nuniform vec4 outputFrame;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n    return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n}\n\nvoid texcoords(vec2 fragCoord, vec2 inverseVP,\n               out vec2 v_rgbNW, out vec2 v_rgbNE,\n               out vec2 v_rgbSW, out vec2 v_rgbSE,\n               out vec2 v_rgbM) {\n    v_rgbNW = (fragCoord + vec2(-1.0, -1.0)) * inverseVP;\n    v_rgbNE = (fragCoord + vec2(1.0, -1.0)) * inverseVP;\n    v_rgbSW = (fragCoord + vec2(-1.0, 1.0)) * inverseVP;\n    v_rgbSE = (fragCoord + vec2(1.0, 1.0)) * inverseVP;\n    v_rgbM = vec2(fragCoord * inverseVP);\n}\n\nvoid main(void) {\n\n   gl_Position = filterVertexPosition();\n\n   vFragCoord = aVertexPosition * outputFrame.zw;\n\n   texcoords(vFragCoord, inputSize.zw, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n}\n";
-
-  var fragment$1 = "varying vec2 v_rgbNW;\nvarying vec2 v_rgbNE;\nvarying vec2 v_rgbSW;\nvarying vec2 v_rgbSE;\nvarying vec2 v_rgbM;\n\nvarying vec2 vFragCoord;\nuniform sampler2D uSampler;\nuniform highp vec4 inputSize;\n\n\n/**\n Basic FXAA implementation based on the code on geeks3d.com with the\n modification that the texture2DLod stuff was removed since it's\n unsupported by WebGL.\n\n --\n\n From:\n https://github.com/mitsuhiko/webgl-meincraft\n\n Copyright (c) 2011 by Armin Ronacher.\n\n Some rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are\n met:\n\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n * Redistributions in binary form must reproduce the above\n copyright notice, this list of conditions and the following\n disclaimer in the documentation and/or other materials provided\n with the distribution.\n\n * The names of the contributors may not be used to endorse or\n promote products derived from this software without specific\n prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n#ifndef FXAA_REDUCE_MIN\n#define FXAA_REDUCE_MIN   (1.0/ 128.0)\n#endif\n#ifndef FXAA_REDUCE_MUL\n#define FXAA_REDUCE_MUL   (1.0 / 8.0)\n#endif\n#ifndef FXAA_SPAN_MAX\n#define FXAA_SPAN_MAX     8.0\n#endif\n\n//optimized version for mobile, where dependent\n//texture reads can be a bottleneck\nvec4 fxaa(sampler2D tex, vec2 fragCoord, vec2 inverseVP,\n          vec2 v_rgbNW, vec2 v_rgbNE,\n          vec2 v_rgbSW, vec2 v_rgbSE,\n          vec2 v_rgbM) {\n    vec4 color;\n    vec3 rgbNW = texture2D(tex, v_rgbNW).xyz;\n    vec3 rgbNE = texture2D(tex, v_rgbNE).xyz;\n    vec3 rgbSW = texture2D(tex, v_rgbSW).xyz;\n    vec3 rgbSE = texture2D(tex, v_rgbSE).xyz;\n    vec4 texColor = texture2D(tex, v_rgbM);\n    vec3 rgbM  = texColor.xyz;\n    vec3 luma = vec3(0.299, 0.587, 0.114);\n    float lumaNW = dot(rgbNW, luma);\n    float lumaNE = dot(rgbNE, luma);\n    float lumaSW = dot(rgbSW, luma);\n    float lumaSE = dot(rgbSE, luma);\n    float lumaM  = dot(rgbM,  luma);\n    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));\n    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));\n\n    mediump vec2 dir;\n    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));\n    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));\n\n    float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) *\n                          (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);\n\n    float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);\n    dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX),\n              max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),\n                  dir * rcpDirMin)) * inverseVP;\n\n    vec3 rgbA = 0.5 * (\n                       texture2D(tex, fragCoord * inverseVP + dir * (1.0 / 3.0 - 0.5)).xyz +\n                       texture2D(tex, fragCoord * inverseVP + dir * (2.0 / 3.0 - 0.5)).xyz);\n    vec3 rgbB = rgbA * 0.5 + 0.25 * (\n                                     texture2D(tex, fragCoord * inverseVP + dir * -0.5).xyz +\n                                     texture2D(tex, fragCoord * inverseVP + dir * 0.5).xyz);\n\n    float lumaB = dot(rgbB, luma);\n    if ((lumaB < lumaMin) || (lumaB > lumaMax))\n        color = vec4(rgbA, texColor.a);\n    else\n        color = vec4(rgbB, texColor.a);\n    return color;\n}\n\nvoid main() {\n\n      vec4 color;\n\n      color = fxaa(uSampler, vFragCoord, inputSize.zw, v_rgbNW, v_rgbNE, v_rgbSW, v_rgbSE, v_rgbM);\n\n      gl_FragColor = color;\n}\n";
-
-  /**
-   * Basic FXAA (Fast Approximate Anti-Aliasing) implementation based on the code on geeks3d.com
-   * with the modification that the texture2DLod stuff was removed since it is unsupported by WebGL.
-   * @see https://github.com/mitsuhiko/webgl-meincraft
-   * @memberof PIXI.filters
-   */
-  var FXAAFilter = /** @class */ (function (_super) {
-      __extends$3(FXAAFilter, _super);
-      function FXAAFilter() {
-          // TODO - needs work
-          return _super.call(this, vertex, fragment$1) || this;
-      }
-      return FXAAFilter;
-  }(Filter));
-
-  /*!
-   * @pixi/filter-noise - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/filter-noise is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$2 = function(d, b) {
-      extendStatics$2 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$2(d, b);
-  };
-
-  function __extends$2(d, b) {
-      extendStatics$2(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  var fragment = "precision highp float;\n\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\n\nuniform float uNoise;\nuniform float uSeed;\nuniform sampler2D uSampler;\n\nfloat rand(vec2 co)\n{\n    return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvoid main()\n{\n    vec4 color = texture2D(uSampler, vTextureCoord);\n    float randomValue = rand(gl_FragCoord.xy * uSeed);\n    float diff = (randomValue - 0.5) * uNoise;\n\n    // Un-premultiply alpha before applying the color matrix. See issue #3539.\n    if (color.a > 0.0) {\n        color.rgb /= color.a;\n    }\n\n    color.r += diff;\n    color.g += diff;\n    color.b += diff;\n\n    // Premultiply alpha again.\n    color.rgb *= color.a;\n\n    gl_FragColor = color;\n}\n";
-
-  /**
-   * A Noise effect filter.
-   *
-   * original filter: https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/noise.js
-   * @memberof PIXI.filters
-   * @author Vico @vicocotea
-   */
-  var NoiseFilter = /** @class */ (function (_super) {
-      __extends$2(NoiseFilter, _super);
-      /**
-       * @param {number} [noise=0.5] - The noise intensity, should be a normalized value in the range [0, 1].
-       * @param {number} [seed] - A random seed for the noise generation. Default is `Math.random()`.
-       */
-      function NoiseFilter(noise, seed) {
-          if (noise === void 0) { noise = 0.5; }
-          if (seed === void 0) { seed = Math.random(); }
-          var _this = _super.call(this, defaultFilterVertex, fragment, {
-              uNoise: 0,
-              uSeed: 0,
-          }) || this;
-          _this.noise = noise;
-          _this.seed = seed;
-          return _this;
-      }
-      Object.defineProperty(NoiseFilter.prototype, "noise", {
-          /**
-           * The amount of noise to apply, this value should be in the range (0, 1].
-           * @default 0.5
-           */
-          get: function () {
-              return this.uniforms.uNoise;
-          },
-          set: function (value) {
-              this.uniforms.uNoise = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(NoiseFilter.prototype, "seed", {
-          /** A seed value to apply to the random noise generation. `Math.random()` is a good value to use. */
-          get: function () {
-              return this.uniforms.uSeed;
-          },
-          set: function (value) {
-              this.uniforms.uSeed = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return NoiseFilter;
-  }(Filter));
-
-  /*!
-   * @pixi/mixin-cache-as-bitmap - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/mixin-cache-as-bitmap is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  var _tempMatrix = new Matrix();
-  DisplayObject.prototype._cacheAsBitmap = false;
-  DisplayObject.prototype._cacheData = null;
-  DisplayObject.prototype._cacheAsBitmapResolution = null;
-  DisplayObject.prototype._cacheAsBitmapMultisample = exports.MSAA_QUALITY.NONE;
-  // figured there's no point adding ALL the extra variables to prototype.
-  // this model can hold the information needed. This can also be generated on demand as
-  // most objects are not cached as bitmaps.
-  /**
-   * @class
-   * @ignore
-   * @private
-   */
-  var CacheData = /** @class */ (function () {
-      function CacheData() {
-          this.textureCacheId = null;
-          this.originalRender = null;
-          this.originalRenderCanvas = null;
-          this.originalCalculateBounds = null;
-          this.originalGetLocalBounds = null;
-          this.originalUpdateTransform = null;
-          this.originalDestroy = null;
-          this.originalMask = null;
-          this.originalFilterArea = null;
-          this.originalContainsPoint = null;
-          this.sprite = null;
-      }
-      return CacheData;
-  }());
-  Object.defineProperties(DisplayObject.prototype, {
-      /**
-       * The resolution to use for cacheAsBitmap. By default this will use the renderer's resolution
-       * but can be overriden for performance. Lower values will reduce memory usage at the expense
-       * of render quality. A falsey value of `null` or `0` will default to the renderer's resolution.
-       * If `cacheAsBitmap` is set to `true`, this will re-render with the new resolution.
-       * @member {number} cacheAsBitmapResolution
-       * @memberof PIXI.DisplayObject#
-       * @default null
-       */
-      cacheAsBitmapResolution: {
-          get: function () {
-              return this._cacheAsBitmapResolution;
-          },
-          set: function (resolution) {
-              if (resolution === this._cacheAsBitmapResolution) {
-                  return;
-              }
-              this._cacheAsBitmapResolution = resolution;
-              if (this.cacheAsBitmap) {
-                  // Toggle to re-render at the new resolution
-                  this.cacheAsBitmap = false;
-                  this.cacheAsBitmap = true;
-              }
-          },
-      },
-      /**
-       * The number of samples to use for cacheAsBitmap. If set to `null`, the renderer's
-       * sample count is used.
-       * If `cacheAsBitmap` is set to `true`, this will re-render with the new number of samples.
-       * @member {number} cacheAsBitmapMultisample
-       * @memberof PIXI.DisplayObject#
-       * @default PIXI.MSAA_QUALITY.NONE
-       */
-      cacheAsBitmapMultisample: {
-          get: function () {
-              return this._cacheAsBitmapMultisample;
-          },
-          set: function (multisample) {
-              if (multisample === this._cacheAsBitmapMultisample) {
-                  return;
-              }
-              this._cacheAsBitmapMultisample = multisample;
-              if (this.cacheAsBitmap) {
-                  // Toggle to re-render with new multisample
-                  this.cacheAsBitmap = false;
-                  this.cacheAsBitmap = true;
-              }
-          },
-      },
-      /**
-       * Set this to true if you want this display object to be cached as a bitmap.
-       * This basically takes a snap shot of the display object as it is at that moment. It can
-       * provide a performance benefit for complex static displayObjects.
-       * To remove simply set this property to `false`
-       *
-       * IMPORTANT GOTCHA - Make sure that all your textures are preloaded BEFORE setting this property to true
-       * as it will take a snapshot of what is currently there. If the textures have not loaded then they will not appear.
-       * @member {boolean}
-       * @memberof PIXI.DisplayObject#
-       */
-      cacheAsBitmap: {
-          get: function () {
-              return this._cacheAsBitmap;
-          },
-          set: function (value) {
-              if (this._cacheAsBitmap === value) {
-                  return;
-              }
-              this._cacheAsBitmap = value;
-              var data;
-              if (value) {
-                  if (!this._cacheData) {
-                      this._cacheData = new CacheData();
-                  }
-                  data = this._cacheData;
-                  data.originalRender = this.render;
-                  data.originalRenderCanvas = this.renderCanvas;
-                  data.originalUpdateTransform = this.updateTransform;
-                  data.originalCalculateBounds = this.calculateBounds;
-                  data.originalGetLocalBounds = this.getLocalBounds;
-                  data.originalDestroy = this.destroy;
-                  data.originalContainsPoint = this.containsPoint;
-                  data.originalMask = this._mask;
-                  data.originalFilterArea = this.filterArea;
-                  this.render = this._renderCached;
-                  this.renderCanvas = this._renderCachedCanvas;
-                  this.destroy = this._cacheAsBitmapDestroy;
-              }
-              else {
-                  data = this._cacheData;
-                  if (data.sprite) {
-                      this._destroyCachedDisplayObject();
-                  }
-                  this.render = data.originalRender;
-                  this.renderCanvas = data.originalRenderCanvas;
-                  this.calculateBounds = data.originalCalculateBounds;
-                  this.getLocalBounds = data.originalGetLocalBounds;
-                  this.destroy = data.originalDestroy;
-                  this.updateTransform = data.originalUpdateTransform;
-                  this.containsPoint = data.originalContainsPoint;
-                  this._mask = data.originalMask;
-                  this.filterArea = data.originalFilterArea;
-              }
-          },
-      },
-  });
-  /**
-   * Renders a cached version of the sprite with WebGL
-   * @private
-   * @method _renderCached
-   * @memberof PIXI.DisplayObject#
-   * @param {PIXI.Renderer} renderer - the WebGL renderer
-   */
-  DisplayObject.prototype._renderCached = function _renderCached(renderer) {
-      if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
-          return;
-      }
-      this._initCachedDisplayObject(renderer);
-      this._cacheData.sprite.transform._worldID = this.transform._worldID;
-      this._cacheData.sprite.worldAlpha = this.worldAlpha;
-      this._cacheData.sprite._render(renderer);
-  };
-  /**
-   * Prepares the WebGL renderer to cache the sprite
-   * @private
-   * @method _initCachedDisplayObject
-   * @memberof PIXI.DisplayObject#
-   * @param {PIXI.Renderer} renderer - the WebGL renderer
-   */
-  DisplayObject.prototype._initCachedDisplayObject = function _initCachedDisplayObject(renderer) {
-      var _a;
-      if (this._cacheData && this._cacheData.sprite) {
-          return;
-      }
-      // make sure alpha is set to 1 otherwise it will get rendered as invisible!
-      var cacheAlpha = this.alpha;
-      this.alpha = 1;
-      // first we flush anything left in the renderer (otherwise it would get rendered to the cached texture)
-      renderer.batch.flush();
-      // this.filters= [];
-      // next we find the dimensions of the untransformed object
-      // this function also calls updatetransform on all its children as part of the measuring.
-      // This means we don't need to update the transform again in this function
-      // TODO pass an object to clone too? saves having to create a new one each time!
-      var bounds = this.getLocalBounds(null, true).clone();
-      // add some padding!
-      if (this.filters && this.filters.length) {
-          var padding = this.filters[0].padding;
-          bounds.pad(padding);
-      }
-      bounds.ceil(settings.RESOLUTION);
-      // for now we cache the current renderTarget that the WebGL renderer is currently using.
-      // this could be more elegant..
-      var cachedRenderTexture = renderer.renderTexture.current;
-      var cachedSourceFrame = renderer.renderTexture.sourceFrame.clone();
-      var cachedDestinationFrame = renderer.renderTexture.destinationFrame.clone();
-      var cachedProjectionTransform = renderer.projection.transform;
-      // We also store the filter stack - I will definitely look to change how this works a little later down the line.
-      // const stack = renderer.filterManager.filterStack;
-      // this renderTexture will be used to store the cached DisplayObject
-      var renderTexture = RenderTexture.create({
-          width: bounds.width,
-          height: bounds.height,
-          resolution: this.cacheAsBitmapResolution || renderer.resolution,
-          multisample: (_a = this.cacheAsBitmapMultisample) !== null && _a !== void 0 ? _a : renderer.multisample,
-      });
-      var textureCacheId = "cacheAsBitmap_" + uid();
-      this._cacheData.textureCacheId = textureCacheId;
-      BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);
-      Texture.addToCache(renderTexture, textureCacheId);
-      // need to set //
-      var m = this.transform.localTransform.copyTo(_tempMatrix).invert().translate(-bounds.x, -bounds.y);
-      // set all properties to there original so we can render to a texture
-      this.render = this._cacheData.originalRender;
-      renderer.render(this, { renderTexture: renderTexture, clear: true, transform: m, skipUpdateTransform: false });
-      renderer.framebuffer.blit();
-      // now restore the state be setting the new properties
-      renderer.projection.transform = cachedProjectionTransform;
-      renderer.renderTexture.bind(cachedRenderTexture, cachedSourceFrame, cachedDestinationFrame);
-      // renderer.filterManager.filterStack = stack;
-      this.render = this._renderCached;
-      // the rest is the same as for Canvas
-      this.updateTransform = this.displayObjectUpdateTransform;
-      this.calculateBounds = this._calculateCachedBounds;
-      this.getLocalBounds = this._getCachedLocalBounds;
-      this._mask = null;
-      this.filterArea = null;
-      this.alpha = cacheAlpha;
-      // create our cached sprite
-      var cachedSprite = new Sprite(renderTexture);
-      cachedSprite.transform.worldTransform = this.transform.worldTransform;
-      cachedSprite.anchor.x = -(bounds.x / bounds.width);
-      cachedSprite.anchor.y = -(bounds.y / bounds.height);
-      cachedSprite.alpha = cacheAlpha;
-      cachedSprite._bounds = this._bounds;
-      this._cacheData.sprite = cachedSprite;
-      this.transform._parentID = -1;
-      // restore the transform of the cached sprite to avoid the nasty flicker..
-      if (!this.parent) {
-          this.enableTempParent();
-          this.updateTransform();
-          this.disableTempParent(null);
-      }
-      else {
-          this.updateTransform();
-      }
-      // map the hit test..
-      this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
-  };
-  /**
-   * Renders a cached version of the sprite with canvas
-   * @private
-   * @method _renderCachedCanvas
-   * @memberof PIXI.DisplayObject#
-   * @param {PIXI.CanvasRenderer} renderer - The canvas renderer
-   */
-  DisplayObject.prototype._renderCachedCanvas = function _renderCachedCanvas(renderer) {
-      if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
-          return;
-      }
-      this._initCachedDisplayObjectCanvas(renderer);
-      this._cacheData.sprite.worldAlpha = this.worldAlpha;
-      this._cacheData.sprite._renderCanvas(renderer);
-  };
-  // TODO this can be the same as the WebGL version.. will need to do a little tweaking first though..
-  /**
-   * Prepares the Canvas renderer to cache the sprite
-   * @private
-   * @method _initCachedDisplayObjectCanvas
-   * @memberof PIXI.DisplayObject#
-   * @param {PIXI.CanvasRenderer} renderer - The canvas renderer
-   */
-  DisplayObject.prototype._initCachedDisplayObjectCanvas = function _initCachedDisplayObjectCanvas(renderer) {
-      if (this._cacheData && this._cacheData.sprite) {
-          return;
-      }
-      // get bounds actually transforms the object for us already!
-      var bounds = this.getLocalBounds(null, true);
-      var cacheAlpha = this.alpha;
-      this.alpha = 1;
-      var cachedRenderTarget = renderer.context;
-      var cachedProjectionTransform = renderer._projTransform;
-      bounds.ceil(settings.RESOLUTION);
-      var renderTexture = RenderTexture.create({ width: bounds.width, height: bounds.height });
-      var textureCacheId = "cacheAsBitmap_" + uid();
-      this._cacheData.textureCacheId = textureCacheId;
-      BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);
-      Texture.addToCache(renderTexture, textureCacheId);
-      // need to set //
-      var m = _tempMatrix;
-      this.transform.localTransform.copyTo(m);
-      m.invert();
-      m.tx -= bounds.x;
-      m.ty -= bounds.y;
-      // m.append(this.transform.worldTransform.)
-      // set all properties to there original so we can render to a texture
-      this.renderCanvas = this._cacheData.originalRenderCanvas;
-      renderer.render(this, { renderTexture: renderTexture, clear: true, transform: m, skipUpdateTransform: false });
-      // now restore the state be setting the new properties
-      renderer.context = cachedRenderTarget;
-      renderer._projTransform = cachedProjectionTransform;
-      this.renderCanvas = this._renderCachedCanvas;
-      // the rest is the same as for WebGL
-      this.updateTransform = this.displayObjectUpdateTransform;
-      this.calculateBounds = this._calculateCachedBounds;
-      this.getLocalBounds = this._getCachedLocalBounds;
-      this._mask = null;
-      this.filterArea = null;
-      this.alpha = cacheAlpha;
-      // create our cached sprite
-      var cachedSprite = new Sprite(renderTexture);
-      cachedSprite.transform.worldTransform = this.transform.worldTransform;
-      cachedSprite.anchor.x = -(bounds.x / bounds.width);
-      cachedSprite.anchor.y = -(bounds.y / bounds.height);
-      cachedSprite.alpha = cacheAlpha;
-      cachedSprite._bounds = this._bounds;
-      this._cacheData.sprite = cachedSprite;
-      this.transform._parentID = -1;
-      // restore the transform of the cached sprite to avoid the nasty flicker..
-      if (!this.parent) {
-          this.parent = renderer._tempDisplayObjectParent;
-          this.updateTransform();
-          this.parent = null;
-      }
-      else {
-          this.updateTransform();
-      }
-      // map the hit test..
-      this.containsPoint = cachedSprite.containsPoint.bind(cachedSprite);
-  };
-  /**
-   * Calculates the bounds of the cached sprite
-   * @private
-   * @method
-   */
-  DisplayObject.prototype._calculateCachedBounds = function _calculateCachedBounds() {
-      this._bounds.clear();
-      this._cacheData.sprite.transform._worldID = this.transform._worldID;
-      this._cacheData.sprite._calculateBounds();
-      this._bounds.updateID = this._boundsID;
-  };
-  /**
-   * Gets the bounds of the cached sprite.
-   * @private
-   * @method
-   * @returns {Rectangle} The local bounds.
-   */
-  DisplayObject.prototype._getCachedLocalBounds = function _getCachedLocalBounds() {
-      return this._cacheData.sprite.getLocalBounds(null);
-  };
-  /**
-   * Destroys the cached sprite.
-   * @private
-   * @method
-   */
-  DisplayObject.prototype._destroyCachedDisplayObject = function _destroyCachedDisplayObject() {
-      this._cacheData.sprite._texture.destroy(true);
-      this._cacheData.sprite = null;
-      BaseTexture.removeFromCache(this._cacheData.textureCacheId);
-      Texture.removeFromCache(this._cacheData.textureCacheId);
-      this._cacheData.textureCacheId = null;
-  };
-  /**
-   * Destroys the cached object.
-   * @private
-   * @method
-   * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-   *  have been set to that value.
-   *  Used when destroying containers, see the Container.destroy method.
-   */
-  DisplayObject.prototype._cacheAsBitmapDestroy = function _cacheAsBitmapDestroy(options) {
-      this.cacheAsBitmap = false;
-      this.destroy(options);
-  };
-
-  /*!
-   * @pixi/mixin-get-child-by-name - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/mixin-get-child-by-name is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * The instance name of the object.
-   * @memberof PIXI.DisplayObject#
-   * @member {string} name
-   */
-  DisplayObject.prototype.name = null;
-  /**
-   * Returns the display object in the container.
-   *
-   * Recursive searches are done in a preorder traversal.
-   * @method getChildByName
-   * @memberof PIXI.Container#
-   * @param {string} name - Instance name.
-   * @param {boolean}[deep=false] - Whether to search recursively
-   * @returns {PIXI.DisplayObject} The child with the specified name.
-   */
-  Container.prototype.getChildByName = function getChildByName(name, deep) {
-      for (var i = 0, j = this.children.length; i < j; i++) {
-          if (this.children[i].name === name) {
-              return this.children[i];
-          }
-      }
-      if (deep) {
-          for (var i = 0, j = this.children.length; i < j; i++) {
-              var child = this.children[i];
-              if (!child.getChildByName) {
-                  continue;
-              }
-              var target = child.getChildByName(name, true);
-              if (target) {
-                  return target;
-              }
-          }
-      }
-      return null;
-  };
-
-  /*!
-   * @pixi/mixin-get-global-position - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/mixin-get-global-position is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Returns the global position of the displayObject. Does not depend on object scale, rotation and pivot.
-   * @method getGlobalPosition
-   * @memberof PIXI.DisplayObject#
-   * @param {PIXI.Point} [point=new PIXI.Point()] - The point to write the global value to.
-   * @param {boolean} [skipUpdate=false] - Setting to true will stop the transforms of the scene graph from
-   *  being updated. This means the calculation returned MAY be out of date BUT will give you a
-   *  nice performance boost.
-   * @returns {PIXI.Point} The updated point.
-   */
-  DisplayObject.prototype.getGlobalPosition = function getGlobalPosition(point, skipUpdate) {
-      if (point === void 0) { point = new Point(); }
-      if (skipUpdate === void 0) { skipUpdate = false; }
-      if (this.parent) {
-          this.parent.toGlobal(this.position, point, skipUpdate);
-      }
-      else {
-          point.x = this.position.x;
-          point.y = this.position.y;
-      }
-      return point;
-  };
-
-  /*!
-   * @pixi/app - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/app is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /**
-   * Middleware for for Application's resize functionality
-   * @private
-   * @class
-   */
-  var ResizePlugin = /** @class */ (function () {
-      function ResizePlugin() {
-      }
-      /**
-       * Initialize the plugin with scope of application instance
-       * @static
-       * @private
-       * @param {object} [options] - See application options
-       */
-      ResizePlugin.init = function (options) {
-          var _this = this;
-          Object.defineProperty(this, 'resizeTo', 
-          /**
-           * The HTML element or window to automatically resize the
-           * renderer's view element to match width and height.
-           * @member {Window|HTMLElement}
-           * @name resizeTo
-           * @memberof PIXI.Application#
-           */
-          {
-              set: function (dom) {
-                  globalThis.removeEventListener('resize', this.queueResize);
-                  this._resizeTo = dom;
-                  if (dom) {
-                      globalThis.addEventListener('resize', this.queueResize);
-                      this.resize();
-                  }
-              },
-              get: function () {
-                  return this._resizeTo;
-              },
-          });
-          /**
-           * Resize is throttled, so it's safe to call this multiple times per frame and it'll
-           * only be called once.
-           * @memberof PIXI.Application#
-           * @method queueResize
-           * @private
-           */
-          this.queueResize = function () {
-              if (!_this._resizeTo) {
-                  return;
-              }
-              _this.cancelResize();
-              // // Throttle resize events per raf
-              _this._resizeId = requestAnimationFrame(function () { return _this.resize(); });
-          };
-          /**
-           * Cancel the resize queue.
-           * @memberof PIXI.Application#
-           * @method cancelResize
-           * @private
-           */
-          this.cancelResize = function () {
-              if (_this._resizeId) {
-                  cancelAnimationFrame(_this._resizeId);
-                  _this._resizeId = null;
-              }
-          };
-          /**
-           * Execute an immediate resize on the renderer, this is not
-           * throttled and can be expensive to call many times in a row.
-           * Will resize only if `resizeTo` property is set.
-           * @memberof PIXI.Application#
-           * @method resize
-           */
-          this.resize = function () {
-              if (!_this._resizeTo) {
-                  return;
-              }
-              // clear queue resize
-              _this.cancelResize();
-              var width;
-              var height;
-              // Resize to the window
-              if (_this._resizeTo === globalThis.window) {
-                  width = globalThis.innerWidth;
-                  height = globalThis.innerHeight;
-              }
-              // Resize to other HTML entities
-              else {
-                  var _a = _this._resizeTo, clientWidth = _a.clientWidth, clientHeight = _a.clientHeight;
-                  width = clientWidth;
-                  height = clientHeight;
-              }
-              _this.renderer.resize(width, height);
-          };
-          // On resize
-          this._resizeId = null;
-          this._resizeTo = null;
-          this.resizeTo = options.resizeTo || null;
-      };
-      /**
-       * Clean up the ticker, scoped to application
-       * @static
-       * @private
-       */
-      ResizePlugin.destroy = function () {
-          globalThis.removeEventListener('resize', this.queueResize);
-          this.cancelResize();
-          this.cancelResize = null;
-          this.queueResize = null;
-          this.resizeTo = null;
-          this.resize = null;
-      };
-      /** @ignore */
-      ResizePlugin.extension = exports.ExtensionType.Application;
-      return ResizePlugin;
-  }());
-
-  /**
-   * Convenience class to create a new PIXI application.
-   *
-   * This class automatically creates the renderer, ticker and root container.
-   * @example
-   * // Create the application
-   * const app = new PIXI.Application();
-   *
-   * // Add the view to the DOM
-   * document.body.appendChild(app.view);
-   *
-   * // ex, add display objects
-   * app.stage.addChild(PIXI.Sprite.from('something.png'));
-   * @class
-   * @memberof PIXI
-   */
-  var Application = /** @class */ (function () {
-      /**
-       * @param {PIXI.IApplicationOptions} [options] - The optional application and renderer parameters.
-       * @param {boolean} [options.antialias=false] -
-       *  **WebGL Only.** Whether to enable anti-aliasing. This may affect performance.
-       * @param {boolean} [options.autoDensity=false] -
-       *  Whether the CSS dimensions of the renderer's view should be resized automatically.
-       * @param {boolean} [options.autoStart=true] - Automatically starts the rendering after the construction.
-       *  **Note**: Setting this parameter to false does NOT stop the shared ticker even if you set
-       *  `options.sharedTicker` to `true` in case that it is already started. Stop it by your own.
-       * @param {number} [options.backgroundAlpha=1] -
-       *  Transparency of the background color, value from `0` (fully transparent) to `1` (fully opaque).
-       * @param {number} [options.backgroundColor=0x000000] -
-       *  The background color used to clear the canvas. It accepts hex numbers (e.g. `0xff0000`).
-       * @param {boolean} [options.clearBeforeRender=true] - Whether to clear the canvas before new render passes.
-       * @param {PIXI.IRenderingContext} [options.context] - **WebGL Only.** User-provided WebGL rendering context object.
-       * @param {boolean} [options.forceCanvas=false] -
-       *  Force using {@link PIXI.CanvasRenderer}, even if WebGL is available. This option only is available when
-       *  using **pixi.js-legacy** or **@pixi/canvas-renderer** packages, otherwise it is ignored.
-       * @param {number} [options.height=600] - The height of the renderer's view.
-       * @param {string} [options.powerPreference] -
-       *  **WebGL Only.** A hint indicating what configuration of GPU is suitable for the WebGL context,
-       *  can be `'default'`, `'high-performance'` or `'low-power'`.
-       *  Setting to `'high-performance'` will prioritize rendering performance over power consumption,
-       *  while setting to `'low-power'` will prioritize power saving over rendering performance.
-       * @param {boolean} [options.premultipliedAlpha=true] -
-       *  **WebGL Only.** Whether the compositor will assume the drawing buffer contains colors with premultiplied alpha.
-       * @param {boolean} [options.preserveDrawingBuffer=false] -
-       *  **WebGL Only.** Whether to enable drawing buffer preservation. If enabled, the drawing buffer will preserve
-       *  its value until cleared or overwritten. Enable this if you need to call `toDataUrl` on the WebGL context.
-       * @param {Window|HTMLElement} [options.resizeTo] - Element to automatically resize stage to.
-       * @param {number} [options.resolution=PIXI.settings.RESOLUTION] -
-       *  The resolution / device pixel ratio of the renderer.
-       * @param {boolean} [options.sharedLoader=false] - `true` to use PIXI.Loader.shared, `false` to create new Loader.
-       * @param {boolean} [options.sharedTicker=false] - `true` to use PIXI.Ticker.shared, `false` to create new ticker.
-       *  If set to `false`, you cannot register a handler to occur before anything that runs on the shared ticker.
-       *  The system ticker will always run before both the shared ticker and the app ticker.
-       * @param {boolean} [options.transparent] -
-       *  **Deprecated since 6.0.0, Use `backgroundAlpha` instead.** \
-       *  `true` sets `backgroundAlpha` to `0`, `false` sets `backgroundAlpha` to `1`.
-       * @param {boolean|'notMultiplied'} [options.useContextAlpha=true] -
-       *  Pass-through value for canvas' context attribute `alpha`. This option is for cases where the
-       *  canvas needs to be opaque, possibly for performance reasons on some older devices.
-       *  If you want to set transparency, please use `backgroundAlpha`. \
-       *  **WebGL Only:** When set to `'notMultiplied'`, the canvas' context attribute `alpha` will be
-       *  set to `true` and `premultipliedAlpha` will be to `false`.
-       * @param {HTMLCanvasElement} [options.view=null] -
-       *  The canvas to use as the view. If omitted, a new canvas will be created.
-       * @param {number} [options.width=800] - The width of the renderer's view.
-       */
-      function Application(options) {
-          var _this = this;
-          /**
-           * The root display container that's rendered.
-           * @member {PIXI.Container}
-           */
-          this.stage = new Container();
-          // The default options
-          options = Object.assign({
-              forceCanvas: false,
-          }, options);
-          this.renderer = autoDetectRenderer(options);
-          // install plugins here
-          Application._plugins.forEach(function (plugin) {
-              plugin.init.call(_this, options);
-          });
-      }
-      /**
-       * Use the {@link PIXI.extensions.add} API to register plugins.
-       * @deprecated since 6.5.0
-       * @static
-       * @param {PIXI.IApplicationPlugin} plugin - Plugin being installed
-       */
-      Application.registerPlugin = function (plugin) {
-          deprecation('6.5.0', 'Application.registerPlugin() is deprecated, use extensions.add()');
-          extensions.add({
-              type: exports.ExtensionType.Application,
-              ref: plugin,
-          });
-      };
-      /** Render the current stage. */
-      Application.prototype.render = function () {
-          this.renderer.render(this.stage);
-      };
-      Object.defineProperty(Application.prototype, "view", {
-          /**
-           * Reference to the renderer's canvas element.
-           * @member {HTMLCanvasElement}
-           * @readonly
-           */
-          get: function () {
-              return this.renderer.view;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(Application.prototype, "screen", {
-          /**
-           * Reference to the renderer's screen rectangle. Its safe to use as `filterArea` or `hitArea` for the whole screen.
-           * @member {PIXI.Rectangle}
-           * @readonly
-           */
-          get: function () {
-              return this.renderer.screen;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /**
-       * Destroy and don't use after this.
-       * @param {boolean} [removeView=false] - Automatically remove canvas from DOM.
-       * @param {object|boolean} [stageOptions] - Options parameter. A boolean will act as if all options
-       *  have been set to that value
-       * @param {boolean} [stageOptions.children=false] - if set to true, all the children will have their destroy
-       *  method called as well. 'stageOptions' will be passed on to those calls.
-       * @param {boolean} [stageOptions.texture=false] - Only used for child Sprites if stageOptions.children is set
-       *  to true. Should it destroy the texture of the child sprite
-       * @param {boolean} [stageOptions.baseTexture=false] - Only used for child Sprites if stageOptions.children is set
-       *  to true. Should it destroy the base texture of the child sprite
-       */
-      Application.prototype.destroy = function (removeView, stageOptions) {
-          var _this = this;
-          // Destroy plugins in the opposite order
-          // which they were constructed
-          var plugins = Application._plugins.slice(0);
-          plugins.reverse();
-          plugins.forEach(function (plugin) {
-              plugin.destroy.call(_this);
-          });
-          this.stage.destroy(stageOptions);
-          this.stage = null;
-          this.renderer.destroy(removeView);
-          this.renderer = null;
-      };
-      /** Collection of installed plugins. */
-      Application._plugins = [];
-      return Application;
-  }());
-  extensions.handleByList(exports.ExtensionType.Application, Application._plugins);
-
-  extensions.add(ResizePlugin);
-
-  /*!
-   * @pixi/mesh-extras - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/mesh-extras is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics$1 = function(d, b) {
-      extendStatics$1 = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics$1(d, b);
-  };
-
-  function __extends$1(d, b) {
-      extendStatics$1(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * @memberof PIXI
-   */
-  var PlaneGeometry = /** @class */ (function (_super) {
-      __extends$1(PlaneGeometry, _super);
-      /**
-       * @param width - The width of the plane.
-       * @param height - The height of the plane.
-       * @param segWidth - Number of horizontal segments.
-       * @param segHeight - Number of vertical segments.
-       */
-      function PlaneGeometry(width, height, segWidth, segHeight) {
-          if (width === void 0) { width = 100; }
-          if (height === void 0) { height = 100; }
-          if (segWidth === void 0) { segWidth = 10; }
-          if (segHeight === void 0) { segHeight = 10; }
-          var _this = _super.call(this) || this;
-          _this.segWidth = segWidth;
-          _this.segHeight = segHeight;
-          _this.width = width;
-          _this.height = height;
-          _this.build();
-          return _this;
-      }
-      /**
-       * Refreshes plane coordinates
-       * @private
-       */
-      PlaneGeometry.prototype.build = function () {
-          var total = this.segWidth * this.segHeight;
-          var verts = [];
-          var uvs = [];
-          var indices = [];
-          var segmentsX = this.segWidth - 1;
-          var segmentsY = this.segHeight - 1;
-          var sizeX = (this.width) / segmentsX;
-          var sizeY = (this.height) / segmentsY;
-          for (var i = 0; i < total; i++) {
-              var x = (i % this.segWidth);
-              var y = ((i / this.segWidth) | 0);
-              verts.push(x * sizeX, y * sizeY);
-              uvs.push(x / segmentsX, y / segmentsY);
-          }
-          var totalSub = segmentsX * segmentsY;
-          for (var i = 0; i < totalSub; i++) {
-              var xpos = i % segmentsX;
-              var ypos = (i / segmentsX) | 0;
-              var value = (ypos * this.segWidth) + xpos;
-              var value2 = (ypos * this.segWidth) + xpos + 1;
-              var value3 = ((ypos + 1) * this.segWidth) + xpos;
-              var value4 = ((ypos + 1) * this.segWidth) + xpos + 1;
-              indices.push(value, value2, value3, value2, value4, value3);
-          }
-          this.buffers[0].data = new Float32Array(verts);
-          this.buffers[1].data = new Float32Array(uvs);
-          this.indexBuffer.data = new Uint16Array(indices);
-          // ensure that the changes are uploaded
-          this.buffers[0].update();
-          this.buffers[1].update();
-          this.indexBuffer.update();
-      };
-      return PlaneGeometry;
-  }(MeshGeometry));
-
-  /**
-   * RopeGeometry allows you to draw a geometry across several points and then manipulate these points.
-   *
-   * ```js
-   * for (let i = 0; i < 20; i++) {
-   *     points.push(new PIXI.Point(i * 50, 0));
-   * };
-   * const rope = new PIXI.RopeGeometry(100, points);
-   * ```
-   * @memberof PIXI
-   */
-  var RopeGeometry = /** @class */ (function (_super) {
-      __extends$1(RopeGeometry, _super);
-      /**
-       * @param width - The width (i.e., thickness) of the rope.
-       * @param points - An array of {@link PIXI.Point} objects to construct this rope.
-       * @param textureScale - By default the rope texture will be stretched to match
-       *     rope length. If textureScale is positive this value will be treated as a scaling
-       *     factor and the texture will preserve its aspect ratio instead. To create a tiling rope
-       *     set baseTexture.wrapMode to {@link PIXI.WRAP_MODES.REPEAT} and use a power of two texture,
-       *     then set textureScale=1 to keep the original texture pixel size.
-       *     In order to reduce alpha channel artifacts provide a larger texture and downsample -
-       *     i.e. set textureScale=0.5 to scale it down twice.
-       */
-      function RopeGeometry(width, points, textureScale) {
-          if (width === void 0) { width = 200; }
-          if (textureScale === void 0) { textureScale = 0; }
-          var _this = _super.call(this, new Float32Array(points.length * 4), new Float32Array(points.length * 4), new Uint16Array((points.length - 1) * 6)) || this;
-          _this.points = points;
-          _this._width = width;
-          _this.textureScale = textureScale;
-          _this.build();
-          return _this;
-      }
-      Object.defineProperty(RopeGeometry.prototype, "width", {
-          /**
-           * The width (i.e., thickness) of the rope.
-           * @readonly
-           */
-          get: function () {
-              return this._width;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Refreshes Rope indices and uvs */
-      RopeGeometry.prototype.build = function () {
-          var points = this.points;
-          if (!points)
-              { return; }
-          var vertexBuffer = this.getBuffer('aVertexPosition');
-          var uvBuffer = this.getBuffer('aTextureCoord');
-          var indexBuffer = this.getIndex();
-          // if too little points, or texture hasn't got UVs set yet just move on.
-          if (points.length < 1) {
-              return;
-          }
-          // if the number of points has changed we will need to recreate the arraybuffers
-          if (vertexBuffer.data.length / 4 !== points.length) {
-              vertexBuffer.data = new Float32Array(points.length * 4);
-              uvBuffer.data = new Float32Array(points.length * 4);
-              indexBuffer.data = new Uint16Array((points.length - 1) * 6);
-          }
-          var uvs = uvBuffer.data;
-          var indices = indexBuffer.data;
-          uvs[0] = 0;
-          uvs[1] = 0;
-          uvs[2] = 0;
-          uvs[3] = 1;
-          var amount = 0;
-          var prev = points[0];
-          var textureWidth = this._width * this.textureScale;
-          var total = points.length; // - 1;
-          for (var i = 0; i < total; i++) {
-              // time to do some smart drawing!
-              var index = i * 4;
-              if (this.textureScale > 0) {
-                  // calculate pixel distance from previous point
-                  var dx = prev.x - points[i].x;
-                  var dy = prev.y - points[i].y;
-                  var distance = Math.sqrt((dx * dx) + (dy * dy));
-                  prev = points[i];
-                  amount += distance / textureWidth;
-              }
-              else {
-                  // stretch texture
-                  amount = i / (total - 1);
-              }
-              uvs[index] = amount;
-              uvs[index + 1] = 0;
-              uvs[index + 2] = amount;
-              uvs[index + 3] = 1;
-          }
-          var indexCount = 0;
-          for (var i = 0; i < total - 1; i++) {
-              var index = i * 2;
-              indices[indexCount++] = index;
-              indices[indexCount++] = index + 1;
-              indices[indexCount++] = index + 2;
-              indices[indexCount++] = index + 2;
-              indices[indexCount++] = index + 1;
-              indices[indexCount++] = index + 3;
-          }
-          // ensure that the changes are uploaded
-          uvBuffer.update();
-          indexBuffer.update();
-          this.updateVertices();
-      };
-      /** refreshes vertices of Rope mesh */
-      RopeGeometry.prototype.updateVertices = function () {
-          var points = this.points;
-          if (points.length < 1) {
-              return;
-          }
-          var lastPoint = points[0];
-          var nextPoint;
-          var perpX = 0;
-          var perpY = 0;
-          var vertices = this.buffers[0].data;
-          var total = points.length;
-          for (var i = 0; i < total; i++) {
-              var point = points[i];
-              var index = i * 4;
-              if (i < points.length - 1) {
-                  nextPoint = points[i + 1];
-              }
-              else {
-                  nextPoint = point;
-              }
-              perpY = -(nextPoint.x - lastPoint.x);
-              perpX = nextPoint.y - lastPoint.y;
-              var perpLength = Math.sqrt((perpX * perpX) + (perpY * perpY));
-              var num = this.textureScale > 0 ? this.textureScale * this._width / 2 : this._width / 2;
-              perpX /= perpLength;
-              perpY /= perpLength;
-              perpX *= num;
-              perpY *= num;
-              vertices[index] = point.x + perpX;
-              vertices[index + 1] = point.y + perpY;
-              vertices[index + 2] = point.x - perpX;
-              vertices[index + 3] = point.y - perpY;
-              lastPoint = point;
-          }
-          this.buffers[0].update();
-      };
-      RopeGeometry.prototype.update = function () {
-          if (this.textureScale > 0) {
-              this.build(); // we need to update UVs
-          }
-          else {
-              this.updateVertices();
-          }
-      };
-      return RopeGeometry;
-  }(MeshGeometry));
-
-  /**
-   * The rope allows you to draw a texture across several points and then manipulate these points
-   *
-   *```js
-   * for (let i = 0; i < 20; i++) {
-   *     points.push(new PIXI.Point(i * 50, 0));
-   * };
-   * let rope = new PIXI.SimpleRope(PIXI.Texture.from("snake.png"), points);
-   *  ```
-   * @memberof PIXI
-   */
-  var SimpleRope = /** @class */ (function (_super) {
-      __extends$1(SimpleRope, _super);
-      /**
-       * @param texture - The texture to use on the rope.
-       * @param points - An array of {@link PIXI.Point} objects to construct this rope.
-       * @param {number} textureScale - Optional. Positive values scale rope texture
-       * keeping its aspect ratio. You can reduce alpha channel artifacts by providing a larger texture
-       * and downsampling here. If set to zero, texture will be stretched instead.
-       */
-      function SimpleRope(texture, points, textureScale) {
-          if (textureScale === void 0) { textureScale = 0; }
-          var _this = this;
-          var ropeGeometry = new RopeGeometry(texture.height, points, textureScale);
-          var meshMaterial = new MeshMaterial(texture);
-          if (textureScale > 0) {
-              // attempt to set UV wrapping, will fail on non-power of two textures
-              texture.baseTexture.wrapMode = exports.WRAP_MODES.REPEAT;
-          }
-          _this = _super.call(this, ropeGeometry, meshMaterial) || this;
-          /**
-           * re-calculate vertices by rope points each frame
-           * @member {boolean}
-           */
-          _this.autoUpdate = true;
-          return _this;
-      }
-      SimpleRope.prototype._render = function (renderer) {
-          var geometry = this.geometry;
-          if (this.autoUpdate || geometry._width !== this.shader.texture.height) {
-              geometry._width = this.shader.texture.height;
-              geometry.update();
-          }
-          _super.prototype._render.call(this, renderer);
-      };
-      return SimpleRope;
-  }(Mesh));
-
-  /**
-   * The SimplePlane allows you to draw a texture across several points and then manipulate these points
-   *
-   *```js
-   * for (let i = 0; i < 20; i++) {
-   *     points.push(new PIXI.Point(i * 50, 0));
-   * };
-   * let SimplePlane = new PIXI.SimplePlane(PIXI.Texture.from("snake.png"), points);
-   *  ```
-   * @memberof PIXI
-   */
-  var SimplePlane = /** @class */ (function (_super) {
-      __extends$1(SimplePlane, _super);
-      /**
-       * @param texture - The texture to use on the SimplePlane.
-       * @param verticesX - The number of vertices in the x-axis
-       * @param verticesY - The number of vertices in the y-axis
-       */
-      function SimplePlane(texture, verticesX, verticesY) {
-          var _this = this;
-          var planeGeometry = new PlaneGeometry(texture.width, texture.height, verticesX, verticesY);
-          var meshMaterial = new MeshMaterial(Texture.WHITE);
-          _this = _super.call(this, planeGeometry, meshMaterial) || this;
-          // lets call the setter to ensure all necessary updates are performed
-          _this.texture = texture;
-          _this.autoResize = true;
-          return _this;
-      }
-      /**
-       * Method used for overrides, to do something in case texture frame was changed.
-       * Meshes based on plane can override it and change more details based on texture.
-       */
-      SimplePlane.prototype.textureUpdated = function () {
-          this._textureID = this.shader.texture._updateID;
-          var geometry = this.geometry;
-          var _a = this.shader.texture, width = _a.width, height = _a.height;
-          if (this.autoResize && (geometry.width !== width || geometry.height !== height)) {
-              geometry.width = this.shader.texture.width;
-              geometry.height = this.shader.texture.height;
-              geometry.build();
-          }
-      };
-      Object.defineProperty(SimplePlane.prototype, "texture", {
-          get: function () {
-              return this.shader.texture;
-          },
-          set: function (value) {
-              // Track texture same way sprite does.
-              // For generated meshes like NineSlicePlane it can change the geometry.
-              // Unfortunately, this method might not work if you directly change texture in material.
-              if (this.shader.texture === value) {
-                  return;
-              }
-              this.shader.texture = value;
-              this._textureID = -1;
-              if (value.baseTexture.valid) {
-                  this.textureUpdated();
-              }
-              else {
-                  value.once('update', this.textureUpdated, this);
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      SimplePlane.prototype._render = function (renderer) {
-          if (this._textureID !== this.shader.texture._updateID) {
-              this.textureUpdated();
-          }
-          _super.prototype._render.call(this, renderer);
-      };
-      SimplePlane.prototype.destroy = function (options) {
-          this.shader.texture.off('update', this.textureUpdated, this);
-          _super.prototype.destroy.call(this, options);
-      };
-      return SimplePlane;
-  }(Mesh));
-
-  /**
-   * The Simple Mesh class mimics Mesh in PixiJS v4, providing easy-to-use constructor arguments.
-   * For more robust customization, use {@link PIXI.Mesh}.
-   * @memberof PIXI
-   */
-  var SimpleMesh = /** @class */ (function (_super) {
-      __extends$1(SimpleMesh, _super);
-      /**
-       * @param texture - The texture to use
-       * @param {Float32Array} [vertices] - if you want to specify the vertices
-       * @param {Float32Array} [uvs] - if you want to specify the uvs
-       * @param {Uint16Array} [indices] - if you want to specify the indices
-       * @param drawMode - the drawMode, can be any of the Mesh.DRAW_MODES consts
-       */
-      function SimpleMesh(texture, vertices, uvs, indices, drawMode) {
-          if (texture === void 0) { texture = Texture.EMPTY; }
-          var _this = this;
-          var geometry = new MeshGeometry(vertices, uvs, indices);
-          geometry.getBuffer('aVertexPosition').static = false;
-          var meshMaterial = new MeshMaterial(texture);
-          _this = _super.call(this, geometry, meshMaterial, null, drawMode) || this;
-          _this.autoUpdate = true;
-          return _this;
-      }
-      Object.defineProperty(SimpleMesh.prototype, "vertices", {
-          /**
-           * Collection of vertices data.
-           * @type {Float32Array}
-           */
-          get: function () {
-              return this.geometry.getBuffer('aVertexPosition').data;
-          },
-          set: function (value) {
-              this.geometry.getBuffer('aVertexPosition').data = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      SimpleMesh.prototype._render = function (renderer) {
-          if (this.autoUpdate) {
-              this.geometry.getBuffer('aVertexPosition').update();
-          }
-          _super.prototype._render.call(this, renderer);
-      };
-      return SimpleMesh;
-  }(Mesh));
-
-  var DEFAULT_BORDER_SIZE = 10;
-  /**
-   * The NineSlicePlane allows you to stretch a texture using 9-slice scaling. The corners will remain unscaled (useful
-   * for buttons with rounded corners for example) and the other areas will be scaled horizontally and or vertically
-   *
-   *```js
-   * let Plane9 = new PIXI.NineSlicePlane(PIXI.Texture.from('BoxWithRoundedCorners.png'), 15, 15, 15, 15);
-   *  ```
-   * <pre>
-   *      A                          B
-   *    +---+----------------------+---+
-   *  C | 1 |          2           | 3 |
-   *    +---+----------------------+---+
-   *    |   |                      |   |
-   *    | 4 |          5           | 6 |
-   *    |   |                      |   |
-   *    +---+----------------------+---+
-   *  D | 7 |          8           | 9 |
-   *    +---+----------------------+---+
-   *  When changing this objects width and/or height:
-   *     areas 1 3 7 and 9 will remain unscaled.
-   *     areas 2 and 8 will be stretched horizontally
-   *     areas 4 and 6 will be stretched vertically
-   *     area 5 will be stretched both horizontally and vertically
-   * </pre>
-   * @memberof PIXI
-   */
-  var NineSlicePlane = /** @class */ (function (_super) {
-      __extends$1(NineSlicePlane, _super);
-      /**
-       * @param texture - The texture to use on the NineSlicePlane.
-       * @param {number} [leftWidth=10] - size of the left vertical bar (A)
-       * @param {number} [topHeight=10] - size of the top horizontal bar (C)
-       * @param {number} [rightWidth=10] - size of the right vertical bar (B)
-       * @param {number} [bottomHeight=10] - size of the bottom horizontal bar (D)
-       */
-      function NineSlicePlane(texture, leftWidth, topHeight, rightWidth, bottomHeight) {
-          if (leftWidth === void 0) { leftWidth = DEFAULT_BORDER_SIZE; }
-          if (topHeight === void 0) { topHeight = DEFAULT_BORDER_SIZE; }
-          if (rightWidth === void 0) { rightWidth = DEFAULT_BORDER_SIZE; }
-          if (bottomHeight === void 0) { bottomHeight = DEFAULT_BORDER_SIZE; }
-          var _this = _super.call(this, Texture.WHITE, 4, 4) || this;
-          _this._origWidth = texture.orig.width;
-          _this._origHeight = texture.orig.height;
-          /** The width of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
-          _this._width = _this._origWidth;
-          /** The height of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
-          _this._height = _this._origHeight;
-          _this._leftWidth = leftWidth;
-          _this._rightWidth = rightWidth;
-          _this._topHeight = topHeight;
-          _this._bottomHeight = bottomHeight;
-          // lets call the setter to ensure all necessary updates are performed
-          _this.texture = texture;
-          return _this;
-      }
-      NineSlicePlane.prototype.textureUpdated = function () {
-          this._textureID = this.shader.texture._updateID;
-          this._refresh();
-      };
-      Object.defineProperty(NineSlicePlane.prototype, "vertices", {
-          get: function () {
-              return this.geometry.getBuffer('aVertexPosition').data;
-          },
-          set: function (value) {
-              this.geometry.getBuffer('aVertexPosition').data = value;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Updates the horizontal vertices. */
-      NineSlicePlane.prototype.updateHorizontalVertices = function () {
-          var vertices = this.vertices;
-          var scale = this._getMinScale();
-          vertices[9] = vertices[11] = vertices[13] = vertices[15] = this._topHeight * scale;
-          vertices[17] = vertices[19] = vertices[21] = vertices[23] = this._height - (this._bottomHeight * scale);
-          vertices[25] = vertices[27] = vertices[29] = vertices[31] = this._height;
-      };
-      /** Updates the vertical vertices. */
-      NineSlicePlane.prototype.updateVerticalVertices = function () {
-          var vertices = this.vertices;
-          var scale = this._getMinScale();
-          vertices[2] = vertices[10] = vertices[18] = vertices[26] = this._leftWidth * scale;
-          vertices[4] = vertices[12] = vertices[20] = vertices[28] = this._width - (this._rightWidth * scale);
-          vertices[6] = vertices[14] = vertices[22] = vertices[30] = this._width;
-      };
-      /**
-       * Returns the smaller of a set of vertical and horizontal scale of nine slice corners.
-       * @returns Smaller number of vertical and horizontal scale.
-       */
-      NineSlicePlane.prototype._getMinScale = function () {
-          var w = this._leftWidth + this._rightWidth;
-          var scaleW = this._width > w ? 1.0 : this._width / w;
-          var h = this._topHeight + this._bottomHeight;
-          var scaleH = this._height > h ? 1.0 : this._height / h;
-          var scale = Math.min(scaleW, scaleH);
-          return scale;
-      };
-      Object.defineProperty(NineSlicePlane.prototype, "width", {
-          /** The width of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
-          get: function () {
-              return this._width;
-          },
-          set: function (value) {
-              this._width = value;
-              this._refresh();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(NineSlicePlane.prototype, "height", {
-          /** The height of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
-          get: function () {
-              return this._height;
-          },
-          set: function (value) {
-              this._height = value;
-              this._refresh();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(NineSlicePlane.prototype, "leftWidth", {
-          /** The width of the left column. */
-          get: function () {
-              return this._leftWidth;
-          },
-          set: function (value) {
-              this._leftWidth = value;
-              this._refresh();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(NineSlicePlane.prototype, "rightWidth", {
-          /** The width of the right column. */
-          get: function () {
-              return this._rightWidth;
-          },
-          set: function (value) {
-              this._rightWidth = value;
-              this._refresh();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(NineSlicePlane.prototype, "topHeight", {
-          /** The height of the top row. */
-          get: function () {
-              return this._topHeight;
-          },
-          set: function (value) {
-              this._topHeight = value;
-              this._refresh();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(NineSlicePlane.prototype, "bottomHeight", {
-          /** The height of the bottom row. */
-          get: function () {
-              return this._bottomHeight;
-          },
-          set: function (value) {
-              this._bottomHeight = value;
-              this._refresh();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      /** Refreshes NineSlicePlane coords. All of them. */
-      NineSlicePlane.prototype._refresh = function () {
-          var texture = this.texture;
-          var uvs = this.geometry.buffers[1].data;
-          this._origWidth = texture.orig.width;
-          this._origHeight = texture.orig.height;
-          var _uvw = 1.0 / this._origWidth;
-          var _uvh = 1.0 / this._origHeight;
-          uvs[0] = uvs[8] = uvs[16] = uvs[24] = 0;
-          uvs[1] = uvs[3] = uvs[5] = uvs[7] = 0;
-          uvs[6] = uvs[14] = uvs[22] = uvs[30] = 1;
-          uvs[25] = uvs[27] = uvs[29] = uvs[31] = 1;
-          uvs[2] = uvs[10] = uvs[18] = uvs[26] = _uvw * this._leftWidth;
-          uvs[4] = uvs[12] = uvs[20] = uvs[28] = 1 - (_uvw * this._rightWidth);
-          uvs[9] = uvs[11] = uvs[13] = uvs[15] = _uvh * this._topHeight;
-          uvs[17] = uvs[19] = uvs[21] = uvs[23] = 1 - (_uvh * this._bottomHeight);
-          this.updateHorizontalVertices();
-          this.updateVerticalVertices();
-          this.geometry.buffers[0].update();
-          this.geometry.buffers[1].update();
-      };
-      return NineSlicePlane;
-  }(SimplePlane));
-
-  /*!
-   * @pixi/sprite-animated - v6.5.10
-   * Compiled Thu, 06 Jul 2023 15:25:11 UTC
-   *
-   * @pixi/sprite-animated is licensed under the MIT License.
-   * http://www.opensource.org/licenses/mit-license
-   */
-
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-  /* global Reflect, Promise */
-
-  var extendStatics = function(d, b) {
-      extendStatics = Object.setPrototypeOf ||
-          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-          function (d, b) { for (var p in b) { if (b.hasOwnProperty(p)) { d[p] = b[p]; } } };
-      return extendStatics(d, b);
-  };
-
-  function __extends(d, b) {
-      extendStatics(d, b);
-      function __() { this.constructor = d; }
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  }
-
-  /**
-   * An AnimatedSprite is a simple way to display an animation depicted by a list of textures.
-   *
-   * ```js
-   * let alienImages = ["image_sequence_01.png","image_sequence_02.png","image_sequence_03.png","image_sequence_04.png"];
-   * let textureArray = [];
-   *
-   * for (let i=0; i < 4; i++)
-   * {
-   *      let texture = PIXI.Texture.from(alienImages[i]);
-   *      textureArray.push(texture);
-   * };
-   *
-   * let animatedSprite = new PIXI.AnimatedSprite(textureArray);
-   * ```
-   *
-   * The more efficient and simpler way to create an animated sprite is using a {@link PIXI.Spritesheet}
-   * containing the animation definitions:
-   *
-   * ```js
-   * PIXI.Loader.shared.add("assets/spritesheet.json").load(setup);
-   *
-   * function setup() {
-   *   let sheet = PIXI.Loader.shared.resources["assets/spritesheet.json"].spritesheet;
-   *   animatedSprite = new PIXI.AnimatedSprite(sheet.animations["image_sequence"]);
-   *   ...
-   * }
-   * ```
-   * @memberof PIXI
-   */
-  var AnimatedSprite = /** @class */ (function (_super) {
-      __extends(AnimatedSprite, _super);
-      /**
-       * @param textures - An array of {@link PIXI.Texture} or frame
-       *  objects that make up the animation.
-       * @param {boolean} [autoUpdate=true] - Whether to use PIXI.Ticker.shared to auto update animation time.
-       */
-      function AnimatedSprite(textures, autoUpdate) {
-          if (autoUpdate === void 0) { autoUpdate = true; }
-          var _this = _super.call(this, textures[0] instanceof Texture ? textures[0] : textures[0].texture) || this;
-          _this._textures = null;
-          _this._durations = null;
-          _this._autoUpdate = autoUpdate;
-          _this._isConnectedToTicker = false;
-          _this.animationSpeed = 1;
-          _this.loop = true;
-          _this.updateAnchor = false;
-          _this.onComplete = null;
-          _this.onFrameChange = null;
-          _this.onLoop = null;
-          _this._currentTime = 0;
-          _this._playing = false;
-          _this._previousFrame = null;
-          _this.textures = textures;
-          return _this;
-      }
-      /** Stops the AnimatedSprite. */
-      AnimatedSprite.prototype.stop = function () {
-          if (!this._playing) {
-              return;
-          }
-          this._playing = false;
-          if (this._autoUpdate && this._isConnectedToTicker) {
-              Ticker.shared.remove(this.update, this);
-              this._isConnectedToTicker = false;
-          }
-      };
-      /** Plays the AnimatedSprite. */
-      AnimatedSprite.prototype.play = function () {
-          if (this._playing) {
-              return;
-          }
-          this._playing = true;
-          if (this._autoUpdate && !this._isConnectedToTicker) {
-              Ticker.shared.add(this.update, this, exports.UPDATE_PRIORITY.HIGH);
-              this._isConnectedToTicker = true;
-          }
-      };
-      /**
-       * Stops the AnimatedSprite and goes to a specific frame.
-       * @param frameNumber - Frame index to stop at.
-       */
-      AnimatedSprite.prototype.gotoAndStop = function (frameNumber) {
-          this.stop();
-          var previousFrame = this.currentFrame;
-          this._currentTime = frameNumber;
-          if (previousFrame !== this.currentFrame) {
-              this.updateTexture();
-          }
-      };
-      /**
-       * Goes to a specific frame and begins playing the AnimatedSprite.
-       * @param frameNumber - Frame index to start at.
-       */
-      AnimatedSprite.prototype.gotoAndPlay = function (frameNumber) {
-          var previousFrame = this.currentFrame;
-          this._currentTime = frameNumber;
-          if (previousFrame !== this.currentFrame) {
-              this.updateTexture();
-          }
-          this.play();
-      };
-      /**
-       * Updates the object transform for rendering.
-       * @param deltaTime - Time since last tick.
-       */
-      AnimatedSprite.prototype.update = function (deltaTime) {
-          if (!this._playing) {
-              return;
-          }
-          var elapsed = this.animationSpeed * deltaTime;
-          var previousFrame = this.currentFrame;
-          if (this._durations !== null) {
-              var lag = this._currentTime % 1 * this._durations[this.currentFrame];
-              lag += elapsed / 60 * 1000;
-              while (lag < 0) {
-                  this._currentTime--;
-                  lag += this._durations[this.currentFrame];
-              }
-              var sign = Math.sign(this.animationSpeed * deltaTime);
-              this._currentTime = Math.floor(this._currentTime);
-              while (lag >= this._durations[this.currentFrame]) {
-                  lag -= this._durations[this.currentFrame] * sign;
-                  this._currentTime += sign;
-              }
-              this._currentTime += lag / this._durations[this.currentFrame];
-          }
-          else {
-              this._currentTime += elapsed;
-          }
-          if (this._currentTime < 0 && !this.loop) {
-              this.gotoAndStop(0);
-              if (this.onComplete) {
-                  this.onComplete();
-              }
-          }
-          else if (this._currentTime >= this._textures.length && !this.loop) {
-              this.gotoAndStop(this._textures.length - 1);
-              if (this.onComplete) {
-                  this.onComplete();
-              }
-          }
-          else if (previousFrame !== this.currentFrame) {
-              if (this.loop && this.onLoop) {
-                  if (this.animationSpeed > 0 && this.currentFrame < previousFrame) {
-                      this.onLoop();
-                  }
-                  else if (this.animationSpeed < 0 && this.currentFrame > previousFrame) {
-                      this.onLoop();
-                  }
-              }
-              this.updateTexture();
-          }
-      };
-      /** Updates the displayed texture to match the current frame index. */
-      AnimatedSprite.prototype.updateTexture = function () {
-          var currentFrame = this.currentFrame;
-          if (this._previousFrame === currentFrame) {
-              return;
-          }
-          this._previousFrame = currentFrame;
-          this._texture = this._textures[currentFrame];
-          this._textureID = -1;
-          this._textureTrimmedID = -1;
-          this._cachedTint = 0xFFFFFF;
-          this.uvs = this._texture._uvs.uvsFloat32;
-          if (this.updateAnchor) {
-              this._anchor.copyFrom(this._texture.defaultAnchor);
-          }
-          if (this.onFrameChange) {
-              this.onFrameChange(this.currentFrame);
-          }
-      };
-      /**
-       * Stops the AnimatedSprite and destroys it.
-       * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
-       *  have been set to that value.
-       * @param {boolean} [options.children=false] - If set to true, all the children will have their destroy
-       *      method called as well. 'options' will be passed on to those calls.
-       * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well.
-       * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well.
-       */
-      AnimatedSprite.prototype.destroy = function (options) {
-          this.stop();
-          _super.prototype.destroy.call(this, options);
-          this.onComplete = null;
-          this.onFrameChange = null;
-          this.onLoop = null;
-      };
-      /**
-       * A short hand way of creating an AnimatedSprite from an array of frame ids.
-       * @param frames - The array of frames ids the AnimatedSprite will use as its texture frames.
-       * @returns - The new animated sprite with the specified frames.
-       */
-      AnimatedSprite.fromFrames = function (frames) {
-          var textures = [];
-          for (var i = 0; i < frames.length; ++i) {
-              textures.push(Texture.from(frames[i]));
-          }
-          return new AnimatedSprite(textures);
-      };
-      /**
-       * A short hand way of creating an AnimatedSprite from an array of image ids.
-       * @param images - The array of image urls the AnimatedSprite will use as its texture frames.
-       * @returns The new animate sprite with the specified images as frames.
-       */
-      AnimatedSprite.fromImages = function (images) {
-          var textures = [];
-          for (var i = 0; i < images.length; ++i) {
-              textures.push(Texture.from(images[i]));
-          }
-          return new AnimatedSprite(textures);
-      };
-      Object.defineProperty(AnimatedSprite.prototype, "totalFrames", {
-          /**
-           * The total number of frames in the AnimatedSprite. This is the same as number of textures
-           * assigned to the AnimatedSprite.
-           * @readonly
-           * @default 0
-           */
-          get: function () {
-              return this._textures.length;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(AnimatedSprite.prototype, "textures", {
-          /** The array of textures used for this AnimatedSprite. */
-          get: function () {
-              return this._textures;
-          },
-          set: function (value) {
-              if (value[0] instanceof Texture) {
-                  this._textures = value;
-                  this._durations = null;
-              }
-              else {
-                  this._textures = [];
-                  this._durations = [];
-                  for (var i = 0; i < value.length; i++) {
-                      this._textures.push(value[i].texture);
-                      this._durations.push(value[i].time);
-                  }
-              }
-              this._previousFrame = null;
-              this.gotoAndStop(0);
-              this.updateTexture();
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(AnimatedSprite.prototype, "currentFrame", {
-          /**
-           * The AnimatedSprites current frame index.
-           * @readonly
-           */
-          get: function () {
-              var currentFrame = Math.floor(this._currentTime) % this._textures.length;
-              if (currentFrame < 0) {
-                  currentFrame += this._textures.length;
-              }
-              return currentFrame;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(AnimatedSprite.prototype, "playing", {
-          /**
-           * Indicates if the AnimatedSprite is currently playing.
-           * @readonly
-           */
-          get: function () {
-              return this._playing;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(AnimatedSprite.prototype, "autoUpdate", {
-          /** Whether to use PIXI.Ticker.shared to auto update animation time. */
-          get: function () {
-              return this._autoUpdate;
-          },
-          set: function (value) {
-              if (value !== this._autoUpdate) {
-                  this._autoUpdate = value;
-                  if (!this._autoUpdate && this._isConnectedToTicker) {
-                      Ticker.shared.remove(this.update, this);
-                      this._isConnectedToTicker = false;
-                  }
-                  else if (this._autoUpdate && !this._isConnectedToTicker && this._playing) {
-                      Ticker.shared.add(this.update, this);
-                      this._isConnectedToTicker = true;
-                  }
-              }
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return AnimatedSprite;
-  }(Sprite));
-
-  extensions.add(
-  // Install renderer plugins
-  AccessibilityManager, Extract, InteractionManager, ParticleRenderer, Prepare, BatchRenderer, TilingSpriteRenderer, 
-  // Install loader plugins
-  BitmapFontLoader, CompressedTextureLoader, DDSLoader, KTXLoader, SpritesheetLoader, 
-  // Install application plugins
-  TickerPlugin, AppLoaderPlugin);
-  /**
-   * This namespace contains WebGL-only display filters that can be applied
-   * to DisplayObjects using the {@link PIXI.DisplayObject#filters filters} property.
-   *
-   * Since PixiJS only had a handful of built-in filters, additional filters
-   * can be downloaded {@link https://github.com/pixijs/pixi-filters here} from the
-   * PixiJS Filters repository.
-   *
-   * All filters must extend {@link PIXI.Filter}.
-   * @example
-   * // Create a new application
-   * const app = new PIXI.Application();
-   *
-   * // Draw a green rectangle
-   * const rect = new PIXI.Graphics()
-   *     .beginFill(0x00ff00)
-   *     .drawRect(40, 40, 200, 200);
-   *
-   * // Add a blur filter
-   * rect.filters = [new PIXI.filters.BlurFilter()];
-   *
-   * // Display rectangle
-   * app.stage.addChild(rect);
-   * document.body.appendChild(app.view);
-   * @namespace PIXI.filters
-   */
-  var filters = {
-      AlphaFilter: AlphaFilter,
-      BlurFilter: BlurFilter,
-      BlurFilterPass: BlurFilterPass,
-      ColorMatrixFilter: ColorMatrixFilter,
-      DisplacementFilter: DisplacementFilter,
-      FXAAFilter: FXAAFilter,
-      NoiseFilter: NoiseFilter,
-  };
-
-  exports.AbstractBatchRenderer = AbstractBatchRenderer;
-  exports.AbstractMultiResource = AbstractMultiResource;
-  exports.AbstractRenderer = AbstractRenderer;
-  exports.AccessibilityManager = AccessibilityManager;
-  exports.AnimatedSprite = AnimatedSprite;
-  exports.AppLoaderPlugin = AppLoaderPlugin;
-  exports.Application = Application;
-  exports.ArrayResource = ArrayResource;
-  exports.Attribute = Attribute;
-  exports.BaseImageResource = BaseImageResource;
-  exports.BasePrepare = BasePrepare;
-  exports.BaseRenderTexture = BaseRenderTexture;
-  exports.BaseTexture = BaseTexture;
-  exports.BatchDrawCall = BatchDrawCall;
-  exports.BatchGeometry = BatchGeometry;
-  exports.BatchPluginFactory = BatchPluginFactory;
-  exports.BatchRenderer = BatchRenderer;
-  exports.BatchShaderGenerator = BatchShaderGenerator;
-  exports.BatchSystem = BatchSystem;
-  exports.BatchTextureArray = BatchTextureArray;
-  exports.BitmapFont = BitmapFont;
-  exports.BitmapFontData = BitmapFontData;
-  exports.BitmapFontLoader = BitmapFontLoader;
-  exports.BitmapText = BitmapText;
-  exports.BlobResource = BlobResource;
-  exports.Bounds = Bounds;
-  exports.BrowserAdapter = BrowserAdapter;
-  exports.Buffer = Buffer;
-  exports.BufferResource = BufferResource;
-  exports.CanvasResource = CanvasResource;
-  exports.Circle = Circle;
-  exports.CompressedTextureLoader = CompressedTextureLoader;
-  exports.CompressedTextureResource = CompressedTextureResource;
-  exports.Container = Container;
-  exports.ContextSystem = ContextSystem;
-  exports.CountLimiter = CountLimiter;
-  exports.CubeResource = CubeResource;
-  exports.DDSLoader = DDSLoader;
-  exports.DEG_TO_RAD = DEG_TO_RAD;
-  exports.DisplayObject = DisplayObject;
-  exports.Ellipse = Ellipse;
-  exports.Extract = Extract;
-  exports.FORMATS_TO_COMPONENTS = FORMATS_TO_COMPONENTS;
-  exports.FillStyle = FillStyle;
-  exports.Filter = Filter;
-  exports.FilterState = FilterState;
-  exports.FilterSystem = FilterSystem;
-  exports.Framebuffer = Framebuffer;
-  exports.FramebufferSystem = FramebufferSystem;
-  exports.GLFramebuffer = GLFramebuffer;
-  exports.GLProgram = GLProgram;
-  exports.GLTexture = GLTexture;
-  exports.GRAPHICS_CURVES = GRAPHICS_CURVES;
-  exports.Geometry = Geometry;
-  exports.GeometrySystem = GeometrySystem;
-  exports.Graphics = Graphics;
-  exports.GraphicsData = GraphicsData;
-  exports.GraphicsGeometry = GraphicsGeometry;
-  exports.IGLUniformData = IGLUniformData;
-  exports.INSTALLED = INSTALLED;
-  exports.INTERNAL_FORMAT_TO_BYTES_PER_PIXEL = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL;
-  exports.ImageBitmapResource = ImageBitmapResource;
-  exports.ImageResource = ImageResource;
-  exports.InteractionData = InteractionData;
-  exports.InteractionEvent = InteractionEvent;
-  exports.InteractionManager = InteractionManager;
-  exports.InteractionTrackingData = InteractionTrackingData;
-  exports.KTXLoader = KTXLoader;
-  exports.LineStyle = LineStyle;
-  exports.Loader = Loader;
-  exports.MaskData = MaskData;
-  exports.MaskSystem = MaskSystem;
-  exports.Matrix = Matrix;
-  exports.Mesh = Mesh;
-  exports.MeshBatchUvs = MeshBatchUvs;
-  exports.MeshGeometry = MeshGeometry;
-  exports.MeshMaterial = MeshMaterial;
-  exports.NineSlicePlane = NineSlicePlane;
-  exports.ObjectRenderer = ObjectRenderer;
-  exports.ObservablePoint = ObservablePoint;
-  exports.PI_2 = PI_2;
-  exports.ParticleContainer = ParticleContainer;
-  exports.ParticleRenderer = ParticleRenderer;
-  exports.PlaneGeometry = PlaneGeometry;
-  exports.Point = Point;
-  exports.Polygon = Polygon;
-  exports.Prepare = Prepare;
-  exports.Program = Program;
-  exports.ProjectionSystem = ProjectionSystem;
-  exports.Quad = Quad;
-  exports.QuadUv = QuadUv;
-  exports.RAD_TO_DEG = RAD_TO_DEG;
-  exports.Rectangle = Rectangle;
-  exports.RenderTexture = RenderTexture;
-  exports.RenderTexturePool = RenderTexturePool;
-  exports.RenderTextureSystem = RenderTextureSystem;
-  exports.Renderer = Renderer;
-  exports.ResizePlugin = ResizePlugin;
-  exports.Resource = Resource;
-  exports.RopeGeometry = RopeGeometry;
-  exports.RoundedRectangle = RoundedRectangle;
-  exports.Runner = Runner;
-  exports.SVGResource = SVGResource;
-  exports.ScissorSystem = ScissorSystem;
-  exports.Shader = Shader;
-  exports.ShaderSystem = ShaderSystem;
-  exports.SimpleMesh = SimpleMesh;
-  exports.SimplePlane = SimplePlane;
-  exports.SimpleRope = SimpleRope;
-  exports.Sprite = Sprite;
-  exports.SpriteMaskFilter = SpriteMaskFilter;
-  exports.Spritesheet = Spritesheet;
-  exports.SpritesheetLoader = SpritesheetLoader;
-  exports.State = State;
-  exports.StateSystem = StateSystem;
-  exports.StencilSystem = StencilSystem;
-  exports.System = System;
-  exports.TYPES_TO_BYTES_PER_COMPONENT = TYPES_TO_BYTES_PER_COMPONENT;
-  exports.TYPES_TO_BYTES_PER_PIXEL = TYPES_TO_BYTES_PER_PIXEL;
-  exports.TemporaryDisplayObject = TemporaryDisplayObject;
-  exports.Text = Text;
-  exports.TextFormat = TextFormat;
-  exports.TextMetrics = TextMetrics;
-  exports.TextStyle = TextStyle;
-  exports.Texture = Texture;
-  exports.TextureGCSystem = TextureGCSystem;
-  exports.TextureLoader = TextureLoader;
-  exports.TextureMatrix = TextureMatrix;
-  exports.TextureSystem = TextureSystem;
-  exports.TextureUvs = TextureUvs;
-  exports.Ticker = Ticker;
-  exports.TickerPlugin = TickerPlugin;
-  exports.TilingSprite = TilingSprite;
-  exports.TilingSpriteRenderer = TilingSpriteRenderer;
-  exports.TimeLimiter = TimeLimiter;
-  exports.Transform = Transform;
-  exports.UniformGroup = UniformGroup;
-  exports.VERSION = VERSION;
-  exports.VideoResource = VideoResource;
-  exports.ViewableBuffer = ViewableBuffer;
-  exports.XMLFormat = XMLFormat;
-  exports.XMLStringFormat = XMLStringFormat;
-  exports.accessibleTarget = accessibleTarget;
-  exports.autoDetectFormat = autoDetectFormat;
-  exports.autoDetectRenderer = autoDetectRenderer;
-  exports.autoDetectResource = autoDetectResource;
-  exports.checkMaxIfStatementsInShader = checkMaxIfStatementsInShader;
-  exports.createUBOElements = createUBOElements;
-  exports.defaultFilterVertex = defaultFilterVertex;
-  exports.defaultVertex = defaultVertex$1;
-  exports.extensions = extensions;
-  exports.filters = filters;
-  exports.generateProgram = generateProgram;
-  exports.generateUniformBufferSync = generateUniformBufferSync;
-  exports.getTestContext = getTestContext;
-  exports.getUBOData = getUBOData;
-  exports.graphicsUtils = graphicsUtils;
-  exports.groupD8 = groupD8;
-  exports.interactiveTarget = interactiveTarget;
-  exports.isMobile = isMobile;
-  exports.parseDDS = parseDDS;
-  exports.parseKTX = parseKTX;
-  exports.resources = resources;
-  exports.settings = settings;
-  exports.systems = systems;
-  exports.uniformParsers = uniformParsers;
-  exports.utils = utils;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-  return exports;
-
-})({});
-//# sourceMappingURL=pixi.js.map

From dd911d7a2105a39a34cb40a27b583fd7f201f877 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 14:27:30 -0500
Subject: [PATCH 068/188] Scope: added (disabled) benchmark for time spent
 drawing

---
 IDE/frontend-dev/scope-src/scope-browser.js | 21 +++++++++++++++++++++
 IDE/public/gui/js/GuiHandler.js             | 13 +++++++++++++
 IDE/public/scope/index.html                 |  4 +++-
 IDE/public/scope/js/bundle.js               | 21 +++++++++++++++++++++
 4 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 0a45973eb..c92a74c6d 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -378,9 +378,17 @@ function CPU(data){
     }
   };
   
+  const benchmarkDrawing = false;
+  const plotRuns = 50;
+  let plotRunsSum = 0;
+  let plotRunsStart = 0;
+  let plotRunsIdx = 0;
   function plotLoop(){
     if (plot){
       plot = false;
+      let start;
+      if(benchmarkDrawing)
+        start = performance.now();
       ctx.clear();
       let minY = 0;
       let maxY = renderer.height;
@@ -418,6 +426,19 @@ function CPU(data){
       }
       renderer.render(stage);
       triggerStatus();
+      if(benchmarkDrawing) {
+        let stop = performance.now();
+        let dur = stop - start;
+        plotRunsSum += dur;
+        plotRunsIdx++;
+        if(plotRunsIdx >= plotRuns) {
+          let perc = plotRunsSum / (stop - plotRunsStart) * 100;
+          console.log("sum: " + plotRunsSum.toFixed(2) + ", avg: ", + perc.toFixed(2) + "%, avg fps: ", plotRuns / ((stop - plotRunsStart) / 1000));
+          plotRunsSum = 0;
+          plotRunsIdx = 0;
+          plotRunsStart = stop;
+        }
+      }
     } /*else {
       console.log('not plotting');
     }*/
diff --git a/IDE/public/gui/js/GuiHandler.js b/IDE/public/gui/js/GuiHandler.js
index ed31d9e93..d328ac9bc 100644
--- a/IDE/public/gui/js/GuiHandler.js
+++ b/IDE/public/gui/js/GuiHandler.js
@@ -1,5 +1,18 @@
 import * as utils from './utils.js'
 import GuiCreator from './GuiCreator.js'
+function setup() {
+	console.log("P5 setup");
+}
+
+function draw() {
+	console.log("DRAW")
+	background(0); // Set the background to black
+	y = y - 1;
+	if (y < 0) {
+		y = height;
+	}
+	line(0, y, width, y);
+}
 
 export default class GuiHandler {
 	constructor(control, parentId='gui') {
diff --git a/IDE/public/scope/index.html b/IDE/public/scope/index.html
index a081aa1a5..02cc7b4f9 100644
--- a/IDE/public/scope/index.html
+++ b/IDE/public/scope/index.html
@@ -299,12 +299,14 @@ <h3><span data-channel-name>Channel 1</span></h3>
 
     <div class="scopeWrapper">
       <canvas id="scopeBG"></canvas>
+      <div id="p5-ctx"></div>
     </div><!-- end scope wrapper -->
 
     <script src="js/jquery.js"></script>
+    <script src="../js/p5.min.js"></script>
     <script src="../socket.io/socket.io.js"></script>
     <script src="js/polyfill.js"></script>
-    <script src="js/pixi.js"></script>
+    <script src="js/pixi-legacy.js"></script>
     <script src="js/bundle.js"></script>
 
   </body>
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index fe6397e30..eefedde19 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1684,6 +1684,8 @@ function CPU(data) {
   var plotLoop = function plotLoop() {
     if (plot) {
       plot = false;
+      var start = void 0;
+      if (benchmarkDrawing) start = performance.now();
       ctx.clear();
       var minY = 0;
       var maxY = renderer.height;
@@ -1718,6 +1720,19 @@ function CPU(data) {
       }
       renderer.render(stage);
       triggerStatus();
+      if (benchmarkDrawing) {
+        var stop = performance.now();
+        var dur = stop - start;
+        plotRunsSum += dur;
+        plotRunsIdx++;
+        if (plotRunsIdx >= plotRuns) {
+          var perc = plotRunsSum / (stop - plotRunsStart) * 100;
+          console.log("sum: " + plotRunsSum.toFixed(2) + ", avg: ", +perc.toFixed(2) + "%, avg fps: ", plotRuns / ((stop - plotRunsStart) / 1000));
+          plotRunsSum = 0;
+          plotRunsIdx = 0;
+          plotRunsStart = stop;
+        }
+      }
     } /*else {
       console.log('not plotting');
       }*/
@@ -1818,6 +1833,12 @@ function CPU(data) {
     }
   };
 
+  var benchmarkDrawing = false;
+  var plotRuns = 50;
+  var plotRunsSum = 0;
+  var plotRunsStart = 0;
+  var plotRunsIdx = 0;
+
   plotLoop();
 
   // update the status indicator when triggered

From 93aea3d1450e9a735852ec8d2edcd8a4379db373 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 14:43:35 -0500
Subject: [PATCH 069/188] Scope: allow to set native line

---
 IDE/frontend-dev/scope-src/scope-browser.js | 7 ++++++-
 IDE/public/scope/js/bundle.js               | 7 ++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index c92a74c6d..91ed7fdb9 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -395,7 +395,12 @@ function CPU(data){
       for (var i=0; i<numChannels; i++){
         if(!channelConfig[i].enabled)
           continue;
-        ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, 1);
+        ctx.lineStyle({
+          width: channelConfig[i].lineWeight,
+          color: channelConfig[i].color,
+          alpha: 1,
+          native: false, // setting this to true may reduce CPU usage but only allows width: 1
+        });
         let iLength = i*length;
         let constrain = (v, min, max) => {
           if(v < min)
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index eefedde19..14aa9e5ef 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1691,7 +1691,12 @@ function CPU(data) {
       var maxY = renderer.height;
       for (var i = 0; i < numChannels; i++) {
         if (!channelConfig[i].enabled) continue;
-        ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, 1);
+        ctx.lineStyle({
+          width: channelConfig[i].lineWeight,
+          color: channelConfig[i].color,
+          alpha: 1,
+          native: false // setting this to true may reduce CPU usage but only allows width: 1
+        });
         var iLength = i * length;
         var constrain = function constrain(v, min, max) {
           if (v < min) return min;

From 3fda4e9cb66249ad697755d615de81d2ab72cd2e Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 16:25:48 -0500
Subject: [PATCH 070/188] NIT: Scope: removed dead branch and reindented

---
 IDE/frontend-dev/scope-src/scope-browser.js | 117 ++++++++++----------
 IDE/public/scope/js/bundle.js               | 109 +++++++++---------
 2 files changed, 112 insertions(+), 114 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 91ed7fdb9..6a680eee4 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -384,69 +384,68 @@ function CPU(data){
   let plotRunsStart = 0;
   let plotRunsIdx = 0;
   function plotLoop(){
-    if (plot){
-      plot = false;
-      let start;
-      if(benchmarkDrawing)
-        start = performance.now();
-      ctx.clear();
-      let minY = 0;
-      let maxY = renderer.height;
-      for (var i=0; i<numChannels; i++){
-        if(!channelConfig[i].enabled)
-          continue;
-        ctx.lineStyle({
-          width: channelConfig[i].lineWeight,
-          color: channelConfig[i].color,
-          alpha: 1,
-          native: false, // setting this to true may reduce CPU usage but only allows width: 1
-        });
-        let iLength = i*length;
-        let constrain = (v, min, max) => {
-          if(v < min)
-            return min;
-          if(v > max)
-            return max;
-          return v;
-        }
-        let curr = constrain(frame[iLength], minY, maxY);
-        let next = constrain(frame[iLength + 1], minY, maxY);
-        ctx.moveTo(0, curr + xOff*(next - curr));
-        let lastAlpha = 1;
-        for (var j=1; (j-xOff)<length; j++){
-          let curr = constrain(frame[j + iLength], minY, maxY);
-          // when drawing incrementally, alpha will be 1 when close to the most
-          // recent and then progressively fade out for older values
-          if(oldDataSeparator >= 0) {
-            let dist = (length + oldDataSeparator - j - 1) % length;
-            let alpha = dist < length / 2 ? 1 : 1 - (dist - length / 2) / (length / 2);
-            // throttle lineStyle() calls as they are CPU-heavy
-            if(Math.abs(alpha - lastAlpha) > 0.1 || (lastAlpha != 1 && alpha == 1)) {
-              lastAlpha = alpha;
-              ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, alpha);
-            }
+    if (!plot){
+      return
+    }
+    plot = false;
+    let start;
+    if(benchmarkDrawing)
+      start = performance.now();
+    ctx.clear();
+    let minY = 0;
+    let maxY = renderer.height;
+    for (var i=0; i<numChannels; i++){
+      if(!channelConfig[i].enabled)
+        continue;
+      ctx.lineStyle({
+        width: channelConfig[i].lineWeight,
+        color: channelConfig[i].color,
+        alpha: 1,
+        native: false, // setting this to true may reduce CPU usage but only allows width: 1
+      });
+      let iLength = i*length;
+      let constrain = (v, min, max) => {
+        if(v < min)
+          return min;
+        if(v > max)
+          return max;
+        return v;
+      }
+      let curr = constrain(frame[iLength], minY, maxY);
+      let next = constrain(frame[iLength + 1], minY, maxY);
+      ctx.moveTo(0, curr + xOff*(next - curr));
+      let lastAlpha = 1;
+      for (var j=1; (j-xOff)<length; j++){
+        let curr = constrain(frame[j + iLength], minY, maxY);
+        // when drawing incrementally, alpha will be 1 when close to the most
+        // recent and then progressively fade out for older values
+        if(oldDataSeparator >= 0) {
+          let dist = (length + oldDataSeparator - j - 1) % length;
+          let alpha = dist < length / 2 ? 1 : 1 - (dist - length / 2) / (length / 2);
+          // throttle lineStyle() calls as they are CPU-heavy
+          if(Math.abs(alpha - lastAlpha) > 0.1 || (lastAlpha != 1 && alpha == 1)) {
+            lastAlpha = alpha;
+            ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, alpha);
           }
-          ctx.lineTo(j-xOff, curr);
         }
+        ctx.lineTo(j-xOff, curr);
       }
-      renderer.render(stage);
-      triggerStatus();
-      if(benchmarkDrawing) {
-        let stop = performance.now();
-        let dur = stop - start;
-        plotRunsSum += dur;
-        plotRunsIdx++;
-        if(plotRunsIdx >= plotRuns) {
-          let perc = plotRunsSum / (stop - plotRunsStart) * 100;
-          console.log("sum: " + plotRunsSum.toFixed(2) + ", avg: ", + perc.toFixed(2) + "%, avg fps: ", plotRuns / ((stop - plotRunsStart) / 1000));
-          plotRunsSum = 0;
-          plotRunsIdx = 0;
-          plotRunsStart = stop;
-        }
+    }
+    renderer.render(stage);
+    triggerStatus();
+    if(benchmarkDrawing) {
+      let stop = performance.now();
+      let dur = stop - start;
+      plotRunsSum += dur;
+      plotRunsIdx++;
+      if(plotRunsIdx >= plotRuns) {
+        let perc = plotRunsSum / (stop - plotRunsStart) * 100;
+        console.log("sum: " + plotRunsSum.toFixed(2) + ", avg: ", + perc.toFixed(2) + "%, avg fps: ", plotRuns / ((stop - plotRunsStart) / 1000));
+        plotRunsSum = 0;
+        plotRunsIdx = 0;
+        plotRunsStart = stop;
       }
-    } /*else {
-      console.log('not plotting');
-    }*/
+    }
   }
   plotLoop();
   
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 14aa9e5ef..45fbe5f89 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1682,65 +1682,64 @@ function CPU(data) {
 // plotting
 {
   var plotLoop = function plotLoop() {
-    if (plot) {
-      plot = false;
-      var start = void 0;
-      if (benchmarkDrawing) start = performance.now();
-      ctx.clear();
-      var minY = 0;
-      var maxY = renderer.height;
-      for (var i = 0; i < numChannels; i++) {
-        if (!channelConfig[i].enabled) continue;
-        ctx.lineStyle({
-          width: channelConfig[i].lineWeight,
-          color: channelConfig[i].color,
-          alpha: 1,
-          native: false // setting this to true may reduce CPU usage but only allows width: 1
-        });
-        var iLength = i * length;
-        var constrain = function constrain(v, min, max) {
-          if (v < min) return min;
-          if (v > max) return max;
-          return v;
-        };
-        var curr = constrain(frame[iLength], minY, maxY);
-        var next = constrain(frame[iLength + 1], minY, maxY);
-        ctx.moveTo(0, curr + xOff * (next - curr));
-        var lastAlpha = 1;
-        for (var j = 1; j - xOff < length; j++) {
-          var _curr = constrain(frame[j + iLength], minY, maxY);
-          // when drawing incrementally, alpha will be 1 when close to the most
-          // recent and then progressively fade out for older values
-          if (oldDataSeparator >= 0) {
-            var dist = (length + oldDataSeparator - j - 1) % length;
-            var alpha = dist < length / 2 ? 1 : 1 - (dist - length / 2) / (length / 2);
-            // throttle lineStyle() calls as they are CPU-heavy
-            if (Math.abs(alpha - lastAlpha) > 0.1 || lastAlpha != 1 && alpha == 1) {
-              lastAlpha = alpha;
-              ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, alpha);
-            }
+    if (!plot) {
+      return;
+    }
+    plot = false;
+    var start = void 0;
+    if (benchmarkDrawing) start = performance.now();
+    ctx.clear();
+    var minY = 0;
+    var maxY = renderer.height;
+    for (var i = 0; i < numChannels; i++) {
+      if (!channelConfig[i].enabled) continue;
+      ctx.lineStyle({
+        width: channelConfig[i].lineWeight,
+        color: channelConfig[i].color,
+        alpha: 1,
+        native: false // setting this to true may reduce CPU usage but only allows width: 1
+      });
+      var iLength = i * length;
+      var constrain = function constrain(v, min, max) {
+        if (v < min) return min;
+        if (v > max) return max;
+        return v;
+      };
+      var curr = constrain(frame[iLength], minY, maxY);
+      var next = constrain(frame[iLength + 1], minY, maxY);
+      ctx.moveTo(0, curr + xOff * (next - curr));
+      var lastAlpha = 1;
+      for (var j = 1; j - xOff < length; j++) {
+        var _curr = constrain(frame[j + iLength], minY, maxY);
+        // when drawing incrementally, alpha will be 1 when close to the most
+        // recent and then progressively fade out for older values
+        if (oldDataSeparator >= 0) {
+          var dist = (length + oldDataSeparator - j - 1) % length;
+          var alpha = dist < length / 2 ? 1 : 1 - (dist - length / 2) / (length / 2);
+          // throttle lineStyle() calls as they are CPU-heavy
+          if (Math.abs(alpha - lastAlpha) > 0.1 || lastAlpha != 1 && alpha == 1) {
+            lastAlpha = alpha;
+            ctx.lineStyle(channelConfig[i].lineWeight, channelConfig[i].color, alpha);
           }
-          ctx.lineTo(j - xOff, _curr);
         }
+        ctx.lineTo(j - xOff, _curr);
       }
-      renderer.render(stage);
-      triggerStatus();
-      if (benchmarkDrawing) {
-        var stop = performance.now();
-        var dur = stop - start;
-        plotRunsSum += dur;
-        plotRunsIdx++;
-        if (plotRunsIdx >= plotRuns) {
-          var perc = plotRunsSum / (stop - plotRunsStart) * 100;
-          console.log("sum: " + plotRunsSum.toFixed(2) + ", avg: ", +perc.toFixed(2) + "%, avg fps: ", plotRuns / ((stop - plotRunsStart) / 1000));
-          plotRunsSum = 0;
-          plotRunsIdx = 0;
-          plotRunsStart = stop;
-        }
+    }
+    renderer.render(stage);
+    triggerStatus();
+    if (benchmarkDrawing) {
+      var stop = performance.now();
+      var dur = stop - start;
+      plotRunsSum += dur;
+      plotRunsIdx++;
+      if (plotRunsIdx >= plotRuns) {
+        var perc = plotRunsSum / (stop - plotRunsStart) * 100;
+        console.log("sum: " + plotRunsSum.toFixed(2) + ", avg: ", +perc.toFixed(2) + "%, avg fps: ", plotRuns / ((stop - plotRunsStart) / 1000));
+        plotRunsSum = 0;
+        plotRunsIdx = 0;
+        plotRunsStart = stop;
       }
-    } /*else {
-      console.log('not plotting');
-      }*/
+    }
   };
 
   var triggerStatus = function triggerStatus() {

From d2e6239ab3114065a5b82bb94efcfbe3ade6da0c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 19:54:35 -0500
Subject: [PATCH 071/188] Scope: removed exponential notation from x axis
 markers

---
 IDE/frontend-dev/scope-src/BackgroundView.js | 11 +++++++++--
 IDE/public/scope/js/bundle.js                |  6 ++++--
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/BackgroundView.js b/IDE/frontend-dev/scope-src/BackgroundView.js
index 8f949a0de..83ca8e6a6 100644
--- a/IDE/frontend-dev/scope-src/BackgroundView.js
+++ b/IDE/frontend-dev/scope-src/BackgroundView.js
@@ -47,10 +47,17 @@ class BackgroundView extends View{
 		for (var i=1; i<numVLines; i++){
 			ctx.moveTo(canvas.width/2 + i*xPixels, 0);
 			ctx.lineTo(canvas.width/2 + i*xPixels, canvas.height);
-			ctx.fillText((i*mspersample).toPrecision(2), canvas.width/2 + i*xPixels, canvas.height/2+11);
+			let val = (i * mspersample);
+			if(val < 10)
+				val = val.toFixed(2);
+			else if(val < 100)
+				val = val.toFixed(1);
+			else
+				val = val.toFixed(0);
+			ctx.fillText(val, canvas.width/2 + i*xPixels, canvas.height/2+11);
 			ctx.moveTo(canvas.width/2 - i*xPixels, 0);
 			ctx.lineTo(canvas.width/2 - i*xPixels, canvas.height);
-			ctx.fillText((-i*mspersample).toPrecision(2), canvas.width/2 - i*xPixels, canvas.height/2+11);
+			ctx.fillText("-" + val, canvas.width/2 - i*xPixels, canvas.height/2+11);
 		}
 		
 		var numHLines = 6;
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 45fbe5f89..dea0a27b0 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -368,10 +368,12 @@ var BackgroundView = function (_View) {
 			for (var i = 1; i < numVLines; i++) {
 				ctx.moveTo(canvas.width / 2 + i * xPixels, 0);
 				ctx.lineTo(canvas.width / 2 + i * xPixels, canvas.height);
-				ctx.fillText((i * mspersample).toPrecision(2), canvas.width / 2 + i * xPixels, canvas.height / 2 + 11);
+				var val = i * mspersample;
+				if (val < 10) val = val.toFixed(2);else if (val < 100) val = val.toFixed(1);else val = val.toFixed(0);
+				ctx.fillText(val, canvas.width / 2 + i * xPixels, canvas.height / 2 + 11);
 				ctx.moveTo(canvas.width / 2 - i * xPixels, 0);
 				ctx.lineTo(canvas.width / 2 - i * xPixels, canvas.height);
-				ctx.fillText((-i * mspersample).toPrecision(2), canvas.width / 2 - i * xPixels, canvas.height / 2 + 11);
+				ctx.fillText("-" + val, canvas.width / 2 - i * xPixels, canvas.height / 2 + 11);
 			}
 
 			var numHLines = 6;

From 7469e1a45788ea0a6749dbbf7238f8b8c0b4e5c2 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 20:19:23 -0500
Subject: [PATCH 072/188] Scope: update frontend with backend data for more
 (all?) parameters

---
 IDE/frontend-dev/scope-src/ControlView.js | 16 ++++++++++++++++
 IDE/public/scope/js/bundle.js             | 20 ++++++++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/IDE/frontend-dev/scope-src/ControlView.js b/IDE/frontend-dev/scope-src/ControlView.js
index a7c0abde1..143282b14 100644
--- a/IDE/frontend-dev/scope-src/ControlView.js
+++ b/IDE/frontend-dev/scope-src/ControlView.js
@@ -172,6 +172,22 @@ class ControlView extends View{
   _triggerLevel(value){
     this.$elements.filterByData('key', 'triggerLevel').val(value);
   }
+
+  _xAxisBehaviour(value){
+    this.$elements.filterByData('key', 'xAxisBehaviour').val(value);
+  }
+
+  _holdOff(value){
+    this.$elements.filterByData('key', 'holdOff').val(value);
+  }
+
+  _xOffset(value){
+    this.$elements.filterByData('key', 'xOffset').val(value);
+  }
+
+  _interpolation(value){
+    this.$elements.filterByData('key', 'interpolation').val(value);
+  }
 }
 
 module.exports = ControlView;
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index dea0a27b0..ce0456137 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1027,6 +1027,26 @@ var ControlView = function (_View) {
     value: function _triggerLevel(value) {
       this.$elements.filterByData('key', 'triggerLevel').val(value);
     }
+  }, {
+    key: '_xAxisBehaviour',
+    value: function _xAxisBehaviour(value) {
+      this.$elements.filterByData('key', 'xAxisBehaviour').val(value);
+    }
+  }, {
+    key: '_holdOff',
+    value: function _holdOff(value) {
+      this.$elements.filterByData('key', 'holdOff').val(value);
+    }
+  }, {
+    key: '_xOffset',
+    value: function _xOffset(value) {
+      this.$elements.filterByData('key', 'xOffset').val(value);
+    }
+  }, {
+    key: '_interpolation',
+    value: function _interpolation(value) {
+      this.$elements.filterByData('key', 'interpolation').val(value);
+    }
   }]);
 
   return ControlView;

From 279a5102b2c21338810cb8d348f09e73c5e7549a Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 20:19:23 -0500
Subject: [PATCH 073/188] Scope: update frontend with backend data for more
 (all?) parameters

---
 IDE/frontend-dev/scope-src/ControlView.js | 32 ++++++++++++---------
 IDE/public/scope/js/bundle.js             | 35 +++++++++++------------
 2 files changed, 35 insertions(+), 32 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/ControlView.js b/IDE/frontend-dev/scope-src/ControlView.js
index 143282b14..7545fc813 100644
--- a/IDE/frontend-dev/scope-src/ControlView.js
+++ b/IDE/frontend-dev/scope-src/ControlView.js
@@ -9,6 +9,7 @@ class ControlView extends View{
     super(className, models);
     $('#controlsButton, .overlay').on('click', () => this.toggleControls());
     $('body').on('keydown', (e) => this.keyHandler(e));
+    this.addGenericHandlers();
   }
 
   toggleControls(){
@@ -157,20 +158,23 @@ class ControlView extends View{
     }
   }
 
-  _triggerMode(value){
-    this.$elements.filterByData('key', 'triggerMode').val(value);
-  }
-
-  _triggerChannel(value){
-    this.$elements.filterByData('key', 'triggerChannel').val(value);
-  }
-
-  _triggerDir(value){
-    this.$elements.filterByData('key', 'triggerDir').val(value);
-  }
-
-  _triggerLevel(value){
-    this.$elements.filterByData('key', 'triggerLevel').val(value);
+  addGenericHandlers() {
+    let genericHandlers = [
+      "triggerMode",
+      "triggerChannel",
+      "triggerDir",
+      "triggerLevel",
+      "xAxisBehaviour",
+      "holdOff",
+      "xOffset",
+      "interpolation",
+    ];
+    for(let n = 0; n < genericHandlers.length; ++n) {
+      let h = genericHandlers[n];
+      this["_" + h] = (value) => {
+        this.$elements.filterByData('key', h).val(value);
+      }
+    }
   }
 
   _xAxisBehaviour(value){
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index ce0456137..bd6000a0e 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -819,6 +819,7 @@ var ControlView = function (_View) {
     $('body').on('keydown', function (e) {
       return _this.keyHandler(e);
     });
+    _this.addGenericHandlers();
     return _this;
   }
 
@@ -1008,24 +1009,22 @@ var ControlView = function (_View) {
       }
     }
   }, {
-    key: '_triggerMode',
-    value: function _triggerMode(value) {
-      this.$elements.filterByData('key', 'triggerMode').val(value);
-    }
-  }, {
-    key: '_triggerChannel',
-    value: function _triggerChannel(value) {
-      this.$elements.filterByData('key', 'triggerChannel').val(value);
-    }
-  }, {
-    key: '_triggerDir',
-    value: function _triggerDir(value) {
-      this.$elements.filterByData('key', 'triggerDir').val(value);
-    }
-  }, {
-    key: '_triggerLevel',
-    value: function _triggerLevel(value) {
-      this.$elements.filterByData('key', 'triggerLevel').val(value);
+    key: 'addGenericHandlers',
+    value: function addGenericHandlers() {
+      var _this2 = this;
+
+      var genericHandlers = ["triggerMode", "triggerChannel", "triggerDir", "triggerLevel", "xAxisBehaviour", "holdOff", "xOffset", "interpolation"];
+
+      var _loop = function _loop(n) {
+        var h = genericHandlers[n];
+        _this2["_" + h] = function (value) {
+          _this2.$elements.filterByData('key', h).val(value);
+        };
+      };
+
+      for (var n = 0; n < genericHandlers.length; ++n) {
+        _loop(n);
+      }
     }
   }, {
     key: '_xAxisBehaviour',

From 77f8d15a1d67ee3207059d8d64c0be61c7eeb5e0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 24 Aug 2023 22:56:27 -0500
Subject: [PATCH 074/188] NIT: Scope: removed stale sliders code

---
 IDE/frontend-dev/scope-src/SliderView.js    |  81 -------------
 IDE/frontend-dev/scope-src/scope-browser.js |  18 ---
 IDE/public/scope/js/bundle.js               | 122 ++------------------
 3 files changed, 10 insertions(+), 211 deletions(-)
 delete mode 100644 IDE/frontend-dev/scope-src/SliderView.js

diff --git a/IDE/frontend-dev/scope-src/SliderView.js b/IDE/frontend-dev/scope-src/SliderView.js
deleted file mode 100644
index 06bf12a8f..000000000
--- a/IDE/frontend-dev/scope-src/SliderView.js
+++ /dev/null
@@ -1,81 +0,0 @@
-'use strict';
-var View = require('./View');
-
-class SliderView extends View{
-	
-	constructor(className, models){
-		super(className, models);
-		
-		this.on('set-slider', args => {
-			$('#scopeSlider'+args.slider)
-				.find('input[type=range]')
-					.prop('min', args.min)
-					.prop('max', args.max)
-					.prop('step', args.step)
-					.val(args.value)
-				.siblings('input[type=number]')
-					.prop('min', args.min)
-					.prop('max', args.max)
-					.prop('step', args.step)
-					.val(args.value)
-				.siblings('h1')
-					.html((args.name == 'Slider') ? 'Slider '+args.slider : args.name);
-					
-			var inputs = $('#scopeSlider'+args.slider).find('input[type=number]');
-			inputs.filterByData('key', 'min').val(args.min);
-			inputs.filterByData('key', 'max').val(args.max);
-			inputs.filterByData('key', 'step').val(args.step);
-		});
-		
-	}
-	
-	inputChanged($element, e){
-		
-		var key = $element.data().key;
-		var slider = $element.data().slider;
-		var value = $element.val();
-		
-		if (key === 'value'){
-			this.emit('slider-value', parseInt(slider), parseFloat(value));
-		} else {
-			$element.closest('div.sliderView')
-				.find('input[type=range]').prop(key, value)
-				.siblings('input[type=number]').prop(key, value);
-		}
-
-		$element.siblings('input').val(value);
-	}
-	
-	_numSliders(val){
-
-		var el = $('#scopeSlider0');
-		
-		$('#sliderColumn').empty();
-		
-		if (val == 0){
-			el.appendTo($('#sliderColumn')).css('display', 'none');
-		}
-		
-		for (var i=0; i<val; i++){
-			var slider = el
-				.clone(true)
-				.prop('id', 'scopeSlider'+i)
-				.appendTo($('#sliderColumn'))
-				.css('display', 'block');
-				
-			slider.find('input')
-				.data('slider', i)
-				.on('input', (e) => this.inputChanged($(e.currentTarget), e));
-		}
-		
-	}
-	
-}
-
-module.exports = SliderView;
-
-$.fn.filterByData = function(prop, val) {
-    return this.filter(
-        function() { return $(this).data(prop)==val; }
-    );
-}
diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 6a680eee4..3e242653d 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -40,7 +40,6 @@ var stage = new PIXI.Container();
 var controlView = new (require('./ControlView'))('scope-controls', [settings]);
 var backgroundView = new (require('./BackgroundView'))('scopeBG', [settings], renderer);
 var channelView = new (require('./ChannelView'))('channelView', [settings]);
-var sliderView = new (require('./SliderView'))('sliderView', [settings]);
 
 // main bela socket
 var belaSocket = io('/IDE');
@@ -89,8 +88,6 @@ var ws_onmessage = function(msg){
       return;
     }
     if (ws && ws.readyState === 1) ws.send(out);
-  } else if (data.event == 'set-slider'){
-    sliderView.emit('set-slider', data);
   } else if (data.event == 'set-setting'){
     if (settings.getKey(data.setting) !== undefined) {
       settings.setKey(data.setting, data.value);
@@ -190,19 +187,6 @@ channelView.on('channelConfig', (channelConfig) => {
   legend.update(channelConfig);
 });
 
-sliderView.on('slider-value', (slider, value) => {
-  var obj = {event: "slider", slider, value};
-  var out;
-  try{
-    out = JSON.stringify(obj);
-  }
-  catch(e){
-    console.log('could not stringify slider json:', e);
-    return;
-  }
-  if (ws && ws.readyState === 1) ws.send(out)
-});
-
 belaSocket.on('cpu-usage', CPU);
 
 // model events
@@ -524,7 +508,6 @@ function CPU(data){
 settings.setData({
   numChannels : 2,
   sampleRate  : 44100,
-  numSliders  : 0,
   frameWidth  : 1280,
   plotMode  : 0,
   triggerMode : 0,
@@ -539,7 +522,6 @@ settings.setData({
   FFTXAxis  : 0,
   FFTYAxis  : 0,
   holdOff   : 0,
-  numSliders  : 0,
   interpolation : 0
 });
 
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index bd6000a0e..ded63a437 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -542,7 +542,7 @@ var BackgroundView = function (_View) {
 
 module.exports = BackgroundView;
 
-},{"./View":7}],3:[function(require,module,exports){
+},{"./View":6}],3:[function(require,module,exports){
 'use strict';
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
@@ -786,7 +786,7 @@ $.fn.filterByData = function (prop, val) {
   });
 };
 
-},{"./View":7}],4:[function(require,module,exports){
+},{"./View":6}],4:[function(require,module,exports){
 'use strict';
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
@@ -1059,7 +1059,7 @@ $.fn.filterByData = function (prop, val) {
   });
 };
 
-},{"./View":7}],5:[function(require,module,exports){
+},{"./View":6}],5:[function(require,module,exports){
 'use strict';
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
@@ -1178,89 +1178,6 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-var View = require('./View');
-
-var SliderView = function (_View) {
-	_inherits(SliderView, _View);
-
-	function SliderView(className, models) {
-		_classCallCheck(this, SliderView);
-
-		var _this = _possibleConstructorReturn(this, (SliderView.__proto__ || Object.getPrototypeOf(SliderView)).call(this, className, models));
-
-		_this.on('set-slider', function (args) {
-			$('#scopeSlider' + args.slider).find('input[type=range]').prop('min', args.min).prop('max', args.max).prop('step', args.step).val(args.value).siblings('input[type=number]').prop('min', args.min).prop('max', args.max).prop('step', args.step).val(args.value).siblings('h1').html(args.name == 'Slider' ? 'Slider ' + args.slider : args.name);
-
-			var inputs = $('#scopeSlider' + args.slider).find('input[type=number]');
-			inputs.filterByData('key', 'min').val(args.min);
-			inputs.filterByData('key', 'max').val(args.max);
-			inputs.filterByData('key', 'step').val(args.step);
-		});
-
-		return _this;
-	}
-
-	_createClass(SliderView, [{
-		key: 'inputChanged',
-		value: function inputChanged($element, e) {
-
-			var key = $element.data().key;
-			var slider = $element.data().slider;
-			var value = $element.val();
-
-			if (key === 'value') {
-				this.emit('slider-value', parseInt(slider), parseFloat(value));
-			} else {
-				$element.closest('div.sliderView').find('input[type=range]').prop(key, value).siblings('input[type=number]').prop(key, value);
-			}
-
-			$element.siblings('input').val(value);
-		}
-	}, {
-		key: '_numSliders',
-		value: function _numSliders(val) {
-			var _this2 = this;
-
-			var el = $('#scopeSlider0');
-
-			$('#sliderColumn').empty();
-
-			if (val == 0) {
-				el.appendTo($('#sliderColumn')).css('display', 'none');
-			}
-
-			for (var i = 0; i < val; i++) {
-				var slider = el.clone(true).prop('id', 'scopeSlider' + i).appendTo($('#sliderColumn')).css('display', 'block');
-
-				slider.find('input').data('slider', i).on('input', function (e) {
-					return _this2.inputChanged($(e.currentTarget), e);
-				});
-			}
-		}
-	}]);
-
-	return SliderView;
-}(View);
-
-module.exports = SliderView;
-
-$.fn.filterByData = function (prop, val) {
-	return this.filter(function () {
-		return $(this).data(prop) == val;
-	});
-};
-
-},{"./View":7}],7:[function(require,module,exports){
-'use strict';
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
 var EventEmitter = require('events').EventEmitter;
 
 var View = function (_EventEmitter) {
@@ -1379,20 +1296,16 @@ var View = function (_EventEmitter) {
 
 module.exports = View;
 
-},{"events":1}],8:[function(require,module,exports){
+},{"events":1}],7:[function(require,module,exports){
 'use strict';
 
 var scope = require('./scope-browser');
 
-},{"./scope-browser":9}],9:[function(require,module,exports){
+},{"./scope-browser":8}],8:[function(require,module,exports){
 'use strict';
 
 // worker
 
-var _settings$setData;
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 var remoteHost = location.hostname + ":5432";
 var qs = new URLSearchParams(location.search);
 var qsRemoteHost = qs.get("remoteHost");
@@ -1431,7 +1344,6 @@ var stage = new PIXI.Container();
 var controlView = new (require('./ControlView'))('scope-controls', [settings]);
 var backgroundView = new (require('./BackgroundView'))('scopeBG', [settings], renderer);
 var channelView = new (require('./ChannelView'))('channelView', [settings]);
-var sliderView = new (require('./SliderView'))('sliderView', [settings]);
 
 // main bela socket
 var belaSocket = io('/IDE');
@@ -1477,8 +1389,6 @@ var ws_onmessage = function ws_onmessage(msg) {
       return;
     }
     if (ws && ws.readyState === 1) ws.send(out);
-  } else if (data.event == 'set-slider') {
-    sliderView.emit('set-slider', data);
   } else if (data.event == 'set-setting') {
     if (settings.getKey(data.setting) !== undefined) {
       settings.setKey(data.setting, data.value);
@@ -1577,18 +1487,6 @@ channelView.on('channelConfig', function (channelConfig) {
   legend.update(channelConfig);
 });
 
-sliderView.on('slider-value', function (slider, value) {
-  var obj = { event: "slider", slider: slider, value: value };
-  var out;
-  try {
-    out = JSON.stringify(obj);
-  } catch (e) {
-    console.log('could not stringify slider json:', e);
-    return;
-  }
-  if (ws && ws.readyState === 1) ws.send(out);
-});
-
 belaSocket.on('cpu-usage', CPU);
 
 // model events
@@ -1917,10 +1815,9 @@ function CPU(data) {
   });
 }
 
-settings.setData((_settings$setData = {
+settings.setData({
   numChannels: 2,
   sampleRate: 44100,
-  numSliders: 0,
   frameWidth: 1280,
   plotMode: 0,
   triggerMode: 0,
@@ -1934,9 +1831,10 @@ settings.setData((_settings$setData = {
   FFTLength: 1024,
   FFTXAxis: 0,
   FFTYAxis: 0,
-  holdOff: 0
-}, _defineProperty(_settings$setData, "numSliders", 0), _defineProperty(_settings$setData, "interpolation", 0), _settings$setData));
+  holdOff: 0,
+  interpolation: 0
+});
 
-},{"./BackgroundView":2,"./ChannelView":3,"./ControlView":4,"./Model":5,"./SliderView":6}]},{},[8])
+},{"./BackgroundView":2,"./ChannelView":3,"./ControlView":4,"./Model":5}]},{},[7])
 
 //# sourceMappingURL=bundle.js.map

From 72c57988522656cb82d8819403323e573be6efb7 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 15:36:23 -0500
Subject: [PATCH 075/188] Scope: factored out sending to websocket

---
 IDE/frontend-dev/scope-src/scope-browser.js | 46 ++++++++-------------
 IDE/public/scope/js/bundle.js               | 42 ++++++++-----------
 2 files changed, 35 insertions(+), 53 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 3e242653d..b07045f3b 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -38,12 +38,26 @@ var stage = new PIXI.Container();
 
 // views
 var controlView = new (require('./ControlView'))('scope-controls', [settings]);
-var backgroundView = new (require('./BackgroundView'))('scopeBG', [settings], renderer);
+var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', [settings], renderer);
 var channelView = new (require('./ChannelView'))('channelView', [settings]);
 
 // main bela socket
 var belaSocket = io('/IDE');
 
+function sendToWs(obj) {
+  if (ws && ws.readyState === 1) {
+    let out;
+    try {
+      let out = JSON.stringify(obj);
+      ws.send(out);
+    }
+    catch(e){
+      console.log('could not stringify settings:', e);
+      return;
+    }
+  }
+}
+
 var ws_onerror = function(e){
   setTimeout(() => {
     ws = new WebSocket(wsUrl);
@@ -79,15 +93,7 @@ var ws_onmessage = function(msg){
 
     var obj = settings._getData();
     obj.event = "connection-reply";
-    var out;
-    try{
-      out = JSON.stringify(obj);
-    }
-    catch(e){
-      console.log('could not stringify settings:', e);
-      return;
-    }
-    if (ws && ws.readyState === 1) ws.send(out);
+    sendToWs(obj);
   } else if (data.event == 'set-setting'){
     if (settings.getKey(data.setting) !== undefined) {
       settings.setKey(data.setting, data.value);
@@ -134,15 +140,7 @@ controlView.on('settings-event', (key, value) => {
   if (value === undefined) return;
   var obj = {};
   obj[key] = value;
-  var out;
-  try{
-    out = JSON.stringify(obj);
-  }
-  catch(e){
-    console.log('error creating settings JSON', e);
-    return;
-  }
-  if (ws && ws.readyState === 1) ws.send(out);
+  sendToWs(obj);
   settings.setKey(key, value);
 });
 
@@ -194,15 +192,7 @@ settings.on('set', (data, changedKeys) => {
   if (changedKeys.indexOf('frameWidth') !== -1){
     var xTimeBase = Math.max(Math.floor(1000*(data.frameWidth/8)/data.sampleRate), 1);
     settings.setKey('xTimeBase', xTimeBase);
-    var out;
-    try{
-      out = JSON.stringify({frameWidth: data.frameWidth});
-    }
-    catch(e){
-      console.log('unable to stringify framewidth', e);
-      return;
-    }
-    if (ws && ws.readyState === 1) ws.send(out);
+    sendToWs({frameWidth: data.frameWidth});
   } else {
     worker.postMessage({
       event   : 'settings',
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index ded63a437..064d42295 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1342,12 +1342,25 @@ var stage = new PIXI.Container();
 
 // views
 var controlView = new (require('./ControlView'))('scope-controls', [settings]);
-var backgroundView = new (require('./BackgroundView'))('scopeBG', [settings], renderer);
+var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', [settings], renderer);
 var channelView = new (require('./ChannelView'))('channelView', [settings]);
 
 // main bela socket
 var belaSocket = io('/IDE');
 
+function sendToWs(obj) {
+  if (ws && ws.readyState === 1) {
+    var out = void 0;
+    try {
+      var _out = JSON.stringify(obj);
+      ws.send(_out);
+    } catch (e) {
+      console.log('could not stringify settings:', e);
+      return;
+    }
+  }
+}
+
 var ws_onerror = function ws_onerror(e) {
   setTimeout(function () {
     ws = new WebSocket(wsUrl);
@@ -1381,14 +1394,7 @@ var ws_onmessage = function ws_onmessage(msg) {
 
     var obj = settings._getData();
     obj.event = "connection-reply";
-    var out;
-    try {
-      out = JSON.stringify(obj);
-    } catch (e) {
-      console.log('could not stringify settings:', e);
-      return;
-    }
-    if (ws && ws.readyState === 1) ws.send(out);
+    sendToWs(obj);
   } else if (data.event == 'set-setting') {
     if (settings.getKey(data.setting) !== undefined) {
       settings.setKey(data.setting, data.value);
@@ -1436,14 +1442,7 @@ controlView.on('settings-event', function (key, value) {
   if (value === undefined) return;
   var obj = {};
   obj[key] = value;
-  var out;
-  try {
-    out = JSON.stringify(obj);
-  } catch (e) {
-    console.log('error creating settings JSON', e);
-    return;
-  }
-  if (ws && ws.readyState === 1) ws.send(out);
+  sendToWs(obj);
   settings.setKey(key, value);
 });
 
@@ -1494,14 +1493,7 @@ settings.on('set', function (data, changedKeys) {
   if (changedKeys.indexOf('frameWidth') !== -1) {
     var xTimeBase = Math.max(Math.floor(1000 * (data.frameWidth / 8) / data.sampleRate), 1);
     settings.setKey('xTimeBase', xTimeBase);
-    var out;
-    try {
-      out = JSON.stringify({ frameWidth: data.frameWidth });
-    } catch (e) {
-      console.log('unable to stringify framewidth', e);
-      return;
-    }
-    if (ws && ws.readyState === 1) ws.send(out);
+    sendToWs({ frameWidth: data.frameWidth });
   } else {
     worker.postMessage({
       event: 'settings',

From 98da8640ac9df8fab5cb378f35fdd8e00e571cbb Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 16:02:14 -0500
Subject: [PATCH 076/188] NIT: Scope: refactored setScopeStatus()

---
 IDE/frontend-dev/scope-src/scope-browser.js | 48 ++++++++++++++++----
 IDE/public/scope/js/bundle.js               | 50 +++++++++++++++++----
 2 files changed, 82 insertions(+), 16 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index b07045f3b..fab3ec81a 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -45,6 +45,10 @@ var channelView = new (require('./ChannelView'))('channelView', [settings]);
 var belaSocket = io('/IDE');
 
 function sendToWs(obj) {
+  // do not send frameWidth if we are not receiving data,
+  // or the server will get confused
+  if(dataDisabled)
+    delete obj.frameWidth;
   if (ws && ws.readyState === 1) {
     let out;
     try {
@@ -117,16 +121,44 @@ if(!controlDisabled) {
 var paused = false, oneShot = false;
 
 // view events
+const kScopeWaiting = 0, kScopeTriggered = 1, kScopePaused = 2, kScopeWaitingOneShot = 3, kScopeDisabled = 4;
+function setScopeStatus(status) {
+  let d = $('#scopeStatus');
+  let trigCls = 'scope-status-triggered';
+  let waitCls = 'scope-status-waiting';
+  d.removeClass(trigCls).removeClass(waitCls);
+  switch(status) {
+    case(kScopeWaiting):
+      d.addClass(waitCls);
+      d.html('waiting');
+      break;
+    case(kScopeTriggered):
+      d.addClass(trigCls);
+      d.html('triggered');
+      break;
+    case(kScopePaused):
+      d.addClass(waitCls);
+      d.html('paused');
+      break;
+    case(kScopeWaitingOneShot):
+      d.addClass(waitCls);
+	  d.html('waiting (one-shot)');
+      break;
+    case(kScopeDisabled):
+      d.html('DISABLED');
+      break;
+  }
+}
 controlView.on('settings-event', (key, value) => {
   if (key === 'scopePause'){
     if (paused){
       paused = false;
       $('.pause-button').html('Pause plotting');
-      $('#scopeStatus').html('waiting');
+      setScopeStatus(kScopeWaiting);
     } else {
       paused = true;
       $('.pause-button').html('Resume plotting');
-      $('#scopeStatus').removeClass('scope-status-triggered').addClass('scope-status-waiting').html('paused');
+      setScopeStatus(kScopePaused);
     }
     return;
   } else if (key === 'scopeOneShot'){
@@ -135,7 +167,7 @@ controlView.on('settings-event', (key, value) => {
       paused = false;
       $('#pauseButton').html('pause');
     }
-    $('#scopeStatus').removeClass('scope-status-triggered').addClass('scope-status-waiting').html('waiting (one-shot)');
+    setScopeStatus(kScopeWaitingOneShot);
   }
   if (value === undefined) return;
   var obj = {};
@@ -428,7 +460,6 @@ function CPU(data){
   let inactiveTimeout = setTimeout(() => {
     if (!oneShot && !paused) inactiveOverlay.addClass('inactive-overlay-visible');
   }, 5000);
-  let scopeStatus = $('#scopeStatus');
   let inactiveOverlay = $('#inactive-overlay');
   function triggerStatus(){
   
@@ -437,13 +468,14 @@ function CPU(data){
     if (oneShot){
       oneShot = false;
       paused = true;
-      $('.pause-button').html('resume');
-      scopeStatus.removeClass('scope-status-triggered').addClass('scope-status-waiting').html('paused');
+      $('.pause-button').html('Resume plotting');
+      setScopeStatus(kScopePaused);
     } else {
-      scopeStatus.removeClass('scope-status-waiting').addClass('scope-status-triggered').html('triggered');
+      setScopeStatus(kScopeTriggered);
       if (triggerTimeout) clearTimeout(triggerTimeout);
       triggerTimeout = setTimeout(() => {
-        if (!oneShot && !paused) scopeStatus.removeClass('scope-status-triggered').addClass('scope-status-waiting').html('waiting');
+        if (!oneShot && !paused)
+          setScopeStatus(kScopeWaiting);
       }, 1000);
       
       if (inactiveTimeout) clearTimeout(inactiveTimeout);
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 064d42295..88f3519a5 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1349,6 +1349,9 @@ var channelView = new (require('./ChannelView'))('channelView', [settings]);
 var belaSocket = io('/IDE');
 
 function sendToWs(obj) {
+  // do not send frameWidth if we are not receiving data,
+  // or the server will get confused
+  if (dataDisabled) delete obj.frameWidth;
   if (ws && ws.readyState === 1) {
     var out = void 0;
     try {
@@ -1419,16 +1422,48 @@ var paused = false,
     oneShot = false;
 
 // view events
+var kScopeWaiting = 0,
+    kScopeTriggered = 1,
+    kScopePaused = 2,
+    kScopeWaitingOneShot = 3,
+    kScopeDisabled = 4;
+function setScopeStatus(status) {
+  var d = $('#scopeStatus');
+  var trigCls = 'scope-status-triggered';
+  var waitCls = 'scope-status-waiting';
+  d.removeClass(trigCls).removeClass(waitCls);
+  switch (status) {
+    case kScopeWaiting:
+      d.addClass(waitCls);
+      d.html('waiting');
+      break;
+    case kScopeTriggered:
+      d.addClass(trigCls);
+      d.html('triggered');
+      break;
+    case kScopePaused:
+      d.addClass(waitCls);
+      d.html('paused');
+      break;
+    case kScopeWaitingOneShot:
+      d.addClass(waitCls);
+      d.html('waiting (one-shot)');
+      break;
+    case kScopeDisabled:
+      d.html('DISABLED');
+      break;
+  }
+}
 controlView.on('settings-event', function (key, value) {
   if (key === 'scopePause') {
     if (paused) {
       paused = false;
       $('.pause-button').html('Pause plotting');
-      $('#scopeStatus').html('waiting');
+      setScopeStatus(kScopeWaiting);
     } else {
       paused = true;
       $('.pause-button').html('Resume plotting');
-      $('#scopeStatus').removeClass('scope-status-triggered').addClass('scope-status-waiting').html('paused');
+      setScopeStatus(kScopePaused);
     }
     return;
   } else if (key === 'scopeOneShot') {
@@ -1437,7 +1472,7 @@ controlView.on('settings-event', function (key, value) {
       paused = false;
       $('#pauseButton').html('pause');
     }
-    $('#scopeStatus').removeClass('scope-status-triggered').addClass('scope-status-waiting').html('waiting (one-shot)');
+    setScopeStatus(kScopeWaitingOneShot);
   }
   if (value === undefined) return;
   var obj = {};
@@ -1660,13 +1695,13 @@ function CPU(data) {
     if (oneShot) {
       oneShot = false;
       paused = true;
-      $('.pause-button').html('resume');
-      scopeStatus.removeClass('scope-status-triggered').addClass('scope-status-waiting').html('paused');
+      $('.pause-button').html('Resume plotting');
+      setScopeStatus(kScopePaused);
     } else {
-      scopeStatus.removeClass('scope-status-waiting').addClass('scope-status-triggered').html('triggered');
+      setScopeStatus(kScopeTriggered);
       if (triggerTimeout) clearTimeout(triggerTimeout);
       triggerTimeout = setTimeout(function () {
-        if (!oneShot && !paused) scopeStatus.removeClass('scope-status-triggered').addClass('scope-status-waiting').html('waiting');
+        if (!oneShot && !paused) setScopeStatus(kScopeWaiting);
       }, 1000);
 
       if (inactiveTimeout) clearTimeout(inactiveTimeout);
@@ -1761,7 +1796,6 @@ function CPU(data) {
   var inactiveTimeout = setTimeout(function () {
     if (!oneShot && !paused) inactiveOverlay.addClass('inactive-overlay-visible');
   }, 5000);
-  var scopeStatus = $('#scopeStatus');
   var inactiveOverlay = $('#inactive-overlay');
 
 

From 1e4fefcc30b623b2268a581baac8d6846a1bce4b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 16:22:45 -0500
Subject: [PATCH 077/188] NIT: Scope: controlsVisibility()

---
 IDE/frontend-dev/scope-src/ControlView.js | 16 +++++++++-------
 IDE/public/scope/js/bundle.js             | 20 ++++++++++++--------
 2 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/ControlView.js b/IDE/frontend-dev/scope-src/ControlView.js
index 7545fc813..021967476 100644
--- a/IDE/frontend-dev/scope-src/ControlView.js
+++ b/IDE/frontend-dev/scope-src/ControlView.js
@@ -12,17 +12,19 @@ class ControlView extends View{
     this.addGenericHandlers();
   }
 
-  toggleControls(){
-    if (controls) {
-      controls = false;
-      $('#control-panel').addClass('hidden');
-      $('.overlay').removeClass('active');
-    } else {
-      controls = true;
+  controlsVisibility(show) {
+    controls = show;
+    if(show) {
       $('#control-panel').removeClass('hidden');
       $('.overlay').addClass('active');
+    } else {
+      $('#control-panel').addClass('hidden');
+      $('.overlay').removeClass('active');
     }
   }
+  toggleControls(){
+    this.controlsVisibility(!controls);
+  }
 
   keyHandler(e){
     if (e.key === 'Escape') {
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 88f3519a5..69f4ab396 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -824,18 +824,22 @@ var ControlView = function (_View) {
   }
 
   _createClass(ControlView, [{
-    key: 'toggleControls',
-    value: function toggleControls() {
-      if (controls) {
-        controls = false;
-        $('#control-panel').addClass('hidden');
-        $('.overlay').removeClass('active');
-      } else {
-        controls = true;
+    key: 'controlsVisibility',
+    value: function controlsVisibility(show) {
+      controls = show;
+      if (show) {
         $('#control-panel').removeClass('hidden');
         $('.overlay').addClass('active');
+      } else {
+        $('#control-panel').addClass('hidden');
+        $('.overlay').removeClass('active');
       }
     }
+  }, {
+    key: 'toggleControls',
+    value: function toggleControls() {
+      this.controlsVisibility(!controls);
+    }
   }, {
     key: 'keyHandler',
     value: function keyHandler(e) {

From 846db389b1f6e4f5dae71b575ca16b4bec0ce095 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 16:23:59 -0500
Subject: [PATCH 078/188] Scope: if dataDisabled, show controls by default and
 hide some stuff

---
 IDE/frontend-dev/scope-src/scope-browser.js | 11 ++++++++++-
 IDE/public/scope/index.html                 |  2 +-
 IDE/public/scope/js/bundle.js               |  9 ++++++++-
 3 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index fab3ec81a..f012ddd9f 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -10,7 +10,12 @@ if(qsRemoteHost)
   remoteHost = qsRemoteHost
 var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
-if(!dataDisabled) {
+if(dataDisabled) {
+  $('#ide-cpu').hide();
+  $('#bela-cpu').hide();
+  $('#scopeMouseX').hide();
+  $('#scopeMouseY').hide();
+} else {
   worker.postMessage({
     event: 'wsConnect',
     remote: wsRemote,
@@ -38,6 +43,8 @@ var stage = new PIXI.Container();
 
 // views
 var controlView = new (require('./ControlView'))('scope-controls', [settings]);
+if(dataDisabled)
+  controlView.controlsVisibility(true);
 var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', [settings], renderer);
 var channelView = new (require('./ChannelView'))('channelView', [settings]);
 
@@ -123,6 +130,8 @@ var paused = false, oneShot = false;
 // view events
 const kScopeWaiting = 0, kScopeTriggered = 1, kScopePaused = 2, kScopeWaitingOneShot = 3, kScopeDisabled = 4;
 function setScopeStatus(status) {
+  if(dataDisabled)
+    status = kScopeDisabled;
   let d = $('#scopeStatus');
   let trigCls = 'scope-status-triggered';
   let waitCls = 'scope-status-waiting';
diff --git a/IDE/public/scope/index.html b/IDE/public/scope/index.html
index 02cc7b4f9..b9f73a1a7 100644
--- a/IDE/public/scope/index.html
+++ b/IDE/public/scope/index.html
@@ -29,7 +29,7 @@
       <span id="bela-cpu">Bela CPU:</span>
       <span id="scopeMouseX">Mouse X position:</span>
       <span id="scopeMouseY">Mouse Y position:</span>
-      <span id="scopeStatus" class="scope-status-waiting">waiting</span>
+      <span id="scopeStatus" class="scope-status-waiting">DISABLED</span>
     </div>
 
     <div id="control-panel" class="hidden scope-controls-parent channelView-parent">
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 69f4ab396..a747712bc 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1318,7 +1318,12 @@ var dataDisabled = qs.get("dataDisabled");
 if (qsRemoteHost) remoteHost = qsRemoteHost;
 var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
-if (!dataDisabled) {
+if (dataDisabled) {
+  $('#ide-cpu').hide();
+  $('#bela-cpu').hide();
+  $('#scopeMouseX').hide();
+  $('#scopeMouseY').hide();
+} else {
   worker.postMessage({
     event: 'wsConnect',
     remote: wsRemote
@@ -1346,6 +1351,7 @@ var stage = new PIXI.Container();
 
 // views
 var controlView = new (require('./ControlView'))('scope-controls', [settings]);
+if (dataDisabled) controlView.controlsVisibility(true);
 var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', [settings], renderer);
 var channelView = new (require('./ChannelView'))('channelView', [settings]);
 
@@ -1432,6 +1438,7 @@ var kScopeWaiting = 0,
     kScopeWaitingOneShot = 3,
     kScopeDisabled = 4;
 function setScopeStatus(status) {
+  if (dataDisabled) status = kScopeDisabled;
   var d = $('#scopeStatus');
   var trigCls = 'scope-status-triggered';
   var waitCls = 'scope-status-waiting';

From e616cb66f86f2b66932aeed6b527289dda1e9acc Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 16:32:46 -0500
Subject: [PATCH 079/188] NIT: Scope: added note of TODO

---
 IDE/frontend-dev/scope-src/scope-browser.js | 8 ++++++++
 IDE/public/scope/js/bundle.js               | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index f012ddd9f..ed365d231 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -105,6 +105,14 @@ var ws_onmessage = function(msg){
     var obj = settings._getData();
     obj.event = "connection-reply";
     sendToWs(obj);
+  } else if (data.event == 'update'){
+    // this is a full update due to the setting having changed in a different tab
+	// unfortunately we don't yet have a way to handle it properly without
+	// causing a ping-pong between the two tabs.
+	// Another issue with two clients open receiving data at the same time is
+	// that they need to share the same frameWidth or it's going to be a
+	// problem!
+	// TODO: do it!
   } else if (data.event == 'set-setting'){
     if (settings.getKey(data.setting) !== undefined) {
       settings.setKey(data.setting, data.value);
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index a747712bc..464b9f0ea 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1408,6 +1408,14 @@ var ws_onmessage = function ws_onmessage(msg) {
     var obj = settings._getData();
     obj.event = "connection-reply";
     sendToWs(obj);
+  } else if (data.event == 'update') {
+    // this is a full update due to the setting having changed in a different tab
+    // unfortunately we don't yet have a way to handle it properly without
+    // causing a ping-pong between the two tabs.
+    // Another issue with two clients open receiving data at the same time is
+    // that they need to share the same frameWidth or it's going to be a
+    // problem!
+    // TODO: do it!
   } else if (data.event == 'set-setting') {
     if (settings.getKey(data.setting) !== undefined) {
       settings.setKey(data.setting, data.value);

From fb8054f4482a9defb2d70cbee385ef68044ef397 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 16:40:16 -0500
Subject: [PATCH 080/188] Scope: querytsring for tweaking GUI performance

---
 IDE/frontend-dev/scope-src/scope-browser.js | 14 ++++++++++----
 IDE/public/scope/js/bundle.js               | 16 +++++++++++-----
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index ed365d231..67ee0a7f8 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -4,8 +4,12 @@
 let remoteHost = location.hostname + ":5432";
 let qs = new URLSearchParams(location.search);
 let qsRemoteHost = qs.get("remoteHost");
-let controlDisabled = qs.get("controlDisabled");
-let dataDisabled = qs.get("dataDisabled");
+let controlDisabled = parseInt(qs.get("controlDisabled"));
+let dataDisabled = parseInt(qs.get("dataDisabled"));
+let forceWebGl = parseInt(qs.get("forceWebGl"));
+let antialias = parseInt(qs.get("antialias"));
+let resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
+
 if(qsRemoteHost)
   remoteHost = qsRemoteHost
 var wsRemote = "ws://" + remoteHost + "/";
@@ -31,10 +35,12 @@ var renderer = PIXI.autoDetectRenderer({
   width: window.innerWidth,
   heigh: window.innerHeight,
   backgroundAlpha: 0,
-  antialias: true,
+  antialias: antialias,
+  forceCanvas: !forceWebGl,
   autoDensity: true, // somehow makes CSS compensate for increased resolution. Not sure it's needed for us
-  //resolution: 2, // sort of oversampling for antialias
+  resolution: resolution, // sort of oversampling for antialias
 });
+console.log(renderer)
 renderer.view.style.position = "absolute";
 renderer.view.style.display = "block";
 renderer.autoResize = true;
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 464b9f0ea..c8adf2d51 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1313,8 +1313,12 @@ var scope = require('./scope-browser');
 var remoteHost = location.hostname + ":5432";
 var qs = new URLSearchParams(location.search);
 var qsRemoteHost = qs.get("remoteHost");
-var controlDisabled = qs.get("controlDisabled");
-var dataDisabled = qs.get("dataDisabled");
+var controlDisabled = parseInt(qs.get("controlDisabled"));
+var dataDisabled = parseInt(qs.get("dataDisabled"));
+var forceWebGl = parseInt(qs.get("forceWebGl"));
+var antialias = parseInt(qs.get("antialias"));
+var resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
+
 if (qsRemoteHost) remoteHost = qsRemoteHost;
 var wsRemote = "ws://" + remoteHost + "/";
 var worker = new Worker("js/scope-worker.js");
@@ -1339,10 +1343,12 @@ var renderer = PIXI.autoDetectRenderer({
   width: window.innerWidth,
   heigh: window.innerHeight,
   backgroundAlpha: 0,
-  antialias: true,
-  autoDensity: true // somehow makes CSS compensate for increased resolution. Not sure it's needed for us
-  //resolution: 2, // sort of oversampling for antialias
+  antialias: antialias,
+  forceCanvas: !forceWebGl,
+  autoDensity: true, // somehow makes CSS compensate for increased resolution. Not sure it's needed for us
+  resolution: resolution // sort of oversampling for antialias
 });
+console.log(renderer);
 renderer.view.style.position = "absolute";
 renderer.view.style.display = "block";
 renderer.autoResize = true;

From 10687fa727d99967c8cdebdbef241c420c86b6fc Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 16:50:12 -0500
Subject: [PATCH 081/188] Scope: fixed load test

---
 IDE/public/scope/js/scope-worker.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/IDE/public/scope/js/scope-worker.js b/IDE/public/scope/js/scope-worker.js
index ce15bc7de..c407eea40 100644
--- a/IDE/public/scope/js/scope-worker.js
+++ b/IDE/public/scope/js/scope-worker.js
@@ -160,14 +160,14 @@ var ws_onmessage = function(ws, e){
 
 // load test
 /*
-let testArray = new Float32Array(0);
 let testPtr = 0;
 setInterval(() => {
+	let testArray = new Float32Array(0);
 	if(testArray.length != outArrayWidth) {
 		testArray = new Float32Array(outArrayWidth);
 		for(let n = 0; n < outFrameWidth ; ++n) {
 			for(let c = 0; c < numChannels ; ++c) {
-				testArray[c * outFrameWidth + n] = (n + testPtr) / outFrameWidth* 150 + c * 150;
+				testArray[c * outFrameWidth + n ] = ((n % (outFrameWidth / 2)) + testPtr) / outFrameWidth* 150 + c * 150;
 			}
 		}
 		testPtr += 10;

From 4c7fbd168e1945a0aab23eee91fee60c6f8e546d Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 25 Aug 2023 21:54:39 -0500
Subject: [PATCH 082/188] NIT: Scope: removed stale code

---
 IDE/frontend-dev/scope-src/scope-browser.js | 15 ++-------------
 IDE/public/scope/js/bundle.js               | 14 +-------------
 2 files changed, 3 insertions(+), 26 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 67ee0a7f8..e82c69b9d 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -388,22 +388,11 @@ function CPU(data){
     
     // interpolate the trigger sample to get the sub-pixel x-offset
     if (settings.getKey('plotMode') == 0){
-  //    if (upSampling == 1){
         let one = Math.abs(frame[Math.floor(triggerChannel*length+length/2)+xOffset-1] + (height/2) * ((channelConfig[triggerChannel].yOffset + triggerLevel)/channelConfig[triggerChannel].yAmplitude - 1));
         let two = Math.abs(frame[Math.floor(triggerChannel*length+length/2)+xOffset] + (height/2) * ((channelConfig[triggerChannel].yOffset + triggerLevel)/channelConfig[triggerChannel].yAmplitude - 1));
         xOff = (one/(one+two)-1.5);
-  /*    } else {
-        for (var i=0; i<=(upSampling*2); i++){
-          let one = frame[Math.floor(triggerChannel*length+length/2)+xOffset*upSampling-i] + (height/2) * ((channelConfig[triggerChannel].yOffset + triggerLevel)/channelConfig[triggerChannel].yAmplitude - 1);
-          let two = frame[Math.floor(triggerChannel*length+length/2)+xOffset*upSampling+i] + (height/2) * ((channelConfig[triggerChannel].yOffset + triggerLevel)/channelConfig[triggerChannel].yAmplitude - 1);
-          if ((one > triggerLevel && two < triggerLevel) || (one < triggerLevel && two > triggerLevel)){
-            xOff = i*(Math.abs(one)/(Math.abs(one)+Math.abs(two))-1);
-            break;
-          }
-        }
-      }
-      console.log(xOff);
-  */    if (isNaN(xOff)) xOff = 0;
+      if (isNaN(xOff))
+        xOff = 0;
     }
   };
   
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index c8adf2d51..adec6a894 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1789,22 +1789,10 @@ function CPU(data) {
 
     // interpolate the trigger sample to get the sub-pixel x-offset
     if (settings.getKey('plotMode') == 0) {
-      //    if (upSampling == 1){
       var one = Math.abs(frame[Math.floor(triggerChannel * length + length / 2) + xOffset - 1] + height / 2 * ((channelConfig[triggerChannel].yOffset + triggerLevel) / channelConfig[triggerChannel].yAmplitude - 1));
       var two = Math.abs(frame[Math.floor(triggerChannel * length + length / 2) + xOffset] + height / 2 * ((channelConfig[triggerChannel].yOffset + triggerLevel) / channelConfig[triggerChannel].yAmplitude - 1));
       xOff = one / (one + two) - 1.5;
-      /*    } else {
-            for (var i=0; i<=(upSampling*2); i++){
-              let one = frame[Math.floor(triggerChannel*length+length/2)+xOffset*upSampling-i] + (height/2) * ((channelConfig[triggerChannel].yOffset + triggerLevel)/channelConfig[triggerChannel].yAmplitude - 1);
-              let two = frame[Math.floor(triggerChannel*length+length/2)+xOffset*upSampling+i] + (height/2) * ((channelConfig[triggerChannel].yOffset + triggerLevel)/channelConfig[triggerChannel].yAmplitude - 1);
-              if ((one > triggerLevel && two < triggerLevel) || (one < triggerLevel && two > triggerLevel)){
-                xOff = i*(Math.abs(one)/(Math.abs(one)+Math.abs(two))-1);
-                break;
-              }
-            }
-          }
-          console.log(xOff);
-      */if (isNaN(xOff)) xOff = 0;
+      if (isNaN(xOff)) xOff = 0;
     }
   };
 

From ba824912a7581c0518a3775f3418cae3ff4a4fd4 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 4 Sep 2023 12:15:17 -0500
Subject: [PATCH 083/188] Scope: have 0 scope channels by default, always send
 to frontend all values from the backend when creating a new channel

---
 IDE/frontend-dev/scope-src/ChannelView.js | 18 +++++++++++++-----
 IDE/public/scope/index.html               | 16 ++++++++--------
 IDE/public/scope/js/bundle.js             | 15 ++++++++++-----
 3 files changed, 31 insertions(+), 18 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/ChannelView.js b/IDE/frontend-dev/scope-src/ChannelView.js
index d3f42bee3..a3aeef6cc 100644
--- a/IDE/frontend-dev/scope-src/ChannelView.js
+++ b/IDE/frontend-dev/scope-src/ChannelView.js
@@ -9,7 +9,7 @@ function ChannelConfig(){
   this.enabled = 1;
 }
 
-var channelConfig = [new ChannelConfig()];
+var channelConfig = [];
 var colours = ['0xff0000', '0x0000ff', '0x00ff00', '0xff8800', '0xff00ff', '0x00ffff', '0x888800', '0xff8888'];
 
 var tdGainVal = 1, tdOffsetVal = 0, tdGainMin = 0.5, tdGainMax = 2, tdOffsetMin = -5, tdOffsetMax = 5;
@@ -91,17 +91,25 @@ class ChannelView extends View{
       }
     } else if (numChannels > channelConfig.length){
       while(numChannels > channelConfig.length){
-        channelConfig.push(new ChannelConfig());
-        channelConfig[channelConfig.length-1].color = colours[(channelConfig.length-1)%colours.length];
-        var el = $('.channel-view-0')
+        let cf = new ChannelConfig();
+        channelConfig.push(cf);
+        cf.color = this.colors[(channelConfig.length - 1) % this.colors.length];
+        var el = $('.channel-view-template')
           .clone(true)
           .prop('class', 'channel-view-'+(channelConfig.length))
+          .prop('style', '') // remove display: none
           .appendTo($('.control-section.channel'));
         el.find('[data-channel-name]').html('Channel ' + channelConfig.length);
         el.find('input').each(function(){
           $(this).data('channel', channelConfig.length-1)
         });
-        el.find('input[type=color]').val(colours[(channelConfig.length-1)%colours.length].replace('0x', '#'));
+        for(let key in cf) {
+          let prop = el.find('input[data-key=' + key + ']');
+          if('color' === key)
+            prop.val(cf.color.replace('0x', '#'));
+          else
+            prop.val(cf[key]);
+        }
       }
     }
     this.emit('channelConfig', channelConfig);
diff --git a/IDE/public/scope/index.html b/IDE/public/scope/index.html
index b9f73a1a7..f2ec969ad 100644
--- a/IDE/public/scope/index.html
+++ b/IDE/public/scope/index.html
@@ -235,7 +235,7 @@ <h3>Misc</h3>
 
       <div class="control-panel-column channels">
         <div class="control-section channel">
-          <div class="channel-view-0">
+          <div class="channel-view-template" style="display: none">
             <h3><span data-channel-name>Channel 1</span></h3>
 
             <div class="block-section">
@@ -244,11 +244,11 @@ <h3><span data-channel-name>Channel 1</span></h3>
               </div>
 
               <div class="slider value">
-                <input class="channelView number-box" data-key="yAmplitude" data-channel="0" type="number" value="1" step="0.00001" />
+                <input class="channelView number-box" data-key="yAmplitude" data-channel="template" type="number" value step="0.00001" />
               </div>
 
               <div class="slider range">
-                <input class="channelView scope-range-slider" data-key="yAmplitudeSlider" data-channel="0" type="range" min="0" max="100" value="1" step="0.0001" />
+                <input class="channelView scope-range-slider" data-key="yAmplitudeSlider" data-channel="template" type="range" min="0" max="100" value step="0.0001" />
               </div>
             </div>
 
@@ -258,11 +258,11 @@ <h3><span data-channel-name>Channel 1</span></h3>
               </div>
 
               <div class="slider value">
-                <input class="channelView number-box" data-key="yOffset" data-channel="0" type="number" value="0" step="0.00001" />
+                <input class="channelView number-box" data-key="yOffset" data-channel="template" type="number" value step="0.00001" />
               </div>
 
               <div class="slider range">
-                <input class="channelView scope-range-slider" data-key="yOffset" data-channel="0" type="range" min="-1" max="1" value="0" step="0.0001" />
+                <input class="channelView scope-range-slider" data-key="yOffset" data-channel="template" type="range" min="-1" max="1" value step="0.0001" />
               </div>
             </div>
 
@@ -272,11 +272,11 @@ <h3><span data-channel-name>Channel 1</span></h3>
               </div>
 
               <div class="slider value">
-                <input class="channelView number-box" data-key="lineWeight" data-channel="0" type="number" value="1.5" min="1" max="10" step="0.1" />
+                <input class="channelView number-box" data-key="lineWeight" data-channel="template" type="number" value min="1" max="10" step="0.1" />
               </div>
 
               <div class="slider range">
-                <input class="channelView scope-range-slider" data-key="lineWeight" data-channel="0" type="range" value="1.5" min="1" max="10" step="0.1" />
+                <input class="channelView scope-range-slider" data-key="lineWeight" data-channel="template" type="range" value min="1" max="10" step="0.1" />
               </div>
             </div>
 
@@ -286,7 +286,7 @@ <h3><span data-channel-name>Channel 1</span></h3>
               </div>
 
               <div class="slider value colour">
-                <input class="channelView number-box" data-key="color" data-channel="0" type="color" value="#ff0000" />
+                <input class="channelView number-box" data-key="color" data-channel="template" type="color" value="#000000" />
               </div>
             </div>
 
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index adec6a894..8d25069e6 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -563,7 +563,7 @@ function ChannelConfig() {
   this.enabled = 1;
 }
 
-var channelConfig = [new ChannelConfig()];
+var channelConfig = [];
 var colours = ['0xff0000', '0x0000ff', '0x00ff00', '0xff8800', '0xff00ff', '0x00ffff', '0x888800', '0xff8888'];
 
 var tdGainVal = 1,
@@ -716,14 +716,19 @@ var ChannelView = function (_View) {
         }
       } else if (numChannels > channelConfig.length) {
         while (numChannels > channelConfig.length) {
-          channelConfig.push(new ChannelConfig());
-          channelConfig[channelConfig.length - 1].color = colours[(channelConfig.length - 1) % colours.length];
-          var el = $('.channel-view-0').clone(true).prop('class', 'channel-view-' + channelConfig.length).appendTo($('.control-section.channel'));
+          var cf = new ChannelConfig();
+          channelConfig.push(cf);
+          cf.color = this.colors[(channelConfig.length - 1) % this.colors.length];
+          var el = $('.channel-view-template').clone(true).prop('class', 'channel-view-' + channelConfig.length).prop('style', '') // remove display: none
+          .appendTo($('.control-section.channel'));
           el.find('[data-channel-name]').html('Channel ' + channelConfig.length);
           el.find('input').each(function () {
             $(this).data('channel', channelConfig.length - 1);
           });
-          el.find('input[type=color]').val(colours[(channelConfig.length - 1) % colours.length].replace('0x', '#'));
+          for (var key in cf) {
+            var prop = el.find('input[data-key=' + key + ']');
+            if ('color' === key) prop.val(cf.color.replace('0x', '#'));else prop.val(cf[key]);
+          }
         }
       }
       this.emit('channelConfig', channelConfig);

From ed5367767bcdf2fd7fa7e0a48b3fd23f2bcc534c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 4 Sep 2023 13:31:56 -0500
Subject: [PATCH 084/188] Scope: added dark mode. Also slightly changed the
 blue color (more may need attention).

---
 IDE/frontend-dev/scope-src/BackgroundView.js | 17 +++++---
 IDE/frontend-dev/scope-src/ChannelView.js    | 16 +++++++-
 IDE/frontend-dev/scope-src/scope-browser.js  | 13 ++++--
 IDE/public/scope/index.html                  |  7 ++--
 IDE/public/scope/js/bundle.js                | 43 +++++++++++++++-----
 5 files changed, 74 insertions(+), 22 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/BackgroundView.js b/IDE/frontend-dev/scope-src/BackgroundView.js
index 83ca8e6a6..cb472097f 100644
--- a/IDE/frontend-dev/scope-src/BackgroundView.js
+++ b/IDE/frontend-dev/scope-src/BackgroundView.js
@@ -5,6 +5,7 @@ class BackgroundView extends View{
 
 	constructor(className, models, renderer){
 		super(className, models);
+		this.darkMode = models[1].getKey('darkMode');
 		var saveCanvas =  document.getElementById('saveCanvas');
 		this.canvas = document.getElementById('scopeBG');
 		saveCanvas.addEventListener('click', () => {
@@ -20,7 +21,7 @@ class BackgroundView extends View{
 		canvas.height = window.innerHeight;
 		var ctx = canvas.getContext('2d');
 		ctx.rect(0, 0, canvas.width, canvas.height);
-		ctx.fillStyle="white";
+		ctx.fillStyle = this.darkMode ? "black" : "white";
 		ctx.fill();
 		//ctx.clearRect(0, 0, canvas.width, canvas.height);
 		
@@ -36,11 +37,11 @@ class BackgroundView extends View{
 		//console.log(xTime);
 
 		//faint lines
-		ctx.strokeStyle = '#000000';
-		ctx.fillStyle="grey";
+		ctx.strokeStyle = this.darkMode ? '#fff' : '#000';
+		ctx.fillStyle= this.darkMode ? '#fff' : '#000';
 		ctx.font = "14px inconsolata";
 		ctx.textAlign = "center";
-		ctx.lineWidth = 0.2;
+		ctx.lineWidth = this.darkMode ? 1 : 0.2;
 		ctx.setLineDash([]);
 		ctx.beginPath();
 		ctx.fillText(0, canvas.width/2, canvas.height/2+11);
@@ -102,6 +103,7 @@ class BackgroundView extends View{
 		//dashed lines
 		ctx.beginPath();
 		ctx.setLineDash([2, 5]);
+		ctx.lineWidth = this.darkMode ? 0.5 : 0.2;
 		
 		ctx.moveTo(0, canvas.height*3/4);
 		ctx.lineTo(canvas.width, canvas.height*3/4);
@@ -142,7 +144,7 @@ class BackgroundView extends View{
 		var numVlines = 10;
 		
 		//faint lines
-		ctx.strokeStyle = '#000000';
+		ctx.strokeStyle = this.darkMode ? '#fff' : '#000';
 		ctx.fillStyle="grey";
 		ctx.font = "14px inconsolata";
 		ctx.textAlign = "center";
@@ -187,6 +189,11 @@ class BackgroundView extends View{
 		ctx.stroke();
 	}
 	
+	_darkMode(value, data) {
+		this.darkMode = value;
+		this.repaintBG(this.models[0].getKey('xTimeBase'), this.models[0]._getData());
+	}
+
 	__xTimeBase(value, data){
 		//console.log(value);
 		this.repaintBG(value, data);
diff --git a/IDE/frontend-dev/scope-src/ChannelView.js b/IDE/frontend-dev/scope-src/ChannelView.js
index a3aeef6cc..e8c3caaab 100644
--- a/IDE/frontend-dev/scope-src/ChannelView.js
+++ b/IDE/frontend-dev/scope-src/ChannelView.js
@@ -10,7 +10,6 @@ function ChannelConfig(){
 }
 
 var channelConfig = [];
-var colours = ['0xff0000', '0x0000ff', '0x00ff00', '0xff8800', '0xff00ff', '0x00ffff', '0x888800', '0xff8888'];
 
 var tdGainVal = 1, tdOffsetVal = 0, tdGainMin = 0.5, tdGainMax = 2, tdOffsetMin = -5, tdOffsetMax = 5;
 var FFTNGainVal = 1, FFTNOffsetVal = -0.005, FFTNGainMin = 0.5, FFTNGainMax = 2, FFTNOffsetMin = -1, FFTNOffsetMax = 1;
@@ -22,6 +21,17 @@ class ChannelView extends View{
 
   constructor(className, models){
     super(className, models);
+    this.darkMode = this.models[1].getKey('darkMode');
+    this.colors = [
+      '0xff0000',
+      '0x94d6ff',
+      '0x00ff00',
+      '0xff8800',
+      '0xff00ff',
+      '0x00ffff',
+      '0x888800',
+      '0xff8888'
+    ];
   }
 
   // UI events
@@ -82,6 +92,10 @@ class ChannelView extends View{
     }
   }
 
+  _darkMode(val){
+    this.darkMode = val;
+  }
+
   _numChannels(val){
     var numChannels = val;
     if (numChannels < channelConfig.length){
diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index e82c69b9d..e8bd97af5 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -9,6 +9,7 @@ let dataDisabled = parseInt(qs.get("dataDisabled"));
 let forceWebGl = parseInt(qs.get("forceWebGl"));
 let antialias = parseInt(qs.get("antialias"));
 let resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
+let darkMode = qs.get("darkMode") ? parseInt(qs.get("darkMode")) : 0;
 
 if(qsRemoteHost)
   remoteHost = qsRemoteHost
@@ -29,6 +30,9 @@ if(dataDisabled) {
 // models
 var Model = require('./Model');
 var settings = new Model();
+var tabSettings = new Model();
+tabSettings.setKey('darkMode', darkMode);
+var allSettings = [ settings, tabSettings ];
 
 // Pixi.js renderer and stage
 var renderer = PIXI.autoDetectRenderer({
@@ -48,11 +52,11 @@ $('.scopeWrapper').append(renderer.view);
 var stage = new PIXI.Container();
 
 // views
-var controlView = new (require('./ControlView'))('scope-controls', [settings]);
+var controlView = new (require('./ControlView'))('scope-controls', allSettings);
 if(dataDisabled)
   controlView.controlsVisibility(true);
-var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', [settings], renderer);
-var channelView = new (require('./ChannelView'))('channelView', [settings]);
+var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', allSettings, renderer);
+var channelView = new (require('./ChannelView'))('channelView', allSettings);
 
 // main bela socket
 var belaSocket = io('/IDE');
@@ -191,6 +195,9 @@ controlView.on('settings-event', (key, value) => {
       $('#pauseButton').html('pause');
     }
     setScopeStatus(kScopeWaitingOneShot);
+  } else if (key === 'darkMode') {
+    tabSettings.setKey('darkMode', !tabSettings.getKey('darkMode'));
+    return; // do not send via websocket
   }
   if (value === undefined) return;
   var obj = {};
diff --git a/IDE/public/scope/index.html b/IDE/public/scope/index.html
index f2ec969ad..a398a0ce1 100644
--- a/IDE/public/scope/index.html
+++ b/IDE/public/scope/index.html
@@ -225,9 +225,10 @@ <h3>FFT</h3>
 
           <h3>Misc</h3>
           <div class="block-section">
-            <button class="scope-controls pause-button" data-key="scopePause" data-func="pauseButton">Pause plotting</button>
-            <a href="" download="scope" id="saveCanvas"><button class="scope-controls">Export scope image</button></a>
-            <a href="" download="scopeData.csv" id="saveCanvasData"><button class="scope-controls export">Export CSV data</button></a>
+            <button class="scope-controls dark-mode-button" data-key="darkMode" data-func="darkMode">Dark mode</button><br />
+            <button class="scope-controls pause-button" data-key="scopePause" data-func="pauseButton">Pause plotting</button><br />
+            <a href="" download="scope" id="saveCanvas"><button class="scope-controls">Export scope image</button></a><br />
+            <a href="" download="scopeData.csv" id="saveCanvasData"><button class="scope-controls export">Export CSV data</button></a><br />
           </div>
         </div> <!-- end misc -->
 
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 8d25069e6..7fbd37759 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -323,6 +323,7 @@ var BackgroundView = function (_View) {
 
 		var _this = _possibleConstructorReturn(this, (BackgroundView.__proto__ || Object.getPrototypeOf(BackgroundView)).call(this, className, models));
 
+		_this.darkMode = models[1].getKey('darkMode');
 		var saveCanvas = document.getElementById('saveCanvas');
 		_this.canvas = document.getElementById('scopeBG');
 		saveCanvas.addEventListener('click', function () {
@@ -341,7 +342,7 @@ var BackgroundView = function (_View) {
 			canvas.height = window.innerHeight;
 			var ctx = canvas.getContext('2d');
 			ctx.rect(0, 0, canvas.width, canvas.height);
-			ctx.fillStyle = "white";
+			ctx.fillStyle = this.darkMode ? "black" : "white";
 			ctx.fill();
 			//ctx.clearRect(0, 0, canvas.width, canvas.height);
 
@@ -357,11 +358,11 @@ var BackgroundView = function (_View) {
 			//console.log(xTime);
 
 			//faint lines
-			ctx.strokeStyle = '#000000';
-			ctx.fillStyle = "grey";
+			ctx.strokeStyle = this.darkMode ? '#fff' : '#000';
+			ctx.fillStyle = this.darkMode ? '#fff' : '#000';
 			ctx.font = "14px inconsolata";
 			ctx.textAlign = "center";
-			ctx.lineWidth = 0.2;
+			ctx.lineWidth = this.darkMode ? 1 : 0.2;
 			ctx.setLineDash([]);
 			ctx.beginPath();
 			ctx.fillText(0, canvas.width / 2, canvas.height / 2 + 11);
@@ -418,6 +419,7 @@ var BackgroundView = function (_View) {
 			//dashed lines
 			ctx.beginPath();
 			ctx.setLineDash([2, 5]);
+			ctx.lineWidth = this.darkMode ? 0.5 : 0.2;
 
 			ctx.moveTo(0, canvas.height * 3 / 4);
 			ctx.lineTo(canvas.width, canvas.height * 3 / 4);
@@ -459,7 +461,7 @@ var BackgroundView = function (_View) {
 			var numVlines = 10;
 
 			//faint lines
-			ctx.strokeStyle = '#000000';
+			ctx.strokeStyle = this.darkMode ? '#fff' : '#000';
 			ctx.fillStyle = "grey";
 			ctx.font = "14px inconsolata";
 			ctx.textAlign = "center";
@@ -504,6 +506,12 @@ var BackgroundView = function (_View) {
 
 			ctx.stroke();
 		}
+	}, {
+		key: '_darkMode',
+		value: function _darkMode(value, data) {
+			this.darkMode = value;
+			this.repaintBG(this.models[0].getKey('xTimeBase'), this.models[0]._getData());
+		}
 	}, {
 		key: '__xTimeBase',
 		value: function __xTimeBase(value, data) {
@@ -564,7 +572,6 @@ function ChannelConfig() {
 }
 
 var channelConfig = [];
-var colours = ['0xff0000', '0x0000ff', '0x00ff00', '0xff8800', '0xff00ff', '0x00ffff', '0x888800', '0xff8888'];
 
 var tdGainVal = 1,
     tdOffsetVal = 0,
@@ -593,7 +600,11 @@ var ChannelView = function (_View) {
   function ChannelView(className, models) {
     _classCallCheck(this, ChannelView);
 
-    return _possibleConstructorReturn(this, (ChannelView.__proto__ || Object.getPrototypeOf(ChannelView)).call(this, className, models));
+    var _this = _possibleConstructorReturn(this, (ChannelView.__proto__ || Object.getPrototypeOf(ChannelView)).call(this, className, models));
+
+    _this.darkMode = _this.models[1].getKey('darkMode');
+    _this.colors = ['0xff0000', '0x94d6ff', '0x00ff00', '0xff8800', '0xff00ff', '0x00ffff', '0x888800', '0xff8888'];
+    return _this;
   }
 
   // UI events
@@ -705,6 +716,11 @@ var ChannelView = function (_View) {
         this.$elements.filterByData('key', 'yOffset').filterByData('channel', i).val(channelConfig[i].yOffset);
       }
     }
+  }, {
+    key: '_darkMode',
+    value: function _darkMode(val) {
+      this.darkMode = val;
+    }
   }, {
     key: '_numChannels',
     value: function _numChannels(val) {
@@ -1323,6 +1339,7 @@ var dataDisabled = parseInt(qs.get("dataDisabled"));
 var forceWebGl = parseInt(qs.get("forceWebGl"));
 var antialias = parseInt(qs.get("antialias"));
 var resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
+var darkMode = qs.get("darkMode") ? parseInt(qs.get("darkMode")) : 0;
 
 if (qsRemoteHost) remoteHost = qsRemoteHost;
 var wsRemote = "ws://" + remoteHost + "/";
@@ -1342,6 +1359,9 @@ if (dataDisabled) {
 // models
 var Model = require('./Model');
 var settings = new Model();
+var tabSettings = new Model();
+tabSettings.setKey('darkMode', darkMode);
+var allSettings = [settings, tabSettings];
 
 // Pixi.js renderer and stage
 var renderer = PIXI.autoDetectRenderer({
@@ -1361,10 +1381,10 @@ $('.scopeWrapper').append(renderer.view);
 var stage = new PIXI.Container();
 
 // views
-var controlView = new (require('./ControlView'))('scope-controls', [settings]);
+var controlView = new (require('./ControlView'))('scope-controls', allSettings);
 if (dataDisabled) controlView.controlsVisibility(true);
-var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', [settings], renderer);
-var channelView = new (require('./ChannelView'))('channelView', [settings]);
+var backgroundView = dataDisabled ? {} : new (require('./BackgroundView'))('scopeBG', allSettings, renderer);
+var channelView = new (require('./ChannelView'))('channelView', allSettings);
 
 // main bela socket
 var belaSocket = io('/IDE');
@@ -1503,6 +1523,9 @@ controlView.on('settings-event', function (key, value) {
       $('#pauseButton').html('pause');
     }
     setScopeStatus(kScopeWaitingOneShot);
+  } else if (key === 'darkMode') {
+    tabSettings.setKey('darkMode', !tabSettings.getKey('darkMode'));
+    return; // do not send via websocket
   }
   if (value === undefined) return;
   var obj = {};

From ed718ac6070c223b04ca45fe6c0b34addd52df99 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 4 Sep 2023 13:56:13 -0500
Subject: [PATCH 085/188] Scope: added showLabels

---
 IDE/frontend-dev/scope-src/BackgroundView.js | 18 ++++++++++++++----
 IDE/frontend-dev/scope-src/scope-browser.js  |  5 +++++
 IDE/public/scope/index.html                  |  1 +
 IDE/public/scope/js/bundle.js                | 20 ++++++++++++++++----
 4 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/BackgroundView.js b/IDE/frontend-dev/scope-src/BackgroundView.js
index cb472097f..d2812e1c4 100644
--- a/IDE/frontend-dev/scope-src/BackgroundView.js
+++ b/IDE/frontend-dev/scope-src/BackgroundView.js
@@ -6,6 +6,7 @@ class BackgroundView extends View{
 	constructor(className, models, renderer){
 		super(className, models);
 		this.darkMode = models[1].getKey('darkMode');
+		this.showLabels = models[1].getKey('showLabels');
 		var saveCanvas =  document.getElementById('saveCanvas');
 		this.canvas = document.getElementById('scopeBG');
 		saveCanvas.addEventListener('click', () => {
@@ -44,7 +45,8 @@ class BackgroundView extends View{
 		ctx.lineWidth = this.darkMode ? 1 : 0.2;
 		ctx.setLineDash([]);
 		ctx.beginPath();
-		ctx.fillText(0, canvas.width/2, canvas.height/2+11);
+		if(this.showLabels)
+			ctx.fillText(0, canvas.width/2, canvas.height/2+11);
 		for (var i=1; i<numVLines; i++){
 			ctx.moveTo(canvas.width/2 + i*xPixels, 0);
 			ctx.lineTo(canvas.width/2 + i*xPixels, canvas.height);
@@ -55,10 +57,12 @@ class BackgroundView extends View{
 				val = val.toFixed(1);
 			else
 				val = val.toFixed(0);
-			ctx.fillText(val, canvas.width/2 + i*xPixels, canvas.height/2+11);
+			if(this.showLabels)
+				ctx.fillText(val, canvas.width/2 + i*xPixels, canvas.height/2+11);
 			ctx.moveTo(canvas.width/2 - i*xPixels, 0);
 			ctx.lineTo(canvas.width/2 - i*xPixels, canvas.height);
-			ctx.fillText("-" + val, canvas.width/2 - i*xPixels, canvas.height/2+11);
+			if(this.showLabels)
+				ctx.fillText("-" + val, canvas.width/2 - i*xPixels, canvas.height/2+11);
 		}
 		
 		var numHLines = 6;
@@ -164,7 +168,8 @@ class BackgroundView extends View{
 					val = (Math.pow(Math.E, -(Math.log(1/window.innerWidth))*i/numVlines) * (this.models[0].getKey('sampleRate')/(2*window.innerWidth)) * (data.upSampling/data.downSampling)).toFixed(0);
 				}
 				
-				ctx.fillText(val, i*window.innerWidth/numVlines, canvas.height-2);
+				if(this.showLabels)
+					ctx.fillText(val, i*window.innerWidth/numVlines, canvas.height-2);
 			}
 		}
 		
@@ -189,6 +194,11 @@ class BackgroundView extends View{
 		ctx.stroke();
 	}
 	
+	_showLabels(value, data){
+		this.showLabels = value;
+		this.repaintBG(this.models[0].getKey('xTimeBase'), this.models[0]._getData());
+	}
+
 	_darkMode(value, data) {
 		this.darkMode = value;
 		this.repaintBG(this.models[0].getKey('xTimeBase'), this.models[0]._getData());
diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index e8bd97af5..055b45b30 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -10,6 +10,7 @@ let forceWebGl = parseInt(qs.get("forceWebGl"));
 let antialias = parseInt(qs.get("antialias"));
 let resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
 let darkMode = qs.get("darkMode") ? parseInt(qs.get("darkMode")) : 0;
+let showLabels = qs.get("showLabels") ? parseInt(qs.get("showLabels")) : 0;
 
 if(qsRemoteHost)
   remoteHost = qsRemoteHost
@@ -32,6 +33,7 @@ var Model = require('./Model');
 var settings = new Model();
 var tabSettings = new Model();
 tabSettings.setKey('darkMode', darkMode);
+tabSettings.setKey('showLabels', showLabels);
 var allSettings = [ settings, tabSettings ];
 
 // Pixi.js renderer and stage
@@ -198,6 +200,9 @@ controlView.on('settings-event', (key, value) => {
   } else if (key === 'darkMode') {
     tabSettings.setKey('darkMode', !tabSettings.getKey('darkMode'));
     return; // do not send via websocket
+  } else if (key === 'showLabels') {
+    tabSettings.setKey('showLabels', !tabSettings.getKey('showLabels'));
+    return; // do not send via websocket
   }
   if (value === undefined) return;
   var obj = {};
diff --git a/IDE/public/scope/index.html b/IDE/public/scope/index.html
index a398a0ce1..698924de9 100644
--- a/IDE/public/scope/index.html
+++ b/IDE/public/scope/index.html
@@ -226,6 +226,7 @@ <h3>FFT</h3>
           <h3>Misc</h3>
           <div class="block-section">
             <button class="scope-controls dark-mode-button" data-key="darkMode" data-func="darkMode">Dark mode</button><br />
+            <button class="scope-controls show-labels-button" data-key="showLabels" data-func="showLabels">Show labels</button><br />
             <button class="scope-controls pause-button" data-key="scopePause" data-func="pauseButton">Pause plotting</button><br />
             <a href="" download="scope" id="saveCanvas"><button class="scope-controls">Export scope image</button></a><br />
             <a href="" download="scopeData.csv" id="saveCanvasData"><button class="scope-controls export">Export CSV data</button></a><br />
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 7fbd37759..cb9661112 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -324,6 +324,7 @@ var BackgroundView = function (_View) {
 		var _this = _possibleConstructorReturn(this, (BackgroundView.__proto__ || Object.getPrototypeOf(BackgroundView)).call(this, className, models));
 
 		_this.darkMode = models[1].getKey('darkMode');
+		_this.showLabels = models[1].getKey('showLabels');
 		var saveCanvas = document.getElementById('saveCanvas');
 		_this.canvas = document.getElementById('scopeBG');
 		saveCanvas.addEventListener('click', function () {
@@ -365,16 +366,16 @@ var BackgroundView = function (_View) {
 			ctx.lineWidth = this.darkMode ? 1 : 0.2;
 			ctx.setLineDash([]);
 			ctx.beginPath();
-			ctx.fillText(0, canvas.width / 2, canvas.height / 2 + 11);
+			if (this.showLabels) ctx.fillText(0, canvas.width / 2, canvas.height / 2 + 11);
 			for (var i = 1; i < numVLines; i++) {
 				ctx.moveTo(canvas.width / 2 + i * xPixels, 0);
 				ctx.lineTo(canvas.width / 2 + i * xPixels, canvas.height);
 				var val = i * mspersample;
 				if (val < 10) val = val.toFixed(2);else if (val < 100) val = val.toFixed(1);else val = val.toFixed(0);
-				ctx.fillText(val, canvas.width / 2 + i * xPixels, canvas.height / 2 + 11);
+				if (this.showLabels) ctx.fillText(val, canvas.width / 2 + i * xPixels, canvas.height / 2 + 11);
 				ctx.moveTo(canvas.width / 2 - i * xPixels, 0);
 				ctx.lineTo(canvas.width / 2 - i * xPixels, canvas.height);
-				ctx.fillText("-" + val, canvas.width / 2 - i * xPixels, canvas.height / 2 + 11);
+				if (this.showLabels) ctx.fillText("-" + val, canvas.width / 2 - i * xPixels, canvas.height / 2 + 11);
 			}
 
 			var numHLines = 6;
@@ -482,7 +483,7 @@ var BackgroundView = function (_View) {
 						val = (Math.pow(Math.E, -Math.log(1 / window.innerWidth) * i / numVlines) * (this.models[0].getKey('sampleRate') / (2 * window.innerWidth)) * (data.upSampling / data.downSampling)).toFixed(0);
 					}
 
-					ctx.fillText(val, i * window.innerWidth / numVlines, canvas.height - 2);
+					if (this.showLabels) ctx.fillText(val, i * window.innerWidth / numVlines, canvas.height - 2);
 				}
 			}
 
@@ -506,6 +507,12 @@ var BackgroundView = function (_View) {
 
 			ctx.stroke();
 		}
+	}, {
+		key: '_showLabels',
+		value: function _showLabels(value, data) {
+			this.showLabels = value;
+			this.repaintBG(this.models[0].getKey('xTimeBase'), this.models[0]._getData());
+		}
 	}, {
 		key: '_darkMode',
 		value: function _darkMode(value, data) {
@@ -1340,6 +1347,7 @@ var forceWebGl = parseInt(qs.get("forceWebGl"));
 var antialias = parseInt(qs.get("antialias"));
 var resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
 var darkMode = qs.get("darkMode") ? parseInt(qs.get("darkMode")) : 0;
+var showLabels = qs.get("showLabels") ? parseInt(qs.get("showLabels")) : 0;
 
 if (qsRemoteHost) remoteHost = qsRemoteHost;
 var wsRemote = "ws://" + remoteHost + "/";
@@ -1361,6 +1369,7 @@ var Model = require('./Model');
 var settings = new Model();
 var tabSettings = new Model();
 tabSettings.setKey('darkMode', darkMode);
+tabSettings.setKey('showLabels', showLabels);
 var allSettings = [settings, tabSettings];
 
 // Pixi.js renderer and stage
@@ -1526,6 +1535,9 @@ controlView.on('settings-event', function (key, value) {
   } else if (key === 'darkMode') {
     tabSettings.setKey('darkMode', !tabSettings.getKey('darkMode'));
     return; // do not send via websocket
+  } else if (key === 'showLabels') {
+    tabSettings.setKey('showLabels', !tabSettings.getKey('showLabels'));
+    return; // do not send via websocket
   }
   if (value === undefined) return;
   var obj = {};

From 291d2353150057df09e650089b6f5de4f0a74a8f Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 4 Sep 2023 13:57:12 -0500
Subject: [PATCH 086/188] Scope: changed default lineWidth

---
 IDE/frontend-dev/scope-src/ChannelView.js | 2 +-
 IDE/public/scope/js/bundle.js             | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/ChannelView.js b/IDE/frontend-dev/scope-src/ChannelView.js
index e8c3caaab..9aed8829b 100644
--- a/IDE/frontend-dev/scope-src/ChannelView.js
+++ b/IDE/frontend-dev/scope-src/ChannelView.js
@@ -5,7 +5,7 @@ function ChannelConfig(){
   this.yAmplitude = 1;
   this.yOffset = 0;
   this.color = '0xff0000';
-  this.lineWeight = 1.5;
+  this.lineWeight = 5;
   this.enabled = 1;
 }
 
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index cb9661112..d03bdf71b 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -574,7 +574,7 @@ function ChannelConfig() {
   this.yAmplitude = 1;
   this.yOffset = 0;
   this.color = '0xff0000';
-  this.lineWeight = 1.5;
+  this.lineWeight = 5;
   this.enabled = 1;
 }
 

From 28a28733615982de1bd1734534f5bb5640fab799 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 4 Sep 2023 14:32:36 -0500
Subject: [PATCH 087/188] Scope: default to showLabels

---
 IDE/frontend-dev/scope-src/scope-browser.js | 2 +-
 IDE/public/scope/js/bundle.js               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index 055b45b30..f715a8797 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -10,7 +10,7 @@ let forceWebGl = parseInt(qs.get("forceWebGl"));
 let antialias = parseInt(qs.get("antialias"));
 let resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
 let darkMode = qs.get("darkMode") ? parseInt(qs.get("darkMode")) : 0;
-let showLabels = qs.get("showLabels") ? parseInt(qs.get("showLabels")) : 0;
+let showLabels = qs.get("showLabels") ? parseInt(qs.get("showLabels")) : 1;
 
 if(qsRemoteHost)
   remoteHost = qsRemoteHost
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index d03bdf71b..720fd659a 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1347,7 +1347,7 @@ var forceWebGl = parseInt(qs.get("forceWebGl"));
 var antialias = parseInt(qs.get("antialias"));
 var resolution = qs.get("resolution") ? parseInt(qs.get("resolution")) : 1;
 var darkMode = qs.get("darkMode") ? parseInt(qs.get("darkMode")) : 0;
-var showLabels = qs.get("showLabels") ? parseInt(qs.get("showLabels")) : 0;
+var showLabels = qs.get("showLabels") ? parseInt(qs.get("showLabels")) : 1;
 
 if (qsRemoteHost) remoteHost = qsRemoteHost;
 var wsRemote = "ws://" + remoteHost + "/";

From 42ecd8963c7d730c0919a7055b98a32c2c7b8180 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 4 Sep 2023 15:18:33 -0500
Subject: [PATCH 088/188] Scope: darkMode toggles a class in <body> which in
 turns affects some text colors

---
 IDE/frontend-dev/scope-src/scope-browser.js | 18 +++++++++++++++---
 IDE/frontend-dev/scss/_scope.scss           |  7 +++++++
 IDE/public/css/style.css                    |  5 +++++
 IDE/public/scope/js/bundle.js               | 15 ++++++++++++---
 4 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/IDE/frontend-dev/scope-src/scope-browser.js b/IDE/frontend-dev/scope-src/scope-browser.js
index f715a8797..e3469b6ed 100644
--- a/IDE/frontend-dev/scope-src/scope-browser.js
+++ b/IDE/frontend-dev/scope-src/scope-browser.js
@@ -32,10 +32,22 @@ if(dataDisabled) {
 var Model = require('./Model');
 var settings = new Model();
 var tabSettings = new Model();
-tabSettings.setKey('darkMode', darkMode);
-tabSettings.setKey('showLabels', showLabels);
 var allSettings = [ settings, tabSettings ];
 
+let toggleDarkMode = () => {
+  let newState = !tabSettings.getKey('darkMode');
+  setDarkMode(newState);
+}
+let setDarkMode = (newState) => {
+  tabSettings.setKey('darkMode', newState);
+  if(newState)
+    $('body').addClass('darkMode');
+  else
+    $('body').removeClass('darkMode');
+}
+setDarkMode(darkMode);
+tabSettings.setKey('showLabels', showLabels);
+
 // Pixi.js renderer and stage
 var renderer = PIXI.autoDetectRenderer({
   width: window.innerWidth,
@@ -198,7 +210,7 @@ controlView.on('settings-event', (key, value) => {
     }
     setScopeStatus(kScopeWaitingOneShot);
   } else if (key === 'darkMode') {
-    tabSettings.setKey('darkMode', !tabSettings.getKey('darkMode'));
+    toggleDarkMode();
     return; // do not send via websocket
   } else if (key === 'showLabels') {
     tabSettings.setKey('showLabels', !tabSettings.getKey('showLabels'));
diff --git a/IDE/frontend-dev/scss/_scope.scss b/IDE/frontend-dev/scss/_scope.scss
index 39316d492..173e912b7 100644
--- a/IDE/frontend-dev/scss/_scope.scss
+++ b/IDE/frontend-dev/scss/_scope.scss
@@ -116,6 +116,10 @@ button.scope-controls {
   }
 }
 
+body.darkMode .mini-dropdown select[data-key=plotMode] {
+  color: white;
+}
+
 .number-box[type=number] {
   border: 0;
   font-family: inconsolata;
@@ -305,6 +309,9 @@ input[type="range"].scope-range-slider {
   display: inline-block;
   text-align: right;
   padding-right: 3px;
+  body.darkMode & {
+    color:white;
+  }
 }
 
 [data-legend-color-box] {
diff --git a/IDE/public/css/style.css b/IDE/public/css/style.css
index 5427e2eb2..674045dff 100644
--- a/IDE/public/css/style.css
+++ b/IDE/public/css/style.css
@@ -1995,6 +1995,9 @@ button.scope-controls {
       display: inline;
       margin-left: 165px; }
 
+body.darkMode .mini-dropdown select[data-key=plotMode] {
+  color: white; }
+
 .number-box[type=number] {
   border: 0;
   font-family: inconsolata;
@@ -2143,6 +2146,8 @@ input[type="range"].scope-range-slider {
   display: inline-block;
   text-align: right;
   padding-right: 3px; }
+  body.darkMode [data-legend-color-label] {
+    color: white; }
 
 [data-legend-color-box] {
   width: 12px;
diff --git a/IDE/public/scope/js/bundle.js b/IDE/public/scope/js/bundle.js
index 720fd659a..2196a069b 100644
--- a/IDE/public/scope/js/bundle.js
+++ b/IDE/public/scope/js/bundle.js
@@ -1368,10 +1368,19 @@ if (dataDisabled) {
 var Model = require('./Model');
 var settings = new Model();
 var tabSettings = new Model();
-tabSettings.setKey('darkMode', darkMode);
-tabSettings.setKey('showLabels', showLabels);
 var allSettings = [settings, tabSettings];
 
+var toggleDarkMode = function toggleDarkMode() {
+  var newState = !tabSettings.getKey('darkMode');
+  setDarkMode(newState);
+};
+var setDarkMode = function setDarkMode(newState) {
+  tabSettings.setKey('darkMode', newState);
+  if (newState) $('body').addClass('darkMode');else $('body').removeClass('darkMode');
+};
+setDarkMode(darkMode);
+tabSettings.setKey('showLabels', showLabels);
+
 // Pixi.js renderer and stage
 var renderer = PIXI.autoDetectRenderer({
   width: window.innerWidth,
@@ -1533,7 +1542,7 @@ controlView.on('settings-event', function (key, value) {
     }
     setScopeStatus(kScopeWaitingOneShot);
   } else if (key === 'darkMode') {
-    tabSettings.setKey('darkMode', !tabSettings.getKey('darkMode'));
+    toggleDarkMode();
     return; // do not send via websocket
   } else if (key === 'showLabels') {
     tabSettings.setKey('showLabels', !tabSettings.getKey('showLabels'));

From 78111a88c0bec305034859dbddf15b5318455491 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 4 Sep 2023 15:35:50 -0500
Subject: [PATCH 089/188] Scope: added  apple-specific stuff so it can be
 visualised full screen on iPad. See
 https://forum.bela.io/d/2275-bela-gui-as-fullscreen-app-on-ios

---
 IDE/public/scope/index.html | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/IDE/public/scope/index.html b/IDE/public/scope/index.html
index 698924de9..76ddb5ec0 100644
--- a/IDE/public/scope/index.html
+++ b/IDE/public/scope/index.html
@@ -4,6 +4,11 @@
     <meta charset="utf-8">
     <title>Bela Oscilloscope</title>
     <link rel="stylesheet" type="text/css" href="/css/style.css" />
+    <link rel="icon" href="/favicon.ico">
+    <link rel="apple-touch-icon" href="/favicon.ico">
+    <meta name="apple-mobile-web-app-title" content="Bela Scope">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
   </head>
   <body>
 

From bd96fdb61f445ed2a078527aaaf552b994569658 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 5 Sep 2023 18:02:14 +0000
Subject: [PATCH 090/188] default_libpd_render: handle lists/msgs sent to
 bela_system and execute them with system()

---
 core/default_libpd_render.cpp | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index b330091ba..7db191081 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -573,6 +573,30 @@ void setTrillPrintError()
 }
 #endif // BELA_LIBPD_TRILL
 
+static void belaSystem(const char* first, int argc, t_atom* argv)
+{
+	printf("belaSystem %s, %d\n", first, argc);
+	std::string cmd = first ? first : "";
+	for(size_t n = 0; n < argc; ++n)
+	{
+		cmd += " ";
+		if(libpd_is_float(argv + n)) {
+			float arg = libpd_get_float(argv + n);
+			if(arg == (int)arg)
+				cmd += std::to_string((int)arg);
+			else
+				cmd += std::to_string(arg);
+		} else if(libpd_is_symbol(argv + n)) {
+			cmd += libpd_get_symbol(argv + n);
+		} else {
+			fprintf(stderr, "Error: argument %d of bela_system is not a float or symbol. Command so far: '%s', this will be discarded\n", n, cmd.c_str());
+			return;
+		}
+	}
+	printf("system(\"%s\");\n", cmd.c_str());
+	system(cmd.c_str());
+}
+
 void Bela_listHook(const char *source, int argc, t_atom *argv)
 {
 #ifdef BELA_LIBPD_GUI
@@ -615,6 +639,12 @@ void Bela_listHook(const char *source, int argc, t_atom *argv)
 		return;
 	}
 #endif // BELA_LIBPD_GUI
+	if(0 == strcmp(source, "bela_system"))
+	{
+		printf("list: %d\n", argc);
+		belaSystem(nullptr, argc, argv);
+		return;
+	}
 }
 void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *argv){
 #ifdef BELA_LIBPD_MIDI
@@ -691,6 +721,10 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 		dcm.manage(channel, direction, isMessageRate);
 		return;
 	}
+	if(strcmp(source, "bela_system") == 0){
+		printf("msg: %s %d\n", symbol, argc);
+		belaSystem(symbol, argc, argv);
+	}
 	if(strcmp(source, "bela_control") == 0){
 		if(strcmp("stop", symbol) == 0){
 			rt_printf("bela_control: stop\n");
@@ -1134,6 +1168,7 @@ bool setup(BelaContext *context, void *userData)
 		libpd_bind(gReceiverOutputNames[i].c_str());
 	libpd_bind("bela_setDigital");
 	libpd_bind("bela_control");
+	libpd_bind("bela_system");
 #ifdef BELA_LIBPD_MIDI
 	libpd_bind("bela_setMidi");
 #endif // BELA_LIBPD_MIDI

From 97b86de0e83b32358016df6220d3c7d35d4923fe Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 7 Sep 2023 12:39:41 -0500
Subject: [PATCH 091/188] Gui: use location.hostname instead of location.host
 so it works even with non-80 ports

---
 IDE/public/gui/js/Bela.js          | 2 +-
 IDE/public/gui/js/BelaControl.js   | 2 +-
 IDE/public/gui/js/BelaData.js      | 2 +-
 IDE/public/gui/js/BelaWebSocket.js | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/IDE/public/gui/js/Bela.js b/IDE/public/gui/js/Bela.js
index bca86700e..bba75bd8f 100644
--- a/IDE/public/gui/js/Bela.js
+++ b/IDE/public/gui/js/Bela.js
@@ -2,7 +2,7 @@ import BelaData from './BelaData.js'
 import BelaControl from './BelaControl.js'
 
 export default class Bela {
-	constructor(ip=location.host) {
+	constructor(ip=location.hostname) {
 		this.port = 5555
 		this.addresses = {
 			data:    'gui_data',
diff --git a/IDE/public/gui/js/BelaControl.js b/IDE/public/gui/js/BelaControl.js
index c4051154e..d6da67cab 100644
--- a/IDE/public/gui/js/BelaControl.js
+++ b/IDE/public/gui/js/BelaControl.js
@@ -3,7 +3,7 @@ import GuiHandler from './GuiHandler.js'
 import * as utils from './utils.js'
 
 export default class BelaControl extends BelaWebSocket {
-	constructor(port=5555, address='gui_control', ip=location.host) {
+	constructor(port=5555, address='gui_control', ip=location.hostname) {
 		super(port, address, ip)
 
 		this.projectName = null;
diff --git a/IDE/public/gui/js/BelaData.js b/IDE/public/gui/js/BelaData.js
index 888a80366..6cb4eb0cc 100644
--- a/IDE/public/gui/js/BelaData.js
+++ b/IDE/public/gui/js/BelaData.js
@@ -1,7 +1,7 @@
 import BelaWebSocket from './BelaWebSocket.js'
 
 export default class BelaData extends BelaWebSocket {
-	constructor(port=5555, address='gui_data', ip=location.host) {
+	constructor(port=5555, address='gui_data', ip=location.hostname) {
 		super(port, address, ip)
 
         this.buffers = new Array();
diff --git a/IDE/public/gui/js/BelaWebSocket.js b/IDE/public/gui/js/BelaWebSocket.js
index eca2ae44f..7863e4372 100644
--- a/IDE/public/gui/js/BelaWebSocket.js
+++ b/IDE/public/gui/js/BelaWebSocket.js
@@ -1,5 +1,5 @@
 export default class BelaWebSocket {
-    constructor(port, address, ip = location.host) {
+    constructor(port, address, ip = location.hostname) {
         this.port = port;
         this.address = address;
         this.ip = ip;

From 3aa80f1af2bc6e12055fdea9c64051f53798ae6b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 10 Sep 2023 12:30:03 -0500
Subject: [PATCH 092/188] PureData/samples-record: have the behaviour match the
 comment

---
 examples/PureData/samples-record/_main.pd | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/PureData/samples-record/_main.pd b/examples/PureData/samples-record/_main.pd
index e600b1029..6ca499c8c 100644
--- a/examples/PureData/samples-record/_main.pd
+++ b/examples/PureData/samples-record/_main.pd
@@ -47,7 +47,7 @@
 #X obj 790 369 tabwrite~ sample-1;
 #X obj 945 417 s sampleLength1;
 #X obj 22 418 phasor~ 1;
-#X obj 864 230 delay 200;
+#X obj 864 230 delay 3;
 #X obj 170 387 expr 44100/$f1;
 #X obj 22 395 *~;
 #X msg 19 228 read -resize greek-rumba.wav sample-1;

From be0500c80bfe95fed49388494717d0e3b288be93 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 13 Sep 2023 23:54:34 +0000
Subject: [PATCH 093/188] Bela_initRtBackend()

---
 core/RTAudio.cpp        | 46 ++++++++++++++++++++++-------------------
 include/xenomai_wraps.h |  3 +++
 2 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index b14bb8aab..75683d35f 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -375,27 +375,8 @@ static int setChannelGains(BelaChannelGainArray& cga, int (*cb)(int, float))
 	return ret;
 }
 
-int Bela_initAudio(BelaInitSettings *settings, void *userData)
+extern "C" void Bela_initRtBackend()
 {
-	if(!settings)
-		return -1;
-	Bela_setVerboseLevel(settings->verbose);
-	// Before we go ahead, let's check if Bela is alreadt running:
-	// check if another real-time thread of the same name is already running.
-	char command[200];
-#if (XENOMAI_MAJOR == 2)
-	char pathToXenomaiStat[] = "/proc/xenomai/stat";
-#endif
-#if (XENOMAI_MAJOR == 3)
-	char pathToXenomaiStat[] = "/proc/xenomai/sched/stat";
-#endif
-	snprintf(command, 199, "grep %s %s", gRTAudioThreadName, pathToXenomaiStat);
-	int ret = system(command);
-	if(ret == 0)
-	{
-		fprintf(stderr, "Error: Bela is already running in another process. Cannot start.\n");
-		return -1;
-	}
 #if (XENOMAI_MAJOR == 3)
 	// initialize Xenomai with manual bootstrapping if needed
 	// we cannot trust gXenomaiInited exclusively, in case the caller
@@ -408,7 +389,7 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 		// object (a mutex). If it fails with EPERM, Xenomai needs to be initialized
 		// See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
 		pthread_mutex_t dummyMutex;
-		ret = __wrap_pthread_mutex_init(&dummyMutex, NULL);
+		int ret = __wrap_pthread_mutex_init(&dummyMutex, NULL);
 		if(0 == ret) {
 			if(gRTAudioVerbose)
 				printf("Xenomai was inited by someone else\n");
@@ -431,6 +412,29 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 	}
 	gXenomaiInited = 1;
 #endif
+}
+int Bela_initAudio(BelaInitSettings *settings, void *userData)
+{
+	if(!settings)
+		return -1;
+	Bela_setVerboseLevel(settings->verbose);
+	// Before we go ahead, let's check if Bela is alreadt running:
+	// check if another real-time thread of the same name is already running.
+	char command[200];
+#if (XENOMAI_MAJOR == 2)
+	char pathToXenomaiStat[] = "/proc/xenomai/stat";
+#endif
+#if (XENOMAI_MAJOR == 3)
+	char pathToXenomaiStat[] = "/proc/xenomai/sched/stat";
+#endif
+	snprintf(command, 199, "grep %s %s", gRTAudioThreadName, pathToXenomaiStat);
+	int ret = system(command);
+	if(ret == 0)
+	{
+		fprintf(stderr, "Error: Bela is already running in another process. Cannot start.\n");
+		return -1;
+	}
+	Bela_initRtBackend();
 #ifdef XENOMAI_CATCH_MSW
 	struct sigaction sa;
 	sigemptyset(&sa.sa_mask);
diff --git a/include/xenomai_wraps.h b/include/xenomai_wraps.h
index a9985d87d..1b48a38a0 100644
--- a/include/xenomai_wraps.h
+++ b/include/xenomai_wraps.h
@@ -51,6 +51,7 @@ ssize_t __wrap_mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *
 int __wrap_mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);
 int __wrap_mq_unlink(const char *name);
 
+extern "C" void Bela_initRtBackend();
 // Handle difference between posix API of Xenomai 2.6 and Xenomai 3
 // Some functions are not wrapped by Xenomai 2.6, so we redefine the __wrap
 // to the actual POSIX service for Xenomai 2.6 while we simply forward declare
@@ -175,9 +176,11 @@ inline int create_and_start_thread(pthread_t* task, const char* taskName, int pr
 	pthread_attr_destroy(&attr);
 	return 0;
 }
+
 // from xenomai-3/demo/posix/cobalt/xddp-echo.c
 inline int createXenomaiPipe(const char* portName, size_t poolsz)
 {
+	Bela_initRtBackend();
 	/*
 	 * Get a datagram socket to bind to the RT endpoint. Each
 	 * endpoint is represented by a port number within the XDDP

From a6cbc7e7b3ece30cdb4704b105197b0b7c033984 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 14 Sep 2023 00:03:10 +0000
Subject: [PATCH 094/188] Bela_initRtBackend() using call_once() for thread
 safety

---
 core/AuxiliaryTasks.cpp | 14 +-------------
 core/RTAudio.cpp        | 28 ++++++++++++++++------------
 2 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index fd8c8ca8f..1b16a06e2 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -8,11 +8,6 @@
 #include <native/task.h>
 #endif
 
-#ifdef XENOMAI_SKIN_posix
-#include <pthread.h>
-extern int gXenomaiInited;
-#endif
-
 #include "../include/xenomai_wraps.h"
 
 using namespace std;
@@ -49,14 +44,7 @@ void auxiliaryTaskLoop(void *taskStruct);
 extern unsigned int gAuxiliaryTaskStackSize;
 AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int priority, const char *name, void* args)
 {
-#if XENOMAI_MAJOR == 3
-	// if a program calls this before xenomai is inited, let's init it here with empty arguments.
-	if(!gXenomaiInited)
-	{
-		fprintf(stderr, "Error: You should call Bela_initAudio() before calling Bela_createAuxiliaryTask()\n");
-		return 0;
-	}
-#endif
+	Bela_initRtBackend()
 	InternalAuxiliaryTask *newTask = (InternalAuxiliaryTask*)malloc(sizeof(InternalAuxiliaryTask));
 
 	// Populate the rest of the data structure
diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 75683d35f..b2fca179b 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -375,14 +375,17 @@ static int setChannelGains(BelaChannelGainArray& cga, int (*cb)(int, float))
 	return ret;
 }
 
+#include <mutex>
 extern "C" void Bela_initRtBackend()
 {
 #if (XENOMAI_MAJOR == 3)
-	// initialize Xenomai with manual bootstrapping if needed
-	// we cannot trust gXenomaiInited exclusively, in case the caller
-	// already initialised Xenomai.
-	bool xenomaiNeedsInit = false;
-	if(!gXenomaiInited) {
+	static std::once_flag flag;
+	std::call_once(flag, [](){
+		// initialize Xenomai with manual bootstrapping if needed
+		// we cannot trust gXenomaiInited exclusively, in case the caller
+		// already initialised Xenomai, so first we check if it is
+		// actually working.
+		bool xenomaiNeedsInit = false;
 		if(gRTAudioVerbose)
 			printf("Xenomai not explicitly inited\n");
 		// To figure out if we need to intialize it, attempt to create a Cobalt
@@ -404,13 +407,14 @@ extern "C" void Bela_initRtBackend()
 			if(gRTAudioVerbose)
 				printf("Xenomai is in unknown state\n");
 		}
-	}
-	if(xenomaiNeedsInit) {
-		int argc = 0;
-		char *const *argv;
-		xenomai_init(&argc, &argv);
-	}
-	gXenomaiInited = 1;
+		if(xenomaiNeedsInit) {
+			int argc = 0;
+			char *const *argv;
+			xenomai_init(&argc, &argv);
+		}
+		// this is no longer requi, but we keep it for backward
+		gXenomaiInited = 1;
+	});
 #endif
 }
 int Bela_initAudio(BelaInitSettings *settings, void *userData)

From 03f6fd4adedb4a91fc0f456d8094ff21a1f44697 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 14 Sep 2023 00:04:46 +0000
Subject: [PATCH 095/188] Pipe: start with an actually invalid fd

---
 core/AuxiliaryTasks.cpp | 2 +-
 libraries/Pipe/Pipe.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index 1b16a06e2..d7a2f2459 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -44,7 +44,7 @@ void auxiliaryTaskLoop(void *taskStruct);
 extern unsigned int gAuxiliaryTaskStackSize;
 AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int priority, const char *name, void* args)
 {
-	Bela_initRtBackend()
+	Bela_initRtBackend();
 	InternalAuxiliaryTask *newTask = (InternalAuxiliaryTask*)malloc(sizeof(InternalAuxiliaryTask));
 
 	// Populate the rest of the data structure
diff --git a/libraries/Pipe/Pipe.cpp b/libraries/Pipe/Pipe.cpp
index be8666fe3..0e9f4dd5d 100644
--- a/libraries/Pipe/Pipe.cpp
+++ b/libraries/Pipe/Pipe.cpp
@@ -14,7 +14,7 @@ bool Pipe::setup(const std::string& pipeName, size_t size, bool newBlockingRt, b
 {
 	if(fd)
 		cleanup();
-	fd = 0;
+	fd = -1;
 	pipeSize = size;
 
 	name = "p_" + pipeName;

From 02e7dc0e1ed0a46ef5f55ce057d561525f413f0d Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 14 Sep 2023 00:06:15 +0000
Subject: [PATCH 096/188] default_libpd_render: system: avoid unnecessary
 leading space

---
 core/default_libpd_render.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index 7db191081..6a0e1c975 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -579,7 +579,8 @@ static void belaSystem(const char* first, int argc, t_atom* argv)
 	std::string cmd = first ? first : "";
 	for(size_t n = 0; n < argc; ++n)
 	{
-		cmd += " ";
+		if(0 != n || first)
+			cmd += " ";
 		if(libpd_is_float(argv + n)) {
 			float arg = libpd_get_float(argv + n);
 			if(arg == (int)arg)

From f9246f4ef9a99b50e2c8a0f5d2abd455067940fb Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 9 Oct 2023 13:47:03 -0500
Subject: [PATCH 097/188] IDE: open scope and GUI in a given target, so if it
 was already opened there it will be there again

---
 IDE/frontend-dev/src/Views/ToolbarView.js | 22 +++++++++++++++++-----
 IDE/public/js/bundle.js                   | 21 ++++++++++++++++-----
 2 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/IDE/frontend-dev/src/Views/ToolbarView.js b/IDE/frontend-dev/src/Views/ToolbarView.js
index 507b7f549..7f53ee094 100644
--- a/IDE/frontend-dev/src/Views/ToolbarView.js
+++ b/IDE/frontend-dev/src/Views/ToolbarView.js
@@ -80,9 +80,22 @@ class ToolbarView extends View {
 				$('[data-toolbar-controltext2]').html('');
 			});
 
+		let openUrl = (url, evt) => {
+			// set a target name so that the same tab is used if it was
+			// previously opened
+			let target = location.host + "/url";
+			if(evt) {
+				// if a modifier is pressed, then just "open" it and the
+				// browser will figure out what the modifier means (e.g.: new
+				// tab vs new window)
+				if(evt.altKey || evt.ctrlKey || evt.shiftKey || evt.metaKey)
+					target = undefined;
+			}
+			window.open(url, target);
+		};
     $('[data-toolbar-scope]')
-      .on('click', function(){
-        window.open('scope');
+      .on('click', function(evt){
+        openUrl('scope', evt)
       });
 
     $('[data-toolbar-gui]')
@@ -94,9 +107,8 @@ class ToolbarView extends View {
 			});
 
     $('[data-toolbar-gui]')
-      .on('click', function(){
-        // window.open('gui');
-        window.open('gui');
+      .on('click', function(evt){
+        openUrl('gui', evt);
       });
 	}
 
diff --git a/IDE/public/js/bundle.js b/IDE/public/js/bundle.js
index a5665675e..25b0c80fe 100644
--- a/IDE/public/js/bundle.js
+++ b/IDE/public/js/bundle.js
@@ -5111,8 +5111,20 @@ var ToolbarView = function (_View) {
 			$('[data-toolbar-controltext2]').html('');
 		});
 
-		$('[data-toolbar-scope]').on('click', function () {
-			window.open('scope');
+		var openUrl = function openUrl(url, evt) {
+			// set a target name so that the same tab is used if it was
+			// previously opened
+			var target = location.host + "/url";
+			if (evt) {
+				// if a modifier is pressed, then just "open" it and the
+				// browser will figure out what the modifier means (e.g.: new
+				// tab vs new window)
+				if (evt.altKey || evt.ctrlKey || evt.shiftKey || evt.metaKey) target = undefined;
+			}
+			window.open(url, target);
+		};
+		$('[data-toolbar-scope]').on('click', function (evt) {
+			openUrl('scope', evt);
 		});
 
 		$('[data-toolbar-gui]').mouseover(function () {
@@ -5121,9 +5133,8 @@ var ToolbarView = function (_View) {
 			$('[data-toolbar-controltext2]').html('');
 		});
 
-		$('[data-toolbar-gui]').on('click', function () {
-			// window.open('gui');
-			window.open('gui');
+		$('[data-toolbar-gui]').on('click', function (evt) {
+			openUrl('gui', evt);
 		});
 		return _this;
 	}

From 3de8124d296deb6ff21ca4c6487edb01b5f450e0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 9 Oct 2023 19:21:26 +0000
Subject: [PATCH 098/188] RTAudio: fixed channel and frame count for Batch

---
 core/RTAudio.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index b2fca179b..6d496cc9d 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -241,12 +241,12 @@ static int initBatch(BelaInitSettings *settings, InternalBelaContext* ctx, const
 {
 	gBatchParams = codecMode;
 	ctx->audioFrames = settings->periodSize;
-	ctx->audioInChannels = 12;
-	ctx->audioOutChannels = 12;
+	ctx->audioInChannels = 2;
+	ctx->audioOutChannels = 2;
 	ctx->digitalChannels = 16;
 	ctx->analogInChannels = settings->numAnalogInChannels;
 	ctx->analogOutChannels = settings->numAnalogOutChannels;
-	ctx->analogFrames = ctx->audioFrames / 2;
+	ctx->analogFrames = settings->uniformSampleRate ? ctx->audioFrames : ctx->audioFrames / 2;
 	ctx->digitalFrames = ctx->audioFrames;
 	ctx->audioSampleRate = 44100;
 	ctx->digitalSampleRate = ctx->audioSampleRate;

From 8014f37d95a692d52106525c72c44fbedffd1fda Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 9 Oct 2023 23:38:51 +0000
Subject: [PATCH 099/188] Gui: a connection can set itself as active/inactive
 and the Gui keeps tabs on that. It doesn't do anything with the information
 yet, but a client can

---
 libraries/Gui/Gui.cpp | 8 ++++++++
 libraries/Gui/Gui.h   | 2 ++
 2 files changed, 10 insertions(+)

diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index 72b3d9bd7..696dc12e4 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -105,6 +105,14 @@ void Gui::ws_onControlData(const std::string& address, const WSServerDetails* id
 		if (event.compare(L"connection-reply") == 0){
 			if(!wsConnections.count(id))
 				wsConnections.insert(id);
+			// by default also set connection as active
+			if(!wsActiveConnections.count(id))
+				wsActiveConnections.insert(id);
+		} else if(event.compare(L"active") == 0){
+			if(!wsActiveConnections.count(id))
+				wsActiveConnections.insert(id);
+		} else if(event.compare(L"inactive") == 0){
+			wsActiveConnections.erase(id);
 		}
 	}
 	delete value;
diff --git a/libraries/Gui/Gui.h b/libraries/Gui/Gui.h
index 31f6455e9..81749e7a2 100644
--- a/libraries/Gui/Gui.h
+++ b/libraries/Gui/Gui.h
@@ -19,6 +19,7 @@ class Gui
 		std::vector<DataBuffer> _buffers;
 		std::unique_ptr<WSServer> ws_server;
 		std::set<const WSServerDetails*> wsConnections;
+		std::set<const WSServerDetails*> wsActiveConnections;
 
 		void ws_connect(const std::string& address, const WSServerDetails* id);
 		void ws_disconnect(const std::string& address, const WSServerDetails* id);
@@ -56,6 +57,7 @@ class Gui
 		void cleanup();
 
 		size_t numConnections(){ return wsConnections.size(); };
+		size_t numActiveConnections(){ return wsActiveConnections.size(); };
 
 		// BUFFERS
 		/**

From 2ed047a973d4dcd246d576fc37ad68ba9472a959 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 10 Oct 2023 21:17:15 +0000
Subject: [PATCH 100/188] Gui: add a count and ts to incoming data buffers so
 the user can know whether they have been updated

---
 IDE/public/gui/js/BelaData.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/IDE/public/gui/js/BelaData.js b/IDE/public/gui/js/BelaData.js
index 6cb4eb0cc..5898f845f 100644
--- a/IDE/public/gui/js/BelaData.js
+++ b/IDE/public/gui/js/BelaData.js
@@ -109,8 +109,11 @@ export default class BelaData extends BelaWebSocket {
                 if(err)
                         return;
                 let idx = this.newBuffer['id'];
+                let count = this.buffers[idx] && "undefined" !== typeof(this.buffers[idx].count) ? this.buffers[idx].count + 1 : 0;
                 this.buffers[idx] = this.newBuffer['data'];
                 this.buffers[idx].type = type;
+                this.buffers[idx].count = count;
+                this.buffers[idx].ts = performance.now();
                 this.bufferReady = true;
 
                 this.target.dispatchEvent( new CustomEvent('buffer-ready', { detail: this.newBuffer['id'] }) );

From c374cbcf168c8634522c62b5b0ecef3c3fc28c8c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 12 Oct 2023 19:39:39 +0000
Subject: [PATCH 101/188] PureData/serial example

---
 examples/PureData/serial/_main.pd | 41 +++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 examples/PureData/serial/_main.pd

diff --git a/examples/PureData/serial/_main.pd b/examples/PureData/serial/_main.pd
new file mode 100644
index 000000000..cd57801df
--- /dev/null
+++ b/examples/PureData/serial/_main.pd
@@ -0,0 +1,41 @@
+#N canvas 190 75 1090 589 12;
+#X obj 31 350 loadbang;
+#X obj 31 398 s bela_setSerial;
+#X obj 29 462 route myserial;
+#X msg 31 374 new myserial /dev/ttyS4 9600 none bytes;
+#X obj 355 486 s bela_serialOut;
+#X obj 355 385 metro 1000;
+#X obj 355 361 loadbang;
+#X obj 403 413 + 1;
+#X obj 355 412 f;
+#X msg 355 455 myserial \$1 2 3 4 5 6;
+#X obj 29 438 r bela_serialIn;
+#X obj 29 486 print serialIn;
+#X text 73 20 Send a `new` message to bela_setSerial to initialise UART communication. Arguments are:;
+#X text 69 50 [new <serialId> <device> <bps> <EOM> <type>;
+#X text 72 65 Where:;
+#X text 82 78 serialId: symbol to use in future communications pertaining this object;
+#X text 85 133 bps: a valid baudrate supported by the device;
+#X text 85 111 device: path to the serial device;
+#X text 85 154 EOM: End Of Message byte \, used to identify boundaries;
+#X text 102 168 in incoming messages. Possible values are:;
+#X text 101 183 `none` (no message splitting) \, `newline` \, or a float;
+#X text 103 198 representing the character code;
+#X text 82 216 type: how the data is output from bela_serialIn. Possible;
+#X text 101 231 values are:;
+#X text 99 263 symbol: convert incoming message string to a symbol;
+#X text 100 246 floats: convert incoming message string to a float;
+#X text 99 279 symbols: convert incoming data to a symbol ignoring EOM;
+#X text 98 294 bytes: convert each incoming byte to a float \, output them;
+#X text 98 307 one byte at a time if EOM is none \, or as one list per message;
+#X text 442 413 Output raw bytes (that's the only output mode supported right now);
+#X connect 0 0 3 0;
+#X connect 2 0 11 0;
+#X connect 3 0 1 0;
+#X connect 5 0 8 0;
+#X connect 6 0 5 0;
+#X connect 7 0 8 1;
+#X connect 8 0 7 0;
+#X connect 8 0 9 0;
+#X connect 9 0 4 0;
+#X connect 10 0 2 0;

From ab3c50a427d9968b6d7d8c623600d2c463ae7f88 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 12 Oct 2023 17:55:17 -0500
Subject: [PATCH 102/188] IDE: remove readonly stuff on opening a file

---
 IDE/frontend-dev/src/IDE-browser.js | 3 ++-
 IDE/public/js/bundle.js             | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/IDE/frontend-dev/src/IDE-browser.js b/IDE/frontend-dev/src/IDE-browser.js
index 4bc9170d8..89207b344 100644
--- a/IDE/frontend-dev/src/IDE-browser.js
+++ b/IDE/frontend-dev/src/IDE-browser.js
@@ -354,7 +354,8 @@ function fileOpenedOrChanged(data, changed) {
 			fileChangedPopup(fileName);
 		else
 			enterReadonlyPopup(fileName);
-	}
+	} else
+		setReadOnlyStatus(false);
 }
 
 // run-on-boot
diff --git a/IDE/public/js/bundle.js b/IDE/public/js/bundle.js
index 25b0c80fe..8b09f395b 100644
--- a/IDE/public/js/bundle.js
+++ b/IDE/public/js/bundle.js
@@ -763,7 +763,7 @@ function fileOpenedOrChanged(data, changed) {
 	// and we arenot ignoring it
 	if (project === models.project.getKey('currentProject') && fileName === models.project.getKey('fileName') && clientId != socket.id && !models.project.getKey('openElsewhere') && !models.project.getKey('readOnly')) {
 		if (changed) fileChangedPopup(fileName);else enterReadonlyPopup(fileName);
-	}
+	} else setReadOnlyStatus(false);
 }
 
 // run-on-boot

From fad556978272d76f08a0c59ebcdfacd7cccf1994 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 12 Oct 2023 17:56:12 -0500
Subject: [PATCH 103/188] IDE: do not refresh the page when reloading the file
 from the file open in other tab popup

Fixes the issue introduced between a4f5bbebc and 361a30cd4d
---
 IDE/frontend-dev/src/IDE-browser.js | 21 +++++++++++++--------
 IDE/public/js/bundle.js             | 21 +++++++++++++--------
 2 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/IDE/frontend-dev/src/IDE-browser.js b/IDE/frontend-dev/src/IDE-browser.js
index 89207b344..29ce38ab9 100644
--- a/IDE/frontend-dev/src/IDE-browser.js
+++ b/IDE/frontend-dev/src/IDE-browser.js
@@ -402,6 +402,16 @@ function setModifiedTimeInterval(mtime){
 	}, 5000);
 }
 
+function reopenFile() {
+	// Not sure how to get the name of the current file without passing it in
+	// So we actually reopen the project instead.
+	var data = {
+		func			: 'openProject',
+		currentProject	: models.project.getKey('currentProject'),
+		timestamp		: performance.now()
+	};
+	socket.emit('project-event', data);
+}
 // current file changed
 var fileChangedPopupVisible = false;
 function fileChangedPopup(fileName){
@@ -413,13 +423,7 @@ function fileChangedPopup(fileName){
 		e => {
 			fileChangedPopupVisible = false;
 			e.preventDefault();
-			var data = {
-				func			: 'openProject',
-				currentProject	: models.project.getKey('currentProject'),
-				timestamp		: performance.now()
-			};
-			socket.emit('project-event', data);
-			consoleView.emit('openNotification', data);
+			reopenFile();
 		},
 		() => {
 			fileChangedPopupVisible = false;
@@ -466,7 +470,8 @@ function exitReadonlyPopup() {
 		// on Submit:
 		e => {
 			setReadOnlyStatus(false);
-			window.location.reload();
+			e.preventDefault();
+			reopenFile();
 		},
 		// on Cancel:
 		() => {
diff --git a/IDE/public/js/bundle.js b/IDE/public/js/bundle.js
index 8b09f395b..d2e0ae943 100644
--- a/IDE/public/js/bundle.js
+++ b/IDE/public/js/bundle.js
@@ -823,6 +823,16 @@ function setModifiedTimeInterval(mtime) {
 	}, 5000);
 }
 
+function reopenFile() {
+	// Not sure how to get the name of the current file without passing it in
+	// So we actually reopen the project instead.
+	var data = {
+		func: 'openProject',
+		currentProject: models.project.getKey('currentProject'),
+		timestamp: performance.now()
+	};
+	socket.emit('project-event', data);
+}
 // current file changed
 var fileChangedPopupVisible = false;
 function fileChangedPopup(fileName) {
@@ -833,13 +843,7 @@ function fileChangedPopup(fileName) {
 	popup.twoButtons(strings, function (e) {
 		fileChangedPopupVisible = false;
 		e.preventDefault();
-		var data = {
-			func: 'openProject',
-			currentProject: models.project.getKey('currentProject'),
-			timestamp: performance.now()
-		};
-		socket.emit('project-event', data);
-		consoleView.emit('openNotification', data);
+		reopenFile();
 	}, function () {
 		fileChangedPopupVisible = false;
 		editorView.emit('upload', editorView.getData());
@@ -883,7 +887,8 @@ function exitReadonlyPopup() {
 	// on Submit:
 	function (e) {
 		setReadOnlyStatus(false);
-		window.location.reload();
+		e.preventDefault();
+		reopenFile();
 	},
 	// on Cancel:
 	function () {

From 6ca640f67cae1d7d640399899aa2637dbf0c6b18 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 19 Oct 2023 16:20:35 +0000
Subject: [PATCH 104/188] Gui: erase active connection on disconnect

---
 libraries/Gui/Gui.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index 696dc12e4..463ec1fd4 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -77,8 +77,9 @@ void Gui::ws_connect(const std::string& address, const WSServerDetails* id)
  */
 void Gui::ws_disconnect(const std::string& address, const WSServerDetails* id)
 {
-	if(wsConnections.count(id))
-		wsConnections.erase(id);
+	for(auto& wsc : {&wsConnections, &wsActiveConnections})
+		if(wsc->count(id))
+			wsc->erase(id);
 }
 
 /*

From bcf6e57b98e709b5ac289455d3e0787300222583 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 10 Jul 2022 16:15:04 +0000
Subject: [PATCH 105/188] Makefile: removed wheezy support

---
 Makefile | 25 -------------------------
 1 file changed, 25 deletions(-)

diff --git a/Makefile b/Makefile
index 081f31dac..5d8058c75 100644
--- a/Makefile
+++ b/Makefile
@@ -255,7 +255,6 @@ XENOMAI_STAT_PATH=/proc/xenomai/sched/stat
 endif
 
 # This is used to run Bela projects from the terminal in the background
-# On wheezy, it is also used for running Bela at startup
 SCREEN_NAME?=Bela
 
 # These are parsed by the IDE to understand if a program is active at startup
@@ -263,21 +262,6 @@ BELA_STARTUP_ENV?=/opt/Bela/startup_env
 BELA_POST_ENABLE_STARTUP_COMMAND=mkdir -p /opt/Bela && printf "ACTIVE=1\nPROJECT=$(PROJECT)\nARGS=$(COMMAND_LINE_OPTIONS)" > $(BELA_STARTUP_ENV)
 BELA_PRE_DISABLE_STARTUP_COMMAND=mkdir -p /opt/Bela && printf "ACTIVE=0\n" > $(BELA_STARTUP_ENV)
 
-ifeq ($(DEBIAN_VERSION), wheezy)
-# this section contains some hardcoded and/or obsolete variables. It is currently unsupported and deprecated and we'll remove it "soon" (GM said on 2021.06.09)
-BELA_IDE_HOME?=$(BELA_DIR)/IDE
-BELA_IDE_SCREEN_NAME?=IDE-Bela
-BELA_IDE_STARTUP_SCRIPT?=/root/Bela_node.sh
-BELA_STARTUP_SCRIPT?=/root/Bela_startup.sh
-BELA_ENABLE_STARTUP_COMMAND=printf "\#!/bin/sh\n\#\n\# This file is autogenerated by Bela. Do not edit!\n\necho Running Bela...\nexport PATH=\"$$PATH:/usr/local/bin\"\n cd $(RUN_FROM) && screen -S $(SCREEN_NAME) -d -m bash -c \"while sleep 0.6 ; do echo Running Bela...; $(RUN_COMMAND);  done\"\n" > $(BELA_STARTUP_SCRIPT) && chmod +x $(BELA_STARTUP_SCRIPT) && $(BELA_POST_ENABLE_STARTUP_COMMAND)
-
-BELA_DISABLE_STARTUP_COMMAND=$(BELA_PRE_DISABLE_STARTUP_COMMAND); printf "\#!/bin/sh\n\#\n\n\# This file is autogenerated by Bela. Do not edit!\n\n\# Run on startup disabled -- nothing to do here\n" > $(BELA_STARTUP_SCRIPT)
-BELA_IDE_START_COMMAND?=cd $(BELA_IDE_HOME) && export USER=root && export HOME=/root && export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin && screen -S $(BELA_IDE_SCREEN_NAME) -d -m bash -c "while true; do /usr/local/bin/node index.js; sleep 0.5; done"
-BELA_IDE_STOP_COMMAND?=screen -X -S $(BELA_IDE_SCREEN_NAME) quit > /dev/null || true
-BELA_IDE_ENABLE_STARTUP_COMMAND?=printf '\#!/bin/sh\n\#\n\# This file is autogenerated by Bela. Do not edit!\n\necho Running the Bela IDE...\n$(BELA_IDE_START_COMMAND)\n' > $(BELA_IDE_STARTUP_SCRIPT)
-BELA_IDE_DISABLE_STARTUP_COMMAND?=printf "#!/bin/sh\n#\n\n# This file is autogenerated by Bela. Do not edit!\n\n# The Bela IDE is disabled on startup.\n" > $(BELA_IDE_STARTUP_SCRIPT)
-BELA_IDE_CONNECT_COMMAND=screen -r -S $(BELA_IDE_SCREEN_NAME)
-else
 BELA_ENABLE_STARTUP_COMMAND=systemctl enable bela_startup && $(BELA_POST_ENABLE_STARTUP_COMMAND)
 BELA_DISABLE_STARTUP_COMMAND=$(BELA_PRE_DISABLE_STARTUP_COMMAND); systemctl disable bela_startup
 BELA_IDE_START_COMMAND=systemctl restart bela_ide
@@ -285,7 +269,6 @@ BELA_IDE_STOP_COMMAND=systemctl stop bela_ide
 BELA_IDE_ENABLE_STARTUP_COMMAND=systemctl enable bela_ide
 BELA_IDE_DISABLE_STARTUP_COMMAND=systemctl disable bela_ide
 BELA_IDE_CONNECT_COMMAND=journalctl -fu bela_ide -n 50
-endif
 SC_CL?=-u 57110 -z 16 -J 8 -K 8 -G 16 -i 2 -o 2 -B 0.0.0.0
 
 ifneq (,$(filter $(QUIET_TARGETS),$(MAKECMDGOALS)))
@@ -636,9 +619,7 @@ startup: ## Same as startuploop
 startup: startuploop # compatibility only
 
 stopstartup: ## stop the system service that ran Bela at startup
-ifneq ($(DEBIAN_VERSION),wheezy)
 	$(AT) systemctl stop bela_startup || true
-endif
 
 stoprunning: ## Stops a Bela program that is currently running
 	$(AT) PID=`grep $(BELA_AUDIO_THREAD_NAME) $(XENOMAI_STAT_PATH) | cut -d " " -f 5 | sed s/\s//g`; if [ -z $$PID ]; then [ $(QUIET) = true ] || echo "No process to kill"; else [  $(QUIET) = true  ] || echo "Killing old Bela process $$PID"; kill -2 $$PID; sleep 0.2; kill -9 $$PID 2> /dev/null; fi; screen -X -S $(SCREEN_NAME) quit > /dev/null; exit 0;
@@ -655,19 +636,13 @@ endif
 stop: ## Stops any system service and Bela program that is currently running
 stop: stopstartup stoprunning
 
-ifneq ($(DEBIAN_VERSION),wheezy)
 connect_startup: ## Connects to Bela program running at startup
 	$(AT) journalctl -fu bela_startup -n 30
-endif
 
 connect: ## Connects to the running Bela program (if any), can detach with ctrl-a ctrl-d.
 	$(AT) screen -r -S $(SCREEN_NAME)
 	
 idestart: ## Starts the on-board IDE
-ifeq ($(DEBIAN_VERSION),wheezy)
-# when using systemctl, idestart does not require idestop.
-idestart: idestop
-endif
 	$(AT) printf "Starting IDE..."
 	$(AT) $(BELA_IDE_START_COMMAND)
 	$(AT) printf "done\n"

From 2e98557b79c6acd61dc2df2abc137189d08c3cd4 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 10 Jul 2022 16:15:57 +0000
Subject: [PATCH 106/188] resources: removed wheezy support

---
 .../deb/libmathneon-dev_1.0.2-1_armhf.deb     |    1 -
 .../deb/libne10-dev_20181116-1_armhf.deb      |    1 -
 ...xenomai-2.6-dev_0.10.1-xenomai-1_armhf.deb |  Bin 313018 -> 0 bytes
 .../deb/libseasocks-dev_20171012-1_armhf.deb  |  Bin 456352 -> 0 bytes
 .../wheezy/dtb/BB-BONE-BAREAUDI-00A0.dtbo     |  Bin 1371 -> 0 bytes
 .../wheezy/dtb/BB-BONE-BAREAUDI-02-00A0.dts   |   76 -
 .../wheezy/dtb/BB-BONE-PRU-BELA-00A0.dts      |   59 -
 resources/wheezy/dtb/am335x-boneblack.dtb     |  Bin 23787 -> 0 bytes
 resources/wheezy/dtb/am335x-boneblack.dts     | 1251 -----------------
 resources/wheezy/dtb/am335x-bonegreen.dtb     |  Bin 23787 -> 0 bytes
 resources/wheezy/dtb/am335x-bonegreen.dts     | 1251 -----------------
 resources/wheezy/include/prussdrv.h           |  203 ---
 resources/wheezy/sh/Bela_capeButtonHold.sh    |    5 -
 resources/wheezy/sh/initd-bela                |   28 -
 .../wheezy/sh/initd-bela_shutdown_switch      |   65 -
 resources/wheezy/sh/shutdown_switch.sh        |   79 --
 16 files changed, 3019 deletions(-)
 delete mode 120000 resources/wheezy/deb/libmathneon-dev_1.0.2-1_armhf.deb
 delete mode 120000 resources/wheezy/deb/libne10-dev_20181116-1_armhf.deb
 delete mode 100644 resources/wheezy/deb/libpd-xenomai-2.6-dev_0.10.1-xenomai-1_armhf.deb
 delete mode 100644 resources/wheezy/deb/libseasocks-dev_20171012-1_armhf.deb
 delete mode 100644 resources/wheezy/dtb/BB-BONE-BAREAUDI-00A0.dtbo
 delete mode 100644 resources/wheezy/dtb/BB-BONE-BAREAUDI-02-00A0.dts
 delete mode 100644 resources/wheezy/dtb/BB-BONE-PRU-BELA-00A0.dts
 delete mode 100755 resources/wheezy/dtb/am335x-boneblack.dtb
 delete mode 100755 resources/wheezy/dtb/am335x-boneblack.dts
 delete mode 100644 resources/wheezy/dtb/am335x-bonegreen.dtb
 delete mode 100644 resources/wheezy/dtb/am335x-bonegreen.dts
 delete mode 100644 resources/wheezy/include/prussdrv.h
 delete mode 100755 resources/wheezy/sh/Bela_capeButtonHold.sh
 delete mode 100755 resources/wheezy/sh/initd-bela
 delete mode 100755 resources/wheezy/sh/initd-bela_shutdown_switch
 delete mode 100755 resources/wheezy/sh/shutdown_switch.sh

diff --git a/resources/wheezy/deb/libmathneon-dev_1.0.2-1_armhf.deb b/resources/wheezy/deb/libmathneon-dev_1.0.2-1_armhf.deb
deleted file mode 120000
index 422e564b2..000000000
--- a/resources/wheezy/deb/libmathneon-dev_1.0.2-1_armhf.deb
+++ /dev/null
@@ -1 +0,0 @@
-../../stretch/deb/libmathneon-dev_1.0.2-1_armhf.deb
\ No newline at end of file
diff --git a/resources/wheezy/deb/libne10-dev_20181116-1_armhf.deb b/resources/wheezy/deb/libne10-dev_20181116-1_armhf.deb
deleted file mode 120000
index 085ddab6f..000000000
--- a/resources/wheezy/deb/libne10-dev_20181116-1_armhf.deb
+++ /dev/null
@@ -1 +0,0 @@
-../../stretch/deb/libne10-dev_20181116-1_armhf.deb
\ No newline at end of file
diff --git a/resources/wheezy/deb/libpd-xenomai-2.6-dev_0.10.1-xenomai-1_armhf.deb b/resources/wheezy/deb/libpd-xenomai-2.6-dev_0.10.1-xenomai-1_armhf.deb
deleted file mode 100644
index 27af26cadeb25a70fa11011f5d5e3eea4c0fdff1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 313018
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%0D&-!>3d4NjN9#ZheeTfd@;!r2GjBT^<;ZM{8d
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
UDK$35Yd$ayivj=u00045S_&70ZU6uP

diff --git a/resources/wheezy/deb/libseasocks-dev_20171012-1_armhf.deb b/resources/wheezy/deb/libseasocks-dev_20171012-1_armhf.deb
deleted file mode 100644
index 0628cfc0884cef4545a2473412d8192521592190..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 456352
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%0A6eHew6TcMzW0v^we|)g`kkSHPAP#DHvD-
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

diff --git a/resources/wheezy/dtb/BB-BONE-BAREAUDI-00A0.dtbo b/resources/wheezy/dtb/BB-BONE-BAREAUDI-00A0.dtbo
deleted file mode 100644
index 7f7a21c9e63e52865b582b4194abe02c715f2af7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1371
zcmbVMON$dh5bo$MC?Y5*9u*N(NSnvHn&gxO7xc0&qFy`<otaK-w&%fgPnZavy?PMw
z;KjS1y$SvUe}MP{1QAc(#II(iGs%LxU@_J8=z2|cb$>bi=Lch(PZ(o8#x?@bYrwO>
zGeCmh&^JqVZEaN2anM`DTh*LMG1GDqM{-@_6D|Dx1G-r%WmE>C80Ube#$!Idzq`Z7
zqX#>qM|bY=c9$$@{{-+tyFF?%e3kAt=*7MMjm|d1y49hz+b`B$v2L?jqT-I%={cs)
zLSLAq2*DcDRLnvd*<mSDo(&-X_Tke{(1z#5bD3(f@H~jDk*Fxla!+;rt_R+b5<q^`
zubVL015H66mbBQTn0JB4fG)>wC6ms@rOtUG3smg+B5`b;h<vG1<Y7bLRk*$f1vK7b
zxeWRW^b+XHioPl7GB4FZXSZ4h$yA5Kx-T7QYukVIg<{e9JPzbkWZJI!&`h~}o8Y5(
zUo6M~;A+T9aVbBCOtrZE7vQPCBoBeFfwWIRvHu5L?00Z>_0c&|KS^Hp!t=}`oW$Cc
zGeCaVfgfA-@U&Luq;<%Q4B+?q2*0Cdfa=0rPF0>IRY^r(&O`roCHBCIbSCY9=7oUj
zCY$fIP3NFZ6<f!?(CZmW|10qSwc@|}-vj)&Z&S_NWlGn-lYSf~!m5duED@>YQ5H^Q
z%5blYiX$d-UuQ<mCC?0=jiPAgVi^_TL1`8@K&vRro5@oV1r(~v7Ku=rrPOA|3Y!@g
zCp?S;#0x@hbZiYnT5e>jgjUaxzGQizQf70iiOacVY0cJm{E!n7;nr53(^G(F!M!ZS
G(XhYEP#BK@

diff --git a/resources/wheezy/dtb/BB-BONE-BAREAUDI-02-00A0.dts b/resources/wheezy/dtb/BB-BONE-BAREAUDI-02-00A0.dts
deleted file mode 100644
index 6f7ba6695..000000000
--- a/resources/wheezy/dtb/BB-BONE-BAREAUDI-02-00A0.dts
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-/dts-v1/;
-/plugin/;
-
-/ {
-	compatible = "ti,beaglebone", "ti,beaglebone-black", "ti,beaglebone-green";
-
-	/* identification */
-	part-number = "BB-BONE-BAREAUDI-02";
-	version = "00A0", "A0";
-
-	/* state the resources this cape uses */
-	exclusive-use =
-		/* the pin header uses */
-		"P9.15",        /* SPI chip select line for the ADC */
-		"P9.31",	/* mcasp0: mcasp0_aclkx */
-		"P9.29",	/* mcasp0: mcasp0_fsx */
-		"P9.28",	/* mcasp0: mcasp0_axr2 */
-		"P9.25",	/* mcasp0: mcasp0_ahclkx */
-		/* the hardware ip uses */
-		"gpio1_18", "gpio1_19",
-		"mcasp0";
-
-	fragment@0 {
-		target = <&am33xx_pinmux>;
-		__overlay__ {
-
-			i2c2_pins: pinmux_i2c2_pins {
-				pinctrl-single,pins = <
-					0x150 0x72 	/*spi0_scl.i2c2_sda,SLEWCTRL_SLOW | INPUT_PULLUP |MODE2*/
-					0x154 0x72	/*spi0_d0.i2c2_scl,SLEWCTRL_SLOW | INPUT_PULLUP | MODE2*/
-				>;
-			};
-
-			bone_audio_cape_audio_pins: pinmux_bone_audio_cape_audio_pins {
-				pinctrl-single,pins = <
-					0x040 0x27      /* SPI chip select line for the ADC */
-					0x1ac 0x00      /* mcasp0_ahclkx,             MODE0 | INPUT */
-					0x19c 0x22		/* mcasp0_ahclkr, */
-					0x194 0x20      /* mcasp0_fsx,         	      MODE0 | OUTPUT  */
-					0x190 0x20      /* mcasp0_aclkr.mcasp0_aclkx, MODE0 | OUTPUT_PULLDOWN */
-					0x198 0x20
-				>;
-			};
-		};
-	};
-
-	fragment@1 {
-		target = <&mcasp0>;
-		__overlay__ {
-			pinctrl-names = "default";
-			pinctrl-0 = <&bone_audio_cape_audio_pins>;
-
-			status = "okay";
-
-			op-mode = <0>;          /* MCASP_IIS_MODE */
-			tdm-slots = <2>;
-			num-serializer = <16>;
-			serial-dir = <  /* 0: INACTIVE, 1: TX, 2: RX */
-				2 0 1 0
-				0 0 0 0
-				0 0 0 0
-				0 0 0 0
-			>;
-			tx-num-evt = <1>;
-			rx-num-evt = <1>;
-		};
-	};
-
-};
diff --git a/resources/wheezy/dtb/BB-BONE-PRU-BELA-00A0.dts b/resources/wheezy/dtb/BB-BONE-PRU-BELA-00A0.dts
deleted file mode 100644
index 94b45b312..000000000
--- a/resources/wheezy/dtb/BB-BONE-PRU-BELA-00A0.dts
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-* Copyright (C) 2013 Matt Ranostay <mranostay@gmail.com>
-*
-* This program is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*/
-/dts-v1/;
-/plugin/;
-
-/ {
-	compatible = "ti,beaglebone", "ti,beaglebone-black", "ti,beaglebone-green";
-
-	/* identification */
-	part-number = "BB-BONE-PRU-BELA";
-	version = "00A0";
-
-	/* state the resources this cape uses */
-	exclusive-use =
-		/* the pin header uses */
-		"P8.41",	/* pru1: pr1_pru1_pru_r30_4 */
-		"P8.42",	/* pru1: pr1_pru1_pru_r30_5 */
-		"P8.43",	/* pru1: pr1_pru1_pru_r30_2 */
-		"P8.44",	/* pru1: pr1_pru1_pru_r30_3 */
-		"P8.45",	/* pru1: pr1_pru1_pru_r30_0 */
-		"P8.46",	/* pru1: pr1_pru1_pru_r30_1 */
-		"P9.27",
-		/* the hardware IP uses */
-		"pru0",
-		"pru1";
-
-	fragment@0 {
-		target = <&am33xx_pinmux>;
-		__overlay__ {
-
-			pru_bela_pins: pinmux_pru_bela_pins {
-				pinctrl-single,pins = <
-					0x1a4 0x37	/* P9 27 GPIO3_19: mcasp0_fsr.gpio3[19] | MODE7 | INPUT | pullup */
-					0x0b0 0x25	/* lcd_data4.pr1_pru1_pru_r30_4, MODE5 | OUTPUT | PRU */
-					0x0b4 0x25	/* lcd_data5.pr1_pru1_pru_r30_5, MODE5 | OUTPUT | PRU */
-					0x0ac 0x25	/* lcd_data3.pr1_pru1_pru_r30_3, MODE5 | OUTPUT | PRU */
-					0x0a0 0x25	/* lcd_data0.pr1_pru1_pru_r30_0, MODE5 | OUTPUT | PRU */
-					0x0a4 0x25	/* lcd_data1.pr1_pru1_pru_r30_1, MODE5 | OUTPUT | PRU */
-					0x0a8 0x25	/* lcd_data2.pr1_pru1_pru_r30_2, MODE5 | OUTPUT | PRU */
-				>;
-			};
-		};
-	};
-
-	fragment@2 {
-		target = <&pruss>;
-		__overlay__ {
-			status = "okay";
-
-			pinctrl-names = "default";
-			pinctrl-0 = <&pru_bela_pins>;
-		};
-	};
-};
\ No newline at end of file
diff --git a/resources/wheezy/dtb/am335x-boneblack.dtb b/resources/wheezy/dtb/am335x-boneblack.dtb
deleted file mode 100755
index 01e47289a0c83f25c1be0ad5f317ded67c8f5aca..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 23787
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
S_|kciWn5v^ym^wkQ~CdH`3XJ%

diff --git a/resources/wheezy/dtb/am335x-boneblack.dts b/resources/wheezy/dtb/am335x-boneblack.dts
deleted file mode 100755
index a41435c8d..000000000
--- a/resources/wheezy/dtb/am335x-boneblack.dts
+++ /dev/null
@@ -1,1251 +0,0 @@
-/dts-v1/;
-
-/ {
-	#address-cells = <0x1>;
-	#size-cells = <0x1>;
-	compatible = "ti,am335x-bone", "ti,am33xx";
-	interrupt-parent = <0x1>;
-	model = "TI AM335x BeagleBone";
-
-	chosen {
-	};
-
-	aliases {
-		serial0 = "/ocp/serial@44e09000";
-		serial1 = "/ocp/serial@48022000";
-		serial2 = "/ocp/serial@48024000";
-		serial3 = "/ocp/serial@481a6000";
-		serial4 = "/ocp/serial@481a8000";
-		serial5 = "/ocp/serial@481aa000";
-	};
-
-	memory {
-		device_type = "memory";
-		reg = <0x80000000 0x10000000>;
-	};
-
-	cpus {
-
-		cpu@0 {
-			compatible = "arm,cortex-a8";
-			operating-points = <0xf4240 0x149970 0xc3500 0x13d620 0x927c0 0x10f7c0 0x493e0 0xec928>;
-			voltage-tolerance = <0x2>;
-			clock-latency = <0x493e0>;
-			cpu0-supply = <0x2>;
-			linux,phandle = <0x12>;
-			phandle = <0x12>;
-		};
-	};
-
-	soc {
-		compatible = "ti,omap-infra";
-
-		mpu {
-			compatible = "ti,omap3-mpu";
-			ti,hwmods = "mpu";
-		};
-	};
-
-	pinmux@44e10800 {
-		compatible = "pinctrl-single";
-		reg = <0x44e10800 0x238>;
-		#address-cells = <0x1>;
-		#size-cells = <0x0>;
-		pinctrl-single,register-width = <0x20>;
-		pinctrl-single,function-mask = <0x7f>;
-		pinctrl-names = "default";
-		pinctrl-0 = <0x3>;
-		linux,phandle = <0x13>;
-		phandle = <0x13>;
-
-		pinmux_userled_pins {
-			pinctrl-single,pins = <0x54 0x7 0x58 0x17 0x5c 0x7 0x60 0x17
-// /*PRU1 GPO 0-7*/ 0xa0 0x05 0xa4 0x05 0xa8 0x05 0xac 0x05 0xb0 0x05 0xb4 0x05 0xb8 0x05 0xbc 0x05
-/*GPIOrt pins*/ 0x90 0x27 0x94 0x27 0x9c 0x27 0x98 0x27 0x34 0x27 0x30 0x27 0x78 0x27 0x48 0x27 0x3c 0x27 0x38 0x27 0x4c 0x27 0x8c 0x27 0xe0 0x27 0xe8 0x27 0xe4 0x27 0xec 0x27
-// /*GPIOrt pins with PRU0 gpo*/ 0x90 0x27 0x94 0x27 0x9c 0x27 0x98 0x27 0x34 0x06 0x30 0x06 0x78 0x27 0x48 0x27 0x3c 0x27 0x38 0x27 0x4c 0x27 0x8c 0x27 0xe0 0x27 0xe8 0x27 0xe4 0x27 0xec 0x27
->;
-			linux,phandle = <0x3>;
-			phandle = <0x3>;
-		};
-
-		pinmux_i2c0_pins {
-			pinctrl-single,pins = <0x188 0x70 0x18c 0x70>;
-			linux,phandle = <0x6>;
-			phandle = <0x6>;
-		};
-
-		pinmux_i2c1_pins {
-			pinctrl-single,pins = <0x180 0x73 0x184 0x73>;
-			linux,phandle = <0x7>;
-			phandle = <0x7>;
-		};
-
-		pinmux_i2c2_pins {
-			pinctrl-single,pins = <0x178 0x73 0x17c 0x73>;
-			linux,phandle = <0x8>;
-			phandle = <0x8>;
-		};
-
-		pinmux_rstctl_pins {
-			pinctrl-single,pins = <0x50 0x17>;
-			linux,phandle = <0x4>;
-			phandle = <0x4>;
-		};
-	};
-
-	ocp {
-		compatible = "simple-bus";
-		#address-cells = <0x1>;
-		#size-cells = <0x1>;
-		ranges;
-		ti,hwmods = "l3_main";
-		linux,phandle = <0x14>;
-		phandle = <0x14>;
-
-		interrupt-controller@48200000 {
-			compatible = "ti,omap2-intc";
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			ti,intc-size = <0x80>;
-			reg = <0x48200000 0x1000>;
-			linux,phandle = <0x1>;
-			phandle = <0x1>;
-		};
-
-		edma@49000000 {
-			compatible = "ti,edma3";
-			ti,hwmods = "tpcc", "tptc0", "tptc1", "tptc2";
-			reg = <0x49000000 0x10000 0x44e10f90 0x40>;
-			interrupt-parent = <0x1>;
-			interrupts = <0xc 0xd 0xe>;
-			#dma-cells = <0x1>;
-			dma-channels = <0x40>;
-			ti,edma-regions = <0x4>;
-			ti,edma-slots = <0x100>;
-			ti,edma-queue-tc-map = <0x0 0x0 0x1 0x1 0x2 0x2>;
-			ti,edma-queue-priority-map = <0x0 0x0 0x1 0x1 0x2 0x2>;
-			ti,edma-default-queue = <0x1>;
-			ti,edma-xbar-event-map = <0x20 0xc 0x1e 0x14>;
-			linux,phandle = <0x9>;
-			phandle = <0x9>;
-		};
-
-		gpio@44e07000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio1";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x44e07000 0x1000>;
-			interrupts = <0x60>;
-			linux,phandle = <0x15>;
-			phandle = <0x15>;
-		};
-
-		gpio@4804c000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio2";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x4804c000 0x1000>;
-			interrupts = <0x62>;
-			linux,phandle = <0x5>;
-			phandle = <0x5>;
-		};
-
-		gpio@481ac000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio3";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x481ac000 0x1000>;
-			interrupts = <0x20>;
-			linux,phandle = <0x16>;
-			phandle = <0x16>;
-		};
-
-		gpio@481ae000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio4";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x481ae000 0x1000>;
-			interrupts = <0x3e>;
-			linux,phandle = <0x17>;
-			phandle = <0x17>;
-		};
-
-		rstctl@0 {
-			status = "okay";
-			compatible = "gpio-rctrl";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x4>;
-			#reset-cells = <0x2>;
-			gpios = <0x5 0x14 0x0>;
-			gpio-names = "eMMC_RSTn";
-			linux,phandle = <0xb>;
-			phandle = <0xb>;
-		};
-
-		serial@44e09000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart1";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x44e09000 0x2000>;
-			interrupts = <0x48>;
-			status = "okay";
-			linux,phandle = <0x18>;
-			phandle = <0x18>;
-		};
-
-		serial@48022000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart2";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x48022000 0x2000>;
-			interrupts = <0x49>;
-			status = "okay";
-			linux,phandle = <0x19>;
-			phandle = <0x19>;
-		};
-
-		serial@48024000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart3";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x48024000 0x2000>;
-			interrupts = <0x4a>;
-			status = "disabled";
-			linux,phandle = <0x1a>;
-			phandle = <0x1a>;
-		};
-
-		serial@481a6000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart4";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x481a6000 0x2000>;
-			interrupts = <0x2c>;
-			status = "disabled";
-			linux,phandle = <0x1b>;
-			phandle = <0x1b>;
-		};
-
-		serial@481a8000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart5";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x481a8000 0x2000>;
-			interrupts = <0x2d>;
-			status = "disabled";
-			linux,phandle = <0x1c>;
-			phandle = <0x1c>;
-		};
-
-		serial@481aa000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart6";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x481aa000 0x2000>;
-			interrupts = <0x2e>;
-			status = "disabled";
-			linux,phandle = <0x1d>;
-			phandle = <0x1d>;
-		};
-
-		i2c@44e0b000 {
-			compatible = "ti,omap4-i2c";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "i2c1";
-			reg = <0x44e0b000 0x1000>;
-			interrupts = <0x46>;
-			status = "okay";
-			clock-frequency = <0x61a80>;
-			pinctrl-names = "default";
-			pinctrl-0 = <0x6>;
-			linux,phandle = <0x1e>;
-			phandle = <0x1e>;
-
-			tps@24 {
-				reg = <0x24>;
-				compatible = "ti,tps65217";
-				ti,pmic-shutdown-controller;
-				linux,phandle = <0x1f>;
-				phandle = <0x1f>;
-
-				regulators {
-					#address-cells = <0x1>;
-					#size-cells = <0x0>;
-
-					regulator@0 {
-						reg = <0x0>;
-						regulator-compatible = "dcdc1";
-						regulator-always-on;
-						linux,phandle = <0x20>;
-						phandle = <0x20>;
-					};
-
-					regulator@1 {
-						reg = <0x1>;
-						regulator-compatible = "dcdc2";
-						regulator-name = "vdd_mpu";
-						regulator-min-microvolt = <0xe1d48>;
-						regulator-max-microvolt = <0x1437c8>;
-						regulator-boot-on;
-						regulator-always-on;
-						linux,phandle = <0x2>;
-						phandle = <0x2>;
-					};
-
-					regulator@2 {
-						reg = <0x2>;
-						regulator-compatible = "dcdc3";
-						regulator-name = "vdd_core";
-						regulator-min-microvolt = <0xe1d48>;
-						regulator-max-microvolt = <0x118c30>;
-						regulator-boot-on;
-						regulator-always-on;
-						linux,phandle = <0x21>;
-						phandle = <0x21>;
-					};
-
-					regulator@3 {
-						reg = <0x3>;
-						regulator-compatible = "ldo1";
-						regulator-always-on;
-						linux,phandle = <0x22>;
-						phandle = <0x22>;
-					};
-
-					regulator@4 {
-						reg = <0x4>;
-						regulator-compatible = "ldo2";
-						regulator-always-on;
-						linux,phandle = <0x23>;
-						phandle = <0x23>;
-					};
-
-					regulator@5 {
-						reg = <0x5>;
-						regulator-compatible = "ldo3";
-						regulator-min-microvolt = <0x1b7740>;
-						regulator-max-microvolt = <0x1b7740>;
-						regulator-always-on;
-						linux,phandle = <0x24>;
-						phandle = <0x24>;
-					};
-
-					regulator@6 {
-						reg = <0x6>;
-						regulator-compatible = "ldo4";
-						regulator-always-on;
-						linux,phandle = <0x25>;
-						phandle = <0x25>;
-					};
-				};
-			};
-
-			baseboard_eeprom@50 {
-				compatible = "at,24c256";
-				reg = <0x50>;
-				linux,phandle = <0xd>;
-				phandle = <0xd>;
-			};
-		};
-
-		i2c@4802a000 {
-			compatible = "ti,omap4-i2c";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "i2c2";
-			reg = <0x4802a000 0x1000>;
-			interrupts = <0x47>;
-			status = "okay";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x7>;
-			clock-frequency = <0x61a80>;
-			linux,phandle = <0x26>;
-			phandle = <0x26>;
-		};
-
-		i2c@4819c000 {
-			compatible = "ti,omap4-i2c";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "i2c3";
-			reg = <0x4819c000 0x1000>;
-			interrupts = <0x1e>;
-			status = "okay";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x8>;
-			clock-frequency = <0x186a0>;
-			linux,phandle = <0x27>;
-			phandle = <0x27>;
-
-			cape_eeprom0@54 {
-				compatible = "at,24c256";
-				reg = <0x54>;
-				linux,phandle = <0xe>;
-				phandle = <0xe>;
-			};
-
-			cape_eeprom1@55 {
-				compatible = "at,24c256";
-				reg = <0x55>;
-				linux,phandle = <0xf>;
-				phandle = <0xf>;
-			};
-
-			cape_eeprom2@56 {
-				compatible = "at,24c256";
-				reg = <0x56>;
-				linux,phandle = <0x10>;
-				phandle = <0x10>;
-			};
-
-			cape_eeprom3@57 {
-				compatible = "at,24c256";
-				reg = <0x57>;
-				linux,phandle = <0x11>;
-				phandle = <0x11>;
-			};
-		};
-
-		mmc@48060000 {
-			compatible = "ti,omap3-hsmmc";
-			ti,hwmods = "mmc1";
-			ti,dual-volt;
-			ti,needs-special-reset;
-			ti,needs-special-hs-handling;
-			dmas = <0x9 0x18 0x9 0x19>;
-			dma-names = "tx", "rx";
-			status = "okay";
-			vmmc-supply = <0xa>;
-			ti,vcc-aux-disable-is-sleep;
-			linux,phandle = <0x28>;
-			phandle = <0x28>;
-		};
-
-		mmc@481d8000 {
-			compatible = "ti,omap3-hsmmc";
-			ti,hwmods = "mmc2";
-			ti,needs-special-reset;
-			ti,needs-special-hs-handling;
-			dmas = <0x9 0x2 0x9 0x3>;
-			dma-names = "tx", "rx";
-			status = "okay";
-			vmmc-supply = <0xa>;
-			bus-width = <0x8>;
-			ti,non-removable;
-			reset = <0xb 0x0 0x0>;
-			reset-names = "eMMC_RSTn-CONSUMER";
-			linux,phandle = <0x29>;
-			phandle = <0x29>;
-		};
-
-		mmc@47810000 {
-			compatible = "ti,omap3-hsmmc";
-			ti,hwmods = "mmc3";
-			ti,needs-special-reset;
-			ti,needs-special-hs-handling;
-			status = "disabled";
-			linux,phandle = <0x2a>;
-			phandle = <0x2a>;
-		};
-
-		wdt@44e35000 {
-			compatible = "ti,omap3-wdt";
-			ti,hwmods = "wd_timer2";
-			reg = <0x44e35000 0x1000>;
-			interrupts = <0x5b>;
-			linux,phandle = <0x2b>;
-			phandle = <0x2b>;
-		};
-
-		d_can@481cc000 {
-			compatible = "bosch,d_can";
-			ti,hwmods = "d_can0";
-			reg = <0x481cc000 0x2000>;
-			interrupts = <0x34>;
-			status = "disabled";
-			linux,phandle = <0x2c>;
-			phandle = <0x2c>;
-		};
-
-		d_can@481d0000 {
-			compatible = "bosch,d_can";
-			ti,hwmods = "d_can1";
-			reg = <0x481d0000 0x2000>;
-			interrupts = <0x37>;
-			status = "disabled";
-			linux,phandle = <0x2d>;
-			phandle = <0x2d>;
-		};
-
-		timer@44e31000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x44e31000 0x400>;
-			interrupts = <0x43>;
-			ti,hwmods = "timer1";
-			ti,timer-alwon;
-			linux,phandle = <0x2e>;
-			phandle = <0x2e>;
-		};
-
-		timer@48040000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48040000 0x400>;
-			interrupts = <0x44>;
-			ti,hwmods = "timer2";
-			linux,phandle = <0x2f>;
-			phandle = <0x2f>;
-		};
-
-		timer@48042000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48042000 0x400>;
-			interrupts = <0x45>;
-			ti,hwmods = "timer3";
-			linux,phandle = <0x30>;
-			phandle = <0x30>;
-		};
-
-		timer@48044000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48044000 0x400>;
-			interrupts = <0x5c>;
-			ti,hwmods = "timer4";
-			ti,timer-pwm;
-			linux,phandle = <0x31>;
-			phandle = <0x31>;
-		};
-
-		timer@48046000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48046000 0x400>;
-			interrupts = <0x5d>;
-			ti,hwmods = "timer5";
-			ti,timer-pwm;
-			linux,phandle = <0x32>;
-			phandle = <0x32>;
-		};
-
-		timer@48048000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48048000 0x400>;
-			interrupts = <0x5e>;
-			ti,hwmods = "timer6";
-			ti,timer-pwm;
-			linux,phandle = <0x33>;
-			phandle = <0x33>;
-		};
-
-		timer@4804a000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x4804a000 0x400>;
-			interrupts = <0x5f>;
-			ti,hwmods = "timer7";
-			ti,timer-pwm;
-			linux,phandle = <0x34>;
-			phandle = <0x34>;
-		};
-
-		pruss@4a300000 {
-			compatible = "ti,pruss-v2";
-			ti,hwmods = "pruss";
-			ti,deassert-hard-reset = "pruss", "pruss";
-			reg = <0x4a300000 0x80000>;
-			ti,pintc-offset = <0x20000>;
-			interrupt-parent = <0x1>;
-			status = "disabled";
-			interrupts = <0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b>;
-			linux,phandle = <0x35>;
-			phandle = <0x35>;
-		};
-
-		rtc@44e3e000 {
-			compatible = "ti,da830-rtc";
-			reg = <0x44e3e000 0x1000>;
-			interrupts = <0x4b 0x4c>;
-			ti,hwmods = "rtc";
-			ti,system-power-controller;
-		};
-
-		spi@48030000 {
-			compatible = "ti,omap4-mcspi";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x48030000 0x400>;
-			interrupt = <0x41>;
-			ti,spi-num-cs = <0x2>;
-			ti,hwmods = "spi0";
-			dmas = <0x9 0x10 0x9 0x11 0x9 0x12 0x9 0x13>;
-			dma-names = "tx0", "rx0", "tx1", "rx1";
-			status = "disabled";
-			linux,phandle = <0x36>;
-			phandle = <0x36>;
-		};
-
-		spi@481a0000 {
-			compatible = "ti,omap4-mcspi";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x481a0000 0x400>;
-			interrupt = <0x7d>;
-			ti,spi-num-cs = <0x2>;
-			ti,hwmods = "spi1";
-			dmas = <0x9 0x2a 0x9 0x2b 0x9 0x2c 0x9 0x2d>;
-			dma-names = "tx0", "rx0", "tx1", "rx1";
-			status = "disabled";
-			linux,phandle = <0x37>;
-			phandle = <0x37>;
-		};
-
-		gpmc@50000000 {
-			compatible = "ti,am3352-gpmc";
-			ti,hwmods = "gpmc";
-			reg = <0x50000000 0x1000000>;
-			interrupts = <0x64>;
-			gpmc,num-cs = <0x7>;
-			gpmc,num-waitpins = <0x2>;
-			#address-cells = <0x2>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			linux,phandle = <0x38>;
-			phandle = <0x38>;
-		};
-
-		nop-phy@0 {
-			compatible = "nop-xceiv-usb";
-		};
-
-		nop-phy@1 {
-			compatible = "nop-xceiv-usb";
-		};
-
-		usb@47400000 {
-			compatible = "ti,musb-am33xx";
-			reg = <0x47400000 0x1000 0x47401000 0x800 0x47401800 0x800>;
-			interrupts = <0x11 0x12 0x13>;
-			multipoint = <0x1>;
-			num-eps = <0x10>;
-			ram-bits = <0xc>;
-			port0-mode = <0x3>;
-			port1-mode = <0x1>;
-			power = <0xfa>;
-			ti,hwmods = "usb_otg_hs";
-			status = "okay";
-			interface_type = <0x1>;
-			linux,phandle = <0x39>;
-			phandle = <0x39>;
-		};
-
-		ethernet@4a100000 {
-			compatible = "ti,cpsw";
-			ti,hwmods = "cpgmac0";
-			cpdma_channels = <0x8>;
-			ale_entries = <0x400>;
-			bd_ram_size = <0x2000>;
-			no_bd_ram = <0x0>;
-			rx_descs = <0x40>;
-			mac_control = <0x20>;
-			slaves = <0x2>;
-			cpts_active_slave = <0x0>;
-			cpts_clock_mult = <0x80000000>;
-			cpts_clock_shift = <0x1d>;
-			reg = <0x4a100000 0x800 0x4a101200 0x100>;
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x28 0x29 0x2a 0x2b>;
-			ranges;
-			disable-napi;
-			linux,phandle = <0x3a>;
-			phandle = <0x3a>;
-
-			mdio@4a101000 {
-				compatible = "ti,davinci_mdio";
-				#address-cells = <0x1>;
-				#size-cells = <0x0>;
-				ti,hwmods = "davinci_mdio";
-				bus_freq = <0xf4240>;
-				reg = <0x4a101000 0x100>;
-				linux,phandle = <0xc>;
-				phandle = <0xc>;
-			};
-
-			slave@4a100200 {
-				mac-address = [00 00 00 00 00 00];
-				phy_id = <0xc 0x0>;
-				linux,phandle = <0x3b>;
-				phandle = <0x3b>;
-			};
-
-			slave@4a100300 {
-				mac-address = [00 00 00 00 00 00];
-				phy_id = <0xc 0x1>;
-				linux,phandle = <0x3c>;
-				phandle = <0x3c>;
-			};
-		};
-
-		tscadc@44e0d000 {
-			compatible = "ti,ti-tscadc";
-			reg = <0x44e0d000 0x1000>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x10>;
-			ti,hwmods = "adc_tsc";
-			status = "disabled";
-			linux,phandle = <0x3d>;
-			phandle = <0x3d>;
-		};
-
-		lcdc@4830e000 {
-			compatible = "ti,am3352-lcdc", "ti,da830-lcdc";
-			reg = <0x4830e000 0x1000>;
-			interrupts = <0x24>;
-			status = "disabled";
-			ti,hwmods = "lcdc";
-			linux,phandle = <0x3e>;
-			phandle = <0x3e>;
-		};
-
-		epwmss@48300000 {
-			compatible = "ti,am33xx-pwmss";
-			reg = <0x48300000 0x10>;
-			ti,hwmods = "epwmss0";
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			ranges = <0x48300100 0x48300100 0x80 0x48300180 0x48300180 0x80 0x48300200 0x48300200 0x80>;
-			linux,phandle = <0x3f>;
-			phandle = <0x3f>;
-
-			ecap@48300100 {
-				compatible = "ti,am33xx-ecap";
-				#pwm-cells = <0x3>;
-				reg = <0x48300100 0x80>;
-				ti,hwmods = "ecap0";
-				status = "disabled";
-				linux,phandle = <0x40>;
-				phandle = <0x40>;
-			};
-
-			ehrpwm@48300200 {
-				compatible = "ti,am33xx-ehrpwm";
-				#pwm-cells = <0x3>;
-				reg = <0x48300200 0x80>;
-				ti,hwmods = "ehrpwm0";
-				status = "disabled";
-				linux,phandle = <0x41>;
-				phandle = <0x41>;
-			};
-		};
-
-		epwmss@48302000 {
-			compatible = "ti,am33xx-pwmss";
-			reg = <0x48302000 0x10>;
-			ti,hwmods = "epwmss1";
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			ranges = <0x48302100 0x48302100 0x80 0x48302180 0x48302180 0x80 0x48302200 0x48302200 0x80>;
-			linux,phandle = <0x42>;
-			phandle = <0x42>;
-
-			ecap@48302100 {
-				compatible = "ti,am33xx-ecap";
-				#pwm-cells = <0x3>;
-				reg = <0x48302100 0x80>;
-				ti,hwmods = "ecap1";
-				status = "disabled";
-				linux,phandle = <0x43>;
-				phandle = <0x43>;
-			};
-
-			ehrpwm@48302200 {
-				compatible = "ti,am33xx-ehrpwm";
-				#pwm-cells = <0x3>;
-				reg = <0x48302200 0x80>;
-				ti,hwmods = "ehrpwm1";
-				status = "disabled";
-				linux,phandle = <0x44>;
-				phandle = <0x44>;
-			};
-		};
-
-		epwmss@48304000 {
-			compatible = "ti,am33xx-pwmss";
-			reg = <0x48304000 0x10>;
-			ti,hwmods = "epwmss2";
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			ranges = <0x48304100 0x48304100 0x80 0x48304180 0x48304180 0x80 0x48304200 0x48304200 0x80>;
-			linux,phandle = <0x45>;
-			phandle = <0x45>;
-
-			ecap@48304100 {
-				compatible = "ti,am33xx-ecap";
-				#pwm-cells = <0x3>;
-				reg = <0x48304100 0x80>;
-				ti,hwmods = "ecap2";
-				status = "disabled";
-				linux,phandle = <0x46>;
-				phandle = <0x46>;
-			};
-
-			ehrpwm@48304200 {
-				compatible = "ti,am33xx-ehrpwm";
-				#pwm-cells = <0x3>;
-				reg = <0x48304200 0x80>;
-				ti,hwmods = "ehrpwm2";
-				status = "disabled";
-				linux,phandle = <0x47>;
-				phandle = <0x47>;
-			};
-		};
-
-		sham@53100000 {
-			compatible = "ti,omap4-sham";
-			ti,hwmods = "sham";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x53100000 0x200>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x6d>;
-			dmas = <0x9 0x24>;
-			dma-names = "rx";
-			status = "okay";
-			linux,phandle = <0x48>;
-			phandle = <0x48>;
-		};
-
-		aes@53500000 {
-			compatible = "ti,omap4-aes";
-			ti,hwmods = "aes";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x53500000 0xa0>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x66>;
-			dmas = <0x9 0x6 0x9 0x5>;
-			dma-names = "tx", "rx";
-			status = "okay";
-			linux,phandle = <0x49>;
-			phandle = <0x49>;
-		};
-
-		mcasp@48038000 {
-			compatible = "ti,omap2-mcasp-audio";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "mcasp0";
-			reg = <0x48038000 0x2000>;
-			interrupts = <0x50 0x51>;
-			status = "disabled";
-			asp-chan-q = <0x2>;
-			tx-dma-offset = <0x46000000>;
-			rx-dma-offset = <0x46000000>;
-			dmas = <0x9 0x8 0x9 0x9>;
-			dma-names = "tx", "rx";
-			linux,phandle = <0x4a>;
-			phandle = <0x4a>;
-		};
-
-		mcasp@4803C000 {
-			compatible = "ti,omap2-mcasp-audio";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "mcasp1";
-			reg = <0x4803c000 0x2000>;
-			interrupts = <0x52 0x53>;
-			status = "disabled";
-			asp-chan-q = <0x2>;
-			tx-dma-offset = <0x46400000>;
-			rx-dma-offset = <0x46400000>;
-			dmas = <0x9 0xa 0x9 0xb>;
-			dma-names = "tx", "rx";
-			linux,phandle = <0x4b>;
-			phandle = <0x4b>;
-		};
-
-		gpio-leds {
-			compatible = "gpio-leds";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x3>;
-
-			led0 {
-				label = "beaglebone:green:usr0";
-				gpios = <0x5 0x15 0x0>;
-				linux,default-trigger = "heartbeat";
-				default-state = "off";
-			};
-
-			led1 {
-				label = "beaglebone:green:usr1";
-				gpios = <0x5 0x16 0x0>;
-				linux,default-trigger = "mmc0";
-				default-state = "off";
-			};
-
-			led2 {
-				label = "beaglebone:green:usr2";
-				gpios = <0x5 0x17 0x0>;
-				linux,default-trigger = "cpu0";
-				default-state = "off";
-			};
-
-			led3 {
-				label = "beaglebone:green:usr3";
-				gpios = <0x5 0x18 0x0>;
-				default-state = "off";
-				linux,default-trigger = "mmc1";
-			};
-		};
-	};
-
-	bone_capemgr {
-		compatible = "ti,bone-capemgr";
-		status = "okay";
-		eeprom = <0xd>;
-
-		baseboardmaps {
-
-			board@0 {
-				board-name = "A335BONE";
-				compatible-name = "ti,beaglebone";
-				linux,phandle = <0x4c>;
-				phandle = <0x4c>;
-			};
-
-			board@1 {
-				board-name = "A335BNLT";
-				compatible-name = "ti,beaglebone-black";
-				linux,phandle = <0x4d>;
-				phandle = <0x4d>;
-			};
-		};
-
-		slots {
-
-			slot@0 {
-				eeprom = <0xe>;
-			};
-
-			slot@1 {
-				eeprom = <0xf>;
-			};
-
-			slot@2 {
-				eeprom = <0x10>;
-			};
-
-			slot@3 {
-				eeprom = <0x11>;
-			};
-
-			slot@5 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-Geiger";
-				version = "00A0";
-				manufacturer = "Geiger Inc.";
-				part-number = "BB-BONE-GEIGER";
-			};
-
-			slot@7 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-Nixie";
-				version = "00A0";
-				manufacturer = "Ranostay Industries";
-				part-number = "BB-BONE-NIXIE";
-			};
-
-			slot@8 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-TFT";
-				version = "00A0";
-				manufacturer = "Adafruit";
-				part-number = "BB-BONE-TFT-01";
-			};
-
-			slot@9 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-RTC";
-				version = "00A0";
-				manufacturer = "Adafruit";
-				part-number = "BB-BONE-RTC-01";
-			};
-
-			slot@10 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-Hexy";
-				version = "00A0";
-				manufacturer = "Koen Kooi";
-				part-number = "BB-BONE-HEXY-01";
-			};
-
-			slot@11 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-MRF24J40";
-				version = "00A0";
-				manufacturer = "Signal 11 Software";
-				part-number = "BB-BONE-MRF24J40";
-			};
-
-			slot@100 {
-				ti,cape-override;
-				priority = <0x1>;
-				compatible = "ti,beaglebone-black";
-				board-name = "Bone-LT-eMMC-2G";
-				version = "00A0";
-				manufacturer = "Texas Instruments";
-				part-number = "BB-BONE-EMMC-2G";
-			};
-
-			slot@101 {
-				ti,cape-override;
-				priority = <0x1>;
-				compatible = "ti,beaglebone-black";
-				board-name = "Bone-Black-HDMI";
-				version = "00A0";
-				manufacturer = "Texas Instruments";
-				part-number = "BB-BONELT-HDMI";
-			};
-		};
-
-		capemaps {
-
-			cape@0 {
-				part-number = "BB-BONE-DVID-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-dvi-00A0.dtbo";
-				};
-
-				version@00A1 {
-					version = "00A1", "01";
-					dtbo = "cape-bone-dvi-00A1.dtbo";
-				};
-
-				version@00A2 {
-					version = "00A2", "A2";
-					dtbo = "cape-bone-dvi-00A2.dtbo";
-				};
-
-				version@00A3 {
-					version = "00A3";
-					dtbo = "cape-bone-dvi-00A2.dtbo";
-				};
-			};
-
-			cape@1 {
-				part-number = "BB-BONE-EMMC-2G";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-2g-emmc1.dtbo";
-				};
-			};
-
-			cape@2 {
-				part-number = "BB-BONE-GEIGER";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-geiger-00A0.dtbo";
-				};
-			};
-
-			cape@3 {
-				part-number = "BB-BONE-LCD3-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-lcd3-00A0.dtbo";
-				};
-
-				version@00A2 {
-					version = "00A2";
-					dtbo = "cape-bone-lcd3-00A2.dtbo";
-				};
-			};
-
-			cape@4 {
-				part-number = "BB-BONE-WTHR-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-weather-00A0.dtbo";
-				};
-			};
-
-			cape@5 {
-				part-number = "BB-BONELT-HDMI";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-boneblack-hdmi-00A0.dtbo";
-				};
-			};
-
-			cape@6 {
-				part-number = "BB-BONE-NIXIE";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-nixie-00A0.dtbo";
-				};
-			};
-
-			cape@7 {
-				part-number = "BB-BONE-TFT-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-adafruit-lcd-00A0.dtbo";
-				};
-			};
-
-			cape@8 {
-				part-number = "BB-BONE-RTC-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-adafruit-rtc-00A0.dtbo";
-				};
-			};
-
-			cape@9 {
-				part-number = "BB-BONE-HEXY-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-hexy-00A0.dtbo";
-				};
-			};
-
-			cape@10 {
-				part-number = "BB-BONE-MRF24J40";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-mrf24j40-00A0.dtbo";
-				};
-			};
-
-			cape@11 {
-				part-number = "BB-BONE-EXPTEST";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-exptest-00A0.dtbo";
-				};
-			};
-		};
-	};
-
-	fixedregulator@0 {
-		compatible = "regulator-fixed";
-		regulator-name = "vmmcsd_fixed";
-		regulator-min-microvolt = <0x325aa0>;
-		regulator-max-microvolt = <0x325aa0>;
-		linux,phandle = <0xa>;
-		phandle = <0xa>;
-	};
-
-	__symbols__ {
-		cpu = "/cpus/cpu@0";
-		am33xx_pinmux = "/pinmux@44e10800";
-		userled_pins = "/pinmux@44e10800/pinmux_userled_pins";
-		i2c0_pins = "/pinmux@44e10800/pinmux_i2c0_pins";
-		i2c1_pins = "/pinmux@44e10800/pinmux_i2c1_pins";
-		i2c2_pins = "/pinmux@44e10800/pinmux_i2c2_pins";
-		rstctl_pins = "/pinmux@44e10800/pinmux_rstctl_pins";
-		ocp = "/ocp";
-		intc = "/ocp/interrupt-controller@48200000";
-		edma = "/ocp/edma@49000000";
-		gpio1 = "/ocp/gpio@44e07000";
-		gpio2 = "/ocp/gpio@4804c000";
-		gpio3 = "/ocp/gpio@481ac000";
-		gpio4 = "/ocp/gpio@481ae000";
-		rstctl = "/ocp/rstctl@0";
-		uart1 = "/ocp/serial@44e09000";
-		uart2 = "/ocp/serial@48022000";
-		uart3 = "/ocp/serial@48024000";
-		uart4 = "/ocp/serial@481a6000";
-		uart5 = "/ocp/serial@481a8000";
-		uart6 = "/ocp/serial@481aa000";
-		i2c0 = "/ocp/i2c@44e0b000";
-		tps = "/ocp/i2c@44e0b000/tps@24";
-		dcdc1_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@0";
-		dcdc2_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@1";
-		dcdc3_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@2";
-		ldo1_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@3";
-		ldo2_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@4";
-		ldo3_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@5";
-		ldo4_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@6";
-		baseboard_eeprom = "/ocp/i2c@44e0b000/baseboard_eeprom@50";
-		i2c1 = "/ocp/i2c@4802a000";
-		i2c2 = "/ocp/i2c@4819c000";
-		cape_eeprom0 = "/ocp/i2c@4819c000/cape_eeprom0@54";
-		cape_eeprom1 = "/ocp/i2c@4819c000/cape_eeprom1@55";
-		cape_eeprom2 = "/ocp/i2c@4819c000/cape_eeprom2@56";
-		cape_eeprom3 = "/ocp/i2c@4819c000/cape_eeprom3@57";
-		mmc1 = "/ocp/mmc@48060000";
-		mmc2 = "/ocp/mmc@481d8000";
-		mmc3 = "/ocp/mmc@47810000";
-		wdt2 = "/ocp/wdt@44e35000";
-		dcan0 = "/ocp/d_can@481cc000";
-		dcan1 = "/ocp/d_can@481d0000";
-		timer1 = "/ocp/timer@44e31000";
-		timer2 = "/ocp/timer@48040000";
-		timer3 = "/ocp/timer@48042000";
-		timer4 = "/ocp/timer@48044000";
-		timer5 = "/ocp/timer@48046000";
-		timer6 = "/ocp/timer@48048000";
-		timer7 = "/ocp/timer@4804a000";
-		pruss = "/ocp/pruss@4a300000";
-		spi0 = "/ocp/spi@48030000";
-		spi1 = "/ocp/spi@481a0000";
-		gpmc = "/ocp/gpmc@50000000";
-		usb_otg_hs = "/ocp/usb@47400000";
-		mac = "/ocp/ethernet@4a100000";
-		davinci_mdio = "/ocp/ethernet@4a100000/mdio@4a101000";
-		cpsw_emac0 = "/ocp/ethernet@4a100000/slave@4a100200";
-		cpsw_emac1 = "/ocp/ethernet@4a100000/slave@4a100300";
-		tscadc = "/ocp/tscadc@44e0d000";
-		lcdc = "/ocp/lcdc@4830e000";
-		epwmss0 = "/ocp/epwmss@48300000";
-		ecap0 = "/ocp/epwmss@48300000/ecap@48300100";
-		ehrpwm0 = "/ocp/epwmss@48300000/ehrpwm@48300200";
-		epwmss1 = "/ocp/epwmss@48302000";
-		ecap1 = "/ocp/epwmss@48302000/ecap@48302100";
-		ehrpwm1 = "/ocp/epwmss@48302000/ehrpwm@48302200";
-		epwmss2 = "/ocp/epwmss@48304000";
-		ecap2 = "/ocp/epwmss@48304000/ecap@48304100";
-		ehrpwm2 = "/ocp/epwmss@48304000/ehrpwm@48304200";
-		sham = "/ocp/sham@53100000";
-		aes = "/ocp/aes@53500000";
-		mcasp0 = "/ocp/mcasp@48038000";
-		mcasp1 = "/ocp/mcasp@4803C000";
-		baseboard_beaglebone = "/bone_capemgr/baseboardmaps/board@0";
-		baseboard_beaglebone_black = "/bone_capemgr/baseboardmaps/board@1";
-		vmmcsd_fixed = "/fixedregulator@0";
-	};
-};
diff --git a/resources/wheezy/dtb/am335x-bonegreen.dtb b/resources/wheezy/dtb/am335x-bonegreen.dtb
deleted file mode 100644
index da33e748a73ad889886e03e2b1182cb6d9ce57dd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 23787
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
S(s_|(Twzrn5qPOPmH!X3-U)gD

diff --git a/resources/wheezy/dtb/am335x-bonegreen.dts b/resources/wheezy/dtb/am335x-bonegreen.dts
deleted file mode 100644
index b496235b9..000000000
--- a/resources/wheezy/dtb/am335x-bonegreen.dts
+++ /dev/null
@@ -1,1251 +0,0 @@
-/dts-v1/;
-
-/ {
-	#address-cells = <0x1>;
-	#size-cells = <0x1>;
-	compatible = "ti,am335x-bone", "ti,am33xx";
-	interrupt-parent = <0x1>;
-	model = "TI AM335x BeagleBone";
-
-	chosen {
-	};
-
-	aliases {
-		serial0 = "/ocp/serial@44e09000";
-		serial1 = "/ocp/serial@48022000";
-		serial2 = "/ocp/serial@48024000";
-		serial3 = "/ocp/serial@481a6000";
-		serial4 = "/ocp/serial@481a8000";
-		serial5 = "/ocp/serial@481aa000";
-	};
-
-	memory {
-		device_type = "memory";
-		reg = <0x80000000 0x10000000>;
-	};
-
-	cpus {
-
-		cpu@0 {
-			compatible = "arm,cortex-a8";
-			operating-points = <0xf4240 0x149970 0xc3500 0x13d620 0x927c0 0x10f7c0 0x493e0 0xec928>;
-			voltage-tolerance = <0x2>;
-			clock-latency = <0x493e0>;
-			cpu0-supply = <0x2>;
-			linux,phandle = <0x12>;
-			phandle = <0x12>;
-		};
-	};
-
-	soc {
-		compatible = "ti,omap-infra";
-
-		mpu {
-			compatible = "ti,omap3-mpu";
-			ti,hwmods = "mpu";
-		};
-	};
-
-	pinmux@44e10800 {
-		compatible = "pinctrl-single";
-		reg = <0x44e10800 0x238>;
-		#address-cells = <0x1>;
-		#size-cells = <0x0>;
-		pinctrl-single,register-width = <0x20>;
-		pinctrl-single,function-mask = <0x7f>;
-		pinctrl-names = "default";
-		pinctrl-0 = <0x3>;
-		linux,phandle = <0x13>;
-		phandle = <0x13>;
-
-		pinmux_userled_pins {
-			pinctrl-single,pins = <0x54 0x7 0x58 0x17 0x5c 0x7 0x60 0x17
-// /*PRU1 GPO 0-7*/ 0xa0 0x05 0xa4 0x05 0xa8 0x05 0xac 0x05 0xb0 0x05 0xb4 0x05 0xb8 0x05 0xbc 0x05
-/*GPIOrt pins*/ 0x90 0x27 0x94 0x27 0x9c 0x27 0x98 0x27 0x34 0x27 0x30 0x27 0x78 0x27 0x48 0x27 0x3c 0x27 0x38 0x27 0x4c 0x27 0x8c 0x27 0xe0 0x27 0xe8 0x27 0xe4 0x27 0xec 0x27
-// /*GPIOrt pins with PRU0 gpo*/ 0x90 0x27 0x94 0x27 0x9c 0x27 0x98 0x27 0x34 0x06 0x30 0x06 0x78 0x27 0x48 0x27 0x3c 0x27 0x38 0x27 0x4c 0x27 0x8c 0x27 0xe0 0x27 0xe8 0x27 0xe4 0x27 0xec 0x27
->;
-			linux,phandle = <0x3>;
-			phandle = <0x3>;
-		};
-
-		pinmux_i2c0_pins {
-			pinctrl-single,pins = <0x188 0x70 0x18c 0x70>;
-			linux,phandle = <0x6>;
-			phandle = <0x6>;
-		};
-
-		pinmux_i2c1_pins {
-			pinctrl-single,pins = <0x180 0x73 0x184 0x73>;
-			linux,phandle = <0x7>;
-			phandle = <0x7>;
-		};
-
-		pinmux_i2c2_pins {
-			pinctrl-single,pins = <0x178 0x73 0x17c 0x73>;
-			linux,phandle = <0x8>;
-			phandle = <0x8>;
-		};
-
-		pinmux_rstctl_pins {
-			pinctrl-single,pins = <0x50 0x17>;
-			linux,phandle = <0x4>;
-			phandle = <0x4>;
-		};
-	};
-
-	ocp {
-		compatible = "simple-bus";
-		#address-cells = <0x1>;
-		#size-cells = <0x1>;
-		ranges;
-		ti,hwmods = "l3_main";
-		linux,phandle = <0x14>;
-		phandle = <0x14>;
-
-		interrupt-controller@48200000 {
-			compatible = "ti,omap2-intc";
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			ti,intc-size = <0x80>;
-			reg = <0x48200000 0x1000>;
-			linux,phandle = <0x1>;
-			phandle = <0x1>;
-		};
-
-		edma@49000000 {
-			compatible = "ti,edma3";
-			ti,hwmods = "tpcc", "tptc0", "tptc1", "tptc2";
-			reg = <0x49000000 0x10000 0x44e10f90 0x40>;
-			interrupt-parent = <0x1>;
-			interrupts = <0xc 0xd 0xe>;
-			#dma-cells = <0x1>;
-			dma-channels = <0x40>;
-			ti,edma-regions = <0x4>;
-			ti,edma-slots = <0x100>;
-			ti,edma-queue-tc-map = <0x0 0x0 0x1 0x1 0x2 0x2>;
-			ti,edma-queue-priority-map = <0x0 0x0 0x1 0x1 0x2 0x2>;
-			ti,edma-default-queue = <0x1>;
-			ti,edma-xbar-event-map = <0x20 0xc 0x1e 0x14>;
-			linux,phandle = <0x9>;
-			phandle = <0x9>;
-		};
-
-		gpio@44e07000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio1";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x44e07000 0x1000>;
-			interrupts = <0x60>;
-			linux,phandle = <0x15>;
-			phandle = <0x15>;
-		};
-
-		gpio@4804c000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio2";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x4804c000 0x1000>;
-			interrupts = <0x62>;
-			linux,phandle = <0x5>;
-			phandle = <0x5>;
-		};
-
-		gpio@481ac000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio3";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x481ac000 0x1000>;
-			interrupts = <0x20>;
-			linux,phandle = <0x16>;
-			phandle = <0x16>;
-		};
-
-		gpio@481ae000 {
-			compatible = "ti,omap4-gpio";
-			ti,hwmods = "gpio4";
-			gpio-controller;
-			#gpio-cells = <0x2>;
-			interrupt-controller;
-			#interrupt-cells = <0x1>;
-			reg = <0x481ae000 0x1000>;
-			interrupts = <0x3e>;
-			linux,phandle = <0x17>;
-			phandle = <0x17>;
-		};
-
-		rstctl@0 {
-			status = "okay";
-			compatible = "gpio-rctrl";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x4>;
-			#reset-cells = <0x2>;
-			gpios = <0x5 0x14 0x0>;
-			gpio-names = "eMMC_RSTn";
-			linux,phandle = <0xb>;
-			phandle = <0xb>;
-		};
-
-		serial@44e09000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart1";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x44e09000 0x2000>;
-			interrupts = <0x48>;
-			status = "okay";
-			linux,phandle = <0x18>;
-			phandle = <0x18>;
-		};
-
-		serial@48022000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart2";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x48022000 0x2000>;
-			interrupts = <0x49>;
-			status = "okay";
-			linux,phandle = <0x19>;
-			phandle = <0x19>;
-		};
-
-		serial@48024000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart3";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x48024000 0x2000>;
-			interrupts = <0x4a>;
-			status = "disabled";
-			linux,phandle = <0x1a>;
-			phandle = <0x1a>;
-		};
-
-		serial@481a6000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart4";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x481a6000 0x2000>;
-			interrupts = <0x2c>;
-			status = "disabled";
-			linux,phandle = <0x1b>;
-			phandle = <0x1b>;
-		};
-
-		serial@481a8000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart5";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x481a8000 0x2000>;
-			interrupts = <0x2d>;
-			status = "disabled";
-			linux,phandle = <0x1c>;
-			phandle = <0x1c>;
-		};
-
-		serial@481aa000 {
-			compatible = "ti,omap3-uart";
-			ti,hwmods = "uart6";
-			clock-frequency = <0x2dc6c00>;
-			reg = <0x481aa000 0x2000>;
-			interrupts = <0x2e>;
-			status = "disabled";
-			linux,phandle = <0x1d>;
-			phandle = <0x1d>;
-		};
-
-		i2c@44e0b000 {
-			compatible = "ti,omap4-i2c";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "i2c1";
-			reg = <0x44e0b000 0x1000>;
-			interrupts = <0x46>;
-			status = "okay";
-			clock-frequency = <0x61a80>;
-			pinctrl-names = "default";
-			pinctrl-0 = <0x6>;
-			linux,phandle = <0x1e>;
-			phandle = <0x1e>;
-
-			tps@24 {
-				reg = <0x24>;
-				compatible = "ti,tps65217";
-				ti,pmic-shutdown-controller;
-				linux,phandle = <0x1f>;
-				phandle = <0x1f>;
-
-				regulators {
-					#address-cells = <0x1>;
-					#size-cells = <0x0>;
-
-					regulator@0 {
-						reg = <0x0>;
-						regulator-compatible = "dcdc1";
-						regulator-always-on;
-						linux,phandle = <0x20>;
-						phandle = <0x20>;
-					};
-
-					regulator@1 {
-						reg = <0x1>;
-						regulator-compatible = "dcdc2";
-						regulator-name = "vdd_mpu";
-						regulator-min-microvolt = <0xe1d48>;
-						regulator-max-microvolt = <0x1437c8>;
-						regulator-boot-on;
-						regulator-always-on;
-						linux,phandle = <0x2>;
-						phandle = <0x2>;
-					};
-
-					regulator@2 {
-						reg = <0x2>;
-						regulator-compatible = "dcdc3";
-						regulator-name = "vdd_core";
-						regulator-min-microvolt = <0xe1d48>;
-						regulator-max-microvolt = <0x118c30>;
-						regulator-boot-on;
-						regulator-always-on;
-						linux,phandle = <0x21>;
-						phandle = <0x21>;
-					};
-
-					regulator@3 {
-						reg = <0x3>;
-						regulator-compatible = "ldo1";
-						regulator-always-on;
-						linux,phandle = <0x22>;
-						phandle = <0x22>;
-					};
-
-					regulator@4 {
-						reg = <0x4>;
-						regulator-compatible = "ldo2";
-						regulator-always-on;
-						linux,phandle = <0x23>;
-						phandle = <0x23>;
-					};
-
-					regulator@5 {
-						reg = <0x5>;
-						regulator-compatible = "ldo3";
-						regulator-min-microvolt = <0x1b7740>;
-						regulator-max-microvolt = <0x1b7740>;
-						regulator-always-on;
-						linux,phandle = <0x24>;
-						phandle = <0x24>;
-					};
-
-					regulator@6 {
-						reg = <0x6>;
-						regulator-compatible = "ldo4";
-						regulator-always-on;
-						linux,phandle = <0x25>;
-						phandle = <0x25>;
-					};
-				};
-			};
-
-			baseboard_eeprom@50 {
-				compatible = "at,24c256";
-				reg = <0x50>;
-				linux,phandle = <0xd>;
-				phandle = <0xd>;
-			};
-		};
-
-		i2c@4802a000 {
-			compatible = "ti,omap4-i2c";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "i2c2";
-			reg = <0x4802a000 0x1000>;
-			interrupts = <0x47>;
-			status = "okay";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x7>;
-			clock-frequency = <0x61a80>;
-			linux,phandle = <0x26>;
-			phandle = <0x26>;
-		};
-
-		i2c@4819c000 {
-			compatible = "ti,omap4-i2c";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "i2c3";
-			reg = <0x4819c000 0x1000>;
-			interrupts = <0x1e>;
-			status = "okay";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x8>;
-			clock-frequency = <0x186a0>;
-			linux,phandle = <0x27>;
-			phandle = <0x27>;
-
-			cape_eeprom0@54 {
-				compatible = "at,24c256";
-				reg = <0x54>;
-				linux,phandle = <0xe>;
-				phandle = <0xe>;
-			};
-
-			cape_eeprom1@55 {
-				compatible = "at,24c256";
-				reg = <0x55>;
-				linux,phandle = <0xf>;
-				phandle = <0xf>;
-			};
-
-			cape_eeprom2@56 {
-				compatible = "at,24c256";
-				reg = <0x56>;
-				linux,phandle = <0x10>;
-				phandle = <0x10>;
-			};
-
-			cape_eeprom3@57 {
-				compatible = "at,24c256";
-				reg = <0x57>;
-				linux,phandle = <0x11>;
-				phandle = <0x11>;
-			};
-		};
-
-		mmc@48060000 {
-			compatible = "ti,omap3-hsmmc";
-			ti,hwmods = "mmc1";
-			ti,dual-volt;
-			ti,needs-special-reset;
-			ti,needs-special-hs-handling;
-			dmas = <0x9 0x18 0x9 0x19>;
-			dma-names = "tx", "rx";
-			status = "okay";
-			vmmc-supply = <0xa>;
-			ti,vcc-aux-disable-is-sleep;
-			linux,phandle = <0x28>;
-			phandle = <0x28>;
-		};
-
-		mmc@481d8000 {
-			compatible = "ti,omap3-hsmmc";
-			ti,hwmods = "mmc2";
-			ti,needs-special-reset;
-			ti,needs-special-hs-handling;
-			dmas = <0x9 0x2 0x9 0x3>;
-			dma-names = "tx", "rx";
-			status = "okay";
-			vmmc-supply = <0xa>;
-			bus-width = <0x8>;
-			ti,non-removable;
-			reset = <0xb 0x0 0x0>;
-			reset-names = "eMMC_RSTn-CONSUMER";
-			linux,phandle = <0x29>;
-			phandle = <0x29>;
-		};
-
-		mmc@47810000 {
-			compatible = "ti,omap3-hsmmc";
-			ti,hwmods = "mmc3";
-			ti,needs-special-reset;
-			ti,needs-special-hs-handling;
-			status = "disabled";
-			linux,phandle = <0x2a>;
-			phandle = <0x2a>;
-		};
-
-		wdt@44e35000 {
-			compatible = "ti,omap3-wdt";
-			ti,hwmods = "wd_timer2";
-			reg = <0x44e35000 0x1000>;
-			interrupts = <0x5b>;
-			linux,phandle = <0x2b>;
-			phandle = <0x2b>;
-		};
-
-		d_can@481cc000 {
-			compatible = "bosch,d_can";
-			ti,hwmods = "d_can0";
-			reg = <0x481cc000 0x2000>;
-			interrupts = <0x34>;
-			status = "disabled";
-			linux,phandle = <0x2c>;
-			phandle = <0x2c>;
-		};
-
-		d_can@481d0000 {
-			compatible = "bosch,d_can";
-			ti,hwmods = "d_can1";
-			reg = <0x481d0000 0x2000>;
-			interrupts = <0x37>;
-			status = "disabled";
-			linux,phandle = <0x2d>;
-			phandle = <0x2d>;
-		};
-
-		timer@44e31000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x44e31000 0x400>;
-			interrupts = <0x43>;
-			ti,hwmods = "timer1";
-			ti,timer-alwon;
-			linux,phandle = <0x2e>;
-			phandle = <0x2e>;
-		};
-
-		timer@48040000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48040000 0x400>;
-			interrupts = <0x44>;
-			ti,hwmods = "timer2";
-			linux,phandle = <0x2f>;
-			phandle = <0x2f>;
-		};
-
-		timer@48042000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48042000 0x400>;
-			interrupts = <0x45>;
-			ti,hwmods = "timer3";
-			linux,phandle = <0x30>;
-			phandle = <0x30>;
-		};
-
-		timer@48044000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48044000 0x400>;
-			interrupts = <0x5c>;
-			ti,hwmods = "timer4";
-			ti,timer-pwm;
-			linux,phandle = <0x31>;
-			phandle = <0x31>;
-		};
-
-		timer@48046000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48046000 0x400>;
-			interrupts = <0x5d>;
-			ti,hwmods = "timer5";
-			ti,timer-pwm;
-			linux,phandle = <0x32>;
-			phandle = <0x32>;
-		};
-
-		timer@48048000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x48048000 0x400>;
-			interrupts = <0x5e>;
-			ti,hwmods = "timer6";
-			ti,timer-pwm;
-			linux,phandle = <0x33>;
-			phandle = <0x33>;
-		};
-
-		timer@4804a000 {
-			compatible = "ti,omap2-timer";
-			reg = <0x4804a000 0x400>;
-			interrupts = <0x5f>;
-			ti,hwmods = "timer7";
-			ti,timer-pwm;
-			linux,phandle = <0x34>;
-			phandle = <0x34>;
-		};
-
-		pruss@4a300000 {
-			compatible = "ti,pruss-v2";
-			ti,hwmods = "pruss";
-			ti,deassert-hard-reset = "pruss", "pruss";
-			reg = <0x4a300000 0x80000>;
-			ti,pintc-offset = <0x20000>;
-			interrupt-parent = <0x1>;
-			status = "disabled";
-			interrupts = <0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b>;
-			linux,phandle = <0x35>;
-			phandle = <0x35>;
-		};
-
-		rtc@44e3e000 {
-			compatible = "ti,da830-rtc";
-			reg = <0x44e3e000 0x1000>;
-			interrupts = <0x4b 0x4c>;
-			ti,hwmods = "rtc";
-			ti,system-power-controller;
-		};
-
-		spi@48030000 {
-			compatible = "ti,omap4-mcspi";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x48030000 0x400>;
-			interrupt = <0x41>;
-			ti,spi-num-cs = <0x2>;
-			ti,hwmods = "spi0";
-			dmas = <0x9 0x10 0x9 0x11 0x9 0x12 0x9 0x13>;
-			dma-names = "tx0", "rx0", "tx1", "rx1";
-			status = "disabled";
-			linux,phandle = <0x36>;
-			phandle = <0x36>;
-		};
-
-		spi@481a0000 {
-			compatible = "ti,omap4-mcspi";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x481a0000 0x400>;
-			interrupt = <0x7d>;
-			ti,spi-num-cs = <0x2>;
-			ti,hwmods = "spi1";
-			dmas = <0x9 0x2a 0x9 0x2b 0x9 0x2c 0x9 0x2d>;
-			dma-names = "tx0", "rx0", "tx1", "rx1";
-			status = "disabled";
-			linux,phandle = <0x37>;
-			phandle = <0x37>;
-		};
-
-		gpmc@50000000 {
-			compatible = "ti,am3352-gpmc";
-			ti,hwmods = "gpmc";
-			reg = <0x50000000 0x1000000>;
-			interrupts = <0x64>;
-			gpmc,num-cs = <0x7>;
-			gpmc,num-waitpins = <0x2>;
-			#address-cells = <0x2>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			linux,phandle = <0x38>;
-			phandle = <0x38>;
-		};
-
-		nop-phy@0 {
-			compatible = "nop-xceiv-usb";
-		};
-
-		nop-phy@1 {
-			compatible = "nop-xceiv-usb";
-		};
-
-		usb@47400000 {
-			compatible = "ti,musb-am33xx";
-			reg = <0x47400000 0x1000 0x47401000 0x800 0x47401800 0x800>;
-			interrupts = <0x11 0x12 0x13>;
-			multipoint = <0x1>;
-			num-eps = <0x10>;
-			ram-bits = <0xc>;
-			port0-mode = <0x3>;
-			port1-mode = <0x1>;
-			power = <0xfa>;
-			ti,hwmods = "usb_otg_hs";
-			status = "okay";
-			interface_type = <0x1>;
-			linux,phandle = <0x39>;
-			phandle = <0x39>;
-		};
-
-		ethernet@4a100000 {
-			compatible = "ti,cpsw";
-			ti,hwmods = "cpgmac0";
-			cpdma_channels = <0x8>;
-			ale_entries = <0x400>;
-			bd_ram_size = <0x2000>;
-			no_bd_ram = <0x0>;
-			rx_descs = <0x40>;
-			mac_control = <0x20>;
-			slaves = <0x2>;
-			cpts_active_slave = <0x0>;
-			cpts_clock_mult = <0x80000000>;
-			cpts_clock_shift = <0x1d>;
-			reg = <0x4a100000 0x800 0x4a101200 0x100>;
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x28 0x29 0x2a 0x2b>;
-			ranges;
-			disable-napi;
-			linux,phandle = <0x3a>;
-			phandle = <0x3a>;
-
-			mdio@4a101000 {
-				compatible = "ti,davinci_mdio";
-				#address-cells = <0x1>;
-				#size-cells = <0x0>;
-				ti,hwmods = "davinci_mdio";
-				bus_freq = <0xf4240>;
-				reg = <0x4a101000 0x100>;
-				linux,phandle = <0xc>;
-				phandle = <0xc>;
-			};
-
-			slave@4a100200 {
-				mac-address = [00 00 00 00 00 00];
-				phy_id = <0xc 0x0>;
-				linux,phandle = <0x3b>;
-				phandle = <0x3b>;
-			};
-
-			slave@4a100300 {
-				mac-address = [00 00 00 00 00 00];
-				phy_id = <0xc 0x1>;
-				linux,phandle = <0x3c>;
-				phandle = <0x3c>;
-			};
-		};
-
-		tscadc@44e0d000 {
-			compatible = "ti,ti-tscadc";
-			reg = <0x44e0d000 0x1000>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x10>;
-			ti,hwmods = "adc_tsc";
-			status = "disabled";
-			linux,phandle = <0x3d>;
-			phandle = <0x3d>;
-		};
-
-		lcdc@4830e000 {
-			compatible = "ti,am3352-lcdc", "ti,da830-lcdc";
-			reg = <0x4830e000 0x1000>;
-			interrupts = <0x24>;
-			status = "disabled";
-			ti,hwmods = "lcdc";
-			linux,phandle = <0x3e>;
-			phandle = <0x3e>;
-		};
-
-		epwmss@48300000 {
-			compatible = "ti,am33xx-pwmss";
-			reg = <0x48300000 0x10>;
-			ti,hwmods = "epwmss0";
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			ranges = <0x48300100 0x48300100 0x80 0x48300180 0x48300180 0x80 0x48300200 0x48300200 0x80>;
-			linux,phandle = <0x3f>;
-			phandle = <0x3f>;
-
-			ecap@48300100 {
-				compatible = "ti,am33xx-ecap";
-				#pwm-cells = <0x3>;
-				reg = <0x48300100 0x80>;
-				ti,hwmods = "ecap0";
-				status = "disabled";
-				linux,phandle = <0x40>;
-				phandle = <0x40>;
-			};
-
-			ehrpwm@48300200 {
-				compatible = "ti,am33xx-ehrpwm";
-				#pwm-cells = <0x3>;
-				reg = <0x48300200 0x80>;
-				ti,hwmods = "ehrpwm0";
-				status = "disabled";
-				linux,phandle = <0x41>;
-				phandle = <0x41>;
-			};
-		};
-
-		epwmss@48302000 {
-			compatible = "ti,am33xx-pwmss";
-			reg = <0x48302000 0x10>;
-			ti,hwmods = "epwmss1";
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			ranges = <0x48302100 0x48302100 0x80 0x48302180 0x48302180 0x80 0x48302200 0x48302200 0x80>;
-			linux,phandle = <0x42>;
-			phandle = <0x42>;
-
-			ecap@48302100 {
-				compatible = "ti,am33xx-ecap";
-				#pwm-cells = <0x3>;
-				reg = <0x48302100 0x80>;
-				ti,hwmods = "ecap1";
-				status = "disabled";
-				linux,phandle = <0x43>;
-				phandle = <0x43>;
-			};
-
-			ehrpwm@48302200 {
-				compatible = "ti,am33xx-ehrpwm";
-				#pwm-cells = <0x3>;
-				reg = <0x48302200 0x80>;
-				ti,hwmods = "ehrpwm1";
-				status = "disabled";
-				linux,phandle = <0x44>;
-				phandle = <0x44>;
-			};
-		};
-
-		epwmss@48304000 {
-			compatible = "ti,am33xx-pwmss";
-			reg = <0x48304000 0x10>;
-			ti,hwmods = "epwmss2";
-			#address-cells = <0x1>;
-			#size-cells = <0x1>;
-			status = "disabled";
-			ranges = <0x48304100 0x48304100 0x80 0x48304180 0x48304180 0x80 0x48304200 0x48304200 0x80>;
-			linux,phandle = <0x45>;
-			phandle = <0x45>;
-
-			ecap@48304100 {
-				compatible = "ti,am33xx-ecap";
-				#pwm-cells = <0x3>;
-				reg = <0x48304100 0x80>;
-				ti,hwmods = "ecap2";
-				status = "disabled";
-				linux,phandle = <0x46>;
-				phandle = <0x46>;
-			};
-
-			ehrpwm@48304200 {
-				compatible = "ti,am33xx-ehrpwm";
-				#pwm-cells = <0x3>;
-				reg = <0x48304200 0x80>;
-				ti,hwmods = "ehrpwm2";
-				status = "disabled";
-				linux,phandle = <0x47>;
-				phandle = <0x47>;
-			};
-		};
-
-		sham@53100000 {
-			compatible = "ti,omap4-sham";
-			ti,hwmods = "sham";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x53100000 0x200>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x6d>;
-			dmas = <0x9 0x24>;
-			dma-names = "rx";
-			status = "okay";
-			linux,phandle = <0x48>;
-			phandle = <0x48>;
-		};
-
-		aes@53500000 {
-			compatible = "ti,omap4-aes";
-			ti,hwmods = "aes";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			reg = <0x53500000 0xa0>;
-			interrupt-parent = <0x1>;
-			interrupts = <0x66>;
-			dmas = <0x9 0x6 0x9 0x5>;
-			dma-names = "tx", "rx";
-			status = "okay";
-			linux,phandle = <0x49>;
-			phandle = <0x49>;
-		};
-
-		mcasp@48038000 {
-			compatible = "ti,omap2-mcasp-audio";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "mcasp0";
-			reg = <0x48038000 0x2000>;
-			interrupts = <0x50 0x51>;
-			status = "disabled";
-			asp-chan-q = <0x2>;
-			tx-dma-offset = <0x46000000>;
-			rx-dma-offset = <0x46000000>;
-			dmas = <0x9 0x8 0x9 0x9>;
-			dma-names = "tx", "rx";
-			linux,phandle = <0x4a>;
-			phandle = <0x4a>;
-		};
-
-		mcasp@4803C000 {
-			compatible = "ti,omap2-mcasp-audio";
-			#address-cells = <0x1>;
-			#size-cells = <0x0>;
-			ti,hwmods = "mcasp1";
-			reg = <0x4803c000 0x2000>;
-			interrupts = <0x52 0x53>;
-			status = "disabled";
-			asp-chan-q = <0x2>;
-			tx-dma-offset = <0x46400000>;
-			rx-dma-offset = <0x46400000>;
-			dmas = <0x9 0xa 0x9 0xb>;
-			dma-names = "tx", "rx";
-			linux,phandle = <0x4b>;
-			phandle = <0x4b>;
-		};
-
-		gpio-leds {
-			compatible = "gpio-leds";
-			pinctrl-names = "default";
-			pinctrl-0 = <0x3>;
-
-			led0 {
-				label = "beaglebone:green:usr0";
-				gpios = <0x5 0x15 0x0>;
-				linux,default-trigger = "heartbeat";
-				default-state = "off";
-			};
-
-			led1 {
-				label = "beaglebone:green:usr1";
-				gpios = <0x5 0x16 0x0>;
-				linux,default-trigger = "mmc0";
-				default-state = "off";
-			};
-
-			led2 {
-				label = "beaglebone:green:usr2";
-				gpios = <0x5 0x17 0x0>;
-				linux,default-trigger = "cpu0";
-				default-state = "off";
-			};
-
-			led3 {
-				label = "beaglebone:green:usr3";
-				gpios = <0x5 0x18 0x0>;
-				default-state = "off";
-				linux,default-trigger = "mmc1";
-			};
-		};
-	};
-
-	bone_capemgr {
-		compatible = "ti,bone-capemgr";
-		status = "okay";
-		eeprom = <0xd>;
-
-		baseboardmaps {
-
-			board@0 {
-				board-name = "A335BONE";
-				compatible-name = "ti,beaglebone";
-				linux,phandle = <0x4c>;
-				phandle = <0x4c>;
-			};
-
-			board@1 {
-				board-name = "A335BNLT";
-				compatible-name = "ti,beaglebone-green";
-				linux,phandle = <0x4d>;
-				phandle = <0x4d>;
-			};
-		};
-
-		slots {
-
-			slot@0 {
-				eeprom = <0xe>;
-			};
-
-			slot@1 {
-				eeprom = <0xf>;
-			};
-
-			slot@2 {
-				eeprom = <0x10>;
-			};
-
-			slot@3 {
-				eeprom = <0x11>;
-			};
-
-			slot@5 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-Geiger";
-				version = "00A0";
-				manufacturer = "Geiger Inc.";
-				part-number = "BB-BONE-GEIGER";
-			};
-
-			slot@7 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-Nixie";
-				version = "00A0";
-				manufacturer = "Ranostay Industries";
-				part-number = "BB-BONE-NIXIE";
-			};
-
-			slot@8 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-TFT";
-				version = "00A0";
-				manufacturer = "Adafruit";
-				part-number = "BB-BONE-TFT-01";
-			};
-
-			slot@9 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-RTC";
-				version = "00A0";
-				manufacturer = "Adafruit";
-				part-number = "BB-BONE-RTC-01";
-			};
-
-			slot@10 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-Hexy";
-				version = "00A0";
-				manufacturer = "Koen Kooi";
-				part-number = "BB-BONE-HEXY-01";
-			};
-
-			slot@11 {
-				ti,cape-override;
-				compatible = "kernel-command-line", "runtime";
-				board-name = "Bone-MRF24J40";
-				version = "00A0";
-				manufacturer = "Signal 11 Software";
-				part-number = "BB-BONE-MRF24J40";
-			};
-
-			slot@100 {
-				ti,cape-override;
-				priority = <0x1>;
-				compatible = "ti,beaglebone-green";
-				board-name = "Bone-LT-eMMC-2G";
-				version = "00A0";
-				manufacturer = "Texas Instruments";
-				part-number = "BB-BONE-EMMC-2G";
-			};
-
-			slot@101 {
-				ti,cape-override;
-				priority = <0x1>;
-				compatible = "ti,beaglebone-green";
-				board-name = "Bone-Black-HDMI";
-				version = "00A0";
-				manufacturer = "Texas Instruments";
-				part-number = "BB-BONELT-HDMI";
-			};
-		};
-
-		capemaps {
-
-			cape@0 {
-				part-number = "BB-BONE-DVID-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-dvi-00A0.dtbo";
-				};
-
-				version@00A1 {
-					version = "00A1", "01";
-					dtbo = "cape-bone-dvi-00A1.dtbo";
-				};
-
-				version@00A2 {
-					version = "00A2", "A2";
-					dtbo = "cape-bone-dvi-00A2.dtbo";
-				};
-
-				version@00A3 {
-					version = "00A3";
-					dtbo = "cape-bone-dvi-00A2.dtbo";
-				};
-			};
-
-			cape@1 {
-				part-number = "BB-BONE-EMMC-2G";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-2g-emmc1.dtbo";
-				};
-			};
-
-			cape@2 {
-				part-number = "BB-BONE-GEIGER";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-geiger-00A0.dtbo";
-				};
-			};
-
-			cape@3 {
-				part-number = "BB-BONE-LCD3-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-lcd3-00A0.dtbo";
-				};
-
-				version@00A2 {
-					version = "00A2";
-					dtbo = "cape-bone-lcd3-00A2.dtbo";
-				};
-			};
-
-			cape@4 {
-				part-number = "BB-BONE-WTHR-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-weather-00A0.dtbo";
-				};
-			};
-
-			cape@5 {
-				part-number = "BB-BONELT-HDMI";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-boneblack-hdmi-00A0.dtbo";
-				};
-			};
-
-			cape@6 {
-				part-number = "BB-BONE-NIXIE";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-nixie-00A0.dtbo";
-				};
-			};
-
-			cape@7 {
-				part-number = "BB-BONE-TFT-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-adafruit-lcd-00A0.dtbo";
-				};
-			};
-
-			cape@8 {
-				part-number = "BB-BONE-RTC-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-adafruit-rtc-00A0.dtbo";
-				};
-			};
-
-			cape@9 {
-				part-number = "BB-BONE-HEXY-01";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-hexy-00A0.dtbo";
-				};
-			};
-
-			cape@10 {
-				part-number = "BB-BONE-MRF24J40";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-mrf24j40-00A0.dtbo";
-				};
-			};
-
-			cape@11 {
-				part-number = "BB-BONE-EXPTEST";
-
-				version@00A0 {
-					version = "00A0";
-					dtbo = "cape-bone-exptest-00A0.dtbo";
-				};
-			};
-		};
-	};
-
-	fixedregulator@0 {
-		compatible = "regulator-fixed";
-		regulator-name = "vmmcsd_fixed";
-		regulator-min-microvolt = <0x325aa0>;
-		regulator-max-microvolt = <0x325aa0>;
-		linux,phandle = <0xa>;
-		phandle = <0xa>;
-	};
-
-	__symbols__ {
-		cpu = "/cpus/cpu@0";
-		am33xx_pinmux = "/pinmux@44e10800";
-		userled_pins = "/pinmux@44e10800/pinmux_userled_pins";
-		i2c0_pins = "/pinmux@44e10800/pinmux_i2c0_pins";
-		i2c1_pins = "/pinmux@44e10800/pinmux_i2c1_pins";
-		i2c2_pins = "/pinmux@44e10800/pinmux_i2c2_pins";
-		rstctl_pins = "/pinmux@44e10800/pinmux_rstctl_pins";
-		ocp = "/ocp";
-		intc = "/ocp/interrupt-controller@48200000";
-		edma = "/ocp/edma@49000000";
-		gpio1 = "/ocp/gpio@44e07000";
-		gpio2 = "/ocp/gpio@4804c000";
-		gpio3 = "/ocp/gpio@481ac000";
-		gpio4 = "/ocp/gpio@481ae000";
-		rstctl = "/ocp/rstctl@0";
-		uart1 = "/ocp/serial@44e09000";
-		uart2 = "/ocp/serial@48022000";
-		uart3 = "/ocp/serial@48024000";
-		uart4 = "/ocp/serial@481a6000";
-		uart5 = "/ocp/serial@481a8000";
-		uart6 = "/ocp/serial@481aa000";
-		i2c0 = "/ocp/i2c@44e0b000";
-		tps = "/ocp/i2c@44e0b000/tps@24";
-		dcdc1_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@0";
-		dcdc2_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@1";
-		dcdc3_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@2";
-		ldo1_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@3";
-		ldo2_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@4";
-		ldo3_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@5";
-		ldo4_reg = "/ocp/i2c@44e0b000/tps@24/regulators/regulator@6";
-		baseboard_eeprom = "/ocp/i2c@44e0b000/baseboard_eeprom@50";
-		i2c1 = "/ocp/i2c@4802a000";
-		i2c2 = "/ocp/i2c@4819c000";
-		cape_eeprom0 = "/ocp/i2c@4819c000/cape_eeprom0@54";
-		cape_eeprom1 = "/ocp/i2c@4819c000/cape_eeprom1@55";
-		cape_eeprom2 = "/ocp/i2c@4819c000/cape_eeprom2@56";
-		cape_eeprom3 = "/ocp/i2c@4819c000/cape_eeprom3@57";
-		mmc1 = "/ocp/mmc@48060000";
-		mmc2 = "/ocp/mmc@481d8000";
-		mmc3 = "/ocp/mmc@47810000";
-		wdt2 = "/ocp/wdt@44e35000";
-		dcan0 = "/ocp/d_can@481cc000";
-		dcan1 = "/ocp/d_can@481d0000";
-		timer1 = "/ocp/timer@44e31000";
-		timer2 = "/ocp/timer@48040000";
-		timer3 = "/ocp/timer@48042000";
-		timer4 = "/ocp/timer@48044000";
-		timer5 = "/ocp/timer@48046000";
-		timer6 = "/ocp/timer@48048000";
-		timer7 = "/ocp/timer@4804a000";
-		pruss = "/ocp/pruss@4a300000";
-		spi0 = "/ocp/spi@48030000";
-		spi1 = "/ocp/spi@481a0000";
-		gpmc = "/ocp/gpmc@50000000";
-		usb_otg_hs = "/ocp/usb@47400000";
-		mac = "/ocp/ethernet@4a100000";
-		davinci_mdio = "/ocp/ethernet@4a100000/mdio@4a101000";
-		cpsw_emac0 = "/ocp/ethernet@4a100000/slave@4a100200";
-		cpsw_emac1 = "/ocp/ethernet@4a100000/slave@4a100300";
-		tscadc = "/ocp/tscadc@44e0d000";
-		lcdc = "/ocp/lcdc@4830e000";
-		epwmss0 = "/ocp/epwmss@48300000";
-		ecap0 = "/ocp/epwmss@48300000/ecap@48300100";
-		ehrpwm0 = "/ocp/epwmss@48300000/ehrpwm@48300200";
-		epwmss1 = "/ocp/epwmss@48302000";
-		ecap1 = "/ocp/epwmss@48302000/ecap@48302100";
-		ehrpwm1 = "/ocp/epwmss@48302000/ehrpwm@48302200";
-		epwmss2 = "/ocp/epwmss@48304000";
-		ecap2 = "/ocp/epwmss@48304000/ecap@48304100";
-		ehrpwm2 = "/ocp/epwmss@48304000/ehrpwm@48304200";
-		sham = "/ocp/sham@53100000";
-		aes = "/ocp/aes@53500000";
-		mcasp0 = "/ocp/mcasp@48038000";
-		mcasp1 = "/ocp/mcasp@4803C000";
-		baseboard_beaglebone = "/bone_capemgr/baseboardmaps/board@0";
-		baseboard_beaglebone_black = "/bone_capemgr/baseboardmaps/board@1";
-		vmmcsd_fixed = "/fixedregulator@0";
-	};
-};
diff --git a/resources/wheezy/include/prussdrv.h b/resources/wheezy/include/prussdrv.h
deleted file mode 100644
index c99f4e1ec..000000000
--- a/resources/wheezy/include/prussdrv.h
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * prussdrv.h
- *
- * Describes PRUSS userspace driver for Industrial Communications
- *
- * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
- *
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *    Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the
- *    distribution.
- *
- *    Neither the name of Texas Instruments Incorporated nor the names of
- *    its contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
-*/
-
-/*
- * ============================================================================
- * Copyright (c) Texas Instruments Inc 2010-11
- *
- * Use of this software is controlled by the terms and conditions found in the
- * license agreement under which this software has been supplied or provided.
- * ============================================================================
-*/
-
-#ifndef _PRUSSDRV_H
-#define _PRUSSDRV_H
-
-#include <sys/types.h>
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-#define NUM_PRU_HOSTIRQS        8
-#define NUM_PRU_HOSTS          10
-#define NUM_PRU_CHANNELS       10
-#define NUM_PRU_SYS_EVTS       64
-
-#define PRUSS0_PRU0_DATARAM     0
-#define PRUSS0_PRU1_DATARAM     1
-#define PRUSS0_PRU0_IRAM        2
-#define PRUSS0_PRU1_IRAM        3
-
-#define PRUSS_V1                1 // AM18XX
-#define PRUSS_V2                2 // AM33XX
-
-//Available in AM33xx series - begin
-#define PRUSS0_SHARED_DATARAM   4
-#define	PRUSS0_CFG              5
-#define	PRUSS0_UART             6
-#define	PRUSS0_IEP              7
-#define	PRUSS0_ECAP             8
-#define	PRUSS0_MII_RT           9
-#define	PRUSS0_MDIO            10
-//Available in AM33xx series - end
-
-#define PRU_EVTOUT_0            0
-#define PRU_EVTOUT_1            1
-#define PRU_EVTOUT_2            2
-#define PRU_EVTOUT_3            3
-#define PRU_EVTOUT_4            4
-#define PRU_EVTOUT_5            5
-#define PRU_EVTOUT_6            6
-#define PRU_EVTOUT_7            7
-
-    typedef struct __sysevt_to_channel_map {
-        short sysevt;
-        short channel;
-    } tsysevt_to_channel_map;
-    typedef struct __channel_to_host_map {
-        short channel;
-        short host;
-    } tchannel_to_host_map;
-    typedef struct __pruss_intc_initdata {
-        //Enabled SYSEVTs - Range:0..63
-        //{-1} indicates end of list
-        char sysevts_enabled[NUM_PRU_SYS_EVTS];
-        //SysEvt to Channel map. SYSEVTs - Range:0..63 Channels -Range: 0..9
-        //{-1, -1} indicates end of list
-        tsysevt_to_channel_map sysevt_to_channel_map[NUM_PRU_SYS_EVTS];
-        //Channel to Host map.Channels -Range: 0..9  HOSTs - Range:0..9
-        //{-1, -1} indicates end of list
-        tchannel_to_host_map channel_to_host_map[NUM_PRU_CHANNELS];
-        //10-bit mask - Enable Host0-Host9 {Host0/1:PRU0/1, Host2..9 : PRUEVT_OUT0..7}
-        unsigned int host_enable_bitmask;
-    } tpruss_intc_initdata;
-
-    int prussdrv_init(void);
-
-    int prussdrv_open(unsigned int host_interrupt);
-
-    /** Return version of PRU.  This must be called after prussdrv_open. */
-    int prussdrv_version();
-
-    /** Return string description of PRU version. */
-    const char* prussdrv_strversion(int version);
-
-    int prussdrv_pru_reset(unsigned int prunum);
-
-    int prussdrv_pru_disable(unsigned int prunum);
-
-    int prussdrv_pru_enable(unsigned int prunum);
-    int prussdrv_pru_enable_at(unsigned int prunum, size_t addr);
-
-    int prussdrv_pru_write_memory(unsigned int pru_ram_id,
-                                  unsigned int wordoffset,
-                                  const unsigned int *memarea,
-                                  unsigned int bytelength);
-
-    int prussdrv_pruintc_init(const tpruss_intc_initdata *prussintc_init_data);
-
-    /** Find and return the channel a specified event is mapped to.
-     * Note that this only searches for the first channel mapped and will not
-     * detect error cases where an event is mapped erroneously to multiple
-     * channels.
-     * @return channel-number to which a system event is mapped.
-     * @return -1 for no mapping found
-     */
-    short prussdrv_get_event_to_channel_map( unsigned int eventnum );
-
-    /** Find and return the host interrupt line a specified channel is mapped
-     * to.  Note that this only searches for the first host interrupt line
-     * mapped and will not detect error cases where a channel is mapped
-     * erroneously to multiple host interrupt lines.
-     * @return host-interrupt-line to which a channel is mapped.
-     * @return -1 for no mapping found
-     */
-    short prussdrv_get_channel_to_host_map( unsigned int channel );
-
-    /** Find and return the host interrupt line a specified event is mapped
-     * to.  This first finds the intermediate channel and then the host.
-     * @return host-interrupt-line to which a system event is mapped.
-     * @return -1 for no mapping found
-     */
-    short prussdrv_get_event_to_host_map( unsigned int eventnum );
-
-    int prussdrv_map_l3mem(void **address);
-
-    int prussdrv_map_extmem(void **address);
-
-    unsigned int prussdrv_extmem_size(void);
-
-    int prussdrv_map_prumem(unsigned int pru_ram_id, void **address);
-
-    int prussdrv_map_peripheral_io(unsigned int per_id, void **address);
-
-    unsigned int prussdrv_get_phys_addr(const void *address);
-
-    void *prussdrv_get_virt_addr(unsigned int phyaddr);
-
-    /** Wait for the specified host interrupt.
-     * @return the number of times the event has happened. */
-    unsigned int prussdrv_pru_wait_event(unsigned int host_interrupt);
-
-    int prussdrv_pru_event_fd(unsigned int host_interrupt);
-
-    int prussdrv_pru_send_event(unsigned int eventnum);
-
-    /** Clear the specified event and re-enable the host interrupt. */
-    int prussdrv_pru_clear_event(unsigned int host_interrupt,
-                                 unsigned int sysevent);
-
-    int prussdrv_pru_send_wait_clear_event(unsigned int send_eventnum,
-                                           unsigned int host_interrupt,
-                                           unsigned int ack_eventnum);
-
-    int prussdrv_exit(void);
-
-    int prussdrv_exec_program(int prunum, const char *filename);
-    int prussdrv_exec_program_at(int prunum, const char *filename, size_t addr);
-
-    int prussdrv_exec_code(int prunum, const unsigned int *code, int codelen);
-    int prussdrv_exec_code_at(int prunum, const unsigned int *code, int codelen, size_t addr);
-    int prussdrv_load_data(int prunum, const unsigned int *code, int codelen);
-    int prussdrv_load_datafile(int prunum, const char *filename);
-
-#if defined (__cplusplus)
-}
-#endif
-#endif
diff --git a/resources/wheezy/sh/Bela_capeButtonHold.sh b/resources/wheezy/sh/Bela_capeButtonHold.sh
deleted file mode 100755
index a21eea430..000000000
--- a/resources/wheezy/sh/Bela_capeButtonHold.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-#this file is executed when the button on the Bela cape is held down for more than 2 seconds.
-
-echo Bela cape button held, shutting down | wall
-halt
diff --git a/resources/wheezy/sh/initd-bela b/resources/wheezy/sh/initd-bela
deleted file mode 100755
index e06d53831..000000000
--- a/resources/wheezy/sh/initd-bela
+++ /dev/null
@@ -1,28 +0,0 @@
-#! /bin/sh
-# /etc/init.d/bela
-#
-
-# Some things that run always
-# ...nothing to do here
-
-# Carry out specific functions when asked to by the system
-case "$1" in
-  start)
-    echo "Adding Bela Overlay..."
-    echo BELA > /sys/devices/platform/bone_capemgr/slots
-    echo "Enabling interface and functional clock of McASP..."
-    /root/Bela/resources/bin/devmem2 0x44E00034 w 0x30002 >> /dev/null
-    cd /root
-    sh Bela_startup.sh
-    sh Bela_node.sh
-    ;;
-  stop)
-    cd /root/Bela && make stop
-    ;;
-  *)
-    echo "Usage: /etc/init.d/bela {start|stop}"
-    exit 1
-    ;;
-esac
-
-exit 0
diff --git a/resources/wheezy/sh/initd-bela_shutdown_switch b/resources/wheezy/sh/initd-bela_shutdown_switch
deleted file mode 100755
index 39d83f85d..000000000
--- a/resources/wheezy/sh/initd-bela_shutdown_switch
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/bin/sh
-# Script to start the GPIO shutdown button checker
-# Adapted from Stephen C Phillips:
-# http://blog.scphillips.com/posts/2013/07/getting-a-python-script-to-run-in-the-background-as-a-service-on-boot/
-
-### BEGIN INIT INFO
-# Provides:          bela_shutdown_swtich
-# Required-Start:    
-# Required-Stop:    
-# Default-Start:     2 3 4 5
-# Default-Stop:      0 1 6
-# Short-Description: Monitor the shutdown button on the Bela cape
-# Description:        Monitor the shutdown button on the Bela cape
-### END INIT INFO
-
-# Change the next 3 lines to suit where you install your script and what you want to call it
-DIR=/root
-DAEMON=$DIR/shutdown_switch.sh
-DAEMON_NAME=shutdown_switch
-
-# Add any command line options for your daemon here
-DAEMON_OPTS=""
-
-# This next line determines what user the script runs as.
-# Root generally not recommended but necessary if you are using the Raspberry Pi GPIO from Python.
-DAEMON_USER=root
-
-# The process ID of the script when it runs is stored here:
-PIDFILE=/var/run/$DAEMON_NAME.pid
-
-. /lib/lsb/init-functions
-
-do_start () {
-    log_daemon_msg "Starting system $DAEMON_NAME daemon"
-    start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --user $DAEMON_USER --chuid $DAEMON_USER --startas $DAEMON -- $DAEMON_OPTS
-    log_end_msg $?
-}
-do_stop () {
-    log_daemon_msg "Stopping system $DAEMON_NAME daemon"
-    start-stop-daemon --stop --pidfile $PIDFILE --retry 10
-    log_end_msg $?
-}
-
-case "$1" in
-
-    start|stop)
-        do_${1}
-        ;;
-
-    restart|reload|force-reload)
-        do_stop
-        do_start
-        ;;
-
-    status)
-        status_of_proc "$DAEMON_NAME" "$DAEMON" && exit 0 || exit $?
-        ;;
-
-    *)
-        echo "Usage: /etc/init.d/$DAEMON_NAME {start|stop|restart|status}"
-        exit 1
-        ;;
-
-esac
-exit 0
\ No newline at end of file
diff --git a/resources/wheezy/sh/shutdown_switch.sh b/resources/wheezy/sh/shutdown_switch.sh
deleted file mode 100755
index 32eedb88e..000000000
--- a/resources/wheezy/sh/shutdown_switch.sh
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/bin/bash
-#
-# shutdown_switch.sh: script for gracefully halting the BeagleBone Black
-# when an onboard button is pressed. 
-#
-# (c) 2016 Andrew McPherson, C4DM, QMUL
-# Developed for Bela: http://bela.io
-
-
-# Prepare P9.27 as input (will be configured with pullup)
-# via BB-BONE-PRU-BELA overlay
-
-MONITOR_COMMAND=/usr/local/bin/bela-cape-btn
-BUTTON_PIN=115
-CLICK_COMMAND=/root/Bela_capeButtonClick.sh
-HOLD_COMMAND=/root/Bela_capeButtonHold.sh
-INITIAL_DELAY=20
-
-ls $MONITOR_COMMAND &> /dev/null
-if [ $? -eq 0 ];
-then
-# if the $MONITOR_COMMAND exists, run it (cheap)
-	echo Using $MONITOR_COMMAND to poll
-	$MONITOR_COMMAND --pin $BUTTON_PIN --hold $HOLD_COMMAND --delay $INITIAL_DELAY --monitor-click 0
-else
-#else, just poll the filesystem (expensive!)
-	echo Polling the filesystem.
-	echo $BUTTON_PIN > /sys/class/gpio/export
-	echo in > /sys/class/gpio/gpio"$BUTTON_PIN"/direction
-
-	if [ ! -r /sys/class/gpio/gpio"$BUTTON_PIN"/value ]
-	then
-		echo "$(basename $0): Unable to read GPIO pin $BUTTON_PIN for shutdown button."
-		exit
-	fi
-
-	# First, wait for pin to go high. If it starts at 0, that's more
-	# likely that the GPIO is not set correctly, so do not treat this
-	# as a button press
-
-	while [ $(cat /sys/class/gpio/gpio"$BUTTON_PIN"/value) -ne 1 ]; do
-		# Keep checking pin is readable in case it gets unexported
-		if [ ! -r /sys/class/gpio/gpio"$BUTTON_PIN"/value ]
-		then
-			echo "$(basename $0): Unable to read GPIO pin $BUTTON_PIN for shutdown button."
-			exit
-		fi
-		sleep 0.5
-	done
-
-	# Now for button press. Make sure the button is held at least
-	# 1 second before shutting down
-
-	PRESS_COUNT=0
-
-	while true; do
-	  # Keep checking pin is readable in case it gets unexported
-	  if [ ! -r /sys/class/gpio/gpio"$BUTTON_PIN"/value ]
-	  then
-		echo "$(basename $0): Unable to read GPIO pin $BUTTON_PIN for shutdown button."
-		exit
-	  fi
-		
-	  # Button pressed? (pressed = low)
-	  if [ $(cat /sys/class/gpio/gpio"$BUTTON_PIN"/value) -eq 0 ]
-	  then
-		PRESS_COUNT=$((PRESS_COUNT+1))
-		if [ "$PRESS_COUNT" -ge 4 ]
-		then
-			echo "$(basename $0): Bela button held. Halting system..."
-			$HOLD_COMMAND
-			exit 1
-		fi
-	  else
-		PRESS_COUNT=0
-	  fi
-	  sleep 0.5
-	done
-fi

From ee6d09d075cd5bb75c934982acae8226af48d7de Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sat, 18 Jun 2022 18:49:33 +0000
Subject: [PATCH 107/188] Xenomai: removed support for Xenomai 2 and
 native/alchemy skin. Preprocessed files have no diff

Verified with
for a in `cd build-new/core/ && find . -name "*.ii"`; do echo ==============================$a; diff <(grep -v "^#\|^\s*$" build-new/core/$a) <(grep -v "^#\|^\s*$" build-old/core/$a); done
---
 core/AuxTaskNonRT.cpp   | 34 ----------------
 core/AuxTaskRT.cpp      | 69 --------------------------------
 core/AuxiliaryTasks.cpp | 49 -----------------------
 core/PRU.cpp            |  8 ----
 core/RTAudio.cpp        | 89 -----------------------------------------
 include/AuxTaskNonRT.h  | 15 -------
 include/AuxTaskRT.h     | 14 -------
 include/xenomai_wraps.h | 35 ----------------
 libraries/Midi/Midi.cpp | 24 -----------
 9 files changed, 337 deletions(-)

diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index 837573c75..06b1c0ff4 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -42,39 +42,20 @@ void AuxTaskNonRT::__create(){
 	// create the xenomai task
 	int priority = 0;
 	int stackSize = 65536 * 4;
-#ifdef XENOMAI_SKIN_native //posix skin does evertything in one go below
-	if (int ret = rt_task_create(&task, name.c_str(), stackSize, priority, T_JOINABLE))
-	{
-		fprintf(stderr, "Unable to create AuxTaskNonRT %s: %i\n", name.c_str(), ret);
-		return;
-	}
-#endif
 
 	// create an rt_pipe
 	std::string p_name = "p_" + name;
-#ifdef XENOMAI_SKIN_native
-	rt_pipe_delete(&pipe);
-	int ret = rt_pipe_create(&pipe, p_name.c_str(), P_MINOR_AUTO, 0);
-	if(ret < 0)
-#endif
-#ifdef XENOMAI_SKIN_posix
 	int pipeSize = 65536 * 10;
 	int ret = createXenomaiPipe(p_name.c_str(), pipeSize);
 	pipeSocket = ret;
 	if(ret <= 0)
-#endif
 	{
 		fprintf(stderr, "Unable to create AuxTaskNonRT %s pipe %s: (%i) %s\n", name.c_str(), p_name.c_str(), ret, strerror(ret));
 		return;
 	}
 	
 	// start the xenomai task
-#ifdef XENOMAI_SKIN_native
-	if (int ret = rt_task_start(&task, AuxTaskNonRT::thread_func, this))
-#endif
-#ifdef XENOMAI_SKIN_posix
 	if(int ret = create_and_start_thread(&thread, name.c_str(), priority, stackSize, (pthread_callback_t*)AuxTaskNonRT::thread_func, this))
-#endif
 	{
 		fprintf(stderr, "Unable to start AuxTaskNonRT %s: %i, %s\n", name.c_str(), ret, strerror(ret));
 		return;
@@ -82,12 +63,7 @@ void AuxTaskNonRT::__create(){
 }
 
 int AuxTaskNonRT::schedule(const void* ptr, size_t size){
-#ifdef XENOMAI_SKIN_native
-	int ret = rt_pipe_write(&pipe, ptr, size, P_NORMAL);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	int ret = __wrap_sendto(pipeSocket, ptr, size, 0, NULL, 0);
-#endif
 	if(ret < 0)
 	{
 		rt_fprintf(stderr, "Error while sending to pipe from %s: (%d) %s (size: %d)\n", name.c_str(), errno, strerror(errno), size);
@@ -105,11 +81,6 @@ int AuxTaskNonRT::schedule(){
 
 void AuxTaskNonRT::cleanup(){
 	lShouldStop = true;
-#ifdef XENOMAI_SKIN_native
-	rt_task_delete(&task);
-	rt_pipe_delete(&pipe);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	// unblock and join thread
 	schedule();
 	int ret = __wrap_pthread_join(thread, NULL);
@@ -126,15 +97,10 @@ void AuxTaskNonRT::cleanup(){
 	{
 		fprintf(stderr, "Error closing pipe_fd: %d %s\n", errno, strerror(errno));
 	}
-#endif
 }
 
 int AuxTaskNonRT::openPipe(){
-#if XENOMAI_SKIN_posix || XENOMAI_MAJOR == 3
 	std::string outPipeNameTemplateString = "/proc/xenomai/registry/rtipc/xddp/p_";
-#else
-	std::string outPipeNameTemplateString = "/proc/xenomai/registry/native/pipes/p_";
-#endif
 	std::string rtp_name = outPipeNameTemplateString + name;
 	pipe_fd = open(rtp_name.c_str(), O_RDWR);
 	if (pipe_fd < 0){
diff --git a/core/AuxTaskRT.cpp b/core/AuxTaskRT.cpp
index 9a21c48ab..8f25b9e8b 100644
--- a/core/AuxTaskRT.cpp
+++ b/core/AuxTaskRT.cpp
@@ -37,23 +37,9 @@ void AuxTaskRT::__create(){
 	
 	// create the xenomai task
 	int stackSize = 0;
-#ifdef XENOMAI_SKIN_native //posix skin does evertything in one go below
-	if (int ret = rt_task_create(&task, name.c_str(), stackSize, priority, T_JOINABLE)){
-		fprintf(stderr, "Unable to create AuxTaskRT %s: %i\n", name.c_str(), ret);
-		return;
-	}
-#endif
 	
 	// create a queue, with prefixed name
 	queueName = std::string("/q_") + name;
-#ifdef XENOMAI_SKIN_native
-	if (int ret = rt_queue_create(&queue, queueName.c_str(), AUX_RT_POOL_SIZE, Q_UNLIMITED, Q_PRIO))
-	{
-		fprintf(stderr, "Unable to create AuxTaskRT %s queue: %i\n", name.c_str(), ret);
-		return;
-	}
-#endif 
-#ifdef XENOMAI_SKIN_posix
 	struct mq_attr attr;
 	attr.mq_maxmsg = 100; 
 	attr.mq_msgsize = 100000;
@@ -63,15 +49,9 @@ void AuxTaskRT::__create(){
 		fprintf(stderr, "Unable to open message queue %s: (%d) %s\n", queueName.c_str(), errno, strerror(errno));
 		return;
 	}
-#endif
 	
 	// start the xenomai task
-#ifdef XENOMAI_SKIN_native
-	if (int ret = rt_task_start(&task, AuxTaskRT::thread_func, this))
-#endif
-#ifdef XENOMAI_SKIN_posix
 	if(int ret = create_and_start_thread(&thread, name.c_str(), priority, stackSize, (pthread_callback_t*)AuxTaskRT::thread_func, this))
-#endif
 	{
 		fprintf(stderr, "Unable to start AuxTaskRT %s: %i\n", name.c_str(), ret);
 		return;
@@ -80,18 +60,11 @@ void AuxTaskRT::__create(){
 }
 
 void AuxTaskRT::schedule(void* buf, size_t size){
-#ifdef XENOMAI_SKIN_native
-	void* q_buf = rt_queue_alloc(&queue, size);
-	memcpy(q_buf, buf, size);
-	rt_queue_send(&queue, q_buf, size, Q_NORMAL);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	if(__wrap_mq_send(queueDesc, (char*)buf, size, 0))
 	{
 		if(!shouldStop()) fprintf(stderr, "Unable to send message to queue for task %s: (%d) %s\n", name.c_str(), errno, strerror(errno));
 		return;
 	}
-#endif
 }
 void AuxTaskRT::schedule(const char* str){
 	schedule((void*)str, strlen(str));
@@ -103,11 +76,6 @@ void AuxTaskRT::schedule(){
 
 void AuxTaskRT::cleanup(){
 	lShouldStop = true;
-#ifdef XENOMAI_SKIN_native
-	rt_task_delete(&task);
-	rt_queue_delete(&queue);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	// unblock and join thread
 	char c = 0;
 	struct timespec absoluteTimeout = {0, 0};
@@ -128,20 +96,9 @@ void AuxTaskRT::cleanup(){
 	{
 		fprintf(stderr, "Error unlinking queue: %d %s\n", errno, strerror(errno));
 	}
-#endif
 }
 
 void AuxTaskRT::empty_loop(){
-#ifdef XENOMAI_SKIN_native
-	while(!shouldStop()){
-		void* buf;
-		rt_queue_receive(&queue, &buf, TM_INFINITE);
-		if (!shouldStop())
-			empty_callback();
-		rt_queue_free(&queue, buf);
-	}
-#endif
-#ifdef XENOMAI_SKIN_posix
 	std::vector<char> buf(AUX_RT_POOL_SIZE);
 	char* buffer = buf.data();
 	while(!shouldStop())
@@ -157,19 +114,8 @@ void AuxTaskRT::empty_loop(){
 			empty_callback();
 		}
 	}
-#endif
 }
 void AuxTaskRT::str_loop(){
-#ifdef XENOMAI_SKIN_native
-	while(!shouldStop()){
-		void* buf;
-		rt_queue_receive(&queue, &buf, TM_INFINITE);
-		if(!shouldStop())
-			str_callback((std::string)buf);
-		rt_queue_free(&queue, buf);
-	}
-#endif
-#ifdef XENOMAI_SKIN_posix
 	std::vector<char> buf(AUX_RT_POOL_SIZE);
 	char* buffer = buf.data();
 	while(!shouldStop())
@@ -184,19 +130,8 @@ void AuxTaskRT::str_loop(){
 		if(!shouldStop())
 			str_callback((std::string)buffer);
 	}
-#endif
 }
 void AuxTaskRT::buf_loop(){
-#ifdef XENOMAI_SKIN_native
-	while(!shouldStop()){
-		void* buf;
-		ssize_t size = rt_queue_receive(&queue, &buf, TM_INFINITE);
-		if(!shouldStop())
-			buf_callback((void*)buf, size);
-		rt_queue_free(&queue, buf);
-	}
-#endif
-#ifdef XENOMAI_SKIN_posix
 	std::vector<char> buf(AUX_RT_POOL_SIZE);
 	char* buffer = buf.data();
 	while(!shouldStop())
@@ -211,14 +146,10 @@ void AuxTaskRT::buf_loop(){
 		if(!shouldStop())
 			buf_callback((void*)buffer, ret);
 	}
-#endif
 }
 
 void AuxTaskRT::thread_func(void* ptr){
 	AuxTaskRT *instance = (AuxTaskRT*)ptr;
-#ifdef XENOMAI_SKIN_native
-	rt_print_auto_init(1);
-#endif
 	if (gRTAudioVerbose)
 		printf("AuxTaskRT %s starting\n", instance->name.c_str());
 	if (instance->mode == 0){
diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index d7a2f2459..1b3c8f5b5 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -4,10 +4,6 @@
 #include <iostream>
 #include <string.h>
 
-#ifdef XENOMAI_SKIN_native
-#include <native/task.h>
-#endif
-
 #include "../include/xenomai_wraps.h"
 
 using namespace std;
@@ -15,14 +11,9 @@ using namespace std;
 // Data structure to keep track of auxiliary tasks we
 // can schedule
 typedef struct {
-#ifdef XENOMAI_SKIN_native
-	RT_TASK task;
-#endif
-#ifdef XENOMAI_SKIN_posix
 	pthread_t task;
 	pthread_cond_t cond;
 	pthread_mutex_t mutex;
-#endif
 	void (*argfunction)(void*);
 	char *name;
 	int priority;
@@ -55,10 +46,6 @@ AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int p
 	newTask->args = args;
 	// Attempt to create the task
 	unsigned int stackSize = gAuxiliaryTaskStackSize;
-#ifdef XENOMAI_SKIN_native
-	if(int ret = rt_task_create(&(newTask->task), name, stackSize, priority, T_JOINABLE | T_FPU))
-#endif
-#ifdef XENOMAI_SKIN_posix
 	if(int ret = __wrap_pthread_cond_init(&(newTask->cond), NULL))
 	{
 		fprintf(stderr, "Error: unable to create condition variable for auxiliary task %s : (%d) %s\n", name, ret, strerror(ret));
@@ -74,7 +61,6 @@ AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int p
 	// Upon calling this function, the thread will start and immediately wait
 	// on the condition variable.
 	if(int ret = create_and_start_thread(&(newTask->task), name, priority, stackSize,(pthread_callback_t*)auxiliaryTaskLoop, newTask))
-#endif
 	{
 		fprintf(stderr, "Error: unable to create auxiliary task %s : (%d) %s\n", name, ret, strerror(ret));
 		free(newTask);
@@ -96,16 +82,6 @@ int Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 		Bela_startAuxiliaryTask(task); // is started (or ready to be resumed), but it probably is the fastest.
                                            // A safer approach would use rt_task_inquire()
 	}
-#ifdef XENOMAI_SKIN_native
-	rt_task_resume(&taskToSchedule->task);
-	// the return value here is hardcoded: returns success
-	// regardless of whether the task is actually scheduled or was
-	// already running. Finding out whether it was successful or not
-	// would require some overhead, through a call to rt_task_inquire,
-	// so we leave it out for now.
-	return 0;
-#endif
-#ifdef XENOMAI_SKIN_posix
 	if(!taskToSchedule->started)
 	{
 		// the task has not yet had a chance to run.
@@ -144,7 +120,6 @@ int Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 		__wrap_pthread_mutex_unlock(&taskToSchedule->mutex);
 		return 0;
 	}
-#endif
 }
 AuxiliaryTask Bela_runAuxiliaryTask(void (*callback)(void*), int priority, void* arg)
 {
@@ -163,15 +138,10 @@ AuxiliaryTask Bela_runAuxiliaryTask(void (*callback)(void*), int priority, void*
 
 static void suspendCurrentTask(InternalAuxiliaryTask* task)
 {
-#ifdef XENOMAI_SKIN_native
-	rt_task_suspend(NULL);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	__wrap_pthread_mutex_lock(&task->mutex);
 	task->started = true;
 	__wrap_pthread_cond_wait(&task->cond, &task->mutex);
 	__wrap_pthread_mutex_unlock(&task->mutex);
-#endif
 }
 // Calculation loop that can be used for other tasks running at a lower
 // priority than the audio thread. Simple wrapper for Xenomai calls.
@@ -213,16 +183,8 @@ int Bela_startAuxiliaryTask(AuxiliaryTask task){
 	taskStruct = (InternalAuxiliaryTask *)task;
 	if(taskStruct->started == true)
 		return 0;
-#ifdef XENOMAI_SKIN_native
-	if(int ret = rt_task_start(&(taskStruct->task), &auxiliaryTaskLoop, taskStruct)) {
-		fprintf(stderr,"Error: unable to start Xenomai task %s: %s\n", taskStruct->name, strerror(-ret));
-		return -1;
-	}
-#endif
-#ifdef XENOMAI_SKIN_posix
 	// The task has already been started upon creation.
 	// It is currently waiting on a condition variable.
-#endif
 	return 0;
 }
 
@@ -253,11 +215,6 @@ void Bela_stopAllAuxiliaryTasks()
 		// each thread should be checking on Bela_stopRequested(), which
 		// should return true at this point. Let's make sure it does:
 		Bela_requestStop();
-#ifdef XENOMAI_SKIN_native
-		rt_task_resume(&taskStruct->task);
-		rt_task_join(&(taskStruct->task));
-#endif
-#ifdef XENOMAI_SKIN_posix
 		// REALLY lock the lock: we really must call _cond_signal here
 		__wrap_pthread_mutex_lock(&taskStruct->mutex);
 		__wrap_pthread_cond_signal(&taskStruct->cond);
@@ -265,7 +222,6 @@ void Bela_stopAllAuxiliaryTasks()
 
 		void* threadReturnValue;
 		__wrap_pthread_join(taskStruct->task, &threadReturnValue);
-#endif
 	}
 }
 
@@ -277,14 +233,9 @@ void Bela_deleteAllAuxiliaryTasks()
 		InternalAuxiliaryTask *taskStruct = *it;
 
 		// Delete the task
-#ifdef XENOMAI_SKIN_native
-		rt_task_delete(&taskStruct->task);
-#endif
-#ifdef XENOMAI_SKIN_posix
 		pthread_cancel(taskStruct->task);
 		__wrap_pthread_cond_destroy(&taskStruct->cond);
 		__wrap_pthread_mutex_destroy(&taskStruct->mutex);
-#endif
 		// Free the name string and the struct itself
 		free(taskStruct->name);
 		free(taskStruct);
diff --git a/core/PRU.cpp b/core/PRU.cpp
index 8aa5ac196..3406a448f 100644
--- a/core/PRU.cpp
+++ b/core/PRU.cpp
@@ -62,15 +62,7 @@ static int rtdm_fd_mcasp_to_pru = 0;
 #endif
 
 // Xenomai-specific includes
-#if defined(XENOMAI_SKIN_native)
-#include <native/task.h>
-#include <native/timer.h>
-#include <rtdk.h>
-#endif
-
-#if defined(XENOMAI_SKIN_posix)
 #include <pthread.h>
-#endif
 
 #include "../include/xenomai_wraps.h"
 
diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 6d496cc9d..38838ef4a 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -32,22 +32,9 @@
 #include "../include/MiscUtilities.h"
 
 // Xenomai-specific includes
-#if XENOMAI_MAJOR == 3
 #include <xenomai/init.h>
-#endif
-
-#if defined(XENOMAI_SKIN_native)
-#include <native/task.h>
-#include <native/timer.h>
-#include <rtdk.h>
-#endif
 
-#if defined(XENOMAI_SKIN_posix)
-#if XENOMAI_MAJOR == 2
-#include <rtdk.h> // for rt_print_auto_init()
-#endif
 #include <pthread.h>
-#endif
 
 #include "../include/xenomai_wraps.h"
 
@@ -180,16 +167,9 @@ void Bela_HwConfig_delete(BelaHwConfig* cfg)
 }
 
 // Real-time tasks and objects
-#ifdef XENOMAI_SKIN_native
-RT_TASK gRTAudioThread;
-#endif
-#ifdef XENOMAI_SKIN_posix
 pthread_t gRTAudioThread;
 static pthread_t gFifoThread;
-#endif
-#if XENOMAI_MAJOR == 3
 int gXenomaiInited = 0;
-#endif
 static const char gRTAudioThreadName[] = "bela-audio";
 static const char gFifoThreadName[] = "bela-audio-fifo";
 
@@ -446,9 +426,6 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 	sa.sa_flags = SA_SIGINFO;
 	sigaction(SIGDEBUG, &sa, NULL);
 #endif // XENOMAI_CATCH_MSW
-#if defined(XENOMAI_SKIN_native) || XENOMAI_MAJOR == 2
-	rt_print_auto_init(1);
-#endif
 
 	// reset this, in case it has been set before
 	gShouldStop = 0;
@@ -939,45 +916,8 @@ static int startAudioInline(){
 
 int Bela_runInSameThread()
 {
-#ifdef XENOMAI_SKIN_native
-	RT_TASK thisTask;
-	int ret = 0;
-
-	// do the initialization
-	ret = startAudioInline();
-	if(ret < 0)
-		return ret;
-
-	// turn the current thread into a Xenomai task: we become the audio thread
-	ret = rt_task_shadow(&thisTask, gRTAudioThreadName, BELA_AUDIO_PRIORITY, T_JOINABLE | T_FPU);
-	if(ret == -EBUSY){
-	// task already is a Xenomai task:
-	// let's only re-adjust the priority
-		ret = rt_task_set_priority(&thisTask, BELA_AUDIO_PRIORITY);
-	}
-
-	if(ret < 0)
-	{
-		fprintf(stderr, "Error: unable to shadow Xenomai audio thread: %s \n", strerror(-ret));
-		return ret;	
-	}
-
-	ret = Bela_startAllAuxiliaryTasks();
-	if(ret < 0)
-		return ret;
-
-	// this starts the infinite loop that can only be broken out of
-	// by calling Bela_requestStop()
-	audioLoop(NULL);
-
-	// Once you get out of it, stop properly (in case you didn't already):
-	Bela_stopAudio();
-	return ret;
-#endif
-#ifdef XENOMAI_SKIN_posix
 	fprintf(stderr, "Turning the current thread into the audio thread is not supported with the POSIX skin.\n");
 	exit(1);
-#endif
 }
 
 int Bela_startAudio()
@@ -987,13 +927,6 @@ int Bela_startAudio()
 	// Create audio thread with high Xenomai priority
 	unsigned int stackSize = gAudioThreadStackSize;
 	int ret;
-#ifdef XENOMAI_SKIN_native
-	if(ret = rt_task_create(&gRTAudioThread, gRTAudioThreadName, stackSize, BELA_AUDIO_PRIORITY, T_JOINABLE | T_FPU))
-	{
-		  fprintf(stderr,"Error: unable to create Xenomai audio thread: %s \n" ,strerror(-ret));
-		  return -1;
-	}
-#endif
 
 	ret = startAudioInline();
 	if(ret < 0)
@@ -1004,19 +937,6 @@ int Bela_startAudio()
 	}
 
 	// Start all RT threads
-#ifdef XENOMAI_SKIN_native
-	if(ret = rt_task_start(&gRTAudioThread, &audioLoop, 0))
-	{
-		fprintf(stderr,"Error: unable to start Xenomai audio thread: %s \n" ,strerror(-ret));
-      		return -1;
-	}
-	if(gBcf)
-	{
-		fprintf(stderr,"Error: cannot use SKIN_native with audio fifo\n");
-		return -1;
-	}
-#endif
-#ifdef XENOMAI_SKIN_posix
 	int audioPriority;
 	if(gBcf)
 	{
@@ -1038,7 +958,6 @@ int Bela_startAudio()
 		fprintf(stderr, "Error: unable to start Xenomai audio thread: %d %s\n", ret, strerror(-ret));
 		return -1;
 	}
-#endif
 
 	ret = Bela_startAllAuxiliaryTasks();
 	return ret;
@@ -1057,10 +976,6 @@ void Bela_stopAudio()
 		return;
 
 	// Now wait for threads to respond and actually stop...
-#ifdef XENOMAI_SKIN_native
-	rt_task_join(&gRTAudioThread);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	void* threadReturnValue;
 	int ret = __wrap_pthread_join(gRTAudioThread, &threadReturnValue);
 	if(ret)
@@ -1073,7 +988,6 @@ void Bela_stopAudio()
 		if(ret)
 			fprintf(stderr, "Failed to join audio fifo thread: (%d) %s\n", ret, strerror(ret));
 	}
-#endif
 
 	Bela_stopAllAuxiliaryTasks();
 }
@@ -1095,9 +1009,6 @@ void Bela_cleanupAudio()
 	Bela_deleteAllAuxiliaryTasks();
 
 	// Delete the audio task
-#ifdef XENOMAI_SKIN_native
-	rt_task_delete(&gRTAudioThread);
-#endif
 
 	delete gPRU;
 	delete gAudioCodec;
diff --git a/include/AuxTaskNonRT.h b/include/AuxTaskNonRT.h
index d623a77ac..41b036477 100644
--- a/include/AuxTaskNonRT.h
+++ b/include/AuxTaskNonRT.h
@@ -2,16 +2,7 @@
 #ifndef __AuxTaskNonRT_H_INCLUDED__
 #define __AuxTaskNonRT_H_INCLUDED__ 
 
-#ifdef XENOMAI_SKIN_native
-#include <rtdk.h>
-#include <native/task.h>
-#include <native/pipe.h>
-#endif
-
-#ifdef XENOMAI_SKIN_posix
 #include <pthread.h>
-#endif
-
 #include <string>
 #include <functional>
 
@@ -38,14 +29,8 @@ class AuxTaskNonRT{
 		bool shouldStop();
 		void cleanup();
 		
-#ifdef XENOMAI_SKIN_native
-		RT_TASK task;
-		RT_PIPE pipe;
-#endif
-#ifdef XENOMAI_SKIN_posix
 		pthread_t thread;
 		int pipeSocket;
-#endif
 		
 		std::string name;
 		int pipe_fd;
diff --git a/include/AuxTaskRT.h b/include/AuxTaskRT.h
index 90c3761b5..7d9aa1941 100644
--- a/include/AuxTaskRT.h
+++ b/include/AuxTaskRT.h
@@ -6,18 +6,10 @@
 #include <string>
 #include <functional>
 
-#ifdef XENOMAI_SKIN_native
-#include <rtdk.h>
-#include <native/task.h>
-#include <native/queue.h>
-#endif
-
-#ifdef XENOMAI_SKIN_posix
 #include <fcntl.h>           /* For O_* constants */
 #include <sys/stat.h>        /* For mode constants */
 #include <pthread.h>
 #include <mqueue.h>
-#endif
 
 #define AUX_RT_POOL_SIZE 500000
 
@@ -42,15 +34,9 @@ class AuxTaskRT{
 		bool shouldStop();
 		void cleanup();
 		
-#ifdef XENOMAI_SKIN_native
-		RT_TASK task;
-		RT_QUEUE queue;
-#endif
-#ifdef XENOMAI_SKIN_posix
 		pthread_t thread;
 		mqd_t queueDesc;
 		std::string queueName;
-#endif
 		
 		std::string name;
 		int priority;
diff --git a/include/xenomai_wraps.h b/include/xenomai_wraps.h
index 1b48a38a0..8dff53b91 100644
--- a/include/xenomai_wraps.h
+++ b/include/xenomai_wraps.h
@@ -2,13 +2,6 @@
 #define XENOMAI_WRAPS_H
 
 #include "Bela.h"
-#if !defined(XENOMAI_MAJOR)
-#error Xenomai version not set
-#endif
-#if !defined(XENOMAI_SKIN_native) && !defined(XENOMAI_SKIN_posix)
-#error Xenomai skin unsupported or not defined
-#endif
-
 #include <time.h>
 #include <stdio.h>
 #include <string.h>
@@ -16,7 +9,6 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-#ifdef XENOMAI_SKIN_posix
 #include <pthread.h>
 #include <mqueue.h>
 #include <sys/socket.h>
@@ -65,37 +57,19 @@ extern "C" void Bela_initRtBackend();
 int __wrap_pthread_join(pthread_t thread, void **retval);
 int __wrap_pthread_attr_init(pthread_attr_t *attr);
 int __wrap_sched_get_priority_max(int policy);
-#endif
-#endif /* XENOMAI_SKIN_posix */
 
-#ifdef XENOMAI_SKIN_native
-#include <native/task.h>
-typedef RTIME time_ns_t;
-#endif
-#ifdef XENOMAI_SKIN_posix
-#if XENOMAI_MAJOR == 3
 #include <rtdm/ipc.h>
-#else
-#include <rtdm/rtipc.h>
-#endif
 typedef long long int time_ns_t;
 typedef void *(pthread_callback_t)(void *);
-#endif
 
 inline int task_sleep_ns(long long int timens)
 {
-#ifdef XENOMAI_SKIN_native
-	return rt_task_sleep((RTIME) timens);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	struct timespec req;
 	req.tv_sec = timens/1000000000;
 	req.tv_nsec = timens - req.tv_sec * 1000000000;
 	return __wrap_nanosleep(&req, NULL);
-#endif
 }
 
-#ifdef XENOMAI_SKIN_posix
 #include <error.h>
 //void error(int exitCode, int errno, char* message)
 //{
@@ -157,15 +131,7 @@ inline int create_and_start_thread(pthread_t* task, const char* taskName, int pr
 	{
 		return ret;
 	}
-#if XENOMAI_MAJOR == 2
-	// note the different spelling. Worst thing is that 
-	// pthread_setname_np would still compile and run (because it is a POSIX
-	// extension provided by Linux), but would not have the desired effect.
-	pthread_set_name_np(*task, taskName);
-#endif
-#if XENOMAI_MAJOR == 3
 	__wrap_pthread_setname_np(*task, taskName);
-#endif
 	// check that effective parameters match the ones we requested
 	//pthread_attr_t actualAttr;
 	//pthread_getattr_np(*task, &actualAttr);
@@ -237,7 +203,6 @@ inline int createXenomaiPipe(const char* portName, size_t poolsz)
 	}
 	return s;
 }
-#endif /* XENOMAI_SKIN_posix */
 
 #ifdef __cplusplus
 }
diff --git a/libraries/Midi/Midi.cpp b/libraries/Midi/Midi.cpp
index 99f1ebcdb..29009572d 100644
--- a/libraries/Midi/Midi.cpp
+++ b/libraries/Midi/Midi.cpp
@@ -104,9 +104,7 @@ Midi::Midi() :
 alsaIn(NULL), alsaOut(NULL),
 inputParser(NULL), parserEnabled(false), inputEnabled(false), outputEnabled(false),
 inId(NULL), outId(NULL), outPipeName(NULL)
-#ifdef XENOMAI_SKIN_posix
 	, sock(0)
-#endif
 {
 	setup();
 }
@@ -125,12 +123,7 @@ void Midi::cleanup() {
 	free(outPipeName);
 	// dummy write so that `poll` stops polling ! 
 	//rt_pipe_write(&outPipe, NULL, 0, P_NORMAL); // does not work :(
-#ifdef XENOMAI_SKIN_native
-	rt_pipe_delete(&outPipe);
-#endif
-#ifdef XENOMAI_SKIN_posix
 	close(sock);
-#endif
 	if(alsaOut){
 		snd_rawmidi_drain(alsaOut);
 		snd_rawmidi_close(alsaOut);
@@ -328,25 +321,14 @@ int Midi::writeTo(const char* port){
 	outId = (char*)malloc((size + 1) * sizeof(char));
 	snprintf(outId, size + 1, "bela-midiOut_%s", port);
 
-#if XENOMAI_SKIN_posix || XENOMAI_MAJOR == 3
 	char outPipeNameTemplateString[] = "/proc/xenomai/registry/rtipc/xddp/%s";
-#else
-	char outPipeNameTemplateString[] = "/proc/xenomai/registry/native/pipes/%s";
-#endif
 	size = snprintf(outPipeName, 0, outPipeNameTemplateString, outId);
 	outPipeName = (char*)malloc((size + 1)*sizeof(char));
 	snprintf(outPipeName, size + 1, outPipeNameTemplateString, outId);
 	int ret;
-#ifdef XENOMAI_SKIN_native
-	ret = rt_pipe_delete(&outPipe);
-	ret = rt_pipe_create(&outPipe, port, P_MINOR_AUTO, 4096);
-	if(ret < 0){
-#endif
-#ifdef XENOMAI_SKIN_posix
 	ret = createXenomaiPipe(outId, 0);
 	sock = ret;
 	if(ret <= 0){
-#endif
 		fprintf(stderr, "Error while creating pipe %s: %s\n", outId, strerror(-ret));
 		return -1;
 	}
@@ -486,14 +468,8 @@ int Midi::writeOutput(midi_byte_t* bytes, unsigned int length){
 		// which would result in incomplete messages being retrieved at
 		// the other end of the pipe.
 		ssize_t size = length < outputBytes.size() ? length : outputBytes.size();
-#ifdef XENOMAI_SKIN_native
-		int ret = rt_pipe_write(&outPipe, bytes, size, P_NORMAL);
-		if(ret < 0){
-#endif
-#ifdef XENOMAI_SKIN_posix
 		int ret = __wrap_sendto(sock, bytes, size, 0, NULL, 0);
 		if (ret != size){
-#endif
 			rt_fprintf(stderr, "Error while streaming to pipe %s: %s\n", outPipeName, strerror(-ret));
 			return -1;
 		} else {

From 66615624f4e213852f7d2a19b11d25e358906bc4 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 19 Jun 2022 13:22:40 +0000
Subject: [PATCH 108/188] Makefile: removed -DXENOMAI_MAJOR and
 -DXENOMAI_SKIN_*. Leaving XENOMAI_VERSION in place as it may become useful
 again soon

---
 Makefile                | 29 +++--------------------------
 core/RTAudio.cpp        |  7 -------
 include/xenomai_wraps.h | 10 ----------
 3 files changed, 3 insertions(+), 43 deletions(-)

diff --git a/Makefile b/Makefile
index 5d8058c75..ac5ec2476 100644
--- a/Makefile
+++ b/Makefile
@@ -214,45 +214,27 @@ DEBIAN_VERSION=$(shell grep "VERSION=" /etc/os-release | sed "s/.*(\(.*\)).*/\1/
 # Lazily, let's assume if we are not on 2.6 we are on 3. I sincerely hope we will survive till Xenomai 4 to see this fail
 XENOMAI_VERSION=$(shell $(XENO_CONFIG) --version | grep -o "2\.6" || echo "3")
 
-ifeq ($(XENOMAI_VERSION),2.6)
-XENOMAI_MAJOR=2
-endif
-ifeq ($(XENOMAI_VERSION),3)
-XENOMAI_MAJOR=3
-endif
-
 # Xenomai flags
 DEFAULT_XENOMAI_CFLAGS := $(shell $(XENO_CONFIG) --skin=$(XENOMAI_SKIN) --cflags)
-DEFAULT_XENOMAI_CFLAGS += -DXENOMAI_SKIN_$(XENOMAI_SKIN) -DXENOMAI_MAJOR=$(XENOMAI_MAJOR)
 # Cleaning up any `pie` introduced because of gcc 6.3, as it would confuse clang
 DEFAULT_XENOMAI_CFLAGS := $(filter-out -no-pie, $(DEFAULT_XENOMAI_CFLAGS))
 DEFAULT_XENOMAI_CFLAGS := $(filter-out -fno-pie, $(DEFAULT_XENOMAI_CFLAGS))
 SED_REMOVE_WRAPPERS_REGEX=sed "s/-Wl,@[A-Za-z_/]*.wrappers\>//g"
-ifeq ($(XENOMAI_VERSION),2.6)
-  DEFAULT_XENOMAI_LDFLAGS := $(shell $(XENO_CONFIG) --skin=$(XENOMAI_SKIN) --ldflags | $(SED_REMOVE_WRAPPERS_REGEX))
-else
-  DEFAULT_XENOMAI_LDFLAGS := $(shell $(XENO_CONFIG) --skin=$(XENOMAI_SKIN) --ldflags --no-auto-init | $(SED_REMOVE_WRAPPERS_REGEX) | sed s/-Wl,--no-as-needed//)
-endif
+DEFAULT_XENOMAI_LDFLAGS := $(shell $(XENO_CONFIG) --skin=$(XENOMAI_SKIN) --ldflags --no-auto-init | $(SED_REMOVE_WRAPPERS_REGEX) | sed s/-Wl,--no-as-needed//)
 DEFAULT_XENOMAI_LDFLAGS := $(filter-out -no-pie, $(DEFAULT_XENOMAI_LDFLAGS))
 DEFAULT_XENOMAI_LDFLAGS := $(filter-out -fno-pie, $(DEFAULT_XENOMAI_LDFLAGS))
 # remove posix wrappers if present: explicitly call __wrap_pthread_... when needed
 DEFAULT_XENOMAI_LDFLAGS := $(filter-out -Wlusr/xenomai/lib/cobalt.wrappers, $(DEFAULT_XENOMAI_LDFLAGS))
 
 #... and cache them to the file
-$(shell printf "DEBIAN_VERSION=$(DEBIAN_VERSION)\nXENOMAI_VERSION=$(XENOMAI_VERSION)\nDEFAULT_XENOMAI_CFLAGS=$(DEFAULT_XENOMAI_CFLAGS)\nDEFAULT_XENOMAI_LDFLAGS=$(DEFAULT_XENOMAI_LDFLAGS)\nXENOMAI_MAJOR=$(XENOMAI_MAJOR)\n" > $(SYSTEM_SPECIFIC_MAKEFILE) )
+$(shell printf "DEBIAN_VERSION=$(DEBIAN_VERSION)\nXENOMAI_VERSION=$(XENOMAI_VERSION)\nDEFAULT_XENOMAI_CFLAGS=$(DEFAULT_XENOMAI_CFLAGS)\nDEFAULT_XENOMAI_LDFLAGS=$(DEFAULT_XENOMAI_LDFLAGS)\n" > $(SYSTEM_SPECIFIC_MAKEFILE) )
 endif  # ifeq ($(DEBIAN_VERSION),)
 
 ifeq ($(AT),)
   $(info Running on __$(DEBIAN_VERSION)__ with Xenomai __$(XENOMAI_VERSION)__)
 endif
 
-ifeq ($(XENOMAI_VERSION),2.6)
-XENOMAI_STAT_PATH=/proc/xenomai/stat
-LIBPD_LIBS=-lpd -lpthread_rt
-endif
-ifeq ($(XENOMAI_VERSION),3)
 XENOMAI_STAT_PATH=/proc/xenomai/sched/stat
-endif
 
 # This is used to run Bela projects from the terminal in the background
 SCREEN_NAME?=Bela
@@ -281,12 +263,7 @@ RM := rm -rf
 LEGACY_INCLUDE_PATH := ./include/legacy
 
 INCLUDES := -I$(PROJECT_DIR) -I$(LEGACY_INCLUDE_PATH)  -I./include -I./build/pru/ -I./
-ifeq ($(XENOMAI_VERSION),2.6)
-  BELA_USE_DEFINE?=BELA_USE_POLL
-endif
-ifeq ($(XENOMAI_VERSION),3)
-  BELA_USE_DEFINE?=BELA_USE_RTDM
-endif
+BELA_USE_DEFINE?=BELA_USE_RTDM
 
 ARCH_FLAGS?=-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=hard
 
diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 38838ef4a..d6ecff00d 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -358,7 +358,6 @@ static int setChannelGains(BelaChannelGainArray& cga, int (*cb)(int, float))
 #include <mutex>
 extern "C" void Bela_initRtBackend()
 {
-#if (XENOMAI_MAJOR == 3)
 	static std::once_flag flag;
 	std::call_once(flag, [](){
 		// initialize Xenomai with manual bootstrapping if needed
@@ -395,7 +394,6 @@ extern "C" void Bela_initRtBackend()
 		// this is no longer requi, but we keep it for backward
 		gXenomaiInited = 1;
 	});
-#endif
 }
 int Bela_initAudio(BelaInitSettings *settings, void *userData)
 {
@@ -405,12 +403,7 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 	// Before we go ahead, let's check if Bela is alreadt running:
 	// check if another real-time thread of the same name is already running.
 	char command[200];
-#if (XENOMAI_MAJOR == 2)
-	char pathToXenomaiStat[] = "/proc/xenomai/stat";
-#endif
-#if (XENOMAI_MAJOR == 3)
 	char pathToXenomaiStat[] = "/proc/xenomai/sched/stat";
-#endif
 	snprintf(command, 199, "grep %s %s", gRTAudioThreadName, pathToXenomaiStat);
 	int ret = system(command);
 	if(ret == 0)
diff --git a/include/xenomai_wraps.h b/include/xenomai_wraps.h
index 8dff53b91..26d51a065 100644
--- a/include/xenomai_wraps.h
+++ b/include/xenomai_wraps.h
@@ -44,16 +44,6 @@ int __wrap_mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned ms
 int __wrap_mq_unlink(const char *name);
 
 extern "C" void Bela_initRtBackend();
-// Handle difference between posix API of Xenomai 2.6 and Xenomai 3
-// Some functions are not wrapped by Xenomai 2.6, so we redefine the __wrap
-// to the actual POSIX service for Xenomai 2.6 while we simply forward declare
-// the __wrap_ version for Xenomai 3
-#if XENOMAI_MAJOR == 2
-#define __wrap_pthread_join(a,b) pthread_join(a,b) // NOWRAP
-#define __wrap_pthread_attr_init(a) pthread_attr_init(a) // NOWRAP
-#define __wrap_sched_get_priority_max(a) sched_get_priority_max(a) // NOWRAP
-#endif
-#if XENOMAI_MAJOR == 3
 int __wrap_pthread_join(pthread_t thread, void **retval);
 int __wrap_pthread_attr_init(pthread_attr_t *attr);
 int __wrap_sched_get_priority_max(int policy);

From 15f4276c3dbbdbbd37831adc9288f0871dc967d8 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 19 Jun 2022 13:30:39 +0000
Subject: [PATCH 109/188] Xenomai: factored out __wrap_ to BELA_RT_WRAP()

These changes were automated with
    sed -i 's/__wrap_\([^"]*\)\([;)]$\)/BELA_RT_WRAP(\1)\2/g' core/* include/*h libraries/*/*.*
More changes to follow
---
 core/AuxTaskNonRT.cpp   |  6 ++--
 core/AuxTaskRT.cpp      | 18 +++++------
 core/AuxiliaryTasks.cpp | 32 +++++++++---------
 core/DataFifo.cpp       | 22 ++++++-------
 core/PRU.cpp            | 14 ++++----
 core/RTAudio.cpp        | 24 +++++++-------
 include/xenomai_wraps.h | 72 ++++++++++++++++++++---------------------
 libraries/Midi/Midi.cpp |  2 +-
 libraries/Pipe/Pipe.cpp | 12 +++----
 9 files changed, 101 insertions(+), 101 deletions(-)

diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index 06b1c0ff4..dabe2b0a0 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -63,7 +63,7 @@ void AuxTaskNonRT::__create(){
 }
 
 int AuxTaskNonRT::schedule(const void* ptr, size_t size){
-	int ret = __wrap_sendto(pipeSocket, ptr, size, 0, NULL, 0);
+	int ret = BELA_RT_WRAP(sendto(pipeSocket, ptr, size, 0, NULL, 0));
 	if(ret < 0)
 	{
 		rt_fprintf(stderr, "Error while sending to pipe from %s: (%d) %s (size: %d)\n", name.c_str(), errno, strerror(errno), size);
@@ -83,11 +83,11 @@ void AuxTaskNonRT::cleanup(){
 	lShouldStop = true;
 	// unblock and join thread
 	schedule();
-	int ret = __wrap_pthread_join(thread, NULL);
+	int ret = BELA_RT_WRAP(pthread_join(thread, NULL));
 	if (ret < 0){
 		fprintf(stderr, "AuxTaskNonRT %s: unable to join thread: (%i) %s\n", name.c_str(), ret, strerror(ret));
 	}
-	ret = __wrap_close(pipeSocket);
+	ret = BELA_RT_WRAP(close(pipeSocket));
 	if(ret)
 	{
 		fprintf(stderr, "Error closing pipeSocket: %d %s\n", errno, strerror(errno));
diff --git a/core/AuxTaskRT.cpp b/core/AuxTaskRT.cpp
index 8f25b9e8b..016248d1c 100644
--- a/core/AuxTaskRT.cpp
+++ b/core/AuxTaskRT.cpp
@@ -43,7 +43,7 @@ void AuxTaskRT::__create(){
 	struct mq_attr attr;
 	attr.mq_maxmsg = 100; 
 	attr.mq_msgsize = 100000;
-	queueDesc = __wrap_mq_open(queueName.c_str(), O_CREAT | O_RDWR, 0644, &attr);
+	queueDesc = BELA_RT_WRAP(mq_open(queueName.c_str(), O_CREAT | O_RDWR, 0644, &attr));
 	if(queueDesc < 0)
 	{
 		fprintf(stderr, "Unable to open message queue %s: (%d) %s\n", queueName.c_str(), errno, strerror(errno));
@@ -60,7 +60,7 @@ void AuxTaskRT::__create(){
 }
 
 void AuxTaskRT::schedule(void* buf, size_t size){
-	if(__wrap_mq_send(queueDesc, (char*)buf, size, 0))
+	if(BELA_RT_WRAP(mq_send(queueDesc, (char*)buf, size, 0)))
 	{
 		if(!shouldStop()) fprintf(stderr, "Unable to send message to queue for task %s: (%d) %s\n", name.c_str(), errno, strerror(errno));
 		return;
@@ -80,18 +80,18 @@ void AuxTaskRT::cleanup(){
 	char c = 0;
 	struct timespec absoluteTimeout = {0, 0};
 	// non blocking write, so if the queue is full it won't fail
-	__wrap_mq_timedsend(queueDesc, &c, sizeof(c), 0, &absoluteTimeout);
-	int ret = __wrap_pthread_join(thread, NULL);
+	BELA_RT_WRAP(mq_timedsend(queueDesc, &c, sizeof(c), 0, &absoluteTimeout));
+	int ret = BELA_RT_WRAP(pthread_join(thread, NULL));
 	if (ret < 0){
 		fprintf(stderr, "AuxTaskNonRT %s: unable to join thread: (%i) %s\n", name.c_str(), ret, strerror(ret));
 	}
 	
-	ret = __wrap_mq_close(queueDesc);
+	ret = BELA_RT_WRAP(mq_close(queueDesc));
 	if(ret)
 	{
 		fprintf(stderr, "Error closing queueDesc: %d %s\n", errno, strerror(errno));
 	}
-	ret = __wrap_mq_unlink(queueName.c_str());
+	ret = BELA_RT_WRAP(mq_unlink(queueName.c_str()));
 	if(ret)
 	{
 		fprintf(stderr, "Error unlinking queue: %d %s\n", errno, strerror(errno));
@@ -104,7 +104,7 @@ void AuxTaskRT::empty_loop(){
 	while(!shouldStop())
 	{
 		unsigned int prio;
-		ssize_t ret = __wrap_mq_receive(queueDesc, buffer, AUX_RT_POOL_SIZE, &prio);
+		ssize_t ret = BELA_RT_WRAP(mq_receive(queueDesc, buffer, AUX_RT_POOL_SIZE, &prio));
 		if(ret < 0)
 		{
 			if(!shouldStop()) fprintf(stderr, "Unable to receive message from queue for task %s: (%d) %s\n", name.c_str(), errno, strerror(errno));
@@ -121,7 +121,7 @@ void AuxTaskRT::str_loop(){
 	while(!shouldStop())
 	{
 		unsigned int prio;
-		ssize_t ret = __wrap_mq_receive(queueDesc, buffer, AUX_RT_POOL_SIZE, &prio);
+		ssize_t ret = BELA_RT_WRAP(mq_receive(queueDesc, buffer, AUX_RT_POOL_SIZE, &prio));
 		if(ret < 0)
 		{
 			if(!shouldStop()) fprintf(stderr, "Unable to receive message from queue for task %s: (%d) %s\n", name.c_str(), errno, strerror(errno));
@@ -137,7 +137,7 @@ void AuxTaskRT::buf_loop(){
 	while(!shouldStop())
 	{
 		unsigned int prio;
-		ssize_t ret = __wrap_mq_receive(queueDesc, buffer, AUX_RT_POOL_SIZE, &prio);
+		ssize_t ret = BELA_RT_WRAP(mq_receive(queueDesc, buffer, AUX_RT_POOL_SIZE, &prio));
 		if(ret < 0)
 		{
 			if(!shouldStop()) fprintf(stderr, "Unable to receive message from queue for task %s: (%d) %s\n", name.c_str(), errno, strerror(errno));
diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index 1b3c8f5b5..73d685c0f 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -46,13 +46,13 @@ AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int p
 	newTask->args = args;
 	// Attempt to create the task
 	unsigned int stackSize = gAuxiliaryTaskStackSize;
-	if(int ret = __wrap_pthread_cond_init(&(newTask->cond), NULL))
+	if(int ret = BELA_RT_WRAP(pthread_cond_init(&(newTask->cond), NULL)))
 	{
 		fprintf(stderr, "Error: unable to create condition variable for auxiliary task %s : (%d) %s\n", name, ret, strerror(ret));
 		free(newTask);
 		return 0;
 	}
-	if(int ret = __wrap_pthread_mutex_init(&(newTask->mutex), NULL))
+	if(int ret = BELA_RT_WRAP(pthread_mutex_init(&(newTask->mutex), NULL)))
 	{
 		fprintf(stderr, "Error: unable to initialize mutex for auxiliary task %s : (%d) %s\n", name, ret, strerror(-ret));
 		free(newTask);
@@ -95,12 +95,12 @@ int Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 		{
 			// set the priority to maximum
 			int originalPriority = param.sched_priority;
-			param.sched_priority = __wrap_sched_get_priority_max(SCHED_FIFO);
+			param.sched_priority = BELA_RT_WRAP(sched_get_priority_max(SCHED_FIFO));
 			__wrap_pthread_setschedparam(taskToSchedule->task,
 					SCHED_FIFO, &param);
 			// just in case we have the same priority, let the
 			// other go first
-			__wrap_pthread_yield();
+			BELA_RT_WRAP(pthread_yield());
 			if(!taskToSchedule->started)
 				fprintf(stderr, "Didn't work\n");
 			// by the time we are here, the other thread has run, set the
@@ -111,13 +111,13 @@ int Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 					policy, &param);
 		}
 	}
-	if(int ret = __wrap_pthread_mutex_trylock(&taskToSchedule->mutex))
+	if(int ret = BELA_RT_WRAP(pthread_mutex_trylock(&taskToSchedule->mutex)))
 	{
 		// If we cannot get the lock, then the task is probably still running.
 		return ret;
 	} else {
-		ret = __wrap_pthread_cond_signal(&taskToSchedule->cond);
-		__wrap_pthread_mutex_unlock(&taskToSchedule->mutex);
+		ret = BELA_RT_WRAP(pthread_cond_signal(&taskToSchedule->cond));
+		BELA_RT_WRAP(pthread_mutex_unlock(&taskToSchedule->mutex));
 		return 0;
 	}
 }
@@ -138,10 +138,10 @@ AuxiliaryTask Bela_runAuxiliaryTask(void (*callback)(void*), int priority, void*
 
 static void suspendCurrentTask(InternalAuxiliaryTask* task)
 {
-	__wrap_pthread_mutex_lock(&task->mutex);
+	BELA_RT_WRAP(pthread_mutex_lock(&task->mutex));
 	task->started = true;
-	__wrap_pthread_cond_wait(&task->cond, &task->mutex);
-	__wrap_pthread_mutex_unlock(&task->mutex);
+	BELA_RT_WRAP(pthread_cond_wait(&task->cond, &task->mutex));
+	BELA_RT_WRAP(pthread_mutex_unlock(&task->mutex));
 }
 // Calculation loop that can be used for other tasks running at a lower
 // priority than the audio thread. Simple wrapper for Xenomai calls.
@@ -216,12 +216,12 @@ void Bela_stopAllAuxiliaryTasks()
 		// should return true at this point. Let's make sure it does:
 		Bela_requestStop();
 		// REALLY lock the lock: we really must call _cond_signal here
-		__wrap_pthread_mutex_lock(&taskStruct->mutex);
-		__wrap_pthread_cond_signal(&taskStruct->cond);
-		__wrap_pthread_mutex_unlock(&taskStruct->mutex);
+		BELA_RT_WRAP(pthread_mutex_lock(&taskStruct->mutex));
+		BELA_RT_WRAP(pthread_cond_signal(&taskStruct->cond));
+		BELA_RT_WRAP(pthread_mutex_unlock(&taskStruct->mutex));
 
 		void* threadReturnValue;
-		__wrap_pthread_join(taskStruct->task, &threadReturnValue);
+		BELA_RT_WRAP(pthread_join(taskStruct->task, &threadReturnValue));
 	}
 }
 
@@ -234,8 +234,8 @@ void Bela_deleteAllAuxiliaryTasks()
 
 		// Delete the task
 		pthread_cancel(taskStruct->task);
-		__wrap_pthread_cond_destroy(&taskStruct->cond);
-		__wrap_pthread_mutex_destroy(&taskStruct->mutex);
+		BELA_RT_WRAP(pthread_cond_destroy(&taskStruct->cond));
+		BELA_RT_WRAP(pthread_mutex_destroy(&taskStruct->mutex));
 		// Free the name string and the struct itself
 		free(taskStruct->name);
 		free(taskStruct);
diff --git a/core/DataFifo.cpp b/core/DataFifo.cpp
index 85b67f3b8..9cdab11bb 100644
--- a/core/DataFifo.cpp
+++ b/core/DataFifo.cpp
@@ -16,23 +16,23 @@ int DataFifo::setup(const std::string& name, size_t msgSize, size_t maxMsg, bool
 	attr.mq_maxmsg = maxMsg;
 	attr.mq_msgsize = msgSize;
 	// Check if queue already exists
-	queue = __wrap_mq_open(name.c_str(), O_RDWR);
+	queue = BELA_RT_WRAP(mq_open(name.c_str(), O_RDWR));
 	if(queue != -1)
 	{
 		if(recreate)
 		{
 			// if there already is a queue with this name, try to close it.
-			__wrap_mq_close(queue);
-			__wrap_mq_unlink(name.c_str());
+			BELA_RT_WRAP(mq_close(queue));
+			BELA_RT_WRAP(mq_unlink(name.c_str()));
 		}
 	}		
 	// Open a new queue
 	int flags = O_CREAT | O_RDWR | (blocking ? 0 : O_NONBLOCK);
-	queue = __wrap_mq_open(name.c_str(), flags, 0644, &attr);
+	queue = BELA_RT_WRAP(mq_open(name.c_str(), flags, 0644, &attr));
 	if(queue < 0)
 		return -errno;
 	struct mq_attr newAttr;
-	__wrap_mq_getattr(queue, &newAttr);
+	BELA_RT_WRAP(mq_getattr(queue, &newAttr));
 	// verify that all settings have been applied (a reason for failure
 	// could be that the queue was not successfully closed above
 	if(recreate && (
@@ -48,7 +48,7 @@ int DataFifo::setup(const std::string& name, size_t msgSize, size_t maxMsg, bool
 
 int DataFifo::send(const char* buf, size_t size)
 {
-	int ret = __wrap_mq_send(queue, (const char*)buf, size, 0);
+	int ret = BELA_RT_WRAP(mq_send(queue, (const char*)buf, size, 0));
 	if(ret != 0)
 		return -errno;
 	return 0;
@@ -61,7 +61,7 @@ int DataFifo::receive(char* buf, double timeoutMs)
 	if(timeoutMs)
 	{
 		struct timespec timeout;
-		__wrap_clock_gettime(CLOCK_REALTIME, &timeout);
+		BELA_RT_WRAP(clock_gettime(CLOCK_REALTIME, &timeout));
 		//struct timespec timeoutbak = timeout;
 		long oneSecondNs = 1000000000;
 		time_t timeoutS = (time_t)(timeoutMs / 1000);
@@ -83,9 +83,9 @@ int DataFifo::receive(char* buf, double timeoutMs)
 					timeout.tv_sec, timeout.tv_nsec
 					);
 #endif
-		ret = __wrap_mq_timedreceive(queue, buf, msgSize, &prio, &timeout);
+		ret = BELA_RT_WRAP(mq_timedreceive(queue, buf, msgSize, &prio, &timeout));
 	} else {
-		ret = __wrap_mq_receive(queue, buf, msgSize, &prio);
+		ret = BELA_RT_WRAP(mq_receive(queue, buf, msgSize, &prio));
 	}
 
 	if(ret < 0)
@@ -95,10 +95,10 @@ int DataFifo::receive(char* buf, double timeoutMs)
 
 int DataFifo::cleanup()
 {
-	int ret = __wrap_mq_close(queue);
+	int ret = BELA_RT_WRAP(mq_close(queue));
 	if(ret < 0)
 		return -errno;
-	ret = __wrap_mq_unlink(qName.c_str());
+	ret = BELA_RT_WRAP(mq_unlink(qName.c_str()));
 	if(ret <0)
 		return -errno;
 	return 0;
diff --git a/core/PRU.cpp b/core/PRU.cpp
index 3406a448f..9087c7d53 100644
--- a/core/PRU.cpp
+++ b/core/PRU.cpp
@@ -768,7 +768,7 @@ int PRU::start(char * const filename, const McaspRegisters& mcaspRegisters)
 #if RTDM_PRUSS_IRQ_VERSION >= 2
 	{
 		// From version 2 onwards we can set the verbose level
-		int ret = __wrap_ioctl(rtdm_fd_pru_to_arm, RTDM_PRUSS_IRQ_VERBOSE, 0);
+		int ret = BELA_RT_WRAP(ioctl(rtdm_fd_pru_to_arm, RTDM_PRUSS_IRQ_VERBOSE, 0));
 		if(ret == -1)
 			fprintf(stderr, "ioctl verbose failed: %d %s\n", errno, strerror(errno));
 		// do not fail
@@ -777,7 +777,7 @@ int PRU::start(char * const filename, const McaspRegisters& mcaspRegisters)
 #if RTDM_PRUSS_IRQ_VERSION >= 1
         // From version 1 onwards, we need to specify the PRU system event we want to receive interrupts from (see rtdm_pruss_irq.h)
         // For rtdm_fd_pru_to_arm we use the default mapping
-        int ret = __wrap_ioctl(rtdm_fd_pru_to_arm, RTDM_PRUSS_IRQ_REGISTER, pru_system_event_rtdm);
+        int ret = BELA_RT_WRAP(ioctl(rtdm_fd_pru_to_arm, RTDM_PRUSS_IRQ_REGISTER, pru_system_event_rtdm));
         if(ret == -1)
         {
                 fprintf(stderr, "ioctl failed: %d %s\n", errno, strerror(errno));
@@ -801,7 +801,7 @@ int PRU::start(char * const filename, const McaspRegisters& mcaspRegisters)
                 rtdm_struct.pru_system_events_count = sizeof(pru_system_events_mcasp);
                 rtdm_struct.pru_intc_channel = mcasp_to_pru_channel;
                 rtdm_struct.pru_intc_host = mcasp_to_pru_channel;
-                int ret = __wrap_ioctl(rtdm_fd_mcasp_to_pru, RTDM_PRUSS_IRQ_REGISTER_FULL, &rtdm_struct);
+                int ret = BELA_RT_WRAP(ioctl(rtdm_fd_mcasp_to_pru, RTDM_PRUSS_IRQ_REGISTER_FULL, &rtdm_struct));
                 if(ret == -1)
                 {
                         fprintf(stderr, "ioctl failed: %d %s\n", errno, strerror(errno));
@@ -970,7 +970,7 @@ void PRU::loop(void *userData, void(*render)(BelaContext*, void*), bool highPerf
 		// make sure we always sleep a tiny bit to prevent hanging the board
 		if(!highPerformanceMode) // unless the user requested us not to.
 			task_sleep_ns(sleepTime / 2);
-		int ret = __wrap_read(rtdm_fd_pru_to_arm, NULL, 0);
+		int ret = BELA_RT_WRAP(read(rtdm_fd_pru_to_arm, NULL, 0));
 		int error = testPruError();
 		if(2 == error) {
                         gShouldStop = true;
@@ -1577,10 +1577,10 @@ void PRU::loop(void *userData, void(*render)(BelaContext*, void*), bool highPerf
 
 #if defined(BELA_USE_RTDM)
         if(rtdm_fd_pru_to_arm)
-                __wrap_close(rtdm_fd_pru_to_arm);
+                BELA_RT_WRAP(close(rtdm_fd_pru_to_arm));
 #if RTDM_PRUSS_IRQ_VERSION >= 1
         if(rtdm_fd_pru_to_arm)
-                __wrap_close(rtdm_fd_mcasp_to_pru);
+                BELA_RT_WRAP(close(rtdm_fd_mcasp_to_pru));
 #endif /* RTDM_PRUSS_IRQ_VERSION */
 #endif /* BELA_USE_RTDM */
 
@@ -1626,7 +1626,7 @@ void PRU::waitForFinish()
 #endif
 #ifdef BELA_USE_RTDM
 	int value;
-	__wrap_read(rtdm_fd_pru_to_arm, &value, sizeof(value));
+	BELA_RT_WRAP(read(rtdm_fd_pru_to_arm, &value, sizeof(value)));
 #endif
 	return;
 }
diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index d6ecff00d..3111c8227 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -292,7 +292,7 @@ static int batchCallbackLoop(InternalBelaContext* context, void (*render)(BelaCo
 	struct sched_param p = {
 		.sched_priority = priority,
 	};
-	__wrap_pthread_setschedparam(pthread_self(), SCHED_FIFO, &p);
+	BELA_RT_WRAP(pthread_setschedparam(pthread_self(), SCHED_FIFO, &p));
 
 	// clock_gettime is relatively expensive. We read it less often to
 	// minimise overhead. This means we lose a bit of accuracy in duration,
@@ -300,7 +300,7 @@ static int batchCallbackLoop(InternalBelaContext* context, void (*render)(BelaCo
 	const unsigned int kGetTimeIters = 10;
 	unsigned int nextGetTime = kGetTimeIters;
 	struct timespec begin, end;
-	if(__wrap_clock_gettime(CLOCK_MONOTONIC, &begin))
+	if(BELA_RT_WRAP(clock_gettime(CLOCK_MONOTONIC, &begin)))
 	{
 		fprintf(stderr, "Error in clock_gettime(): %d %s\n", errno, strerror(errno));
 		return 1;
@@ -314,7 +314,7 @@ static int batchCallbackLoop(InternalBelaContext* context, void (*render)(BelaCo
 			if(!nextGetTime--)
 			{
 				nextGetTime = kGetTimeIters;
-				__wrap_clock_gettime(CLOCK_MONOTONIC, &end);
+				BELA_RT_WRAP(clock_gettime(CLOCK_MONOTONIC, &end));
 				long long unsigned int elapsed = timespec_sub(&end, &begin);
 				if(elapsed > maxTimeNs)
 					break;
@@ -327,10 +327,10 @@ static int batchCallbackLoop(InternalBelaContext* context, void (*render)(BelaCo
 				break;
 		}
 		if(intervalMs)
-			__wrap_nanosleep(&ts, NULL);
+			BELA_RT_WRAP(nanosleep(&ts, NULL));
 	}
 	if(!maxTimeNs) // we may have already gotten a more accurate timestamp above
-		__wrap_clock_gettime(CLOCK_MONOTONIC, &end);
+		BELA_RT_WRAP(clock_gettime(CLOCK_MONOTONIC, &end));
 	long long unsigned int timeNs = timespec_sub(&end, &begin);
 	if(printStats)
 	{
@@ -371,12 +371,12 @@ extern "C" void Bela_initRtBackend()
 		// object (a mutex). If it fails with EPERM, Xenomai needs to be initialized
 		// See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
 		pthread_mutex_t dummyMutex;
-		int ret = __wrap_pthread_mutex_init(&dummyMutex, NULL);
+		int ret = BELA_RT_WRAP(pthread_mutex_init(&dummyMutex, NULL));
 		if(0 == ret) {
 			if(gRTAudioVerbose)
 				printf("Xenomai was inited by someone else\n");
 			// success: cleanup
-			__wrap_pthread_mutex_destroy(&dummyMutex);
+			BELA_RT_WRAP(pthread_mutex_destroy(&dummyMutex));
 		} else if (EPERM == ret) {
 			xenomaiNeedsInit = true;
 			if(gRTAudioVerbose)
@@ -838,7 +838,7 @@ void fifoRender(BelaContext* context, void* userData)
 				.tv_sec = 0,
 				.tv_nsec = 5 * 1000 * 1000,
 			};
-			__wrap_nanosleep(&ts, NULL);
+			BELA_RT_WRAP(nanosleep(&ts, NULL));
 		}
 	}
 	if(rctx)
@@ -970,14 +970,14 @@ void Bela_stopAudio()
 
 	// Now wait for threads to respond and actually stop...
 	void* threadReturnValue;
-	int ret = __wrap_pthread_join(gRTAudioThread, &threadReturnValue);
+	int ret = BELA_RT_WRAP(pthread_join(gRTAudioThread, &threadReturnValue));
 	if(ret)
 	{
 		fprintf(stderr, "Failed to join audio thread: (%d) %s\n", ret, strerror(ret));
 	}
 	if(gBcf)
 	{
-		ret = __wrap_pthread_join(gFifoThread, &threadReturnValue);
+		ret = BELA_RT_WRAP(pthread_join(gFifoThread, &threadReturnValue));
 		if(ret)
 			fprintf(stderr, "Failed to join audio fifo thread: (%d) %s\n", ret, strerror(ret));
 	}
@@ -1047,7 +1047,7 @@ void Bela_cpuTic(BelaCpuData* data)
 	if(!data || !data->count)
 		return;
 	struct timespec tic;
-	__wrap_clock_gettime(CLOCK_MONOTONIC, &tic);
+	BELA_RT_WRAP(clock_gettime(CLOCK_MONOTONIC, &tic));
 	long long unsigned int diff = timespec_sub(&tic, &data->tic);
 	data->tic = tic;
 	data->total += diff;
@@ -1065,7 +1065,7 @@ void Bela_cpuToc(BelaCpuData* data)
 {
 	if(!data || !data->count)
 		return;
-	__wrap_clock_gettime(CLOCK_MONOTONIC, &data->toc);
+	BELA_RT_WRAP(clock_gettime(CLOCK_MONOTONIC, &data->toc));
 	long long unsigned int diff = timespec_sub(&data->toc, &data->tic);
 	data->busy += diff;
 }
diff --git a/include/xenomai_wraps.h b/include/xenomai_wraps.h
index 26d51a065..427c73d20 100644
--- a/include/xenomai_wraps.h
+++ b/include/xenomai_wraps.h
@@ -15,38 +15,38 @@ extern "C" {
 
 // Forward declare __wrap_ versions of POSIX calls.
 // At link time, Xenomai will provide implementations for these
-int __wrap_nanosleep(const struct timespec *req, struct timespec *rem);
-int __wrap_pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
-int __wrap_pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param);
-int __wrap_pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param);
-int __wrap_pthread_yield(void);
-
-int __wrap_pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
-int __wrap_pthread_mutex_destroy(pthread_mutex_t *mutex);
-int __wrap_pthread_mutex_lock(pthread_mutex_t *mutex);
-int __wrap_pthread_mutex_trylock(pthread_mutex_t *mutex);
-int __wrap_pthread_mutex_unlock(pthread_mutex_t *mutex);
-
-int __wrap_pthread_cond_destroy(pthread_cond_t *cond);
-int __wrap_pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
-int __wrap_pthread_cond_signal(pthread_cond_t *cond);
-int __wrap_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
-
-int __wrap_socket(int protocol_family, int socket_type, int protocol);
-int __wrap_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen);
-int __wrap_bind(int fd, const struct sockaddr *my_addr, socklen_t addrlen);
-ssize_t __wrap_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
-
-mqd_t __wrap_mq_open(const char *name, int oflags, ...);
-int __wrap_mq_close(mqd_t mqdes);
-ssize_t __wrap_mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio);
-int __wrap_mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);
-int __wrap_mq_unlink(const char *name);
+int BELA_RT_WRAP(nanosleep(const struct timespec *req, struct timespec *rem));
+int BELA_RT_WRAP(pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg));
+int BELA_RT_WRAP(pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param));
+int BELA_RT_WRAP(pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param));
+int BELA_RT_WRAP(pthread_yield(void));
+
+int BELA_RT_WRAP(pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr));
+int BELA_RT_WRAP(pthread_mutex_destroy(pthread_mutex_t *mutex));
+int BELA_RT_WRAP(pthread_mutex_lock(pthread_mutex_t *mutex));
+int BELA_RT_WRAP(pthread_mutex_trylock(pthread_mutex_t *mutex));
+int BELA_RT_WRAP(pthread_mutex_unlock(pthread_mutex_t *mutex));
+
+int BELA_RT_WRAP(pthread_cond_destroy(pthread_cond_t *cond));
+int BELA_RT_WRAP(pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr));
+int BELA_RT_WRAP(pthread_cond_signal(pthread_cond_t *cond));
+int BELA_RT_WRAP(pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex));
+
+int BELA_RT_WRAP(socket(int protocol_family, int socket_type, int protocol));
+int BELA_RT_WRAP(setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen));
+int BELA_RT_WRAP(bind(int fd, const struct sockaddr *my_addr, socklen_t addrlen));
+ssize_t BELA_RT_WRAP(sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen));
+
+mqd_t BELA_RT_WRAP(mq_open(const char *name, int oflags, ...));
+int BELA_RT_WRAP(mq_close(mqd_t mqdes));
+ssize_t BELA_RT_WRAP(mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio));
+int BELA_RT_WRAP(mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio));
+int BELA_RT_WRAP(mq_unlink(const char *name));
 
 extern "C" void Bela_initRtBackend();
-int __wrap_pthread_join(pthread_t thread, void **retval);
-int __wrap_pthread_attr_init(pthread_attr_t *attr);
-int __wrap_sched_get_priority_max(int policy);
+int BELA_RT_WRAP(pthread_join(pthread_t thread, void **retval));
+int BELA_RT_WRAP(pthread_attr_init(pthread_attr_t *attr));
+int BELA_RT_WRAP(sched_get_priority_max(int policy));
 
 #include <rtdm/ipc.h>
 typedef long long int time_ns_t;
@@ -57,7 +57,7 @@ inline int task_sleep_ns(long long int timens)
 	struct timespec req;
 	req.tv_sec = timens/1000000000;
 	req.tv_nsec = timens - req.tv_sec * 1000000000;
-	return __wrap_nanosleep(&req, NULL);
+	return BELA_RT_WRAP(nanosleep(&req, NULL));
 }
 
 #include <error.h>
@@ -108,7 +108,7 @@ inline int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, in
 inline int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, pthread_callback_t* callback, void* arg)
 {
 	pthread_attr_t attr;
-	if(__wrap_pthread_attr_init(&attr))
+	if(BELA_RT_WRAP(pthread_attr_init(&attr)))
 	{
 		fprintf(stderr, "Error: unable to init thread attributes\n");
 		return -1;
@@ -117,11 +117,11 @@ inline int create_and_start_thread(pthread_t* task, const char* taskName, int pr
 	{
 		return ret;
 	}
-	if(int ret = __wrap_pthread_create(task, &attr, callback, arg))
+	if(int ret = BELA_RT_WRAP(pthread_create(task, &attr, callback, arg)))
 	{
 		return ret;
 	}
-	__wrap_pthread_setname_np(*task, taskName);
+	BELA_RT_WRAP(pthread_setname_np(*task, taskName));
 	// check that effective parameters match the ones we requested
 	//pthread_attr_t actualAttr;
 	//pthread_getattr_np(*task, &actualAttr);
@@ -142,7 +142,7 @@ inline int createXenomaiPipe(const char* portName, size_t poolsz)
 	 * endpoint is represented by a port number within the XDDP
 	 * protocol namespace.
 	 */
-	int s = __wrap_socket(AF_RTIPC, SOCK_DGRAM, IPCPROTO_XDDP);
+	int s = BELA_RT_WRAP(socket(AF_RTIPC, SOCK_DGRAM, IPCPROTO_XDDP));
 	if (s < 0) {
 		fprintf(stderr, "Failed call to socket: %d %s\n", errno, strerror(errno));
 		return -1;
@@ -185,7 +185,7 @@ inline int createXenomaiPipe(const char* portName, size_t poolsz)
 	memset(&saddr, 0, sizeof(saddr));
 	saddr.sipc_family = AF_RTIPC;
 	saddr.sipc_port = -1; // automatically assign port number
-	ret = __wrap_bind(s, (struct sockaddr *)&saddr, sizeof(saddr));
+	ret = BELA_RT_WRAP(bind(s, (struct sockaddr *)&saddr, sizeof(saddr)));
 	if (ret)
 	{
 		fprintf(stderr, "Failed call to __wrap_bind: %d %s\n", errno, strerror(errno));
diff --git a/libraries/Midi/Midi.cpp b/libraries/Midi/Midi.cpp
index 29009572d..4f1792ff5 100644
--- a/libraries/Midi/Midi.cpp
+++ b/libraries/Midi/Midi.cpp
@@ -468,7 +468,7 @@ int Midi::writeOutput(midi_byte_t* bytes, unsigned int length){
 		// which would result in incomplete messages being retrieved at
 		// the other end of the pipe.
 		ssize_t size = length < outputBytes.size() ? length : outputBytes.size();
-		int ret = __wrap_sendto(sock, bytes, size, 0, NULL, 0);
+		int ret = BELA_RT_WRAP(sendto(sock, bytes, size, 0, NULL, 0));
 		if (ret != size){
 			rt_fprintf(stderr, "Error while streaming to pipe %s: %s\n", outPipeName, strerror(-ret));
 			return -1;
diff --git a/libraries/Pipe/Pipe.cpp b/libraries/Pipe/Pipe.cpp
index 0e9f4dd5d..bc25890c9 100644
--- a/libraries/Pipe/Pipe.cpp
+++ b/libraries/Pipe/Pipe.cpp
@@ -46,14 +46,14 @@ bool Pipe::setup(const std::string& pipeName, size_t size, bool newBlockingRt, b
 void Pipe::setBlockingRt(bool blocking)
 {
 	blockingRt = blocking;
-	int flags = __wrap_fcntl(pipeSocket, F_GETFL);
+	int flags = BELA_RT_WRAP(fcntl(pipeSocket, F_GETFL));
 	if(blocking)
 	{
 		flags ^= O_NONBLOCK;
 	} else {
 		flags |= O_NONBLOCK;
 	}
-	if(int ret = __wrap_fcntl(pipeSocket, F_SETFL, flags))
+	if(int ret = BELA_RT_WRAP(fcntl(pipeSocket, F_SETFL, flags)))
 	{
 		fprintf(stderr, "Unable to set socket non blocking\n");
 	}
@@ -88,7 +88,7 @@ void Pipe::setTimeoutMsNonRt(double timeoutMs)
 void Pipe::cleanup()
 {
 	close(fd);
-	__wrap_close(pipeSocket);
+	BELA_RT_WRAP(close(pipeSocket));
 }
 
 bool Pipe::_writeNonRt(void* ptr, size_t size)
@@ -103,7 +103,7 @@ bool Pipe::_writeNonRt(void* ptr, size_t size)
 
 bool Pipe::_writeRt(void* ptr, size_t size)
 {
-	ssize_t ret = __wrap_send(pipeSocket, (void*)ptr, size, 0);
+	ssize_t ret = BELA_RT_WRAP(send(pipeSocket, (void*)ptr, size, 0));
 	if(ret < 0 || ret != size)
 	{
 		return false;
@@ -125,7 +125,7 @@ ssize_t Pipe::_readRtNonRt(void* ptr, size_t size, bool rt)
 {
 	bool blocking = rt ? blockingRt : blockingNonRt;
 	double timeoutMs = rt ? timeoutMsRt : timeoutMsNonRt;
-	int (*_select)(int, fd_set*, fd_set*, fd_set*, struct timeval*) = rt ? __wrap_select : select;
+	int (*_select)(int, fd_set*, fd_set*, fd_set*, struct timeval*) = rt ? BELA_RT_WRAP(select : select);
 	int file = rt ? pipeSocket : fd;
 	bool doIt = false;
 	int ret = 0;
@@ -143,7 +143,7 @@ ssize_t Pipe::_readRtNonRt(void* ptr, size_t size, bool rt)
 	}
 	if(!blocking || doIt){
 		if(rt)
-			ret = __wrap_recv(file, ptr, size, 0);
+			ret = BELA_RT_WRAP(recv(file, ptr, size, 0));
 		else
 			ret = read(file, ptr, size);
 	}

From cb5c258c4db53d26330a0f8469d60e18a7085174 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 19 Jun 2022 13:37:50 +0000
Subject: [PATCH 110/188] Xenomai: factored out __wrap_ to BELA_RT_WRAP()

This commit contains the manual changes done to fix what was not caught by sed in the previous commit. Inlcudes some changes to releavant comments
---
 core/AuxiliaryTasks.cpp | 12 ++++++------
 core/PRU.cpp            |  4 ++--
 include/DataFifo.h      |  2 +-
 include/xenomai_wraps.h | 18 +++++++++---------
 4 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index 73d685c0f..a33402951 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -89,15 +89,15 @@ int Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 		// until the other starts.
 		struct sched_param param;
 		int policy;
-		int ret = __wrap_pthread_getschedparam(taskToSchedule->task,
-				&policy, &param);
+		int ret = BELA_RT_WRAP(pthread_getschedparam(taskToSchedule->task,
+				&policy, &param));
 		if(!ret)
 		{
 			// set the priority to maximum
 			int originalPriority = param.sched_priority;
 			param.sched_priority = BELA_RT_WRAP(sched_get_priority_max(SCHED_FIFO));
-			__wrap_pthread_setschedparam(taskToSchedule->task,
-					SCHED_FIFO, &param);
+			BELA_RT_WRAP(pthread_setschedparam(taskToSchedule->task,
+					SCHED_FIFO, &param));
 			// just in case we have the same priority, let the
 			// other go first
 			BELA_RT_WRAP(pthread_yield());
@@ -107,8 +107,8 @@ int Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 			// started flag, and is now waiting for the cond
 			// So, restore its schedparams
 			param.sched_priority = originalPriority;
-			__wrap_pthread_setschedparam(taskToSchedule->task,
-					policy, &param);
+			BELA_RT_WRAP(pthread_setschedparam(taskToSchedule->task,
+					policy, &param));
 		}
 	}
 	if(int ret = BELA_RT_WRAP(pthread_mutex_trylock(&taskToSchedule->mutex)))
diff --git a/core/PRU.cpp b/core/PRU.cpp
index 9087c7d53..b5239a494 100644
--- a/core/PRU.cpp
+++ b/core/PRU.cpp
@@ -753,7 +753,7 @@ int PRU::start(char * const filename, const McaspRegisters& mcaspRegisters)
         // it will often hang the system (especially for small blocksizes).
         // Not sure why this would happen, perhaps a race condition between the PRU
         // and the rtdm_driver?
-        if ((rtdm_fd_pru_to_arm = __wrap_open(rtdm_driver, O_RDWR)) < 0) {
+        if ((rtdm_fd_pru_to_arm = BELA_RT_WRAP(open(rtdm_driver, O_RDWR))) < 0) {
                 fprintf(stderr, "Failed to open the kernel driver: (%d) %s.\n", errno, strerror(errno));
                 if(errno == EBUSY) // Device or resource busy
                 {
@@ -785,7 +785,7 @@ int PRU::start(char * const filename, const McaspRegisters& mcaspRegisters)
         }
         if(pruUsesMcaspIrq)
 	{
-                if ((rtdm_fd_mcasp_to_pru = __wrap_open(rtdm_driver, O_RDWR)) < 0) {
+                if ((rtdm_fd_mcasp_to_pru = BELA_RT_WRAP(open(rtdm_driver, O_RDWR))) < 0) {
                         fprintf(stderr, "Unable to open rtdm driver to register McASP interrupts: (%d) %s.\n", errno, strerror(errno));
                         return 1;
                 }
diff --git a/include/DataFifo.h b/include/DataFifo.h
index f97399c21..7fbdafe3e 100644
--- a/include/DataFifo.h
+++ b/include/DataFifo.h
@@ -3,7 +3,7 @@
 #include <string>
 /**
 * Uni-directional RT-safe-queue.
-* A light wrapper around __wrap_mq_...
+* A light wrapper around mq_...
 */
 class DataFifo
 {
diff --git a/include/xenomai_wraps.h b/include/xenomai_wraps.h
index 427c73d20..5466c58c1 100644
--- a/include/xenomai_wraps.h
+++ b/include/xenomai_wraps.h
@@ -13,8 +13,8 @@ extern "C" {
 #include <mqueue.h>
 #include <sys/socket.h>
 
-// Forward declare __wrap_ versions of POSIX calls.
-// At link time, Xenomai will provide implementations for these
+// Forward declare wrapped versions of POSIX calls.
+// if BELA_RT_WRAP is __WRAP, then at link time, Xenomai's libcobalt will provide implementations for these
 int BELA_RT_WRAP(nanosleep(const struct timespec *req, struct timespec *rem));
 int BELA_RT_WRAP(pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg));
 int BELA_RT_WRAP(pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param));
@@ -154,11 +154,11 @@ inline int createXenomaiPipe(const char* portName, size_t poolsz)
 	 */
 	struct rtipc_port_label plabel;
 	strcpy(plabel.label, portName);
-	int ret = __wrap_setsockopt(s, SOL_XDDP, XDDP_LABEL,
-			 &plabel, sizeof(plabel));
+	int ret = BELA_RT_WRAP(setsockopt(s, SOL_XDDP, XDDP_LABEL,
+			 &plabel, sizeof(plabel)));
 	if(ret)
 	{
-		fprintf(stderr, "Failed call to __wrap_setsockopt SOL_XDDP XDDP_LABEL: %d %s\n", errno, strerror(errno));
+		fprintf(stderr, "Failed call to setsockopt SOL_XDDP XDDP_LABEL: %d %s\n", errno, strerror(errno));
 		return -1;
 	}
 
@@ -169,11 +169,11 @@ inline int createXenomaiPipe(const char* portName, size_t poolsz)
 	 */
 	if(poolsz == 0)
 		poolsz = 16384; /* bytes */
-	ret = __wrap_setsockopt(s, SOL_XDDP, XDDP_POOLSZ,
-			 &poolsz, sizeof(poolsz));
+	ret = BELA_RT_WRAP(setsockopt(s, SOL_XDDP, XDDP_POOLSZ,
+			 &poolsz, sizeof(poolsz)));
 	if(ret)
 	{
-		fprintf(stderr, "Failed call to __wrap_setsockopt SOL_XDDP XDDP_POOLSZ: %d %s\n", errno, strerror(errno));
+		fprintf(stderr, "Failed call to setsockopt SOL_XDDP XDDP_POOLSZ: %d %s\n", errno, strerror(errno));
 		return -1;
 	}
 
@@ -188,7 +188,7 @@ inline int createXenomaiPipe(const char* portName, size_t poolsz)
 	ret = BELA_RT_WRAP(bind(s, (struct sockaddr *)&saddr, sizeof(saddr)));
 	if (ret)
 	{
-		fprintf(stderr, "Failed call to __wrap_bind: %d %s\n", errno, strerror(errno));
+		fprintf(stderr, "Failed call to bind: %d %s\n", errno, strerror(errno));
 		return -1;
 	}
 	return s;

From e296935b142248e10ec95a4149c960f4740395b2 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 19 Jun 2022 13:44:38 +0000
Subject: [PATCH 111/188] Xenomai: properly define BELA_RT_WRAP so that the
 default behaviour is still to use libcobalt's __wrap_ for all calls changed
 in the previous two commits

---
 Makefile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index ac5ec2476..48cf1c8e4 100644
--- a/Makefile
+++ b/Makefile
@@ -264,10 +264,11 @@ LEGACY_INCLUDE_PATH := ./include/legacy
 
 INCLUDES := -I$(PROJECT_DIR) -I$(LEGACY_INCLUDE_PATH)  -I./include -I./build/pru/ -I./
 BELA_USE_DEFINE?=BELA_USE_RTDM
+BELA_RT_WRAP_FLAGS?=-DBELA_RT_WRAP=__WRAP
 
 ARCH_FLAGS?=-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=hard
 
-DEFAULT_COMMON_FLAGS := $(DEFAULT_XENOMAI_CFLAGS) -O3 -g $(ARCH_FLAGS) -ftree-vectorize -ffast-math -DNDEBUG -D$(BELA_USE_DEFINE) -I$(BASE_DIR)/resources/$(DEBIAN_VERSION)/include -DENABLE_PRU_UIO=1
+DEFAULT_COMMON_FLAGS := $(DEFAULT_XENOMAI_CFLAGS) -O3 -g $(ARCH_FLAGS) -ftree-vectorize -ffast-math -DNDEBUG -D$(BELA_USE_DEFINE) -I$(BASE_DIR)/resources/$(DEBIAN_VERSION)/include -DENABLE_PRU_UIO=1 $(BELA_RT_WRAP_FLAGS)
 ifeq ($(SHARED),1)
 DEFAULT_COMMON_FLAGS+= -fPIC
 PROJ_INFIX=.fpic

From 59abd6abbf8e99716e8d47ce13c714261e73add8 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 19 Jun 2022 14:38:02 +0000
Subject: [PATCH 112/188] Xenomai: replace createXenomaiPipe() with
 createBelaRtPipe(), which is still to be implemented without __COBALT__

---
 core/AuxTaskNonRT.cpp   |  2 +-
 include/xenomai_wraps.h | 13 +++++++++++--
 libraries/Midi/Midi.cpp |  2 +-
 libraries/Pipe/Pipe.cpp |  2 +-
 4 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index dabe2b0a0..0107699fb 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -46,7 +46,7 @@ void AuxTaskNonRT::__create(){
 	// create an rt_pipe
 	std::string p_name = "p_" + name;
 	int pipeSize = 65536 * 10;
-	int ret = createXenomaiPipe(p_name.c_str(), pipeSize);
+	int ret = createBelaRtPipe(p_name.c_str(), pipeSize);
 	pipeSocket = ret;
 	if(ret <= 0)
 	{
diff --git a/include/xenomai_wraps.h b/include/xenomai_wraps.h
index 5466c58c1..adb81a325 100644
--- a/include/xenomai_wraps.h
+++ b/include/xenomai_wraps.h
@@ -48,7 +48,6 @@ int BELA_RT_WRAP(pthread_join(pthread_t thread, void **retval));
 int BELA_RT_WRAP(pthread_attr_init(pthread_attr_t *attr));
 int BELA_RT_WRAP(sched_get_priority_max(int policy));
 
-#include <rtdm/ipc.h>
 typedef long long int time_ns_t;
 typedef void *(pthread_callback_t)(void *);
 
@@ -133,8 +132,12 @@ inline int create_and_start_thread(pthread_t* task, const char* taskName, int pr
 	return 0;
 }
 
+#ifdef __COBALT__
+#include <rtdm/ipc.h>
+#endif // __COBALT__
+inline int createBelaRtPipe(const char* portName, int poolsz)
+#ifdef __COBALT__
 // from xenomai-3/demo/posix/cobalt/xddp-echo.c
-inline int createXenomaiPipe(const char* portName, size_t poolsz)
 {
 	Bela_initRtBackend();
 	/*
@@ -193,6 +196,12 @@ inline int createXenomaiPipe(const char* portName, size_t poolsz)
 	}
 	return s;
 }
+#else // __COBALT__
+{
+#warning BelaRtPipe unsupported without COBALT
+	return -1;
+}
+#endif //__COBALT__
 
 #ifdef __cplusplus
 }
diff --git a/libraries/Midi/Midi.cpp b/libraries/Midi/Midi.cpp
index 4f1792ff5..75cfdd351 100644
--- a/libraries/Midi/Midi.cpp
+++ b/libraries/Midi/Midi.cpp
@@ -326,7 +326,7 @@ int Midi::writeTo(const char* port){
 	outPipeName = (char*)malloc((size + 1)*sizeof(char));
 	snprintf(outPipeName, size + 1, outPipeNameTemplateString, outId);
 	int ret;
-	ret = createXenomaiPipe(outId, 0);
+	ret = createBelaRtPipe(outId, 0);
 	sock = ret;
 	if(ret <= 0){
 		fprintf(stderr, "Error while creating pipe %s: %s\n", outId, strerror(-ret));
diff --git a/libraries/Pipe/Pipe.cpp b/libraries/Pipe/Pipe.cpp
index bc25890c9..308e85d19 100644
--- a/libraries/Pipe/Pipe.cpp
+++ b/libraries/Pipe/Pipe.cpp
@@ -18,7 +18,7 @@ bool Pipe::setup(const std::string& pipeName, size_t size, bool newBlockingRt, b
 	pipeSize = size;
 
 	name = "p_" + pipeName;
-	int ret = createXenomaiPipe(name.c_str(), pipeSize);
+	int ret = createBelaRtPipe(name.c_str(), pipeSize);
 	if(ret < 0)
 	{
 		fprintf(stderr, "Unable to create pipe %s with %u bytes: (%i) %s\n", name.c_str(), pipeSize, ret, strerror(ret));

From 07dec81316f8cacc5cbbcbc668329c22a37b152b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 10 Jul 2022 17:34:34 +0000
Subject: [PATCH 113/188] Do not check for existing instance or initialise
 Xenomai if not __COBALT__

---
 core/RTAudio.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 3111c8227..cc17c5668 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -31,8 +31,7 @@
 #include "../include/BelaContextFifo.h"
 #include "../include/MiscUtilities.h"
 
-// Xenomai-specific includes
-#include <xenomai/init.h>
+int gXenomaiInited = 0;
 
 #include <pthread.h>
 
@@ -169,7 +168,6 @@ void Bela_HwConfig_delete(BelaHwConfig* cfg)
 // Real-time tasks and objects
 pthread_t gRTAudioThread;
 static pthread_t gFifoThread;
-int gXenomaiInited = 0;
 static const char gRTAudioThreadName[] = "bela-audio";
 static const char gFifoThreadName[] = "bela-audio-fifo";
 
@@ -400,7 +398,8 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 	if(!settings)
 		return -1;
 	Bela_setVerboseLevel(settings->verbose);
-	// Before we go ahead, let's check if Bela is alreadt running:
+#ifdef __COBALT__
+	// Before we go ahead, let's check if Bela is already running:
 	// check if another real-time thread of the same name is already running.
 	char command[200];
 	char pathToXenomaiStat[] = "/proc/xenomai/sched/stat";
@@ -411,6 +410,7 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 		fprintf(stderr, "Error: Bela is already running in another process. Cannot start.\n");
 		return -1;
 	}
+#endif // __COBALT__
 	Bela_initRtBackend();
 #ifdef XENOMAI_CATCH_MSW
 	struct sigaction sa;

From 16877f3aed3215af785ee2d6fa3b9e15a694b710 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 19 Jun 2022 15:10:34 +0000
Subject: [PATCH 114/188] Makefile: introducing BELA_RT_BACKEND to select
 between xenomai and another

Currently only _somehow_ supported by Makefile.libraries. It should work
when called through the main Makefile, but this needs a bigger refactoring
---
 Makefile           | 18 ++++++++++++++++--
 Makefile.libraries |  5 +++--
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index 48cf1c8e4..50ff43181 100644
--- a/Makefile
+++ b/Makefile
@@ -204,13 +204,16 @@ BELA_AUDIO_THREAD_NAME?=bela-audio
 XENO_CONFIG=/usr/xenomai/bin/xeno-config
 XENOMAI_SKIN=posix
 
+BELA_RT_BACKEND ?=xenomai
 # Find out what system we are running on and set system-specific variables
 # We cache these in $(SYSTEM_SPECIFIC_MAKEFILE) after every boot
-SYSTEM_SPECIFIC_MAKEFILE=/tmp/BelaMakefile.inc
+SYSTEM_SPECIFIC_MAKEFILE=/tmp/BelaMakefile-$(strip $(BELA_RT_BACKEND)).inc
 -include $(SYSTEM_SPECIFIC_MAKEFILE)
 ifeq ($(DEBIAN_VERSION),)
 # If they are not there, let's go find out ...
 DEBIAN_VERSION=$(shell grep "VERSION=" /etc/os-release | sed "s/.*(\(.*\)).*/\1/g")
+
+ifeq ($(strip $(BELA_RT_BACKEND)),xenomai)
 # Lazily, let's assume if we are not on 2.6 we are on 3. I sincerely hope we will survive till Xenomai 4 to see this fail
 XENOMAI_VERSION=$(shell $(XENO_CONFIG) --version | grep -o "2\.6" || echo "3")
 
@@ -225,6 +228,9 @@ DEFAULT_XENOMAI_LDFLAGS := $(filter-out -no-pie, $(DEFAULT_XENOMAI_LDFLAGS))
 DEFAULT_XENOMAI_LDFLAGS := $(filter-out -fno-pie, $(DEFAULT_XENOMAI_LDFLAGS))
 # remove posix wrappers if present: explicitly call __wrap_pthread_... when needed
 DEFAULT_XENOMAI_LDFLAGS := $(filter-out -Wlusr/xenomai/lib/cobalt.wrappers, $(DEFAULT_XENOMAI_LDFLAGS))
+else # BELA_RT_BACKEND is something else
+XENOMAI_VERSION:=none
+endif
 
 #... and cache them to the file
 $(shell printf "DEBIAN_VERSION=$(DEBIAN_VERSION)\nXENOMAI_VERSION=$(XENOMAI_VERSION)\nDEFAULT_XENOMAI_CFLAGS=$(DEFAULT_XENOMAI_CFLAGS)\nDEFAULT_XENOMAI_LDFLAGS=$(DEFAULT_XENOMAI_LDFLAGS)\n" > $(SYSTEM_SPECIFIC_MAKEFILE) )
@@ -263,8 +269,16 @@ RM := rm -rf
 LEGACY_INCLUDE_PATH := ./include/legacy
 
 INCLUDES := -I$(PROJECT_DIR) -I$(LEGACY_INCLUDE_PATH)  -I./include -I./build/pru/ -I./
+
+ifeq ($(strip $(BELA_RT_BACKEND)), xenomai)
 BELA_USE_DEFINE?=BELA_USE_RTDM
 BELA_RT_WRAP_FLAGS?=-DBELA_RT_WRAP=__WRAP
+BELA_RT_BACKEND_LDLIBS :=$(DEFAULT_XENOMAI_LDFLAGS)
+else # if BELA_RT_BACKEND is not xenomai, hardcode some stuff
+BELA_USE_DEFINE?=BELA_USE_POLL
+BELA_RT_WRAP_FLAGS?="-DBELA_RT_WRAP(call)=call" -Drt_printf=printf -D rt_fprintf=fprintf
+BELA_RT_BACKEND_LDLIBS := -lpthread -lrt
+endif
 
 ARCH_FLAGS?=-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=hard
 
@@ -278,7 +292,7 @@ endif # SHARED
 DEFAULT_CPPFLAGS := $(DEFAULT_COMMON_FLAGS) -std=c++11
 DEFAULT_CFLAGS := $(DEFAULT_COMMON_FLAGS) -std=gnu11
 BELA_LDFLAGS = -Llib/ -Wl,--as-needed
-BELA_CORE_LDLIBS = $(DEFAULT_XENOMAI_LDFLAGS) -lprussdrv -lstdc++ # libraries needed by core code (libbela.so)
+BELA_CORE_LDLIBS = $(BELA_RT_BACKEND_LDLIBS) -lprussdrv -lstdc++ # libraries needed by core code (libbela.so)
 BELA_EXTRA_LDLIBS = -lasound -lseasocks -lNE10 # additional libraries needed by extra code (libbelaextra.so), taken from the dependencies of the libraries of the objects included in $(LIB_EXTRA_OBJS)
 BELA_LDLIBS := $(BELA_CORE_LDLIBS)
 BELA_LDLIBS := $(filter-out -lstdc++,$(BELA_LDLIBS))
diff --git a/Makefile.libraries b/Makefile.libraries
index 01dcd8e33..8afec3279 100644
--- a/Makefile.libraries
+++ b/Makefile.libraries
@@ -13,12 +13,13 @@ AT?=@
 BELA_USE_DEFINE:=BELA_USE_RTDM
 DEBIAN_VERSION :=stretch
 BASE_DIR:=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
-DEFAULT_COMMON_FLAGS := -O3 -g -march=armv7-a -mtune=cortex-a8 -mfloat-abi=hard -mfpu=neon -ftree-vectorize -ffast-math -fPIC
+DEFAULT_COMMON_FLAGS ?= -O3 -g -march=armv7-a -mtune=cortex-a8 -mfloat-abi=hard -mfpu=neon -ftree-vectorize -ffast-math -fPIC
 LIBRARY_CXXFLAGS := $(DEFAULT_COMMON_FLAGS) -std=c++11
 LIBRARY_CFLAGS := $(DEFAULT_COMMON_FLAGS) -std=gnu11
 
+BELA_RT_BACKEND ?=xenomai
 #all this Xenomai stuff is just for Midi.h at the moment and requires you to have run the Bela Makefile before
-SYSTEM_SPECIFIC_MAKEFILE=/tmp/BelaMakefile.inc
+SYSTEM_SPECIFIC_MAKEFILE=/tmp/BelaMakefile-$(strip $(BELA_RT_BACKEND)).inc
 include $(SYSTEM_SPECIFIC_MAKEFILE)
 $(SYSTEM_SPECIFIC_MAKEFILE):
 	make lib

From e460550268b6d83de0b04260dcfcbbc7627417c7 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 22 Aug 2022 17:32:42 +0000
Subject: [PATCH 115/188] RtWrappers: renamed xenomai_wraps.h to RtWrappers.h
 and moved implementations to RtWrappers.cpp

---
 Makefile                                      |  2 +-
 core/AuxTaskNonRT.cpp                         |  2 +-
 core/AuxTaskRT.cpp                            |  2 +-
 core/AuxiliaryTasks.cpp                       |  3 +-
 core/PRU.cpp                                  |  2 +-
 core/RTAudio.cpp                              |  2 +-
 .../xenomai_wraps.h => core/RtWrappers.cpp    | 69 ++----------------
 include/RtWrappers.h                          | 71 +++++++++++++++++++
 8 files changed, 85 insertions(+), 68 deletions(-)
 rename include/xenomai_wraps.h => core/RtWrappers.cpp (54%)
 create mode 100644 include/RtWrappers.h

diff --git a/Makefile b/Makefile
index 50ff43181..6d401b9db 100644
--- a/Makefile
+++ b/Makefile
@@ -392,7 +392,7 @@ CORE_ASM_SRCS := $(wildcard core/*.S)
 CORE_ASM_OBJS := $(addprefix build/core/,$(notdir $(CORE_ASM_SRCS:.S=.o)))
 ALL_DEPS += $(addprefix build/core/,$(notdir $(CORE_ASM_SRCS:.S=.d)))
 
-CORE_CORE_OBJS := build/core/RTAudio.o build/core/PRU.o build/core/RTAudioCommandLine.o build/core/I2c_Codec.o build/core/I2c_MultiTLVCodec.o build/core/I2c_MultiI2sCodec.o build/core/I2c_MultiTdmCodec.o build/core/Spi_Codec.o build/core/Es9080_Codec.o build/core/Tlv320_Es9080_Codec.o build/core/math_runfast.o build/core/GPIOcontrol.o build/core/PruBinary.o build/core/board_detect.o build/core/DataFifo.o build/core/BelaContextFifo.o build/core/BelaContextSplitter.o build/core/MiscUtilities.o build/core/Mmap.o build/core/Mcasp.o build/core/PruManager.o build/core/FormatConvert.o
+CORE_CORE_OBJS := build/core/RTAudio.o build/core/PRU.o build/core/RTAudioCommandLine.o build/core/I2c_Codec.o build/core/I2c_MultiTLVCodec.o build/core/I2c_MultiI2sCodec.o build/core/I2c_MultiTdmCodec.o build/core/Spi_Codec.o build/core/Es9080_Codec.o build/core/Tlv320_Es9080_Codec.o build/core/math_runfast.o build/core/GPIOcontrol.o build/core/PruBinary.o build/core/board_detect.o build/core/DataFifo.o build/core/BelaContextFifo.o build/core/BelaContextSplitter.o build/core/MiscUtilities.o build/core/Mmap.o build/core/Mcasp.o build/core/PruManager.o build/core/FormatConvert.o build/core/RtWrappers.o
 EXTRA_CORE_OBJS := $(filter-out $(CORE_CORE_OBJS), $(CORE_OBJS)) $(filter-out $(CORE_CORE_OBJS),$(CORE_ASM_OBJS))
 # Objects for a system-supplied default main() file, if the user
 # only wants to provide the render functions.
diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index 0107699fb..7f4aa604a 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -1,7 +1,7 @@
 /***** AuxTaskNonRT.cpp *****/
 #include "../include/Bela.h"
 #include <AuxTaskNonRT.h>
-#include "../include/xenomai_wraps.h"
+#include "../include/RtWrappers.h"
 #include <fcntl.h>
 #include <stdlib.h>
 #include <errno.h>
diff --git a/core/AuxTaskRT.cpp b/core/AuxTaskRT.cpp
index 016248d1c..39fcc4268 100644
--- a/core/AuxTaskRT.cpp
+++ b/core/AuxTaskRT.cpp
@@ -1,6 +1,6 @@
 /***** AuxTaskRT.cpp *****/
 #include <AuxTaskRT.h>
-#include "../include/xenomai_wraps.h"
+#include "../include/RtWrappers.h"
 #include <Bela.h>
 #include <stdlib.h>
 #include <vector>
diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index a33402951..c82c9c5a5 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -4,7 +4,8 @@
 #include <iostream>
 #include <string.h>
 
-#include "../include/xenomai_wraps.h"
+#include <pthread.h>
+#include "../include/RtWrappers.h"
 
 using namespace std;
 //
diff --git a/core/PRU.cpp b/core/PRU.cpp
index b5239a494..88789d9f7 100644
--- a/core/PRU.cpp
+++ b/core/PRU.cpp
@@ -64,7 +64,7 @@ static int rtdm_fd_mcasp_to_pru = 0;
 // Xenomai-specific includes
 #include <pthread.h>
 
-#include "../include/xenomai_wraps.h"
+#include "../include/RtWrappers.h"
 
 using namespace std;
 using namespace BelaHwComponent;
diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index cc17c5668..7e144eeb2 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -35,7 +35,7 @@ int gXenomaiInited = 0;
 
 #include <pthread.h>
 
-#include "../include/xenomai_wraps.h"
+#include "../include/RtWrappers.h"
 
 #include "../include/PRU.h"
 #include "../include/I2c_Codec.h"
diff --git a/include/xenomai_wraps.h b/core/RtWrappers.cpp
similarity index 54%
rename from include/xenomai_wraps.h
rename to core/RtWrappers.cpp
index adb81a325..32c7e58fc 100644
--- a/include/xenomai_wraps.h
+++ b/core/RtWrappers.cpp
@@ -1,57 +1,12 @@
-#ifndef XENOMAI_WRAPS_H
-#define XENOMAI_WRAPS_H
-
-#include "Bela.h"
-#include <time.h>
+#include "../include/RtWrappers.h"
 #include <stdio.h>
 #include <string.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 #include <pthread.h>
 #include <mqueue.h>
 #include <sys/socket.h>
 
-// Forward declare wrapped versions of POSIX calls.
-// if BELA_RT_WRAP is __WRAP, then at link time, Xenomai's libcobalt will provide implementations for these
-int BELA_RT_WRAP(nanosleep(const struct timespec *req, struct timespec *rem));
-int BELA_RT_WRAP(pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg));
-int BELA_RT_WRAP(pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param));
-int BELA_RT_WRAP(pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param));
-int BELA_RT_WRAP(pthread_yield(void));
-
-int BELA_RT_WRAP(pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr));
-int BELA_RT_WRAP(pthread_mutex_destroy(pthread_mutex_t *mutex));
-int BELA_RT_WRAP(pthread_mutex_lock(pthread_mutex_t *mutex));
-int BELA_RT_WRAP(pthread_mutex_trylock(pthread_mutex_t *mutex));
-int BELA_RT_WRAP(pthread_mutex_unlock(pthread_mutex_t *mutex));
-
-int BELA_RT_WRAP(pthread_cond_destroy(pthread_cond_t *cond));
-int BELA_RT_WRAP(pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr));
-int BELA_RT_WRAP(pthread_cond_signal(pthread_cond_t *cond));
-int BELA_RT_WRAP(pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex));
-
-int BELA_RT_WRAP(socket(int protocol_family, int socket_type, int protocol));
-int BELA_RT_WRAP(setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen));
-int BELA_RT_WRAP(bind(int fd, const struct sockaddr *my_addr, socklen_t addrlen));
-ssize_t BELA_RT_WRAP(sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen));
-
-mqd_t BELA_RT_WRAP(mq_open(const char *name, int oflags, ...));
-int BELA_RT_WRAP(mq_close(mqd_t mqdes));
-ssize_t BELA_RT_WRAP(mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio));
-int BELA_RT_WRAP(mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio));
-int BELA_RT_WRAP(mq_unlink(const char *name));
-
-extern "C" void Bela_initRtBackend();
-int BELA_RT_WRAP(pthread_join(pthread_t thread, void **retval));
-int BELA_RT_WRAP(pthread_attr_init(pthread_attr_t *attr));
-int BELA_RT_WRAP(sched_get_priority_max(int policy));
-
-typedef long long int time_ns_t;
-typedef void *(pthread_callback_t)(void *);
-
-inline int task_sleep_ns(long long int timens)
+int task_sleep_ns(long long int timens)
 {
 	struct timespec req;
 	req.tv_sec = timens/1000000000;
@@ -60,14 +15,9 @@ inline int task_sleep_ns(long long int timens)
 }
 
 #include <error.h>
-//void error(int exitCode, int errno, char* message)
-//{
-	//fprintf(stderr, "Error during `%s`: %d %s\n", message, errno, strerror(errno));
-	//exit(exitCode);
-//}
 
 // got this from xenomai-3/testsuite/latency/latency.c
-inline void setup_sched_parameters(pthread_attr_t *attr, int prio)
+void setup_sched_parameters(pthread_attr_t *attr, int prio)
 {
 	struct sched_param p;
 	int ret;
@@ -85,7 +35,7 @@ inline void setup_sched_parameters(pthread_attr_t *attr, int prio)
 		error(1, ret, "pthread_attr_setschedparam()");
 }
 
-inline int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, int prio)
+int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, int prio)
 {
 	if(pthread_attr_setdetachstate(attr, PTHREAD_CREATE_JOINABLE))
 	{
@@ -104,7 +54,8 @@ inline int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, in
 	setup_sched_parameters(attr, prio);
 	return 0;
 }
-inline int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, pthread_callback_t* callback, void* arg)
+
+int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, pthread_callback_t* callback, void* arg)
 {
 	pthread_attr_t attr;
 	if(BELA_RT_WRAP(pthread_attr_init(&attr)))
@@ -135,7 +86,7 @@ inline int create_and_start_thread(pthread_t* task, const char* taskName, int pr
 #ifdef __COBALT__
 #include <rtdm/ipc.h>
 #endif // __COBALT__
-inline int createBelaRtPipe(const char* portName, int poolsz)
+int createBelaRtPipe(const char* portName, int poolsz)
 #ifdef __COBALT__
 // from xenomai-3/demo/posix/cobalt/xddp-echo.c
 {
@@ -202,9 +153,3 @@ inline int createBelaRtPipe(const char* portName, int poolsz)
 	return -1;
 }
 #endif //__COBALT__
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* XENOMAI_WRAPS_H */
diff --git a/include/RtWrappers.h b/include/RtWrappers.h
new file mode 100644
index 000000000..1487610a0
--- /dev/null
+++ b/include/RtWrappers.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <time.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <pthread.h>
+#include <mqueue.h>
+#include <sys/socket.h>
+
+// Forward declare wrapped versions of POSIX calls.
+// if BELA_RT_WRAP is __WRAP, then at link time, Xenomai's libcobalt will provide implementations for these
+int BELA_RT_WRAP(nanosleep(const struct timespec *req, struct timespec *rem));
+int BELA_RT_WRAP(pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg));
+int BELA_RT_WRAP(pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param));
+int BELA_RT_WRAP(pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param));
+int BELA_RT_WRAP(pthread_yield(void));
+
+int BELA_RT_WRAP(pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr));
+int BELA_RT_WRAP(pthread_mutex_destroy(pthread_mutex_t *mutex));
+int BELA_RT_WRAP(pthread_mutex_lock(pthread_mutex_t *mutex));
+int BELA_RT_WRAP(pthread_mutex_trylock(pthread_mutex_t *mutex));
+int BELA_RT_WRAP(pthread_mutex_unlock(pthread_mutex_t *mutex));
+
+int BELA_RT_WRAP(pthread_cond_destroy(pthread_cond_t *cond));
+int BELA_RT_WRAP(pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr));
+int BELA_RT_WRAP(pthread_cond_signal(pthread_cond_t *cond));
+int BELA_RT_WRAP(pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex));
+
+int BELA_RT_WRAP(socket(int protocol_family, int socket_type, int protocol));
+int BELA_RT_WRAP(setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen));
+int BELA_RT_WRAP(bind(int fd, const struct sockaddr *my_addr, socklen_t addrlen));
+ssize_t BELA_RT_WRAP(sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen));
+
+mqd_t BELA_RT_WRAP(mq_open(const char *name, int oflags, ...));
+int BELA_RT_WRAP(mq_close(mqd_t mqdes));
+ssize_t BELA_RT_WRAP(mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio));
+int BELA_RT_WRAP(mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio));
+int BELA_RT_WRAP(mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout));
+int BELA_RT_WRAP(mq_unlink(const char *name));
+
+int BELA_RT_WRAP(pthread_join(pthread_t thread, void **retval));
+int BELA_RT_WRAP(pthread_attr_init(pthread_attr_t *attr));
+int BELA_RT_WRAP(sched_get_priority_max(int policy));
+int BELA_RT_WRAP(open(const char *pathname, int flags, ...));
+#ifdef __arm__
+int BELA_RT_WRAP(ioctl(int fd, unsigned int request, ...));
+#else
+int BELA_RT_WRAP(ioctl(int fd, unsigned long int request, ...)) __THROW;
+#endif
+
+typedef long long int time_ns_t;
+typedef void *(pthread_callback_t)(void *);
+
+int task_sleep_ns(long long int timens);
+
+void setup_sched_parameters(pthread_attr_t *attr, int prio);
+
+int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, int prio);
+
+int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, pthread_callback_t* callback, void* arg);
+
+int createBelaRtPipe(const char* portName, size_t poolsz);
+
+void Bela_initRtBackend();
+
+#ifdef __cplusplus
+}
+#endif

From 1a125c1839859fe4bef3a934327580fadae4b346 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 22 Aug 2022 17:41:55 +0000
Subject: [PATCH 116/188] NIT: fixed headers

---
 core/AuxTaskNonRT.cpp | 1 +
 core/AuxTaskRT.cpp    | 1 +
 core/RtWrappers.cpp   | 5 +----
 include/RtWrappers.h  | 3 ---
 4 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index 7f4aa604a..57143362e 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -6,6 +6,7 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <vector>
+#include <string.h>
 
 extern int volatile gRTAudioVerbose;
 
diff --git a/core/AuxTaskRT.cpp b/core/AuxTaskRT.cpp
index 39fcc4268..7148bcb5b 100644
--- a/core/AuxTaskRT.cpp
+++ b/core/AuxTaskRT.cpp
@@ -4,6 +4,7 @@
 #include <Bela.h>
 #include <stdlib.h>
 #include <vector>
+#include <string.h>
 
 extern int volatile gRTAudioVerbose;
 
diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index 32c7e58fc..f64bc9c94 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -1,10 +1,7 @@
 #include "../include/RtWrappers.h"
 #include <stdio.h>
 #include <string.h>
-
-#include <pthread.h>
-#include <mqueue.h>
-#include <sys/socket.h>
+#include <time.h>
 
 int task_sleep_ns(long long int timens)
 {
diff --git a/include/RtWrappers.h b/include/RtWrappers.h
index 1487610a0..cdd6719d1 100644
--- a/include/RtWrappers.h
+++ b/include/RtWrappers.h
@@ -1,8 +1,5 @@
 #pragma once
 
-#include <time.h>
-#include <string.h>
-
 #ifdef __cplusplus
 extern "C" {
 #endif

From f4b7fe1cc2c60b3a26aaccec9d295d26a1429e36 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 22 Aug 2022 13:49:38 +0000
Subject: [PATCH 117/188] Added Bela_*printf. Implemented rt_*printf for
 non-Xenomai cases

---
 core/RtWrappers.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++
 include/Bela.h      | 17 ++++++++++-----
 2 files changed, 63 insertions(+), 5 deletions(-)

diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index f64bc9c94..dea3f4aad 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -150,3 +150,54 @@ int createBelaRtPipe(const char* portName, int poolsz)
 	return -1;
 }
 #endif //__COBALT__
+
+#include <Bela.h>
+#define var_num_to_va_list(stream, fmt, dest) \
+{ \
+	ssize_t ret; \
+	va_list ap; \
+	va_start(ap, fmt); \
+	ret = dest(stream, fmt, ap); \
+	va_end(ap); \
+	return ret; \
+}
+
+#ifndef __COBALT__
+int rt_printf(const char *format, ...)
+{
+	var_num_to_va_list(stdout, format, rt_vfprintf)
+}
+
+int rt_fprintf(FILE *stream, const char *format, ...)
+{
+	var_num_to_va_list(stream, format, rt_vfprintf)
+}
+
+int rt_vprintf(const char *format, va_list ap)
+{
+	return rt_vfprintf(stdout, format, ap);
+}
+
+int rt_vfprintf(FILE *stream, const char *format, va_list ap)
+{
+	// this is the only one that needs to be implemented
+	return vfprintf(stream, format, ap);
+}
+#endif // __COBALT__
+
+int Bela_printf(const char *format, ...)
+{
+	var_num_to_va_list(stdout, format, Bela_vfprintf)
+}
+int Bela_fprintf(FILE *stream, const char *format, ...)
+{
+	var_num_to_va_list(stream, format, Bela_vfprintf)
+}
+int Bela_vprintf(const char *format, va_list ap)
+{
+	return Bela_vfprintf(stdout, format, ap);
+}
+int Bela_vfprintf(FILE *stream, const char *format, va_list ap)
+{
+	return rt_vfprintf(stream, format, ap);
+}
diff --git a/include/Bela.h b/include/Bela.h
index 4bbb0f2cd..06a907526 100644
--- a/include/Bela.h
+++ b/include/Bela.h
@@ -93,9 +93,7 @@ extern "C"
 #include <unistd.h>
 #include <stdbool.h>
 #include <stdio.h>
-// these functions are currently provided by xenomai.
-// We put these declarations here so we do not have to include
-// Xenomai specific files
+
 // use attributes to provide printf-style compiler warnings
 #ifdef __GNUC__
 #define _ATTRIBUTE(attrs) __attribute__ (attrs)
@@ -103,10 +101,19 @@ extern "C"
 #define _ATTRIBUTE(attrs)
 #endif
 
+// RT-safe printing
+// these functions are currently provided by xenomai.
+// We put these declarations here so we do not have to include
+// Xenomai specific files
 int rt_printf(const char *format, ...) _ATTRIBUTE ((__format__ (__printf__, 1, 2)));
 int rt_fprintf(FILE *stream, const char *format, ...) _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int rt_vprintf(const char *format, va_list ap)  _ATTRIBUTE ((__format__ (__printf__, 1, 0)));
-int rt_vfprintf(FILE *stream, const char *format, va_list ap)  _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
+int rt_vprintf(const char *format, va_list ap) _ATTRIBUTE ((__format__ (__printf__, 1, 0)));
+int rt_vfprintf(FILE *stream, const char *format, va_list ap) _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
+// these are more future-proof wrappers
+int Bela_printf(const char *format, ...) _ATTRIBUTE ((__format__ (__printf__, 1, 2)));
+int Bela_fprintf(FILE *stream, const char *format, ...) _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
+int Bela_vprintf(const char *format, va_list ap) _ATTRIBUTE ((__format__ (__printf__, 1, 0)));
+int Bela_vfprintf(FILE *stream, const char *format, va_list ap) _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
 
 /**
  * A type of Bela hardware.

From 4c7a670da1d82589bc505de4cf8e531d08828096 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 22 Aug 2022 18:41:16 +0000
Subject: [PATCH 118/188] Makefile: no longer need to -D rt_*printf

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 6d401b9db..a78dea6e5 100644
--- a/Makefile
+++ b/Makefile
@@ -276,7 +276,7 @@ BELA_RT_WRAP_FLAGS?=-DBELA_RT_WRAP=__WRAP
 BELA_RT_BACKEND_LDLIBS :=$(DEFAULT_XENOMAI_LDFLAGS)
 else # if BELA_RT_BACKEND is not xenomai, hardcode some stuff
 BELA_USE_DEFINE?=BELA_USE_POLL
-BELA_RT_WRAP_FLAGS?="-DBELA_RT_WRAP(call)=call" -Drt_printf=printf -D rt_fprintf=fprintf
+BELA_RT_WRAP_FLAGS?="-DBELA_RT_WRAP(call)=call"
 BELA_RT_BACKEND_LDLIBS := -lpthread -lrt
 endif
 

From 5a37274471c11322ee61fe798ee9ed48628ab9bb Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 11:14:35 +0000
Subject: [PATCH 119/188] Added XenomaiLock.{cpp,h} from
 supercollider@b77311760b0d2bf6e69c4a575a444b6a006fbf81

---
 core/XenomaiLock.cpp  | 202 ++++++++++++++++++++++++++++++++++++++++++
 include/XenomaiLock.h |  44 +++++++++
 2 files changed, 246 insertions(+)
 create mode 100644 core/XenomaiLock.cpp
 create mode 100644 include/XenomaiLock.h

diff --git a/core/XenomaiLock.cpp b/core/XenomaiLock.cpp
new file mode 100644
index 000000000..68398a243
--- /dev/null
+++ b/core/XenomaiLock.cpp
@@ -0,0 +1,202 @@
+#include "../include/XenomaiLock.h"
+
+#include <pthread.h>
+#include <error.h>
+#include <string.h>
+#include <cobalt/sys/cobalt.h>
+#include <xenomai/init.h>
+#ifndef _GNU_SOURCE
+#    define _GNU_SOURCE
+#endif
+#include <unistd.h>
+#include <sys/syscall.h>
+
+#ifndef __COBALT__
+#    error This should be compiled with __COBALT__ and the appropriate Xenomai headers in the #include path
+#endif // __COBALT__
+// All __wrap_* calls below are Xenomai libcobalt calls
+
+//#define PRINT_XENO_LOCK
+
+#ifdef PRINT_XENO_LOCK
+#    define xprintf printf
+#    define xfprintf fprintf
+#else // PRINT_XENO_LOCK
+#    define xprintf(...)
+#    define xfprintf(...)
+#endif // PRINT_XENO_LOCK
+
+// Standard Linux `gettid(2)` not available on Bela
+static inline pid_t getTid() {
+    pid_t tid = syscall(SYS_gettid);
+    return tid;
+}
+
+// throughout, we use heuristics to check whether Xenomai needs to be
+// initialised and whether the current thread is a Xenomai thread.
+// See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
+static void initializeXenomai() {
+    xprintf("initializeXenomai\n");
+    int argc = 2;
+    char blankOpt[] = "";
+#ifdef PRINT_XENO_LOCK
+    char traceOpt[] = "--trace";
+#else // PRINT_XENO_LOCK
+    char traceOpt[] = "";
+#endif // PRINT_XENO_LOCK
+
+    char* const argv[argc] = { blankOpt, traceOpt };
+    char* const* argvPtrs[argc] = { &argv[0], &argv[1] };
+    xenomai_init(&argc, argvPtrs);
+}
+
+static bool turnIntoCobaltThread(bool recurred = false) {
+    struct sched_param param;
+    memset(&param, 0, sizeof(param));
+    int policy;
+    // Guaranteed to succeed as pthread_self() cannot fail and pthread_getschedparam()'s only error condition is when
+    // the given thread does not exist.
+    pthread_getschedparam(pthread_self(), &policy, &param);
+    pid_t tid = getTid();
+
+    if (int ret = __wrap_sched_setscheduler(tid, policy, &param)) {
+        fprintf(stderr, "Warning: unable to turn current thread into a Xenomai thread : (%d) %s\n", -ret,
+                strerror(-ret));
+        initializeXenomai();
+        if (!recurred)
+            return turnIntoCobaltThread(true);
+        else
+            return false;
+    }
+    xprintf("Turned thread %d into a Cobalt thread %s\n", tid, recurred ? "with recursion" : "");
+    return true;
+}
+
+XenomaiInitializer::XenomaiInitializer() { initializeXenomai(); }
+
+XenomaiMutex::XenomaiMutex() {
+    xprintf("Construct mutex\n");
+    if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
+        if (EPERM != ret) {
+            xprintf("__wrap_thread_mutex_init failed with %d %s\n", ret, strerror(ret));
+            return;
+        } else {
+            xprintf("mutex init returned EPERM\n");
+            initializeXenomai();
+            if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
+                fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, strerror(-ret));
+                return;
+            }
+        }
+    }
+    m_enabled = true;
+}
+
+XenomaiMutex::~XenomaiMutex() {
+    xprintf("Destroy mutex %p\n", &m_mutex);
+    if (m_enabled)
+        __wrap_pthread_mutex_destroy(&m_mutex);
+}
+
+// a helper function to try
+// - call func()
+// - if it fails, try to turn the current thread into a cobalt thread and call func() again
+// - if it fails again, just fail
+// - return true if it succeeds, or false if it fails
+// id and name are just for debugging purposes, while m_enabled is there because it saves duplicating some lines
+template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_enabled, T* id, const char* name) {
+    xprintf("tid: %d ", getTid());
+    if (!m_enabled) {
+        xfprintf(stderr, "%s disabled %p\n", name, id);
+        return false;
+    }
+
+    xprintf("%s %p\n", name, id);
+
+    int ret = func();
+    // 0 is "success" (or at least meaningful failure)
+    if (0 == ret) {
+        return true;
+    } else if (EPERM != ret) {
+        return false;
+    } else {
+        // if we got EPERM, we are not a Xenomai thread
+        if (!turnIntoCobaltThread()) {
+            xfprintf(stderr, "%s %p could not turn into cobalt\n", name, id);
+            return false;
+        }
+    }
+
+    // retry after becoming a cobalt thread
+    ret = func();
+    if (0 == ret) {
+        return true;
+    } else {
+        xfprintf(stderr, "%s %p failed after having turned into cobalt: %d\n", name, id, ret);
+        return false;
+    }
+}
+
+// Helper macro to insert this-ptr and function name
+#define tryOrRetry(_func_, _enabled_) tryOrRetryImpl(_func_, _enabled_, this, __func__)
+
+// condition resource_deadlock_would_occur instead of deadlocking. https://en.cppreference.com/w/cpp/thread/mutex/lock
+bool XenomaiMutex::try_lock() {
+    return tryOrRetry([this]() { return __wrap_pthread_mutex_trylock(&this->m_mutex); }, m_enabled);
+    // TODO: An implementation that can detect the invalid usage is encouraged to throw a std::system_error with error
+    // condition resource_deadlock_would_occur instead of deadlocking.
+}
+
+void XenomaiMutex::lock() {
+    tryOrRetry([this]() { return __wrap_pthread_mutex_lock(&this->m_mutex); }, m_enabled);
+}
+
+void XenomaiMutex::unlock() {
+    tryOrRetry([this]() { return __wrap_pthread_mutex_unlock(&this->m_mutex); }, m_enabled);
+}
+
+XenomaiConditionVariable::XenomaiConditionVariable() {
+    xprintf("Construct CondictionVariable\n");
+    if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
+        if (EPERM != ret) {
+            xprintf("__wrap_thread_cond_init failed with %d %s\n", ret, strerror(ret));
+            return;
+        } else {
+            xprintf("mutex init returned EPERM\n");
+            initializeXenomai();
+            if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
+                fprintf(stderr, "Error: unable to create condition variable : (%d) %s\n", ret, strerror(ret));
+                return;
+            }
+        }
+    }
+    m_enabled = true;
+}
+
+XenomaiConditionVariable::~XenomaiConditionVariable() {
+    if (m_enabled) {
+        notify_all();
+        __wrap_pthread_cond_destroy(&m_cond);
+    }
+}
+
+void XenomaiConditionVariable::wait(std::unique_lock<XenomaiMutex>& lck) {
+    // If any parameter has a value that is not valid for this function (such as if lck's mutex object is not locked by
+    // the calling thread), it causes undefined behavior.
+
+    // Otherwise, if an exception is thrown, both the condition_variable_any object and the arguments are in a valid
+    // state (basic guarantee). Additionally, on exception, the state of lck is attempted to be restored before exiting
+    // the function scope (by calling lck.lock()).
+
+    // It may throw system_error in case of failure (transmitting any error condition from the respective call to lock
+    // or unlock). The predicate version (2) may also throw exceptions thrown by pred.
+    tryOrRetry(([this, &lck]() { return __wrap_pthread_cond_wait(&this->m_cond, &lck.mutex()->m_mutex); }), m_enabled);
+}
+
+void XenomaiConditionVariable::notify_one() noexcept {
+    tryOrRetry([this]() { return __wrap_pthread_cond_signal(&this->m_cond); }, m_enabled);
+}
+
+void XenomaiConditionVariable::notify_all() noexcept {
+    tryOrRetry([this]() { return __wrap_pthread_cond_broadcast(&this->m_cond); }, m_enabled);
+}
diff --git a/include/XenomaiLock.h b/include/XenomaiLock.h
new file mode 100644
index 000000000..2687b2f4e
--- /dev/null
+++ b/include/XenomaiLock.h
@@ -0,0 +1,44 @@
+#pragma once
+#include <mutex> //unique_lock
+// Xenomai enforces the requirement to hold the lock so that optimizing
+// the wake up process is possible - under the assumption that the caller
+// owns the lock. There is no hack around this.
+// See: https://www.xenomai.org/pipermail/xenomai/2017-October/037759.html
+#define SC_CONDITION_VARIABLE_ANY_SHOULD_LOCK_BEFORE_NOTIFY
+
+// to make sure Xenomai gets initialised on time, create one object of this
+// class before any XenomaiMutex or XenomaiConditionVariable constructors
+class XenomaiInitializer {
+public:
+    XenomaiInitializer();
+};
+
+class XenomaiMutex {
+    friend class XenomaiConditionVariable;
+
+public:
+    XenomaiMutex();
+    ~XenomaiMutex();
+
+    bool try_lock();
+    void lock();
+    void unlock();
+
+private:
+    pthread_mutex_t m_mutex;
+    bool m_enabled = false;
+};
+
+class XenomaiConditionVariable {
+public:
+    XenomaiConditionVariable();
+    ~XenomaiConditionVariable();
+
+    void wait(std::unique_lock<XenomaiMutex>& lck);
+    void notify_one() noexcept;
+    void notify_all() noexcept;
+
+private:
+    pthread_cond_t m_cond;
+    bool m_enabled = false;
+};

From 4087869e7c114427f2d51148d8dc77d8b384eea8 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 11:18:53 +0000
Subject: [PATCH 120/188] RtLock: renamed XenomaiLock files to RtLock. Also
 substituted within the files: s/Xenomai\([CM]\)/Rt\1/g

---
 core/{XenomaiLock.cpp => RtLock.cpp} | 22 +++++++++++-----------
 include/{XenomaiLock.h => RtLock.h}  | 18 +++++++++---------
 2 files changed, 20 insertions(+), 20 deletions(-)
 rename core/{XenomaiLock.cpp => RtLock.cpp} (93%)
 rename include/{XenomaiLock.h => RtLock.h} (70%)

diff --git a/core/XenomaiLock.cpp b/core/RtLock.cpp
similarity index 93%
rename from core/XenomaiLock.cpp
rename to core/RtLock.cpp
index 68398a243..28a868b97 100644
--- a/core/XenomaiLock.cpp
+++ b/core/RtLock.cpp
@@ -1,4 +1,4 @@
-#include "../include/XenomaiLock.h"
+#include "../include/RtLock.h"
 
 #include <pthread.h>
 #include <error.h>
@@ -74,7 +74,7 @@ static bool turnIntoCobaltThread(bool recurred = false) {
 
 XenomaiInitializer::XenomaiInitializer() { initializeXenomai(); }
 
-XenomaiMutex::XenomaiMutex() {
+RtMutex::RtMutex() {
     xprintf("Construct mutex\n");
     if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
         if (EPERM != ret) {
@@ -92,7 +92,7 @@ XenomaiMutex::XenomaiMutex() {
     m_enabled = true;
 }
 
-XenomaiMutex::~XenomaiMutex() {
+RtMutex::~RtMutex() {
     xprintf("Destroy mutex %p\n", &m_mutex);
     if (m_enabled)
         __wrap_pthread_mutex_destroy(&m_mutex);
@@ -141,21 +141,21 @@ template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_en
 #define tryOrRetry(_func_, _enabled_) tryOrRetryImpl(_func_, _enabled_, this, __func__)
 
 // condition resource_deadlock_would_occur instead of deadlocking. https://en.cppreference.com/w/cpp/thread/mutex/lock
-bool XenomaiMutex::try_lock() {
+bool RtMutex::try_lock() {
     return tryOrRetry([this]() { return __wrap_pthread_mutex_trylock(&this->m_mutex); }, m_enabled);
     // TODO: An implementation that can detect the invalid usage is encouraged to throw a std::system_error with error
     // condition resource_deadlock_would_occur instead of deadlocking.
 }
 
-void XenomaiMutex::lock() {
+void RtMutex::lock() {
     tryOrRetry([this]() { return __wrap_pthread_mutex_lock(&this->m_mutex); }, m_enabled);
 }
 
-void XenomaiMutex::unlock() {
+void RtMutex::unlock() {
     tryOrRetry([this]() { return __wrap_pthread_mutex_unlock(&this->m_mutex); }, m_enabled);
 }
 
-XenomaiConditionVariable::XenomaiConditionVariable() {
+RtConditionVariable::RtConditionVariable() {
     xprintf("Construct CondictionVariable\n");
     if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
         if (EPERM != ret) {
@@ -173,14 +173,14 @@ XenomaiConditionVariable::XenomaiConditionVariable() {
     m_enabled = true;
 }
 
-XenomaiConditionVariable::~XenomaiConditionVariable() {
+RtConditionVariable::~RtConditionVariable() {
     if (m_enabled) {
         notify_all();
         __wrap_pthread_cond_destroy(&m_cond);
     }
 }
 
-void XenomaiConditionVariable::wait(std::unique_lock<XenomaiMutex>& lck) {
+void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
     // If any parameter has a value that is not valid for this function (such as if lck's mutex object is not locked by
     // the calling thread), it causes undefined behavior.
 
@@ -193,10 +193,10 @@ void XenomaiConditionVariable::wait(std::unique_lock<XenomaiMutex>& lck) {
     tryOrRetry(([this, &lck]() { return __wrap_pthread_cond_wait(&this->m_cond, &lck.mutex()->m_mutex); }), m_enabled);
 }
 
-void XenomaiConditionVariable::notify_one() noexcept {
+void RtConditionVariable::notify_one() noexcept {
     tryOrRetry([this]() { return __wrap_pthread_cond_signal(&this->m_cond); }, m_enabled);
 }
 
-void XenomaiConditionVariable::notify_all() noexcept {
+void RtConditionVariable::notify_all() noexcept {
     tryOrRetry([this]() { return __wrap_pthread_cond_broadcast(&this->m_cond); }, m_enabled);
 }
diff --git a/include/XenomaiLock.h b/include/RtLock.h
similarity index 70%
rename from include/XenomaiLock.h
rename to include/RtLock.h
index 2687b2f4e..57982a53a 100644
--- a/include/XenomaiLock.h
+++ b/include/RtLock.h
@@ -7,18 +7,18 @@
 #define SC_CONDITION_VARIABLE_ANY_SHOULD_LOCK_BEFORE_NOTIFY
 
 // to make sure Xenomai gets initialised on time, create one object of this
-// class before any XenomaiMutex or XenomaiConditionVariable constructors
+// class before any RtMutex or RtConditionVariable constructors
 class XenomaiInitializer {
 public:
     XenomaiInitializer();
 };
 
-class XenomaiMutex {
-    friend class XenomaiConditionVariable;
+class RtMutex {
+    friend class RtConditionVariable;
 
 public:
-    XenomaiMutex();
-    ~XenomaiMutex();
+    RtMutex();
+    ~RtMutex();
 
     bool try_lock();
     void lock();
@@ -29,12 +29,12 @@ class XenomaiMutex {
     bool m_enabled = false;
 };
 
-class XenomaiConditionVariable {
+class RtConditionVariable {
 public:
-    XenomaiConditionVariable();
-    ~XenomaiConditionVariable();
+    RtConditionVariable();
+    ~RtConditionVariable();
 
-    void wait(std::unique_lock<XenomaiMutex>& lck);
+    void wait(std::unique_lock<RtMutex>& lck);
     void notify_one() noexcept;
     void notify_all() noexcept;
 

From 21104fae821618bfb4377eee8acd90bfe7e61770 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 11:27:44 +0000
Subject: [PATCH 121/188] RtLock: applied Bela formatting ('s/    /\t/g') and
 removed SC define

---
 core/RtLock.cpp  | 234 +++++++++++++++++++++++------------------------
 include/RtLock.h |  33 ++++---
 2 files changed, 133 insertions(+), 134 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 28a868b97..241faf0b9 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -6,96 +6,96 @@
 #include <cobalt/sys/cobalt.h>
 #include <xenomai/init.h>
 #ifndef _GNU_SOURCE
-#    define _GNU_SOURCE
+#define _GNU_SOURCE
 #endif
 #include <unistd.h>
 #include <sys/syscall.h>
 
 #ifndef __COBALT__
-#    error This should be compiled with __COBALT__ and the appropriate Xenomai headers in the #include path
+#error This should be compiled with __COBALT__ and the appropriate Xenomai headers in the #include path
 #endif // __COBALT__
 // All __wrap_* calls below are Xenomai libcobalt calls
 
 //#define PRINT_XENO_LOCK
 
 #ifdef PRINT_XENO_LOCK
-#    define xprintf printf
-#    define xfprintf fprintf
+#define xprintf printf
+#define xfprintf fprintf
 #else // PRINT_XENO_LOCK
-#    define xprintf(...)
-#    define xfprintf(...)
+#define xprintf(...)
+#define xfprintf(...)
 #endif // PRINT_XENO_LOCK
 
 // Standard Linux `gettid(2)` not available on Bela
 static inline pid_t getTid() {
-    pid_t tid = syscall(SYS_gettid);
-    return tid;
+	pid_t tid = syscall(SYS_gettid);
+	return tid;
 }
 
 // throughout, we use heuristics to check whether Xenomai needs to be
 // initialised and whether the current thread is a Xenomai thread.
 // See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
 static void initializeXenomai() {
-    xprintf("initializeXenomai\n");
-    int argc = 2;
-    char blankOpt[] = "";
+	xprintf("initializeXenomai\n");
+	int argc = 2;
+	char blankOpt[] = "";
 #ifdef PRINT_XENO_LOCK
-    char traceOpt[] = "--trace";
+	char traceOpt[] = "--trace";
 #else // PRINT_XENO_LOCK
-    char traceOpt[] = "";
+	char traceOpt[] = "";
 #endif // PRINT_XENO_LOCK
 
-    char* const argv[argc] = { blankOpt, traceOpt };
-    char* const* argvPtrs[argc] = { &argv[0], &argv[1] };
-    xenomai_init(&argc, argvPtrs);
+	char* const argv[argc] = { blankOpt, traceOpt };
+	char* const* argvPtrs[argc] = { &argv[0], &argv[1] };
+	xenomai_init(&argc, argvPtrs);
 }
 
 static bool turnIntoCobaltThread(bool recurred = false) {
-    struct sched_param param;
-    memset(&param, 0, sizeof(param));
-    int policy;
-    // Guaranteed to succeed as pthread_self() cannot fail and pthread_getschedparam()'s only error condition is when
-    // the given thread does not exist.
-    pthread_getschedparam(pthread_self(), &policy, &param);
-    pid_t tid = getTid();
-
-    if (int ret = __wrap_sched_setscheduler(tid, policy, &param)) {
-        fprintf(stderr, "Warning: unable to turn current thread into a Xenomai thread : (%d) %s\n", -ret,
-                strerror(-ret));
-        initializeXenomai();
-        if (!recurred)
-            return turnIntoCobaltThread(true);
-        else
-            return false;
-    }
-    xprintf("Turned thread %d into a Cobalt thread %s\n", tid, recurred ? "with recursion" : "");
-    return true;
+	struct sched_param param;
+	memset(&param, 0, sizeof(param));
+	int policy;
+	// Guaranteed to succeed as pthread_self() cannot fail and pthread_getschedparam()'s only error condition is when
+	// the given thread does not exist.
+	pthread_getschedparam(pthread_self(), &policy, &param);
+	pid_t tid = getTid();
+
+	if (int ret = __wrap_sched_setscheduler(tid, policy, &param)) {
+		fprintf(stderr, "Warning: unable to turn current thread into a Xenomai thread : (%d) %s\n", -ret,
+				strerror(-ret));
+		initializeXenomai();
+		if (!recurred)
+			return turnIntoCobaltThread(true);
+		else
+			return false;
+	}
+	xprintf("Turned thread %d into a Cobalt thread %s\n", tid, recurred ? "with recursion" : "");
+	return true;
 }
 
 XenomaiInitializer::XenomaiInitializer() { initializeXenomai(); }
 
 RtMutex::RtMutex() {
-    xprintf("Construct mutex\n");
-    if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
-        if (EPERM != ret) {
-            xprintf("__wrap_thread_mutex_init failed with %d %s\n", ret, strerror(ret));
-            return;
-        } else {
-            xprintf("mutex init returned EPERM\n");
-            initializeXenomai();
-            if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
-                fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, strerror(-ret));
-                return;
-            }
-        }
-    }
-    m_enabled = true;
+	xprintf("Construct mutex\n");
+	if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
+		if (EPERM != ret) {
+			xprintf("__wrap_thread_mutex_init failed with %d %s\n", ret, strerror(ret));
+			return;
+		} else {
+			xprintf("mutex init returned EPERM\n");
+			initializeXenomai();
+			if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
+				fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, strerror(-ret));
+				return;
+			}
+		}
+	}
+	m_enabled = true;
 }
 
 RtMutex::~RtMutex() {
-    xprintf("Destroy mutex %p\n", &m_mutex);
-    if (m_enabled)
-        __wrap_pthread_mutex_destroy(&m_mutex);
+	xprintf("Destroy mutex %p\n", &m_mutex);
+	if (m_enabled)
+		__wrap_pthread_mutex_destroy(&m_mutex);
 }
 
 // a helper function to try
@@ -105,36 +105,36 @@ RtMutex::~RtMutex() {
 // - return true if it succeeds, or false if it fails
 // id and name are just for debugging purposes, while m_enabled is there because it saves duplicating some lines
 template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_enabled, T* id, const char* name) {
-    xprintf("tid: %d ", getTid());
-    if (!m_enabled) {
-        xfprintf(stderr, "%s disabled %p\n", name, id);
-        return false;
-    }
-
-    xprintf("%s %p\n", name, id);
-
-    int ret = func();
-    // 0 is "success" (or at least meaningful failure)
-    if (0 == ret) {
-        return true;
-    } else if (EPERM != ret) {
-        return false;
-    } else {
-        // if we got EPERM, we are not a Xenomai thread
-        if (!turnIntoCobaltThread()) {
-            xfprintf(stderr, "%s %p could not turn into cobalt\n", name, id);
-            return false;
-        }
-    }
-
-    // retry after becoming a cobalt thread
-    ret = func();
-    if (0 == ret) {
-        return true;
-    } else {
-        xfprintf(stderr, "%s %p failed after having turned into cobalt: %d\n", name, id, ret);
-        return false;
-    }
+	xprintf("tid: %d ", getTid());
+	if (!m_enabled) {
+		xfprintf(stderr, "%s disabled %p\n", name, id);
+		return false;
+	}
+
+	xprintf("%s %p\n", name, id);
+
+	int ret = func();
+	// 0 is "success" (or at least meaningful failure)
+	if (0 == ret) {
+		return true;
+	} else if (EPERM != ret) {
+		return false;
+	} else {
+		// if we got EPERM, we are not a Xenomai thread
+		if (!turnIntoCobaltThread()) {
+			xfprintf(stderr, "%s %p could not turn into cobalt\n", name, id);
+			return false;
+		}
+	}
+
+	// retry after becoming a cobalt thread
+	ret = func();
+	if (0 == ret) {
+		return true;
+	} else {
+		xfprintf(stderr, "%s %p failed after having turned into cobalt: %d\n", name, id, ret);
+		return false;
+	}
 }
 
 // Helper macro to insert this-ptr and function name
@@ -142,61 +142,61 @@ template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_en
 
 // condition resource_deadlock_would_occur instead of deadlocking. https://en.cppreference.com/w/cpp/thread/mutex/lock
 bool RtMutex::try_lock() {
-    return tryOrRetry([this]() { return __wrap_pthread_mutex_trylock(&this->m_mutex); }, m_enabled);
-    // TODO: An implementation that can detect the invalid usage is encouraged to throw a std::system_error with error
-    // condition resource_deadlock_would_occur instead of deadlocking.
+	return tryOrRetry([this]() { return __wrap_pthread_mutex_trylock(&this->m_mutex); }, m_enabled);
+	// TODO: An implementation that can detect the invalid usage is encouraged to throw a std::system_error with error
+	// condition resource_deadlock_would_occur instead of deadlocking.
 }
 
 void RtMutex::lock() {
-    tryOrRetry([this]() { return __wrap_pthread_mutex_lock(&this->m_mutex); }, m_enabled);
+	tryOrRetry([this]() { return __wrap_pthread_mutex_lock(&this->m_mutex); }, m_enabled);
 }
 
 void RtMutex::unlock() {
-    tryOrRetry([this]() { return __wrap_pthread_mutex_unlock(&this->m_mutex); }, m_enabled);
+	tryOrRetry([this]() { return __wrap_pthread_mutex_unlock(&this->m_mutex); }, m_enabled);
 }
 
 RtConditionVariable::RtConditionVariable() {
-    xprintf("Construct CondictionVariable\n");
-    if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
-        if (EPERM != ret) {
-            xprintf("__wrap_thread_cond_init failed with %d %s\n", ret, strerror(ret));
-            return;
-        } else {
-            xprintf("mutex init returned EPERM\n");
-            initializeXenomai();
-            if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
-                fprintf(stderr, "Error: unable to create condition variable : (%d) %s\n", ret, strerror(ret));
-                return;
-            }
-        }
-    }
-    m_enabled = true;
+	xprintf("Construct CondictionVariable\n");
+	if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
+		if (EPERM != ret) {
+			xprintf("__wrap_thread_cond_init failed with %d %s\n", ret, strerror(ret));
+			return;
+		} else {
+			xprintf("mutex init returned EPERM\n");
+			initializeXenomai();
+			if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
+				fprintf(stderr, "Error: unable to create condition variable : (%d) %s\n", ret, strerror(ret));
+				return;
+			}
+		}
+	}
+	m_enabled = true;
 }
 
 RtConditionVariable::~RtConditionVariable() {
-    if (m_enabled) {
-        notify_all();
-        __wrap_pthread_cond_destroy(&m_cond);
-    }
+	if (m_enabled) {
+		notify_all();
+		__wrap_pthread_cond_destroy(&m_cond);
+	}
 }
 
 void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
-    // If any parameter has a value that is not valid for this function (such as if lck's mutex object is not locked by
-    // the calling thread), it causes undefined behavior.
+	// If any parameter has a value that is not valid for this function (such as if lck's mutex object is not locked by
+	// the calling thread), it causes undefined behavior.
 
-    // Otherwise, if an exception is thrown, both the condition_variable_any object and the arguments are in a valid
-    // state (basic guarantee). Additionally, on exception, the state of lck is attempted to be restored before exiting
-    // the function scope (by calling lck.lock()).
+	// Otherwise, if an exception is thrown, both the condition_variable_any object and the arguments are in a valid
+	// state (basic guarantee). Additionally, on exception, the state of lck is attempted to be restored before exiting
+	// the function scope (by calling lck.lock()).
 
-    // It may throw system_error in case of failure (transmitting any error condition from the respective call to lock
-    // or unlock). The predicate version (2) may also throw exceptions thrown by pred.
-    tryOrRetry(([this, &lck]() { return __wrap_pthread_cond_wait(&this->m_cond, &lck.mutex()->m_mutex); }), m_enabled);
+	// It may throw system_error in case of failure (transmitting any error condition from the respective call to lock
+	// or unlock). The predicate version (2) may also throw exceptions thrown by pred.
+	tryOrRetry(([this, &lck]() { return __wrap_pthread_cond_wait(&this->m_cond, &lck.mutex()->m_mutex); }), m_enabled);
 }
 
 void RtConditionVariable::notify_one() noexcept {
-    tryOrRetry([this]() { return __wrap_pthread_cond_signal(&this->m_cond); }, m_enabled);
+	tryOrRetry([this]() { return __wrap_pthread_cond_signal(&this->m_cond); }, m_enabled);
 }
 
 void RtConditionVariable::notify_all() noexcept {
-    tryOrRetry([this]() { return __wrap_pthread_cond_broadcast(&this->m_cond); }, m_enabled);
+	tryOrRetry([this]() { return __wrap_pthread_cond_broadcast(&this->m_cond); }, m_enabled);
 }
diff --git a/include/RtLock.h b/include/RtLock.h
index 57982a53a..e5e81e101 100644
--- a/include/RtLock.h
+++ b/include/RtLock.h
@@ -4,41 +4,40 @@
 // the wake up process is possible - under the assumption that the caller
 // owns the lock. There is no hack around this.
 // See: https://www.xenomai.org/pipermail/xenomai/2017-October/037759.html
-#define SC_CONDITION_VARIABLE_ANY_SHOULD_LOCK_BEFORE_NOTIFY
 
 // to make sure Xenomai gets initialised on time, create one object of this
 // class before any RtMutex or RtConditionVariable constructors
 class XenomaiInitializer {
 public:
-    XenomaiInitializer();
+	XenomaiInitializer();
 };
 
 class RtMutex {
-    friend class RtConditionVariable;
+	friend class RtConditionVariable;
 
 public:
-    RtMutex();
-    ~RtMutex();
+	RtMutex();
+	~RtMutex();
 
-    bool try_lock();
-    void lock();
-    void unlock();
+	bool try_lock();
+	void lock();
+	void unlock();
 
 private:
-    pthread_mutex_t m_mutex;
-    bool m_enabled = false;
+	pthread_mutex_t m_mutex;
+	bool m_enabled = false;
 };
 
 class RtConditionVariable {
 public:
-    RtConditionVariable();
-    ~RtConditionVariable();
+	RtConditionVariable();
+	~RtConditionVariable();
 
-    void wait(std::unique_lock<RtMutex>& lck);
-    void notify_one() noexcept;
-    void notify_all() noexcept;
+	void wait(std::unique_lock<RtMutex>& lck);
+	void notify_one() noexcept;
+	void notify_all() noexcept;
 
 private:
-    pthread_cond_t m_cond;
-    bool m_enabled = false;
+	pthread_cond_t m_cond;
+	bool m_enabled = false;
 };

From fdc9513345a24922b9512da90ad06e3ae2c2cb2e Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 11:29:47 +0000
Subject: [PATCH 122/188] RtLock: removed XenomaiInitializer

---
 core/RtLock.cpp  | 2 --
 include/RtLock.h | 7 -------
 2 files changed, 9 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 241faf0b9..60a52976f 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -72,8 +72,6 @@ static bool turnIntoCobaltThread(bool recurred = false) {
 	return true;
 }
 
-XenomaiInitializer::XenomaiInitializer() { initializeXenomai(); }
-
 RtMutex::RtMutex() {
 	xprintf("Construct mutex\n");
 	if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
diff --git a/include/RtLock.h b/include/RtLock.h
index e5e81e101..e35945ab6 100644
--- a/include/RtLock.h
+++ b/include/RtLock.h
@@ -5,13 +5,6 @@
 // owns the lock. There is no hack around this.
 // See: https://www.xenomai.org/pipermail/xenomai/2017-October/037759.html
 
-// to make sure Xenomai gets initialised on time, create one object of this
-// class before any RtMutex or RtConditionVariable constructors
-class XenomaiInitializer {
-public:
-	XenomaiInitializer();
-};
-
 class RtMutex {
 	friend class RtConditionVariable;
 

From c0f259b3f405abb736f5baf30ed2596d7a80cddd Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 22 Aug 2022 16:35:56 +0000
Subject: [PATCH 123/188] RtLock: changing __wrap with BELA_RT_WRAP, handling
 non-COBALT case and throwing on failed construction

---
 core/RtLock.cpp | 78 +++++++++++++++++++++++++++++--------------------
 1 file changed, 46 insertions(+), 32 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 60a52976f..9c5dde259 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -1,20 +1,15 @@
 #include "../include/RtLock.h"
+#include "../include/RtWrappers.h"
 
 #include <pthread.h>
 #include <error.h>
 #include <string.h>
-#include <cobalt/sys/cobalt.h>
-#include <xenomai/init.h>
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 #include <unistd.h>
 #include <sys/syscall.h>
-
-#ifndef __COBALT__
-#error This should be compiled with __COBALT__ and the appropriate Xenomai headers in the #include path
-#endif // __COBALT__
-// All __wrap_* calls below are Xenomai libcobalt calls
+#include <stdexcept>
 
 //#define PRINT_XENO_LOCK
 
@@ -32,12 +27,15 @@ static inline pid_t getTid() {
 	return tid;
 }
 
+#ifdef __COBALT__
+#include <xenomai/init.h>
 // throughout, we use heuristics to check whether Xenomai needs to be
 // initialised and whether the current thread is a Xenomai thread.
 // See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
 static void initializeXenomai() {
 	xprintf("initializeXenomai\n");
-	int argc = 2;
+	enum { _argc = 2 };
+	int argc = _argc;
 	char blankOpt[] = "";
 #ifdef PRINT_XENO_LOCK
 	char traceOpt[] = "--trace";
@@ -45,8 +43,8 @@ static void initializeXenomai() {
 	char traceOpt[] = "";
 #endif // PRINT_XENO_LOCK
 
-	char* const argv[argc] = { blankOpt, traceOpt };
-	char* const* argvPtrs[argc] = { &argv[0], &argv[1] };
+	char* const argv[_argc] = { blankOpt, traceOpt };
+	char* const* argvPtrs[_argc] = { &argv[0], &argv[1] };
 	xenomai_init(&argc, argvPtrs);
 }
 
@@ -71,19 +69,36 @@ static bool turnIntoCobaltThread(bool recurred = false) {
 	xprintf("Turned thread %d into a Cobalt thread %s\n", tid, recurred ? "with recursion" : "");
 	return true;
 }
+#endif // __COBALT__
+
+static bool turnIntoRtThread()
+{
+#if defined __COBALT__
+	return turnIntoCobaltThread();
+#else // do nothing
+	return true;
+#endif
+}
+
+static void initializeRt()
+{
+#ifdef __COBALT__
+	initializeXenomai();
+#endif // __COBALT__
+}
 
 RtMutex::RtMutex() {
 	xprintf("Construct mutex\n");
-	if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
+	if (int ret = BELA_RT_WRAP(pthread_mutex_init(&m_mutex, NULL))) {
 		if (EPERM != ret) {
-			xprintf("__wrap_thread_mutex_init failed with %d %s\n", ret, strerror(ret));
-			return;
+			xprintf("thread_mutex_init failed with %d %s\n", ret, strerror(ret));
+			throw std::runtime_error("thread_mutex_init failed on first attempt");
 		} else {
 			xprintf("mutex init returned EPERM\n");
-			initializeXenomai();
-			if (int ret = __wrap_pthread_mutex_init(&m_mutex, NULL)) {
+			initializeRt();
+			if (int ret = BELA_RT_WRAP(pthread_mutex_init(&m_mutex, NULL))) {
 				fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, strerror(-ret));
-				return;
+				throw std::runtime_error("thread_mutex_init failed on second attempt");
 			}
 		}
 	}
@@ -93,7 +108,7 @@ RtMutex::RtMutex() {
 RtMutex::~RtMutex() {
 	xprintf("Destroy mutex %p\n", &m_mutex);
 	if (m_enabled)
-		__wrap_pthread_mutex_destroy(&m_mutex);
+		BELA_RT_WRAP(pthread_mutex_destroy(&m_mutex));
 }
 
 // a helper function to try
@@ -119,7 +134,7 @@ template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_en
 		return false;
 	} else {
 		// if we got EPERM, we are not a Xenomai thread
-		if (!turnIntoCobaltThread()) {
+		if (!turnIntoRtThread()) {
 			xfprintf(stderr, "%s %p could not turn into cobalt\n", name, id);
 			return false;
 		}
@@ -140,31 +155,30 @@ template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_en
 
 // condition resource_deadlock_would_occur instead of deadlocking. https://en.cppreference.com/w/cpp/thread/mutex/lock
 bool RtMutex::try_lock() {
-	return tryOrRetry([this]() { return __wrap_pthread_mutex_trylock(&this->m_mutex); }, m_enabled);
+	return tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_trylock(&this->m_mutex)); }, m_enabled);
 	// TODO: An implementation that can detect the invalid usage is encouraged to throw a std::system_error with error
 	// condition resource_deadlock_would_occur instead of deadlocking.
 }
 
 void RtMutex::lock() {
-	tryOrRetry([this]() { return __wrap_pthread_mutex_lock(&this->m_mutex); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_lock(&this->m_mutex)); }, m_enabled);
 }
 
 void RtMutex::unlock() {
-	tryOrRetry([this]() { return __wrap_pthread_mutex_unlock(&this->m_mutex); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_unlock(&this->m_mutex)); }, m_enabled);
 }
 
 RtConditionVariable::RtConditionVariable() {
 	xprintf("Construct CondictionVariable\n");
-	if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
+	if (int ret = BELA_RT_WRAP(pthread_cond_init(&m_cond, NULL))) {
 		if (EPERM != ret) {
-			xprintf("__wrap_thread_cond_init failed with %d %s\n", ret, strerror(ret));
-			return;
+			xprintf("thread_cond_init failed with %d %s\n", ret, strerror(ret));
+			throw std::runtime_error("thread_cond_init failed at first attempt");
 		} else {
 			xprintf("mutex init returned EPERM\n");
-			initializeXenomai();
-			if (int ret = __wrap_pthread_cond_init(&m_cond, NULL)) {
-				fprintf(stderr, "Error: unable to create condition variable : (%d) %s\n", ret, strerror(ret));
-				return;
+			initializeRt();
+			if (int ret = BELA_RT_WRAP(pthread_cond_init(&m_cond, NULL))) {
+				throw std::runtime_error("thread_cond_init failed at second attempt");
 			}
 		}
 	}
@@ -174,7 +188,7 @@ RtConditionVariable::RtConditionVariable() {
 RtConditionVariable::~RtConditionVariable() {
 	if (m_enabled) {
 		notify_all();
-		__wrap_pthread_cond_destroy(&m_cond);
+		BELA_RT_WRAP(pthread_cond_destroy(&m_cond));
 	}
 }
 
@@ -188,13 +202,13 @@ void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
 
 	// It may throw system_error in case of failure (transmitting any error condition from the respective call to lock
 	// or unlock). The predicate version (2) may also throw exceptions thrown by pred.
-	tryOrRetry(([this, &lck]() { return __wrap_pthread_cond_wait(&this->m_cond, &lck.mutex()->m_mutex); }), m_enabled);
+	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->m_cond, &lck.mutex()->m_mutex)); }), m_enabled);
 }
 
 void RtConditionVariable::notify_one() noexcept {
-	tryOrRetry([this]() { return __wrap_pthread_cond_signal(&this->m_cond); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_signal(&this->m_cond)); }, m_enabled);
 }
 
 void RtConditionVariable::notify_all() noexcept {
-	tryOrRetry([this]() { return __wrap_pthread_cond_broadcast(&this->m_cond); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_broadcast(&this->m_cond)); }, m_enabled);
 }

From d46306f4450ad245d3def03ce71a8f1d376b75bc Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 13:56:32 +0000
Subject: [PATCH 124/188] RtLock: added RtConditionVariable::wait(RtMutex&)

---
 core/RtLock.cpp  | 4 ++++
 include/RtLock.h | 1 +
 2 files changed, 5 insertions(+)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 9c5dde259..221d35ef9 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -192,6 +192,10 @@ RtConditionVariable::~RtConditionVariable() {
 	}
 }
 
+void RtConditionVariable::wait(RtMutex& lck) {
+	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->m_cond, &lck.m_mutex)); }), m_enabled);
+}
+
 void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
 	// If any parameter has a value that is not valid for this function (such as if lck's mutex object is not locked by
 	// the calling thread), it causes undefined behavior.
diff --git a/include/RtLock.h b/include/RtLock.h
index e35945ab6..a55a2e7c4 100644
--- a/include/RtLock.h
+++ b/include/RtLock.h
@@ -27,6 +27,7 @@ class RtConditionVariable {
 	~RtConditionVariable();
 
 	void wait(std::unique_lock<RtMutex>& lck);
+	void wait(RtMutex& lck);
 	void notify_one() noexcept;
 	void notify_all() noexcept;
 

From e254df138184256c6a02eb5006e3dac13c93a9af Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 13:59:49 +0000
Subject: [PATCH 125/188] AuxiliaryTask: use RtLock

---
 Makefile                |  2 +-
 core/AuxiliaryTasks.cpp | 59 ++++++++++++++++++++++-------------------
 2 files changed, 32 insertions(+), 29 deletions(-)

diff --git a/Makefile b/Makefile
index a78dea6e5..81333a85e 100644
--- a/Makefile
+++ b/Makefile
@@ -776,7 +776,7 @@ lib/$(LIB_EXTRA_A): $(LIB_EXTRA_OBJS) $(PRU_OBJS) $(LIB_DEPS)
 
 LIB_SO =libbela.so
 LIB_A = libbela.a
-LIB_OBJS = $(CORE_CORE_OBJS) build/core/AuxiliaryTasks.o build/core/Gpio.o
+LIB_OBJS = $(CORE_CORE_OBJS) build/core/AuxiliaryTasks.o build/core/Gpio.o build/core/RtLock.o
 lib/$(LIB_SO): $(LIB_OBJS)
 	$(AT) echo Building lib/$(LIB_SO)
 	$(AT) $(CXX) $(BELA_LDFLAGS) $(LDFLAGS) -shared -Wl,-soname,$(LIB_SO) $(LDLIBS) -o lib/$(LIB_SO) $(LIB_OBJS) $(LDLIBS) $(BELA_CORE_LDLIBS)
diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index c82c9c5a5..dde9e91ad 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -6,6 +6,7 @@
 
 #include <pthread.h>
 #include "../include/RtWrappers.h"
+#include "../include/RtLock.h"
 
 using namespace std;
 //
@@ -13,8 +14,8 @@ using namespace std;
 // can schedule
 typedef struct {
 	pthread_t task;
-	pthread_cond_t cond;
-	pthread_mutex_t mutex;
+	RtConditionVariable* cond;
+	RtMutex* mutex;
 	void (*argfunction)(void*);
 	char *name;
 	int priority;
@@ -37,7 +38,7 @@ extern unsigned int gAuxiliaryTaskStackSize;
 AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int priority, const char *name, void* args)
 {
 	Bela_initRtBackend();
-	InternalAuxiliaryTask *newTask = (InternalAuxiliaryTask*)malloc(sizeof(InternalAuxiliaryTask));
+	InternalAuxiliaryTask *newTask = (InternalAuxiliaryTask*)calloc(1, sizeof(InternalAuxiliaryTask));
 
 	// Populate the rest of the data structure
 	newTask->argfunction = functionToCall;
@@ -47,23 +48,24 @@ AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int p
 	newTask->args = args;
 	// Attempt to create the task
 	unsigned int stackSize = gAuxiliaryTaskStackSize;
-	if(int ret = BELA_RT_WRAP(pthread_cond_init(&(newTask->cond), NULL)))
+	int ret;
+	try {
+		newTask->cond = new RtConditionVariable;
+		newTask->mutex = new RtMutex;
+		ret = 0;
+	} catch (std::exception& e)
 	{
-		fprintf(stderr, "Error: unable to create condition variable for auxiliary task %s : (%d) %s\n", name, ret, strerror(ret));
-		free(newTask);
-		return 0;
-	}
-	if(int ret = BELA_RT_WRAP(pthread_mutex_init(&(newTask->mutex), NULL)))
-	{
-		fprintf(stderr, "Error: unable to initialize mutex for auxiliary task %s : (%d) %s\n", name, ret, strerror(-ret));
-		free(newTask);
-		return 0;
+		ret = 1;
 	}
 	// Upon calling this function, the thread will start and immediately wait
 	// on the condition variable.
-	if(int ret = create_and_start_thread(&(newTask->task), name, priority, stackSize,(pthread_callback_t*)auxiliaryTaskLoop, newTask))
+	if(!ret)
+		ret = create_and_start_thread(&(newTask->task), name, priority, stackSize,(pthread_callback_t*)auxiliaryTaskLoop, newTask);
+	if(ret)
 	{
 		fprintf(stderr, "Error: unable to create auxiliary task %s : (%d) %s\n", name, ret, strerror(ret));
+		delete newTask->cond;
+		delete newTask->mutex;
 		free(newTask);
 		return 0;
 	}
@@ -112,16 +114,17 @@ int Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 					policy, &param));
 		}
 	}
-	if(int ret = BELA_RT_WRAP(pthread_mutex_trylock(&taskToSchedule->mutex)))
+	if(taskToSchedule->mutex->try_lock())
 	{
-		// If we cannot get the lock, then the task is probably still running.
-		return ret;
-	} else {
-		ret = BELA_RT_WRAP(pthread_cond_signal(&taskToSchedule->cond));
-		BELA_RT_WRAP(pthread_mutex_unlock(&taskToSchedule->mutex));
+		taskToSchedule->cond->notify_one();
+		taskToSchedule->mutex->unlock();
 		return 0;
+	} else {
+		// If we cannot get the lock, then the task is probably still running.
+		return 1;
 	}
 }
+
 AuxiliaryTask Bela_runAuxiliaryTask(void (*callback)(void*), int priority, void* arg)
 {
 	char name[11];
@@ -139,10 +142,10 @@ AuxiliaryTask Bela_runAuxiliaryTask(void (*callback)(void*), int priority, void*
 
 static void suspendCurrentTask(InternalAuxiliaryTask* task)
 {
-	BELA_RT_WRAP(pthread_mutex_lock(&task->mutex));
+	task->mutex->lock();
 	task->started = true;
-	BELA_RT_WRAP(pthread_cond_wait(&task->cond, &task->mutex));
-	BELA_RT_WRAP(pthread_mutex_unlock(&task->mutex));
+	task->cond->wait(*task->mutex);
+	task->mutex->unlock();
 }
 // Calculation loop that can be used for other tasks running at a lower
 // priority than the audio thread. Simple wrapper for Xenomai calls.
@@ -217,9 +220,9 @@ void Bela_stopAllAuxiliaryTasks()
 		// should return true at this point. Let's make sure it does:
 		Bela_requestStop();
 		// REALLY lock the lock: we really must call _cond_signal here
-		BELA_RT_WRAP(pthread_mutex_lock(&taskStruct->mutex));
-		BELA_RT_WRAP(pthread_cond_signal(&taskStruct->cond));
-		BELA_RT_WRAP(pthread_mutex_unlock(&taskStruct->mutex));
+		taskStruct->mutex->lock();
+		taskStruct->cond->notify_one();
+		taskStruct->mutex->unlock();
 
 		void* threadReturnValue;
 		BELA_RT_WRAP(pthread_join(taskStruct->task, &threadReturnValue));
@@ -235,9 +238,9 @@ void Bela_deleteAllAuxiliaryTasks()
 
 		// Delete the task
 		pthread_cancel(taskStruct->task);
-		BELA_RT_WRAP(pthread_cond_destroy(&taskStruct->cond));
-		BELA_RT_WRAP(pthread_mutex_destroy(&taskStruct->mutex));
 		// Free the name string and the struct itself
+		delete taskStruct->mutex;
+		delete taskStruct->cond;
 		free(taskStruct->name);
 		free(taskStruct);
 	}

From a1ce28703cddd5bb497af92de0e9b1a8da417043 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 17:16:20 +0000
Subject: [PATCH 126/188] RtLock: hide implementation in the implementation
 file

---
 core/RtLock.cpp  | 38 ++++++++++++++++++++++++--------------
 include/RtLock.h |  8 +++++---
 2 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 221d35ef9..32e62b806 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -87,16 +87,21 @@ static void initializeRt()
 #endif // __COBALT__
 }
 
+struct RtMutex::Private {
+	pthread_mutex_t m_mutex;
+};
+
 RtMutex::RtMutex() {
+	p = std::unique_ptr<Private>(new Private);
 	xprintf("Construct mutex\n");
-	if (int ret = BELA_RT_WRAP(pthread_mutex_init(&m_mutex, NULL))) {
+	if (int ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))) {
 		if (EPERM != ret) {
 			xprintf("thread_mutex_init failed with %d %s\n", ret, strerror(ret));
 			throw std::runtime_error("thread_mutex_init failed on first attempt");
 		} else {
 			xprintf("mutex init returned EPERM\n");
 			initializeRt();
-			if (int ret = BELA_RT_WRAP(pthread_mutex_init(&m_mutex, NULL))) {
+			if (int ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))) {
 				fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, strerror(-ret));
 				throw std::runtime_error("thread_mutex_init failed on second attempt");
 			}
@@ -106,9 +111,9 @@ RtMutex::RtMutex() {
 }
 
 RtMutex::~RtMutex() {
-	xprintf("Destroy mutex %p\n", &m_mutex);
+	xprintf("Destroy mutex %p\n", &p->m_mutex);
 	if (m_enabled)
-		BELA_RT_WRAP(pthread_mutex_destroy(&m_mutex));
+		BELA_RT_WRAP(pthread_mutex_destroy(&p->m_mutex));
 }
 
 // a helper function to try
@@ -155,29 +160,34 @@ template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_en
 
 // condition resource_deadlock_would_occur instead of deadlocking. https://en.cppreference.com/w/cpp/thread/mutex/lock
 bool RtMutex::try_lock() {
-	return tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_trylock(&this->m_mutex)); }, m_enabled);
+	return tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_trylock(&this->p->m_mutex)); }, m_enabled);
 	// TODO: An implementation that can detect the invalid usage is encouraged to throw a std::system_error with error
 	// condition resource_deadlock_would_occur instead of deadlocking.
 }
 
 void RtMutex::lock() {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_lock(&this->m_mutex)); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_lock(&this->p->m_mutex)); }, m_enabled);
 }
 
 void RtMutex::unlock() {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_unlock(&this->m_mutex)); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_unlock(&this->p->m_mutex)); }, m_enabled);
 }
 
+struct RtConditionVariable::Private {
+	pthread_cond_t m_cond;
+};
+
 RtConditionVariable::RtConditionVariable() {
+	p = std::unique_ptr<Private>(new Private);
 	xprintf("Construct CondictionVariable\n");
-	if (int ret = BELA_RT_WRAP(pthread_cond_init(&m_cond, NULL))) {
+	if (int ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))) {
 		if (EPERM != ret) {
 			xprintf("thread_cond_init failed with %d %s\n", ret, strerror(ret));
 			throw std::runtime_error("thread_cond_init failed at first attempt");
 		} else {
 			xprintf("mutex init returned EPERM\n");
 			initializeRt();
-			if (int ret = BELA_RT_WRAP(pthread_cond_init(&m_cond, NULL))) {
+			if (int ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))) {
 				throw std::runtime_error("thread_cond_init failed at second attempt");
 			}
 		}
@@ -188,12 +198,12 @@ RtConditionVariable::RtConditionVariable() {
 RtConditionVariable::~RtConditionVariable() {
 	if (m_enabled) {
 		notify_all();
-		BELA_RT_WRAP(pthread_cond_destroy(&m_cond));
+		BELA_RT_WRAP(pthread_cond_destroy(&p->m_cond));
 	}
 }
 
 void RtConditionVariable::wait(RtMutex& lck) {
-	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->m_cond, &lck.m_mutex)); }), m_enabled);
+	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->p->m_cond, &lck.p->m_mutex)); }), m_enabled);
 }
 
 void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
@@ -206,13 +216,13 @@ void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
 
 	// It may throw system_error in case of failure (transmitting any error condition from the respective call to lock
 	// or unlock). The predicate version (2) may also throw exceptions thrown by pred.
-	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->m_cond, &lck.mutex()->m_mutex)); }), m_enabled);
+	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->p->m_cond, &lck.mutex()->p->m_mutex)); }), m_enabled);
 }
 
 void RtConditionVariable::notify_one() noexcept {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_signal(&this->m_cond)); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_signal(&this->p->m_cond)); }, m_enabled);
 }
 
 void RtConditionVariable::notify_all() noexcept {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_broadcast(&this->m_cond)); }, m_enabled);
+	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_broadcast(&this->p->m_cond)); }, m_enabled);
 }
diff --git a/include/RtLock.h b/include/RtLock.h
index a55a2e7c4..467146007 100644
--- a/include/RtLock.h
+++ b/include/RtLock.h
@@ -1,5 +1,6 @@
 #pragma once
 #include <mutex> //unique_lock
+#include <memory> 
 // Xenomai enforces the requirement to hold the lock so that optimizing
 // the wake up process is possible - under the assumption that the caller
 // owns the lock. There is no hack around this.
@@ -7,7 +8,6 @@
 
 class RtMutex {
 	friend class RtConditionVariable;
-
 public:
 	RtMutex();
 	~RtMutex();
@@ -17,8 +17,9 @@ class RtMutex {
 	void unlock();
 
 private:
-	pthread_mutex_t m_mutex;
 	bool m_enabled = false;
+	struct Private;
+	std::unique_ptr<Private> p;
 };
 
 class RtConditionVariable {
@@ -32,6 +33,7 @@ class RtConditionVariable {
 	void notify_all() noexcept;
 
 private:
-	pthread_cond_t m_cond;
 	bool m_enabled = false;
+	struct Private;
+	std::unique_ptr<Private> p;
 };

From 063456131acc6b82390cac08e1539bc92f47204f Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 18:23:28 +0000
Subject: [PATCH 127/188] RtLock: PRINT_XENO_LOCK renamed to PRINT_RT_LOCK

---
 core/RtLock.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 32e62b806..6db0b0bf7 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -11,15 +11,19 @@
 #include <sys/syscall.h>
 #include <stdexcept>
 
-//#define PRINT_XENO_LOCK
 
-#ifdef PRINT_XENO_LOCK
-#define xprintf printf
-#define xfprintf fprintf
-#else // PRINT_XENO_LOCK
+//#define PRINT_RT_LOCK
+
+#ifdef PRINT_RT_LOCK
+#ifndef __COBALT__
+#include <Bela.h>
+#endif // __COBALT__
+#define xprintf rt_printf
+#define xfprintf rt_fprintf
+#else // PRINT_RT_LOCK
 #define xprintf(...)
 #define xfprintf(...)
-#endif // PRINT_XENO_LOCK
+#endif // PRINT_RT_LOCK
 
 // Standard Linux `gettid(2)` not available on Bela
 static inline pid_t getTid() {
@@ -37,11 +41,11 @@ static void initializeXenomai() {
 	enum { _argc = 2 };
 	int argc = _argc;
 	char blankOpt[] = "";
-#ifdef PRINT_XENO_LOCK
+#ifdef PRINT_RT_LOCK
 	char traceOpt[] = "--trace";
-#else // PRINT_XENO_LOCK
+#else // PRINT_RT_LOCK
 	char traceOpt[] = "";
-#endif // PRINT_XENO_LOCK
+#endif // PRINT_RT_LOCK
 
 	char* const argv[_argc] = { blankOpt, traceOpt };
 	char* const* argvPtrs[_argc] = { &argv[0], &argv[1] };

From 164ba53ebc0863ca68963074a90214623a904fbe Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 23 Aug 2022 18:38:19 +0000
Subject: [PATCH 128/188] RtLock: NIT: refactored to use pthread_agnostic
 functions and parameter checking. Improved logging

---
 core/RtLock.cpp | 127 ++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 101 insertions(+), 26 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 6db0b0bf7..aabf3d5c7 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -11,6 +11,22 @@
 #include <sys/syscall.h>
 #include <stdexcept>
 
+// What error - if returned by the initialisation routine - means we should
+// force-initialise the RT core and try again
+#if defined(__COBALT__)
+static const int kErrShouldInit = EPERM;
+#else
+static const int kErrShouldInit = 0; // will never be true
+#endif
+
+
+// What error - if returned by the a runtime routine - means we should
+// force-turn the current thread into an RT thread and try again
+#if defined(__COBALT__)
+static const int kErrShouldTurn = EPERM;
+#else
+static const int kErrShouldTurn = 0; // will never be true
+#endif
 
 //#define PRINT_RT_LOCK
 
@@ -91,22 +107,53 @@ static void initializeRt()
 #endif // __COBALT__
 }
 
+static const char* pstrerror(int ret)
+{
+	return strerror(ret < 0 ? -ret : ret);
+}
+
+typedef pthread_mutex_t mutex_t;
+
+// TODO: can we be clever with the preprocessor?
+int mutex_lock(mutex_t* mutex)
+{
+	return BELA_RT_WRAP(pthread_mutex_lock(mutex));
+}
+
+int mutex_trylock(mutex_t* mutex)
+{
+	return BELA_RT_WRAP(pthread_mutex_trylock(mutex));
+}
+
+int mutex_unlock(mutex_t* mutex)
+{
+	return BELA_RT_WRAP(pthread_mutex_unlock(mutex));
+}
+
+int mutex_destroy(mutex_t* mutex)
+{
+	return BELA_RT_WRAP(pthread_mutex_destroy(mutex));
+}
+
 struct RtMutex::Private {
-	pthread_mutex_t m_mutex;
+	mutex_t m_mutex;
 };
 
 RtMutex::RtMutex() {
 	p = std::unique_ptr<Private>(new Private);
 	xprintf("Construct mutex\n");
-	if (int ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))) {
-		if (EPERM != ret) {
-			xprintf("thread_mutex_init failed with %d %s\n", ret, strerror(ret));
+	int ret;
+	if ((ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))))
+	{
+		if (kErrShouldInit != ret) {
+			xprintf("mutex_init failed with %d %s\n", ret, pstrerror(ret));
 			throw std::runtime_error("thread_mutex_init failed on first attempt");
 		} else {
-			xprintf("mutex init returned EPERM\n");
+			xprintf("mutex_init returned %d %s\n", ret, pstrerror(ret));
 			initializeRt();
-			if (int ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))) {
-				fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, strerror(-ret));
+			if ((ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))))
+			{
+				fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, pstrerror(ret));
 				throw std::runtime_error("thread_mutex_init failed on second attempt");
 			}
 		}
@@ -117,12 +164,12 @@ RtMutex::RtMutex() {
 RtMutex::~RtMutex() {
 	xprintf("Destroy mutex %p\n", &p->m_mutex);
 	if (m_enabled)
-		BELA_RT_WRAP(pthread_mutex_destroy(&p->m_mutex));
+		mutex_destroy(&p->m_mutex);
 }
 
 // a helper function to try
 // - call func()
-// - if it fails, try to turn the current thread into a cobalt thread and call func() again
+// - if it fails, try to turn the current thread into a RT thread and call func() again
 // - if it fails again, just fail
 // - return true if it succeeds, or false if it fails
 // id and name are just for debugging purposes, while m_enabled is there because it saves duplicating some lines
@@ -139,10 +186,10 @@ template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_en
 	// 0 is "success" (or at least meaningful failure)
 	if (0 == ret) {
 		return true;
-	} else if (EPERM != ret) {
+	} else if (kErrShouldTurn != ret) {
 		return false;
 	} else {
-		// if we got EPERM, we are not a Xenomai thread
+		// if we got kErrShouldTurn, we are not a RT thread
 		if (!turnIntoRtThread()) {
 			xfprintf(stderr, "%s %p could not turn into cobalt\n", name, id);
 			return false;
@@ -164,35 +211,63 @@ template <typename F, typename T> static bool tryOrRetryImpl(F&& func, bool m_en
 
 // condition resource_deadlock_would_occur instead of deadlocking. https://en.cppreference.com/w/cpp/thread/mutex/lock
 bool RtMutex::try_lock() {
-	return tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_trylock(&this->p->m_mutex)); }, m_enabled);
+	return tryOrRetry([this]() { return mutex_trylock(&this->p->m_mutex); }, m_enabled);
 	// TODO: An implementation that can detect the invalid usage is encouraged to throw a std::system_error with error
 	// condition resource_deadlock_would_occur instead of deadlocking.
 }
 
 void RtMutex::lock() {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_lock(&this->p->m_mutex)); }, m_enabled);
+	tryOrRetry([this]() { return mutex_lock(&this->p->m_mutex); }, m_enabled);
 }
 
 void RtMutex::unlock() {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_mutex_unlock(&this->p->m_mutex)); }, m_enabled);
+	tryOrRetry([this]() { return mutex_unlock(&this->p->m_mutex); }, m_enabled);
+}
+
+
+typedef pthread_cond_t cond_t;
+
+// TODO: can we be clever with the preprocessor?
+int cond_wait(cond_t* cond, mutex_t* mutex)
+{
+	return BELA_RT_WRAP(pthread_cond_wait(cond, mutex));
+}
+
+int cond_signal(cond_t* cond)
+{
+	return BELA_RT_WRAP(pthread_cond_signal(cond));
+}
+
+int cond_broadcast(cond_t* cond)
+{
+	return BELA_RT_WRAP(pthread_cond_broadcast(cond));
+}
+
+int cond_destroy(cond_t* cond)
+{
+	return BELA_RT_WRAP(pthread_cond_destroy(cond));
 }
 
 struct RtConditionVariable::Private {
-	pthread_cond_t m_cond;
+	cond_t m_cond;
 };
 
 RtConditionVariable::RtConditionVariable() {
 	p = std::unique_ptr<Private>(new Private);
 	xprintf("Construct CondictionVariable\n");
-	if (int ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))) {
-		if (EPERM != ret) {
-			xprintf("thread_cond_init failed with %d %s\n", ret, strerror(ret));
+	int ret;
+	if ((ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))))
+	{
+		if (kErrShouldInit != ret) {
+			xprintf("cond_init failed with %d %s\n", ret, pstrerror(ret));
 			throw std::runtime_error("thread_cond_init failed at first attempt");
 		} else {
-			xprintf("mutex init returned EPERM\n");
+			xprintf("cond_init returned %d %s\n", ret, pstrerror(ret));
 			initializeRt();
-			if (int ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))) {
-				throw std::runtime_error("thread_cond_init failed at second attempt");
+			int ret;
+			if ((ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))))
+			{
+				throw std::runtime_error("cond_init failed at second attempt");
 			}
 		}
 	}
@@ -202,12 +277,12 @@ RtConditionVariable::RtConditionVariable() {
 RtConditionVariable::~RtConditionVariable() {
 	if (m_enabled) {
 		notify_all();
-		BELA_RT_WRAP(pthread_cond_destroy(&p->m_cond));
+		cond_destroy(&p->m_cond);
 	}
 }
 
 void RtConditionVariable::wait(RtMutex& lck) {
-	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->p->m_cond, &lck.p->m_mutex)); }), m_enabled);
+	tryOrRetry(([this, &lck]() { return cond_wait(&this->p->m_cond, &lck.p->m_mutex); }), m_enabled);
 }
 
 void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
@@ -220,13 +295,13 @@ void RtConditionVariable::wait(std::unique_lock<RtMutex>& lck) {
 
 	// It may throw system_error in case of failure (transmitting any error condition from the respective call to lock
 	// or unlock). The predicate version (2) may also throw exceptions thrown by pred.
-	tryOrRetry(([this, &lck]() { return BELA_RT_WRAP(pthread_cond_wait(&this->p->m_cond, &lck.mutex()->p->m_mutex)); }), m_enabled);
+	tryOrRetry(([this, &lck]() { return cond_wait(&this->p->m_cond, &lck.mutex()->p->m_mutex); }), m_enabled);
 }
 
 void RtConditionVariable::notify_one() noexcept {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_signal(&this->p->m_cond)); }, m_enabled);
+	tryOrRetry([this]() { return cond_signal(&this->p->m_cond); }, m_enabled);
 }
 
 void RtConditionVariable::notify_all() noexcept {
-	tryOrRetry([this]() { return BELA_RT_WRAP(pthread_cond_broadcast(&this->p->m_cond)); }, m_enabled);
+	tryOrRetry([this]() { return cond_broadcast(&this->p->m_cond); }, m_enabled);
 }

From e65da175f6e61d88c1a4ba0839df7fa31a89a8a0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 24 Aug 2022 16:16:48 +0000
Subject: [PATCH 129/188] MiscUtilities: return error from writeTextFile() if
 the file is no longer in good state

---
 core/MiscUtilities.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/core/MiscUtilities.cpp b/core/MiscUtilities.cpp
index 1933bfa01..cb64fa2c4 100644
--- a/core/MiscUtilities.cpp
+++ b/core/MiscUtilities.cpp
@@ -110,6 +110,11 @@ int writeTextFile(const std::string& path, const std::string& content, Mode mode
 	if(outputFile.is_open())
 	{
 		outputFile << content;
+		if(!outputFile.good())
+		{
+			fprintf(stderr, "File %s is no longer good after writing to it\n.", path.c_str());
+			return -1;
+		}
 		return 0;
 	}
 	fprintf(stderr, "File %s could not be opened\n.", path.c_str());

From c7394005f910094d91579ac04cb4d825266b215e Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 24 Aug 2022 16:15:28 +0000
Subject: [PATCH 130/188] RtWrappers: take cpuset as a parameter.

This is because EVL seems to crash if the correct cpuset is not set before the thread is attached to the core
---
 core/AuxTaskNonRT.cpp   |  2 +-
 core/AuxTaskRT.cpp      |  2 +-
 core/AuxiliaryTasks.cpp |  2 +-
 core/RTAudio.cpp        |  4 ++--
 core/RtWrappers.cpp     | 17 ++++++++++++++++-
 include/RtWrappers.h    |  2 +-
 6 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index 57143362e..e2857905e 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -56,7 +56,7 @@ void AuxTaskNonRT::__create(){
 	}
 	
 	// start the xenomai task
-	if(int ret = create_and_start_thread(&thread, name.c_str(), priority, stackSize, (pthread_callback_t*)AuxTaskNonRT::thread_func, this))
+	if(int ret = create_and_start_thread(&thread, name.c_str(), priority, stackSize, NULL, (pthread_callback_t*)AuxTaskNonRT::thread_func, this))
 	{
 		fprintf(stderr, "Unable to start AuxTaskNonRT %s: %i, %s\n", name.c_str(), ret, strerror(ret));
 		return;
diff --git a/core/AuxTaskRT.cpp b/core/AuxTaskRT.cpp
index 7148bcb5b..b065e66bd 100644
--- a/core/AuxTaskRT.cpp
+++ b/core/AuxTaskRT.cpp
@@ -52,7 +52,7 @@ void AuxTaskRT::__create(){
 	}
 	
 	// start the xenomai task
-	if(int ret = create_and_start_thread(&thread, name.c_str(), priority, stackSize, (pthread_callback_t*)AuxTaskRT::thread_func, this))
+	if(int ret = create_and_start_thread(&thread, name.c_str(), priority, stackSize, NULL, (pthread_callback_t*)AuxTaskRT::thread_func, this))
 	{
 		fprintf(stderr, "Unable to start AuxTaskRT %s: %i\n", name.c_str(), ret);
 		return;
diff --git a/core/AuxiliaryTasks.cpp b/core/AuxiliaryTasks.cpp
index dde9e91ad..75db2de7a 100644
--- a/core/AuxiliaryTasks.cpp
+++ b/core/AuxiliaryTasks.cpp
@@ -60,7 +60,7 @@ AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int p
 	// Upon calling this function, the thread will start and immediately wait
 	// on the condition variable.
 	if(!ret)
-		ret = create_and_start_thread(&(newTask->task), name, priority, stackSize,(pthread_callback_t*)auxiliaryTaskLoop, newTask);
+		ret = create_and_start_thread(&(newTask->task), name, priority, stackSize, NULL, (pthread_callback_t*)auxiliaryTaskLoop, newTask);
 	if(ret)
 	{
 		fprintf(stderr, "Error: unable to create auxiliary task %s : (%d) %s\n", name, ret, strerror(ret));
diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 7e144eeb2..0b202c7e4 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -936,7 +936,7 @@ int Bela_startAudio()
 		//if there is a fifo, the core audio thread below will need a higher priority
 		audioPriority = BELA_AUDIO_PRIORITY + 1;
 		// and we start an extra thread with usual audio priority in which the user's render() will run
-		ret = create_and_start_thread(&gFifoThread, gFifoThreadName, audioPriority - 1, stackSize, (pthread_callback_t*)fifoLoop, NULL);
+		ret = create_and_start_thread(&gFifoThread, gFifoThreadName, audioPriority - 1, stackSize, NULL, (pthread_callback_t*)fifoLoop, NULL);
 		if(ret)
 		{
 			fprintf(stderr, "Error: unable to start Xenomai fifo audio thread: %d %s\n", ret, strerror(-ret));
@@ -945,7 +945,7 @@ int Bela_startAudio()
 	} else {
 		audioPriority = BELA_AUDIO_PRIORITY;
 	}
-	ret = create_and_start_thread(&gRTAudioThread, gRTAudioThreadName, audioPriority, stackSize, (pthread_callback_t*)audioLoop, NULL);
+	ret = create_and_start_thread(&gRTAudioThread, gRTAudioThreadName, audioPriority, stackSize, NULL, (pthread_callback_t*)audioLoop, NULL);
 	if(ret)
 	{
 		fprintf(stderr, "Error: unable to start Xenomai audio thread: %d %s\n", ret, strerror(-ret));
diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index dea3f4aad..309121018 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -52,7 +52,7 @@ int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, int prio)
 	return 0;
 }
 
-int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, pthread_callback_t* callback, void* arg)
+int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, cpu_set_t* req_cpuset, pthread_callback_t* callback, void* arg)
 {
 	pthread_attr_t attr;
 	if(BELA_RT_WRAP(pthread_attr_init(&attr)))
@@ -64,6 +64,21 @@ int create_and_start_thread(pthread_t* task, const char* taskName, int priority,
 	{
 		return ret;
 	}
+	cpu_set_t* cpuset = req_cpuset;
+	cpu_set_t our_cpuset;
+	if(!cpuset || (cpuset && !CPU_COUNT(cpuset)))
+	{
+		// not sure what is supposed to happen if you have an empty cpu_set_t
+		// so - and also as a default in case a NULL is passed in - we set all CPUs in the set
+		cpuset = &our_cpuset;
+		CPU_ZERO(cpuset);
+		for(unsigned int n = 0; n < CPU_SETSIZE; ++n)
+			CPU_SET(n, cpuset);
+	}
+	if(int ret = pthread_attr_setaffinity_np(&attr, sizeof(*cpuset), cpuset))
+	{
+		return ret;
+	}
 	if(int ret = BELA_RT_WRAP(pthread_create(task, &attr, callback, arg)))
 	{
 		return ret;
diff --git a/include/RtWrappers.h b/include/RtWrappers.h
index cdd6719d1..3cb77f881 100644
--- a/include/RtWrappers.h
+++ b/include/RtWrappers.h
@@ -57,7 +57,7 @@ void setup_sched_parameters(pthread_attr_t *attr, int prio);
 
 int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, int prio);
 
-int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, pthread_callback_t* callback, void* arg);
+int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, cpu_set_t* cpuset, pthread_callback_t* callback, void* arg);
 
 int createBelaRtPipe(const char* portName, size_t poolsz);
 

From eabe6e34b105833eaf2d45e611fcd9269ee5f938 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 24 Aug 2022 20:45:37 +0000
Subject: [PATCH 131/188] RtWrappers: moved initialiseRt() and
 turnIntoRtThread() from RtLock to RtWrappers

---
 core/RtLock.cpp      | 66 ---------------------------------------
 core/RtWrappers.cpp  | 73 ++++++++++++++++++++++++++++++++++++++++++++
 include/RtWrappers.h |  4 +++
 3 files changed, 77 insertions(+), 66 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index aabf3d5c7..508c6e547 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -41,72 +41,6 @@ static const int kErrShouldTurn = 0; // will never be true
 #define xfprintf(...)
 #endif // PRINT_RT_LOCK
 
-// Standard Linux `gettid(2)` not available on Bela
-static inline pid_t getTid() {
-	pid_t tid = syscall(SYS_gettid);
-	return tid;
-}
-
-#ifdef __COBALT__
-#include <xenomai/init.h>
-// throughout, we use heuristics to check whether Xenomai needs to be
-// initialised and whether the current thread is a Xenomai thread.
-// See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
-static void initializeXenomai() {
-	xprintf("initializeXenomai\n");
-	enum { _argc = 2 };
-	int argc = _argc;
-	char blankOpt[] = "";
-#ifdef PRINT_RT_LOCK
-	char traceOpt[] = "--trace";
-#else // PRINT_RT_LOCK
-	char traceOpt[] = "";
-#endif // PRINT_RT_LOCK
-
-	char* const argv[_argc] = { blankOpt, traceOpt };
-	char* const* argvPtrs[_argc] = { &argv[0], &argv[1] };
-	xenomai_init(&argc, argvPtrs);
-}
-
-static bool turnIntoCobaltThread(bool recurred = false) {
-	struct sched_param param;
-	memset(&param, 0, sizeof(param));
-	int policy;
-	// Guaranteed to succeed as pthread_self() cannot fail and pthread_getschedparam()'s only error condition is when
-	// the given thread does not exist.
-	pthread_getschedparam(pthread_self(), &policy, &param);
-	pid_t tid = getTid();
-
-	if (int ret = __wrap_sched_setscheduler(tid, policy, &param)) {
-		fprintf(stderr, "Warning: unable to turn current thread into a Xenomai thread : (%d) %s\n", -ret,
-				strerror(-ret));
-		initializeXenomai();
-		if (!recurred)
-			return turnIntoCobaltThread(true);
-		else
-			return false;
-	}
-	xprintf("Turned thread %d into a Cobalt thread %s\n", tid, recurred ? "with recursion" : "");
-	return true;
-}
-#endif // __COBALT__
-
-static bool turnIntoRtThread()
-{
-#if defined __COBALT__
-	return turnIntoCobaltThread();
-#else // do nothing
-	return true;
-#endif
-}
-
-static void initializeRt()
-{
-#ifdef __COBALT__
-	initializeXenomai();
-#endif // __COBALT__
-}
-
 static const char* pstrerror(int ret)
 {
 	return strerror(ret < 0 ? -ret : ret);
diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index 309121018..e522450c7 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -166,6 +166,79 @@ int createBelaRtPipe(const char* portName, int poolsz)
 }
 #endif //__COBALT__
 
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+// Standard Linux `gettid(2)` not available on Bela
+inline pid_t getTid() {
+	pid_t tid = syscall(SYS_gettid);
+	return tid;
+}
+
+#ifdef __COBALT__
+#include <xenomai/init.h>
+// throughout, we use heuristics to check whether Xenomai needs to be
+// initialised and whether the current thread is a Xenomai thread.
+// See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
+static void initializeXenomai() {
+	xprintf("initializeXenomai\n");
+	enum { _argc = 2 };
+	int argc = _argc;
+	char blankOpt[] = "";
+#ifdef PRINT_RT_LOCK
+	char traceOpt[] = "--trace";
+#else // PRINT_RT_LOCK
+	char traceOpt[] = "";
+#endif // PRINT_RT_LOCK
+
+	char* const argv[_argc] = { blankOpt, traceOpt };
+	char* const* argvPtrs[_argc] = { &argv[0], &argv[1] };
+	xenomai_init(&argc, argvPtrs);
+}
+
+static bool turnIntoCobaltThread(bool recurred = false) {
+	struct sched_param param;
+	memset(&param, 0, sizeof(param));
+	int policy;
+	// Guaranteed to succeed as pthread_self() cannot fail and pthread_getschedparam()'s only error condition is when
+	// the given thread does not exist.
+	pthread_getschedparam(pthread_self(), &policy, &param);
+	pid_t tid = getTid();
+
+	if (int ret = __wrap_sched_setscheduler(tid, policy, &param)) {
+		fprintf(stderr, "Warning: unable to turn current thread into a Xenomai thread : (%d) %s\n", -ret,
+				strerror(-ret));
+		initializeXenomai();
+		if (!recurred)
+			return turnIntoCobaltThread(true);
+		else
+			return false;
+	}
+	if(gRTAudioVerbose)
+		rt_printf("Turned thread %d into a Cobalt thread\n", tid);
+	return true;
+}
+#endif // __COBALT__
+
+bool turnIntoRtThread()
+{
+#if defined __COBALT__
+	return turnIntoCobaltThread();
+#else // do nothing
+	return true;
+#endif
+}
+
+void initializeRt()
+{
+#ifdef __COBALT__
+	initializeXenomai();
+#endif // __COBALT__
+}
+
 #include <Bela.h>
 #define var_num_to_va_list(stream, fmt, dest) \
 { \
diff --git a/include/RtWrappers.h b/include/RtWrappers.h
index 3cb77f881..f08276ba6 100644
--- a/include/RtWrappers.h
+++ b/include/RtWrappers.h
@@ -63,6 +63,10 @@ int createBelaRtPipe(const char* portName, size_t poolsz);
 
 void Bela_initRtBackend();
 
+bool turnIntoRtThread();
+
+void initializeRt();
+
 #ifdef __cplusplus
 }
 #endif

From dacc99fe5e2f38cd786361fe077b6c21e9219580 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 27 Sep 2023 19:58:13 +0000
Subject: [PATCH 132/188] Pipe: allow to build with RtWrappers.h

---
 libraries/Pipe/Pipe.cpp     | 7 ++++++-
 libraries/Pipe/lib.metadata | 4 ++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/libraries/Pipe/Pipe.cpp b/libraries/Pipe/Pipe.cpp
index 308e85d19..7d2f3ead9 100644
--- a/libraries/Pipe/Pipe.cpp
+++ b/libraries/Pipe/Pipe.cpp
@@ -1,7 +1,12 @@
 #include "Pipe.h"
-#include <xenomai_wraps.h>
+#include <RtWrappers.h>
 #include <stdexcept>
 #include <sys/select.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
 std::string Pipe::defaultName;
 
 Pipe::Pipe(const std::string& pipeName, size_t size, bool newBlockingRt, bool newBlockingNonRt)
diff --git a/libraries/Pipe/lib.metadata b/libraries/Pipe/lib.metadata
index eb1e36048..5b7c5ed8d 100644
--- a/libraries/Pipe/lib.metadata
+++ b/libraries/Pipe/lib.metadata
@@ -8,8 +8,8 @@ license=LGPL 3.0
 url=
 board=*
 dependencies=
-LDFLAGS=-Wl,--no-as-needed -L/usr/xenomai/lib
-LDLIBS=-lcobalt -lmodechk
+LDFLAGS=
+LDLIBS=
 CXXFLAGS=
 CC=
 CXX=

From cd2df41a7a65d5586c36bee39980a727c4269d64 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 28 Sep 2023 21:17:54 +0000
Subject: [PATCH 133/188] RtLock: rely on the singleton Bela_initRtBackend()

---
 core/RtLock.cpp      | 35 +++++------------------------------
 include/RtWrappers.h |  2 --
 2 files changed, 5 insertions(+), 32 deletions(-)

diff --git a/core/RtLock.cpp b/core/RtLock.cpp
index 508c6e547..750a76220 100644
--- a/core/RtLock.cpp
+++ b/core/RtLock.cpp
@@ -11,15 +11,6 @@
 #include <sys/syscall.h>
 #include <stdexcept>
 
-// What error - if returned by the initialisation routine - means we should
-// force-initialise the RT core and try again
-#if defined(__COBALT__)
-static const int kErrShouldInit = EPERM;
-#else
-static const int kErrShouldInit = 0; // will never be true
-#endif
-
-
 // What error - if returned by the a runtime routine - means we should
 // force-turn the current thread into an RT thread and try again
 #if defined(__COBALT__)
@@ -74,23 +65,14 @@ struct RtMutex::Private {
 };
 
 RtMutex::RtMutex() {
+	Bela_initRtBackend();
 	p = std::unique_ptr<Private>(new Private);
 	xprintf("Construct mutex\n");
 	int ret;
 	if ((ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))))
 	{
-		if (kErrShouldInit != ret) {
-			xprintf("mutex_init failed with %d %s\n", ret, pstrerror(ret));
-			throw std::runtime_error("thread_mutex_init failed on first attempt");
-		} else {
-			xprintf("mutex_init returned %d %s\n", ret, pstrerror(ret));
-			initializeRt();
-			if ((ret = BELA_RT_WRAP(pthread_mutex_init(&p->m_mutex, NULL))))
-			{
-				fprintf(stderr, "Error: unable to initialize mutex : (%d) %s\n", ret, pstrerror(ret));
-				throw std::runtime_error("thread_mutex_init failed on second attempt");
-			}
-		}
+		xprintf("mutex_init failed with %d %s\n", ret, pstrerror(ret));
+		throw std::runtime_error("thread_mutex_init failed on first attempt");
 	}
 	m_enabled = true;
 }
@@ -187,22 +169,15 @@ struct RtConditionVariable::Private {
 };
 
 RtConditionVariable::RtConditionVariable() {
+	Bela_initRtBackend();
 	p = std::unique_ptr<Private>(new Private);
 	xprintf("Construct CondictionVariable\n");
 	int ret;
 	if ((ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))))
 	{
-		if (kErrShouldInit != ret) {
+		if (ret) {
 			xprintf("cond_init failed with %d %s\n", ret, pstrerror(ret));
 			throw std::runtime_error("thread_cond_init failed at first attempt");
-		} else {
-			xprintf("cond_init returned %d %s\n", ret, pstrerror(ret));
-			initializeRt();
-			int ret;
-			if ((ret = BELA_RT_WRAP(pthread_cond_init(&p->m_cond, NULL))))
-			{
-				throw std::runtime_error("cond_init failed at second attempt");
-			}
 		}
 	}
 	m_enabled = true;
diff --git a/include/RtWrappers.h b/include/RtWrappers.h
index f08276ba6..edff22e3a 100644
--- a/include/RtWrappers.h
+++ b/include/RtWrappers.h
@@ -65,8 +65,6 @@ void Bela_initRtBackend();
 
 bool turnIntoRtThread();
 
-void initializeRt();
-
 #ifdef __cplusplus
 }
 #endif

From 47db6656c6c9ad429ded03e204b447f2441dd2e5 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 28 Sep 2023 21:28:40 +0000
Subject: [PATCH 134/188] RTAudio, RtWrapper: moved CATCH_MSW to RtWrapper

---
 core/RTAudio.cpp    | 61 +++----------------------------------------
 core/RtWrappers.cpp | 63 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 66 insertions(+), 58 deletions(-)

diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 0b202c7e4..180579e70 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -51,58 +51,7 @@ extern "C" void disable_runfast();
 
 // ARM interrupt number for PRU event EVTOUT7
 #define PRU_RTAUDIO_IRQ		21
-//#define XENOMAI_CATCH_MSW // get SIGDEBUG when a mode switch takes place
 
-#ifdef XENOMAI_CATCH_MSW
-#include <sys/types.h>
-#include <pthread.h>
-#include <signal.h>
-#include <unistd.h>
-#include <execinfo.h>
-
-static const char *sigdebug_msg[] = {
-	[SIGDEBUG_UNDEFINED] = "latency: received SIGXCPU for unknown reason",
-	[SIGDEBUG_MIGRATE_SIGNAL] = "received signal",
-	[SIGDEBUG_MIGRATE_SYSCALL] = "invoked syscall",
-	[SIGDEBUG_MIGRATE_FAULT] = "triggered fault",
-	[SIGDEBUG_MIGRATE_PRIOINV] = "affected by priority inversion",
-	[SIGDEBUG_NOMLOCK] = "Xenomai: process memory not locked "
-	"(missing mlockall?)",
-	[SIGDEBUG_WATCHDOG] = "Xenomai: watchdog triggered "
-	"(period too short?)",
-};
-
-void sigdebug_handler(int sig, siginfo_t *si, void *context)
-{
-	const char fmt[] = "Mode switch (reason: %s). Backtrace:\n";
-	unsigned int cause = sigdebug_reason(si);
-	static char buffer[256];
-	static void *bt[200];
-	unsigned int n;
-
-	if (cause > SIGDEBUG_WATCHDOG)
-		cause = SIGDEBUG_UNDEFINED;
-
-	switch(cause) {
-	case SIGDEBUG_UNDEFINED:
-	case SIGDEBUG_NOMLOCK:
-	case SIGDEBUG_WATCHDOG:
-		/* These errors are lethal, something went really wrong. */
-		n = snprintf(buffer, sizeof(buffer), "%s\n", sigdebug_msg[cause]);
-		write(STDERR_FILENO, buffer, n);
-		exit(EXIT_FAILURE);
-	}
-
-	/* Retrieve the current backtrace, and decode it to stdout. */
-	n = snprintf(buffer, sizeof(buffer), fmt, sigdebug_msg[cause]);
-	n = write(STDERR_FILENO, buffer, n);
-	n = backtrace(bt, sizeof(bt)/sizeof(bt[0]));
-	backtrace_symbols_fd(bt, n, STDERR_FILENO);
-
-	//signal(sig, SIG_DFL);
-	//kill(getpid(), sig);
-}
-#endif // XENOMAI_CATCH_MSW
 using namespace std;
 using namespace BelaHwComponent;
 
@@ -412,13 +361,7 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 	}
 #endif // __COBALT__
 	Bela_initRtBackend();
-#ifdef XENOMAI_CATCH_MSW
-	struct sigaction sa;
-	sigemptyset(&sa.sa_mask);
-	sa.sa_sigaction = sigdebug_handler;
-	sa.sa_flags = SA_SIGINFO;
-	sigaction(SIGDEBUG, &sa, NULL);
-#endif // XENOMAI_CATCH_MSW
+	turnIntoRtThread();
 
 	// reset this, in case it has been set before
 	gShouldStop = 0;
@@ -790,6 +733,8 @@ int Bela_initAudio(BelaInitSettings *settings, void *userData)
 void audioLoop(void *)
 {
 #ifdef XENOMAI_CATCH_MSW
+	// TODO: this has to be enabled manually alongside the
+	// CATCH_MSW in RtWrappers.cpp when using __COBALT__
 	pthread_setmode_np(0, PTHREAD_WARNSW, NULL);
 #endif // XENOMAI_CATCH_MSW
 	if(gRTAudioVerbose)
diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index e522450c7..21700d6a3 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -3,6 +3,8 @@
 #include <string.h>
 #include <time.h>
 
+//#define CATCH_MSW
+
 int task_sleep_ns(long long int timens)
 {
 	struct timespec req;
@@ -52,6 +54,59 @@ int set_thread_stack_and_priority(pthread_attr_t *attr, int stackSize, int prio)
 	return 0;
 }
 
+#ifdef CATCH_MSW
+#ifdef __COBALT__
+#include <sys/types.h>
+#include <pthread.h>
+#include <signal.h>
+#include <unistd.h>
+#include <execinfo.h>
+
+static const char *sigdebug_msg[] = {
+	[SIGDEBUG_UNDEFINED] = "latency: received SIGXCPU for unknown reason",
+	[SIGDEBUG_MIGRATE_SIGNAL] = "received signal",
+	[SIGDEBUG_MIGRATE_SYSCALL] = "invoked syscall",
+	[SIGDEBUG_MIGRATE_FAULT] = "triggered fault",
+	[SIGDEBUG_MIGRATE_PRIOINV] = "affected by priority inversion",
+	[SIGDEBUG_NOMLOCK] = "Xenomai: process memory not locked "
+	"(missing mlockall?)",
+	[SIGDEBUG_WATCHDOG] = "Xenomai: watchdog triggered "
+	"(period too short?)",
+};
+
+void sigdebug_handler(int sig, siginfo_t *si, void *context)
+{
+	const char fmt[] = "Mode switch (reason: %s). Backtrace:\n";
+	unsigned int cause = sigdebug_reason(si);
+	static char buffer[256];
+	static void *bt[200];
+	unsigned int n;
+
+	if (cause > SIGDEBUG_WATCHDOG)
+		cause = SIGDEBUG_UNDEFINED;
+
+	switch(cause) {
+	case SIGDEBUG_UNDEFINED:
+	case SIGDEBUG_NOMLOCK:
+	case SIGDEBUG_WATCHDOG:
+		/* These errors are lethal, something went really wrong. */
+		n = snprintf(buffer, sizeof(buffer), "%s\n", sigdebug_msg[cause]);
+		write(STDERR_FILENO, buffer, n);
+		exit(EXIT_FAILURE);
+	}
+
+	/* Retrieve the current backtrace, and decode it to stdout. */
+	n = snprintf(buffer, sizeof(buffer), fmt, sigdebug_msg[cause]);
+	n = write(STDERR_FILENO, buffer, n);
+	n = backtrace(bt, sizeof(bt)/sizeof(bt[0]));
+	backtrace_symbols_fd(bt, n, STDERR_FILENO);
+
+	//signal(sig, SIG_DFL);
+	//kill(getpid(), sig);
+}
+#endif // __COBALT__
+#endif // CATCH_MSW
+
 int create_and_start_thread(pthread_t* task, const char* taskName, int priority, int stackSize, cpu_set_t* req_cpuset, pthread_callback_t* callback, void* arg)
 {
 	pthread_attr_t attr;
@@ -92,6 +147,14 @@ int create_and_start_thread(pthread_t* task, const char* taskName, int priority,
 	//printf("measured stack: %d, requested stack: %d\n", stk, stackSize);
 
 	pthread_attr_destroy(&attr);
+
+#ifdef CATCH_MSW
+	struct sigaction sa;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_sigaction = sigdebug_handler;
+	sa.sa_flags = SA_SIGINFO;
+	sigaction(SIGDEBUG, &sa, NULL);
+#endif // CATCH_MSW
 	return 0;
 }
 

From c818a3d42850b4222aff7b0841c823c08f9e0d92 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 28 Sep 2023 21:41:10 +0000
Subject: [PATCH 135/188] RtAudio, RtWrapper: moved Bela_initRtBackend() to
 RtWrapper

---
 core/RTAudio.cpp    | 40 -----------------------
 core/RtWrappers.cpp | 79 +++++++++++++++++++++++++++++++--------------
 2 files changed, 54 insertions(+), 65 deletions(-)

diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index 180579e70..ff67b3cac 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -302,46 +302,6 @@ static int setChannelGains(BelaChannelGainArray& cga, int (*cb)(int, float))
 	return ret;
 }
 
-#include <mutex>
-extern "C" void Bela_initRtBackend()
-{
-	static std::once_flag flag;
-	std::call_once(flag, [](){
-		// initialize Xenomai with manual bootstrapping if needed
-		// we cannot trust gXenomaiInited exclusively, in case the caller
-		// already initialised Xenomai, so first we check if it is
-		// actually working.
-		bool xenomaiNeedsInit = false;
-		if(gRTAudioVerbose)
-			printf("Xenomai not explicitly inited\n");
-		// To figure out if we need to intialize it, attempt to create a Cobalt
-		// object (a mutex). If it fails with EPERM, Xenomai needs to be initialized
-		// See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
-		pthread_mutex_t dummyMutex;
-		int ret = BELA_RT_WRAP(pthread_mutex_init(&dummyMutex, NULL));
-		if(0 == ret) {
-			if(gRTAudioVerbose)
-				printf("Xenomai was inited by someone else\n");
-			// success: cleanup
-			BELA_RT_WRAP(pthread_mutex_destroy(&dummyMutex));
-		} else if (EPERM == ret) {
-			xenomaiNeedsInit = true;
-			if(gRTAudioVerbose)
-				printf("Xenomai is going to be inited by us\n");
-		} else {
-			// it could fail for other reasons, but we couldn't do much about it anyhow.
-			if(gRTAudioVerbose)
-				printf("Xenomai is in unknown state\n");
-		}
-		if(xenomaiNeedsInit) {
-			int argc = 0;
-			char *const *argv;
-			xenomai_init(&argc, &argv);
-		}
-		// this is no longer requi, but we keep it for backward
-		gXenomaiInited = 1;
-	});
-}
 int Bela_initAudio(BelaInitSettings *settings, void *userData)
 {
 	if(!settings)
diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index 21700d6a3..10b1c0424 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -2,7 +2,10 @@
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
+#include <stdlib.h>
+#include <mutex>
 
+extern int gRTAudioVerbose;
 //#define CATCH_MSW
 
 int task_sleep_ns(long long int timens)
@@ -161,7 +164,7 @@ int create_and_start_thread(pthread_t* task, const char* taskName, int priority,
 #ifdef __COBALT__
 #include <rtdm/ipc.h>
 #endif // __COBALT__
-int createBelaRtPipe(const char* portName, int poolsz)
+int createBelaRtPipe(const char* portName, size_t poolsz)
 #ifdef __COBALT__
 // from xenomai-3/demo/posix/cobalt/xddp-echo.c
 {
@@ -246,23 +249,8 @@ inline pid_t getTid() {
 // throughout, we use heuristics to check whether Xenomai needs to be
 // initialised and whether the current thread is a Xenomai thread.
 // See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
-static void initializeXenomai() {
-	xprintf("initializeXenomai\n");
-	enum { _argc = 2 };
-	int argc = _argc;
-	char blankOpt[] = "";
-#ifdef PRINT_RT_LOCK
-	char traceOpt[] = "--trace";
-#else // PRINT_RT_LOCK
-	char traceOpt[] = "";
-#endif // PRINT_RT_LOCK
-
-	char* const argv[_argc] = { blankOpt, traceOpt };
-	char* const* argvPtrs[_argc] = { &argv[0], &argv[1] };
-	xenomai_init(&argc, argvPtrs);
-}
-
-static bool turnIntoCobaltThread(bool recurred = false) {
+static bool turnIntoCobaltThread() {
+	Bela_initRtBackend();
 	struct sched_param param;
 	memset(&param, 0, sizeof(param));
 	int policy;
@@ -274,11 +262,7 @@ static bool turnIntoCobaltThread(bool recurred = false) {
 	if (int ret = __wrap_sched_setscheduler(tid, policy, &param)) {
 		fprintf(stderr, "Warning: unable to turn current thread into a Xenomai thread : (%d) %s\n", -ret,
 				strerror(-ret));
-		initializeXenomai();
-		if (!recurred)
-			return turnIntoCobaltThread(true);
-		else
-			return false;
+		return false;
 	}
 	if(gRTAudioVerbose)
 		rt_printf("Turned thread %d into a Cobalt thread\n", tid);
@@ -295,11 +279,56 @@ bool turnIntoRtThread()
 #endif
 }
 
-void initializeRt()
+void Bela_initRtBackend()
 {
+	static std::once_flag flag;
+	std::call_once(flag, [](){
 #ifdef __COBALT__
-	initializeXenomai();
+		// initialize Xenomai with manual bootstrapping if needed
+		// we cannot trust gXenomaiInited exclusively, in case the caller
+		// already initialised Xenomai, so first we check if it is
+		// actually working.
+		bool xenomaiNeedsInit = false;
+		if(gRTAudioVerbose)
+			printf("Xenomai not explicitly inited\n");
+		// To figure out if we need to intialize it, attempt to create a Cobalt
+		// object (a mutex). If it fails with EPERM, Xenomai needs to be initialized
+		// See https://www.xenomai.org/pipermail/xenomai/2019-January/040203.html
+		pthread_mutex_t dummyMutex;
+		int ret = __wrap_pthread_mutex_init(&dummyMutex, NULL);
+		if(0 == ret) {
+			if(gRTAudioVerbose)
+				printf("Xenomai was inited by someone else\n");
+			// success: cleanup
+			__wrap_pthread_mutex_destroy(&dummyMutex);
+		} else if (EPERM == ret) {
+			xenomaiNeedsInit = true;
+			if(gRTAudioVerbose)
+				printf("Xenomai is going to be inited by us\n");
+		} else {
+			// it could fail for other reasons, but we couldn't do much about it anyhow.
+			if(gRTAudioVerbose)
+				printf("Xenomai is in unknown state\n");
+		}
+		if(xenomaiNeedsInit) {
+			static constexpr int _argc = 2;
+			int argc = _argc;
+			char blankOpt[] = "";
+#ifdef PRINT_RT_LOCK
+			char traceOpt[] = "--trace";
+#else // PRINT_RT_LOCK
+			char traceOpt[] = "";
+#endif // PRINT_RT_LOCK
+			char* const argv[_argc] = { blankOpt, traceOpt };
+			char* const* argvPtrs[_argc] = { &argv[0], &argv[1] };
+			xenomai_init(&argc, argvPtrs);
+		}
 #endif // __COBALT__
+		// this is no longer required, but we keep it for backward
+		// compatibility
+		extern int gXenomaiInited;
+		gXenomaiInited = 1;
+	});
 }
 
 #include <Bela.h>

From 7714c36f7a74d62a5db40ad3588fcaddab898578 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sat, 31 Jul 2021 21:47:18 +0000
Subject: [PATCH 136/188] Parametrised SPI chip select lines

---
 core/PRU.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/PRU.cpp b/core/PRU.cpp
index 88789d9f7..a3c7620b1 100644
--- a/core/PRU.cpp
+++ b/core/PRU.cpp
@@ -187,8 +187,8 @@ const unsigned int belaRevCLedBlue = 79;
 const unsigned int underrunLedDuration = 20000;
 const unsigned int saltSwitch1Gpio = 60; // P9_12
 
-const unsigned int PRU::kPruGPIODACSyncPin = 5;	// GPIO0(5); P9-17
-const unsigned int PRU::kPruGPIOADCSyncPin = 48; // GPIO1(16); P9-15
+const unsigned int PRU::kPruGPIODACSyncPin = kSpiDacChipSelectPin;
+const unsigned int PRU::kPruGPIOADCSyncPin = kSpiAdcChipSelectPin;
 
 #ifdef USE_NEON_FORMAT_CONVERSION
 // These four functions are written in assembly in FormatConvert.S

From 6fedd2c76839c2daa544573505eb13e86cab68d0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 29 Sep 2023 13:29:26 -0500
Subject: [PATCH 137/188] Makefile: NIT: writing CORE_CORE_OBJS entries one per
 line

---
 Makefile | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 81333a85e..80e9fdb01 100644
--- a/Makefile
+++ b/Makefile
@@ -392,7 +392,32 @@ CORE_ASM_SRCS := $(wildcard core/*.S)
 CORE_ASM_OBJS := $(addprefix build/core/,$(notdir $(CORE_ASM_SRCS:.S=.o)))
 ALL_DEPS += $(addprefix build/core/,$(notdir $(CORE_ASM_SRCS:.S=.d)))
 
-CORE_CORE_OBJS := build/core/RTAudio.o build/core/PRU.o build/core/RTAudioCommandLine.o build/core/I2c_Codec.o build/core/I2c_MultiTLVCodec.o build/core/I2c_MultiI2sCodec.o build/core/I2c_MultiTdmCodec.o build/core/Spi_Codec.o build/core/Es9080_Codec.o build/core/Tlv320_Es9080_Codec.o build/core/math_runfast.o build/core/GPIOcontrol.o build/core/PruBinary.o build/core/board_detect.o build/core/DataFifo.o build/core/BelaContextFifo.o build/core/BelaContextSplitter.o build/core/MiscUtilities.o build/core/Mmap.o build/core/Mcasp.o build/core/PruManager.o build/core/FormatConvert.o build/core/RtWrappers.o
+CORE_CORE_OBJS := \
+build/core/BelaContextFifo.o \
+build/core/BelaContextSplitter.o \
+build/core/DataFifo.o \
+build/core/Es9080_Codec.o \
+build/core/FormatConvert.o \
+build/core/GPIOcontrol.o \
+build/core/I2c_Codec.o \
+build/core/I2c_MultiI2sCodec.o \
+build/core/I2c_MultiTLVCodec.o \
+build/core/I2c_MultiTdmCodec.o \
+build/core/Mcasp.o \
+build/core/MiscUtilities.o \
+build/core/Mmap.o \
+build/core/PRU.o \
+build/core/PruBinary.o \
+build/core/PruManager.o \
+build/core/RTAudio.o \
+build/core/RTAudioCommandLine.o \
+build/core/RtWrappers.o \
+build/core/Spi_Codec.o \
+build/core/Tlv320_Es9080_Codec.o \
+build/core/board_detect.o \
+build/core/math_runfast.o \
+# this line intentionally left blank (it's not)
+
 EXTRA_CORE_OBJS := $(filter-out $(CORE_CORE_OBJS), $(CORE_OBJS)) $(filter-out $(CORE_CORE_OBJS),$(CORE_ASM_OBJS))
 # Objects for a system-supplied default main() file, if the user
 # only wants to provide the render functions.

From 0db0e1fb0d9f684d4d389fa55a067b0475ecbc3a Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 23 Oct 2023 20:16:25 +0000
Subject: [PATCH 138/188] xenomai_init: resetting optind before calling it

---
 core/RtWrappers.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index 10b1c0424..6c9e437a8 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -321,6 +321,7 @@ void Bela_initRtBackend()
 #endif // PRINT_RT_LOCK
 			char* const argv[_argc] = { blankOpt, traceOpt };
 			char* const* argvPtrs[_argc] = { &argv[0], &argv[1] };
+			optind = 1;
 			xenomai_init(&argc, argvPtrs);
 		}
 #endif // __COBALT__

From 344e85f41f121edf6cb7ec03d0631189a2368b2d Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 24 Oct 2023 19:39:55 +0000
Subject: [PATCH 139/188] Midi: removed XENOMAI_SKIN_native support and fixed
 include

---
 libraries/Midi/Midi.cpp | 2 +-
 libraries/Midi/Midi.h   | 8 --------
 2 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/libraries/Midi/Midi.cpp b/libraries/Midi/Midi.cpp
index 75cfdd351..11e805ab7 100644
--- a/libraries/Midi/Midi.cpp
+++ b/libraries/Midi/Midi.cpp
@@ -9,7 +9,7 @@
 #include <fcntl.h>
 #include <errno.h>
 #include <glob.h>
-#include "../include/xenomai_wraps.h"
+#include "../include/RtWrappers.h"
 #include <alsa/asoundlib.h>
 
 #define kMidiInput 0
diff --git a/libraries/Midi/Midi.h b/libraries/Midi/Midi.h
index 504c6908d..e680ff3f7 100644
--- a/libraries/Midi/Midi.h
+++ b/libraries/Midi/Midi.h
@@ -2,9 +2,6 @@
 #include <Bela.h>
 #include <vector>
 #include <string>
-#ifdef XENOMAI_SKIN_native
-#include <native/pipe.h>
-#endif
 
 typedef unsigned char midi_byte_t;
 
@@ -410,10 +407,5 @@ class Midi {
 	char* inId;
 	char* outId;
 	char* outPipeName;
-#ifdef XENOMAI_SKIN_native
-	RT_PIPE outPipe;
-#endif
-#ifdef XENOMAI_SKIN_posix
 	int sock;
-#endif
 };

From dd3819e55bc38a53e7d8d39a408b0c2d8c65ac60 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 24 Oct 2023 19:39:20 +0000
Subject: [PATCH 140/188] examples/PureData/custom-render-ADXL345

---
 .../PureData/custom-render-ADXL345/LICENSE    |  675 +++++++
 .../PureData/custom-render-ADXL345/_main.pd   |   51 +
 .../PureData/custom-render-ADXL345/adxl345.c  |  109 ++
 .../PureData/custom-render-ADXL345/adxl345.h  |   51 +
 .../PureData/custom-render-ADXL345/render.cpp | 1659 +++++++++++++++++
 5 files changed, 2545 insertions(+)
 create mode 100644 examples/PureData/custom-render-ADXL345/LICENSE
 create mode 100644 examples/PureData/custom-render-ADXL345/_main.pd
 create mode 100644 examples/PureData/custom-render-ADXL345/adxl345.c
 create mode 100644 examples/PureData/custom-render-ADXL345/adxl345.h
 create mode 100644 examples/PureData/custom-render-ADXL345/render.cpp

diff --git a/examples/PureData/custom-render-ADXL345/LICENSE b/examples/PureData/custom-render-ADXL345/LICENSE
new file mode 100644
index 000000000..6b156fe1d
--- /dev/null
+++ b/examples/PureData/custom-render-ADXL345/LICENSE
@@ -0,0 +1,675 @@
+GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {one line to give the program's name and a brief idea of what it does.}
+    Copyright (C) {year}  {name of author}
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    {project}  Copyright (C) {year}  {fullname}
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+
diff --git a/examples/PureData/custom-render-ADXL345/_main.pd b/examples/PureData/custom-render-ADXL345/_main.pd
new file mode 100644
index 000000000..bf08f484a
--- /dev/null
+++ b/examples/PureData/custom-render-ADXL345/_main.pd
@@ -0,0 +1,51 @@
+#N canvas 542 62 520 564 12;
+#X obj 107 31 r bela_adxl345;
+#X obj 135 65 print;
+#X obj 107 98 unpack f f f;
+#X obj 4 202 phasor~ 100;
+#X obj 83 243 lop~;
+#X obj 107 130 t f f;
+#X obj 107 154 *;
+#X obj 225 252 lop~;
+#X obj 249 139 t f f;
+#X obj 249 163 *;
+#X obj 226 280 *~ 0.5;
+#X obj 376 254 lop~;
+#X obj 400 141 t f f;
+#X obj 400 165 *;
+#X obj 146 211 phasor~ 149.3;
+#X obj 297 213 phasor~ 198.6;
+#X obj 107 180 * 1500;
+#X obj 249 189 * 1500;
+#X obj 400 191 * 1500;
+#X obj 228 369 hip~ 10;
+#X obj 302 371 hip~ 10;
+#X obj 245 415 dac~;
+#X text 229 344 Remove phasor's DC offset;
+#X connect 0 0 1 0;
+#X connect 0 0 2 0;
+#X connect 2 0 5 0;
+#X connect 2 1 8 0;
+#X connect 2 2 12 0;
+#X connect 3 0 4 0;
+#X connect 4 0 19 0;
+#X connect 5 0 6 0;
+#X connect 5 1 6 1;
+#X connect 6 0 16 0;
+#X connect 7 0 10 0;
+#X connect 8 0 9 0;
+#X connect 8 1 9 1;
+#X connect 9 0 17 0;
+#X connect 10 0 19 0;
+#X connect 10 0 20 0;
+#X connect 11 0 20 0;
+#X connect 12 0 13 0;
+#X connect 12 1 13 1;
+#X connect 13 0 18 0;
+#X connect 14 0 7 0;
+#X connect 15 0 11 0;
+#X connect 16 0 4 1;
+#X connect 17 0 7 1;
+#X connect 18 0 11 1;
+#X connect 19 0 21 0;
+#X connect 20 0 21 1;
diff --git a/examples/PureData/custom-render-ADXL345/adxl345.c b/examples/PureData/custom-render-ADXL345/adxl345.c
new file mode 100644
index 000000000..c8d6a36b5
--- /dev/null
+++ b/examples/PureData/custom-render-ADXL345/adxl345.c
@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/i2c-dev.h>
+
+#include "adxl345.h"
+
+#define BW_RATE     0x2c
+#define POWER_CTL   0x2d
+#define INT_SOURCE  0x30
+#define DATA_FORMAT 0x31
+#define DATAX0      0x32
+
+#define DATA_READY 0x80
+
+static int fd;
+
+static int adxl345_open(const char *device, char sdo)
+{
+  if ((fd = open(device, O_RDWR)) < 0) {
+    fprintf(stderr, "Failed to open i2c port %s\n", device);
+    return -1;
+  }
+
+  if (ioctl(fd, I2C_SLAVE, sdo) < 0) {
+    fprintf(stderr, "Unable to get bus access to talk to slave at address %d(%#x)\n", sdo, sdo);
+    return -1;
+  }
+
+  return fd;
+}
+
+static int adxl345_write(unsigned char addr, unsigned char data)
+{
+  unsigned char buf[2];
+
+  buf[0] = addr;
+  buf[1] = data;
+
+  if (write(fd, buf, 2) != 2) {
+    fprintf(stderr, "Error writing to i2c slave\n");
+    return 1;
+  }
+  return 0;
+}
+
+static int adxl345_read(unsigned char addr, int num_byte, unsigned char *data)
+{
+  int i;
+
+  for (i = 0; i < num_byte; ++i, ++addr) {
+    /* write address */
+    if (write(fd, &addr, 1) != 1) {
+      return 1;
+    }
+
+    /* read data */
+    if (read(fd, &data[i], 1) != 1) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+int adxl345_init(const char *device, char sdo, adxl345_datarate rate)
+{
+  int ret = adxl345_open(device, sdo);
+  if(ret < 0)
+    return 1;
+  if(adxl345_write(POWER_CTL, 0x08)) // 測定モード
+    return 1;
+  if(adxl345_write(DATA_FORMAT, 0x03)) // 16g
+    return 1;
+  if(adxl345_write(BW_RATE, rate))
+    return 1;
+  return 0;
+}
+
+int adxl345_default_init(void)
+{
+  return adxl345_init(I2C_DEVICE_0, ADXL345_ADDR_LOW, ADXL345_DATARATE_12_5_HZ);
+}
+
+three_d_space* adxl345_get_acceleration(void)
+{
+  static three_d_space acceleration;
+  unsigned char values[6];
+
+  for (values[0] = 0; !(values[0] & DATA_READY); ) {
+    if(adxl345_read(INT_SOURCE, 1, values))
+      return NULL;
+  }
+
+  adxl345_read(DATAX0, 6, values);
+
+  acceleration.x  = ((int) values[1] << 8) | (int) values[0];
+  acceleration.y  = ((int) values[3] << 8) | (int) values[2];
+  acceleration.z  = ((int) values[5] << 8) | (int) values[4];
+
+  return &acceleration;
+}
+
+void adxl345_finish(void)
+{
+  close(fd);
+}
diff --git a/examples/PureData/custom-render-ADXL345/adxl345.h b/examples/PureData/custom-render-ADXL345/adxl345.h
new file mode 100644
index 000000000..69833f091
--- /dev/null
+++ b/examples/PureData/custom-render-ADXL345/adxl345.h
@@ -0,0 +1,51 @@
+#ifndef ADXL345_H
+#define ADXL345_H
+
+#define I2C_DEVICE_0 "/dev/i2c-0"
+#define I2C_DEVICE_1 "/dev/i2c-1"
+#define I2C_DEVICE_2 "/dev/i2c-2"
+
+#define ADXL345_ADDR_LOW 0x53
+#define ADXL345_ADDR_HIGH 0x1d
+
+/* Used with register 0x2C (ADXL345_REG_BW_RATE) to set bandwidth */
+typedef enum
+{
+  ADXL345_DATARATE_3200_HZ = 0b1111, // 1600Hz Bandwidth 140µA IDD
+  ADXL345_DATARATE_1600_HZ = 0b1110, // 800Hz Bandwidth 90µA IDD
+  ADXL345_DATARATE_800_HZ  = 0b1101, // 400Hz Bandwidth 140µA IDD
+  ADXL345_DATARATE_400_HZ  = 0b1100, // 200Hz Bandwidth 140µA IDD
+  ADXL345_DATARATE_200_HZ  = 0b1011, // 100Hz Bandwidth 140µA IDD
+  ADXL345_DATARATE_100_HZ  = 0b1010, // 50Hz Bandwidth 140µA IDD
+  ADXL345_DATARATE_50_HZ   = 0b1001, // 25Hz Bandwidth 90µA IDD
+  ADXL345_DATARATE_25_HZ   = 0b1000, // 12.5Hz Bandwidth 60µA IDD
+  ADXL345_DATARATE_12_5_HZ = 0b0111, // 6.25Hz Bandwidth 50µA IDD
+  ADXL345_DATARATE_6_25HZ  = 0b0110, // 3.13Hz Bandwidth 45µA IDD
+  ADXL345_DATARATE_3_13_HZ = 0b0101, // 1.56Hz Bandwidth 40µA IDD
+  ADXL345_DATARATE_1_56_HZ = 0b0100, // 0.78Hz Bandwidth 34µA IDD
+  ADXL345_DATARATE_0_78_HZ = 0b0011, // 0.39Hz Bandwidth 23µA IDD
+  ADXL345_DATARATE_0_39_HZ = 0b0010, // 0.20Hz Bandwidth 23µA IDD
+  ADXL345_DATARATE_0_20_HZ = 0b0001, // 0.10Hz Bandwidth 23µA IDD
+  ADXL345_DATARATE_0_10_HZ = 0b0000  // 0.05Hz Bandwidth 23µA IDD (default value)
+} adxl345_datarate;
+
+typedef struct {
+  int x;
+  int y;
+  int z;
+} three_d_space;
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+int adxl345_init(const char *device, char sdo, adxl345_datarate rate);
+int adxl345_default_init(void);
+three_d_space* adxl345_get_acceleration(void);
+void adxl345_finish(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif // ADXL345_H
diff --git a/examples/PureData/custom-render-ADXL345/render.cpp b/examples/PureData/custom-render-ADXL345/render.cpp
new file mode 100644
index 000000000..24c45e7ba
--- /dev/null
+++ b/examples/PureData/custom-render-ADXL345/render.cpp
@@ -0,0 +1,1659 @@
+// Custom libpd render.cpp to use with ADXL345 digital accelerometer
+// This uses the Linux library available at https://github.com/giuliomoro/adxl345-i2c-linux
+// The modifications (marked by `#ifdef AXL345`)
+// applied on top of
+// https://github.com/BelaPlatform/Bela/blob/a4cb254c9cdb1f5c0d3c8fa213179fdccdbc453b/core/default_libpd_render.cpp
+// Place this file in a Bela project alongside a `_main.pd` which contains:
+// [r bela_adxl345]
+// |
+// [print]
+//
+// This expect that you'd connect the ADXL345 to the I2C1 pins on your board
+// and that the ADXL345 is set to its default address. These can be changed in
+// the calle to adxl345_init() below.
+/*
+ * Default render file for Bela projects running Pd patches
+ * using libpd.
+ */
+#include <Bela.h>
+
+// Enable features here. These may be undef'ed below if the corresponding
+// BELA_LIBPD_DISABLE_* flag is passed
+#define BELA_LIBPD_SCOPE
+#define BELA_LIBPD_MIDI
+#define BELA_LIBPD_TRILL
+#define BELA_LIBPD_GUI
+#define BELA_LIBPD_SERIAL
+
+#ifdef BELA_LIBPD_DISABLE_SCOPE
+#undef BELA_LIBPD_SCOPE
+#endif // BELA_LIBPD_DISABLE_SCOPE
+#ifdef BELA_LIBPD_DISABLE_MIDI
+#undef BELA_LIBPD_MIDI
+#endif // BELA_LIBPD_DISABLE_MIDI
+#ifdef BELA_LIBPD_DISABLE_TRILL
+#undef BELA_LIBPD_TRILL
+#endif // BELA_LIBPD_DISABLE_TRILL
+#ifdef BELA_LIBPD_DISABLE_GUI
+#undef BELA_LIBPD_GUI
+#endif // BELA_LIBPD_DISABLE_GUI
+#ifdef BELA_LIBPD_DISABLE_SERIAL
+#undef BELA_LIBPD_SERIAL
+#endif // BELA_LIBPD_DISABLE_SERIAL
+
+#define PD_THREADED_IO
+#include <libraries/libpd/libpd.h>
+#include <DigitalChannelManager.h>
+#include <stdio.h>
+
+#ifdef BELA_LIBPD_MIDI
+#include <libraries/Midi/Midi.h>
+#endif // BELA_LIBPD_MIDI
+#ifdef BELA_LIBPD_SCOPE
+#include <libraries/Scope/Scope.h>
+#endif // BELA_LIBPD_SCOPE
+#include <string>
+#include <sstream>
+#include <string.h>
+#include <vector>
+
+#define ADXL345
+#ifdef ADXL345
+#include "adxl345.h"
+std::array<float,3> gAcceleration;
+volatile size_t gAccelerationUpdated;
+void readAdxl345(void*)
+{
+	while(!Bela_stopRequested())
+	{
+		three_d_space* acc = adxl345_get_acceleration();
+		if(!acc) // something's broken with the device
+			return;
+		gAcceleration[0] = acc->x / 65536.f;
+		gAcceleration[1] = acc->y / 65536.f;
+		gAcceleration[2] = acc->z / 65536.f;
+		gAccelerationUpdated++;
+		usleep(90000);
+	}
+}
+#endif // ADXL345
+#if (defined(BELA_LIBPD_GUI) || defined(BELA_LIBPD_TRILL))
+#include <libraries/Pipe/Pipe.h>
+template <typename T>
+int getIdxFromId(const char* id, std::vector<std::pair<std::string,T>>& db)
+{
+	for(unsigned int n = 0; n < db.size(); ++n)
+	{
+		if(0 == strcmp(id, db[n].first.c_str()))
+			return n;
+	}
+	return -1;
+}
+#endif // BELA_LIBPD_GUI || BELA_LIBPD_TRILL
+
+#ifdef BELA_LIBPD_TRILL
+#include <tuple>
+#include <libraries/Trill/Trill.h>
+AuxiliaryTask gTrillTask;
+Pipe gTrillPipe;
+
+static std::vector<std::string> gTrillAcks;
+static std::vector<std::pair<std::string,Trill*>> gTouchSensors;
+// how often to read the cap sensors inputs.
+float touchSensorSleepInterval = 0.007;
+
+void readTouchSensors(void*)
+{
+	for(unsigned int n = 0; n < gTouchSensors.size(); ++n)
+	{
+		Trill& touchSensor = *gTouchSensors[n].second;
+		int ret;
+		const Trill::Device type = touchSensor.deviceType();
+		if(Trill::NONE == type)
+			ret = 1;
+		else
+			ret = touchSensor.readI2C();
+		if(!ret)
+		{
+			gTrillPipe.writeNonRt(n);
+		}
+	}
+}
+#endif // BELA_LIBPD_TRILL
+
+#ifdef BELA_LIBPD_GUI
+#include <libraries/Gui/Gui.h>
+
+Pipe gGuiPipe;
+Gui gui;
+struct bufferDescription
+{
+	std::string name;
+	int id;
+	int size;
+};
+static std::vector<struct bufferDescription> gGuiDataBuffers;
+static std::vector<std::string> gGuiControlBuffers;
+struct guiControlMessageHeader
+{
+	uint32_t size;
+	uint32_t type;
+	uint32_t id;
+};
+
+bool guiControlDataCallback(JSONObject& root, void* arg)
+{
+	int ret = true;
+	for(unsigned int n = 0; n < gGuiControlBuffers.size(); ++n)
+	{
+		const auto& b = gGuiControlBuffers[n];
+		std::wstring key = JSON::s2ws(b);
+		if (root.end() != root.find(key))
+		{
+			JSONValue* found = root[key];
+			struct guiControlMessageHeader header;
+			header.id = n;
+			char* array;
+			if(found->IsString())
+			{
+				std::string value = JSON::ws2s(found->AsString());
+				header.type = 's';
+				header.size = value.size();
+				array = (char*)alloca(header.size);
+				memcpy(array, value.c_str(), header.size);
+			} else if(found->IsNumber())
+			{
+				float value = found->AsNumber();
+				header.type = 'f';
+				header.size = sizeof(value);
+				array = (char*)alloca(header.size);
+				memcpy(array, &value, header.size);
+			} else {
+				continue;
+			}
+			// do two separate reads: the pipe is datagram-based
+			// so it would be impossible to receive partial messages
+			// at the other end
+			gGuiPipe.writeNonRt(header);
+			gGuiPipe.writeNonRt(&array[0], header.size);
+			// we have successully parsed this message, so the
+			// default parser shouldn't when we return
+			// note: in practice there may be times when we'd want
+			// to have the default parser handle this message
+			// (e.g.: when an "event" field is also present), but
+			// for now we ignore them
+			ret = false;
+			continue;
+		}
+	}
+	return ret;
+}
+
+#endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+#include <libraries/Serial/Serial.h>
+#include <libraries/Pipe/Pipe.h>
+#include <string>
+
+Pipe gSerialPipe;
+Serial gSerial;
+std::string gSerialId;
+int gSerialEom;
+enum SerialType {
+	kSerialFloats,
+	kSerialBytes,
+	kSerialSymbol,
+	kSerialSymbols,
+} gSerialType = kSerialFloats;
+AuxiliaryTask gSerialInputTask;
+AuxiliaryTask gSerialOutputTask;
+
+struct serialMessageHeader
+{
+	uint32_t idSize = 0;
+	uint32_t dataSize = 0;
+};
+enum WaitingFor {
+	kHeader,
+	kId,
+	kData,
+};
+
+struct SerialPipeState {
+	struct serialMessageHeader h;
+	enum WaitingFor waitingFor = kHeader;
+	char id[100];
+};
+
+static void processSerialPipe(bool rt, SerialPipeState& s)
+{
+	// Not sure we actually need while() below. We were using it earlier
+	// when this was coded inside render() in order to be able to perform early returns
+	while(1)
+	{
+		auto& h = s.h;
+		auto& waitingFor = s.waitingFor;
+		auto& id = s.id;
+		if(kHeader == waitingFor)
+		{
+			int ret = rt ? gSerialPipe.readRt(h) : gSerialPipe.readNonRt(h);
+			if(ret <= 0)
+				break;
+			waitingFor = kId;
+		}
+		if(kId == waitingFor)
+		{
+			if(h.idSize > sizeof(id) - 1)
+				rt_fprintf(stderr, "Serial: ID too large\n");
+			else
+			{
+				int ret = rt ? gSerialPipe.readRt(id, h.idSize) : gSerialPipe.readNonRt(id, h.idSize);
+				if(ret <= 0)
+					break;
+				if(int(h.idSize) != ret)
+				{
+					rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.idSize, ret);
+					break;
+				}
+				id[ret] = '\0'; // ensure it's null-terminated
+				waitingFor = kData;
+			}
+		}
+		if(kData == waitingFor)
+		{
+			char data[h.dataSize + 1];
+			int ret = rt ? gSerialPipe.readRt(data, h.dataSize) : gSerialPipe.readNonRt(data, h.dataSize);
+			if(ret <= 0)
+				break;
+			if(int(h.dataSize) != ret)
+			{
+				rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.dataSize, ret);
+				break;
+			}
+			if(rt)
+			{
+				// rt: forward data from pipe to Pd
+				data[h.dataSize] = '\0'; // ensure it's null-terminated
+				if(h.dataSize)
+				{
+					const char* rec = "bela_serialIn";
+					if(kSerialSymbol == gSerialType)
+					{
+						libpd_symbol(rec, data);
+					} else if(kSerialBytes == gSerialType) {
+						if(gSerialEom >= 0) {
+							// messages are separated: send as a list
+							libpd_start_message(h.dataSize);
+							for(size_t n = 0; n < h.dataSize; ++n)
+								libpd_add_float(data[n]);
+							libpd_finish_message(rec, id);
+						} else {
+							// messages are not separated: send one byte at a time
+							for(size_t n = 0; n < h.dataSize; ++n)
+							{
+								libpd_start_message(h.dataSize);
+								libpd_add_float(data[n]);
+								libpd_finish_message(rec, id);
+							}
+						}
+					} else {
+						unsigned int nTokens = 1;
+						const uint8_t separators[] = { ' ', '\0'};
+						// find number of delimiters
+						size_t start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n] && n != start) // exclude empty tokens
+								{
+									start = n + 1;
+									nTokens++;
+								}
+							}
+						}
+						libpd_start_message(nTokens);
+						start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							bool end = false;
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n])
+								{
+									if(start == n)
+										start++; // remove empty tokens
+									else
+										end = true;
+									break; // no need to check for more separators
+								}
+							}
+							if(end)
+							{
+								data[n] = '\0'; // ensure the string is null-terminated so the next line works
+								if(kSerialSymbols == gSerialType)
+									libpd_add_symbol(data + start);
+								else if (kSerialFloats == gSerialType)
+									libpd_add_float(atof(data + start));
+								start = n + 1;
+							}
+						}
+						libpd_finish_message(rec, id);
+					}
+				}
+			} else {
+				// non-rt: forward data from pipe to serial
+				if(h.dataSize)
+					gSerial.write(data, h.dataSize);
+			}
+			waitingFor = kHeader;
+		}
+	}
+}
+
+static void serialOutputLoop(void* arg) {
+	// blocking read with timeout
+	gSerialPipe.setBlockingNonRt(true);
+	gSerialPipe.setTimeoutMsNonRt(100);
+	std::vector<uint8_t> rec(1024);
+	std::vector<uint8_t> id(100);
+
+	SerialPipeState serialStateNonRt {};
+	while(!Bela_stopRequested())
+	{
+		processSerialPipe(false, serialStateNonRt);
+	}
+}
+
+static void serialInputLoop(void* arg) {
+	char serialBuffer[10000];
+	unsigned int i = 0;
+	serialMessageHeader h;
+	h.idSize = strlen(gSerialId.c_str()) + 1;
+	while(!Bela_stopRequested())
+	{
+		// read from the serial port with a timeout of 100ms
+		int ret = gSerial.read(serialBuffer + i, sizeof(serialBuffer) - i, 100);
+		if (ret > 0) {
+			if(gSerialEom < 0)
+			{
+				h.dataSize = ret;
+				// send everything immediately
+				gSerialPipe.writeNonRt(h);
+				gSerialPipe.writeNonRt(gSerialId.c_str(), h.idSize);
+				gSerialPipe.writeNonRt(serialBuffer, h.dataSize);
+			} else {
+				// find EOM in new data
+				unsigned int searchStart = i;
+				unsigned int searchStop = searchStart + ret;
+				unsigned int n;
+				unsigned int lastSent = 0;
+				bool found;
+				do
+				{
+					found = false;
+					for(n = searchStart; n < searchStop; ++n)
+					{
+						if(serialBuffer[n] == gSerialEom)
+						{
+							found = true;
+							break;
+						}
+					}
+					// if found, send all data till that point
+					if(found)
+					{
+						h.dataSize = n - lastSent;
+						if(h.dataSize)
+						{
+							gSerialPipe.writeNonRt(h);
+							gSerialPipe.writeNonRt(gSerialId.c_str(), h.idSize);
+							gSerialPipe.writeNonRt(serialBuffer + lastSent, h.dataSize);
+						}
+						searchStart = n + 1;
+						lastSent += 1 + h.dataSize;
+					}
+				}
+				while(found);
+				// if we are left with any data, move it to the beginning of the buffer.
+				// TODO: avoid this and use it as a circular buffer
+				if(searchStart != i)
+					memmove(serialBuffer, serialBuffer + searchStart, searchStop - searchStart);
+				i = searchStop - searchStart;
+			}
+		}
+	}
+}
+
+#endif // BELA_LIBPD_SERIAL
+
+enum { minFirstDigitalChannel = 10 };
+static unsigned int gAnalogChannelsInUse;
+static unsigned int gDigitalChannelsInUse;
+#ifdef BELA_LIBPD_SCOPE
+static unsigned int gScopeChannelsInUse = 4;
+#else // BELA_LIBPD_SCOPE
+static unsigned int gScopeChannelsInUse = 0;
+#endif // BELA_LIBPD_SCOPE
+static unsigned int gLibpdBlockSize;
+static unsigned int gChannelsInUse;
+//static const unsigned int gFirstAudioChannel = 0;
+static unsigned int gFirstAnalogInChannel;
+static unsigned int gFirstAnalogOutChannel;
+static unsigned int gFirstDigitalChannel;
+static unsigned int gLibpdDigitalChannelOffset;
+static unsigned int gFirstScopeChannel;
+
+void Bela_userSettings(BelaInitSettings *settings)
+{
+	settings->uniformSampleRate = 1;
+	settings->interleave = 0;
+	settings->analogOutputsPersist = 0;
+}
+
+float* gInBuf;
+float* gOutBuf;
+#ifdef BELA_LIBPD_MIDI
+#define PARSE_MIDI
+static std::vector<Midi*> midi;
+std::vector<std::string> gMidiPortNames;
+int gMidiVerbose = 1;
+const int kMidiVerbosePrintLevel = 1;
+
+void dumpMidi()
+{
+	if(midi.size() == 0)
+	{
+		printf("No MIDI device enabled\n");
+		return;
+	}
+	printf("The following MIDI devices are enabled:\n");
+	printf("%4s%20s %3s %3s %s\n",
+			"Num",
+			"Name",
+			"In",
+			"Out",
+			"Pd channels"
+	      );
+	for(unsigned int n = 0; n < midi.size(); ++n)
+	{
+		printf("[%2d]%20s %3s %3s (%d-%d)\n", 
+			n,
+			gMidiPortNames[n].c_str(),
+			midi[n]->isInputEnabled() ? "x" : "_",
+			midi[n]->isOutputEnabled() ? "x" : "_",
+			n * 16 + 1,
+			n * 16 + 16
+		);
+	}
+}
+
+Midi* openMidiDevice(std::string name, bool verboseSuccess = false, bool verboseError = false)
+{
+	Midi* newMidi;
+	newMidi = new Midi();
+	newMidi->readFrom(name.c_str());
+	newMidi->writeTo(name.c_str());
+#ifdef PARSE_MIDI
+	newMidi->enableParser(true);
+#else
+	newMidi->enableParser(false);
+#endif /* PARSE_MIDI */
+	if(newMidi->isOutputEnabled())
+	{
+		if(verboseSuccess)
+			printf("Opened MIDI device %s as output\n", name.c_str());
+	}
+	if(newMidi->isInputEnabled())
+	{
+		if(verboseSuccess)
+			printf("Opened MIDI device %s as input\n", name.c_str());
+	}
+	if(!newMidi->isInputEnabled() && !newMidi->isOutputEnabled())
+	{
+		if(verboseError)
+			fprintf(stderr, "Failed to open  MIDI device %s\n", name.c_str());
+		return nullptr;
+	} else {
+		return newMidi;
+	}
+}
+
+static unsigned int getPortChannel(int* channel){
+	unsigned int port = 0;
+	while(*channel >= 16){
+		*channel -= 16;
+		port += 1;
+	}
+	return port;
+}
+
+void Bela_MidiOutNoteOn(int channel, int pitch, int velocity) {
+	unsigned int port = getPortChannel(&channel);
+	if(gMidiVerbose >= kMidiVerbosePrintLevel)
+		rt_printf("noteout _ port: %d, channel: %d, pitch: %d, velocity %d\n", port, channel, pitch, velocity);
+	port < midi.size() && midi[port]->writeNoteOn(channel, pitch, velocity);
+}
+
+void Bela_MidiOutControlChange(int channel, int controller, int value) {
+	unsigned int port = getPortChannel(&channel);
+	if(gMidiVerbose >= kMidiVerbosePrintLevel)
+		rt_printf("ctlout _ port: %d, channel: %d, controller: %d, value: %d\n", port, channel, controller, value);
+	port < midi.size() && midi[port]->writeControlChange(channel, controller, value);
+}
+
+void Bela_MidiOutProgramChange(int channel, int program) {
+	unsigned int port = getPortChannel(&channel);
+	if(gMidiVerbose >= kMidiVerbosePrintLevel)
+		rt_printf("pgmout _ port: %d, channel: %d, program: %d\n", port, channel, program);
+	port < midi.size() && midi[port]->writeProgramChange(channel, program);
+}
+
+void Bela_MidiOutPitchBend(int channel, int value) {
+	unsigned int port = getPortChannel(&channel);
+	if(gMidiVerbose >= kMidiVerbosePrintLevel)
+		rt_printf("bendout _ port: %d, channel: %d, value: %d\n", port, channel, value);
+	value += 8192; // correct for Pd's oddity
+	port < midi.size() && midi[port]->writePitchBend(channel, value);
+}
+
+void Bela_MidiOutAftertouch(int channel, int pressure){
+	unsigned int port = getPortChannel(&channel);
+	if(gMidiVerbose >= kMidiVerbosePrintLevel)
+		rt_printf("touchout _ port: %d, channel: %d, pressure: %d\n", port, channel, pressure);
+	port < midi.size() && midi[port]->writeChannelPressure(channel, pressure);
+}
+
+void Bela_MidiOutPolyAftertouch(int channel, int pitch, int pressure){
+	unsigned int port = getPortChannel(&channel);
+	if(gMidiVerbose >= kMidiVerbosePrintLevel)
+		rt_printf("polytouchout _ port: %d, channel: %d, pitch: %d, pressure: %d\n", port, channel, pitch, pressure);
+	port < midi.size() && midi[port]->writePolyphonicKeyPressure(channel, pitch, pressure);
+}
+
+void Bela_MidiOutByte(int port, int byte){
+	if(gMidiVerbose >= kMidiVerbosePrintLevel)
+		rt_printf("port: %d, byte: %d\n", port, byte);
+	if(port > (int)midi.size()){
+		// if the port is out of range, redirect to the first port.
+		rt_fprintf(stderr, "Port out of range, using port 0 instead\n");
+		port = 0;
+	}
+	port < (int)midi.size() && midi[port]->writeOutput(byte);
+}
+#endif // BELA_LIBPD_MIDI
+
+void Bela_printHook(const char *received){
+	rt_printf("%s", received);
+}
+
+static DigitalChannelManager dcm;
+
+void sendDigitalMessage(bool state, unsigned int delay, void* receiverName){
+	libpd_float((const char*)receiverName, (float)state);
+//	rt_printf("%s: %d\n", (char*)receiverName, state);
+}
+
+#ifdef BELA_LIBPD_TRILL
+void setTrillPrintError()
+{
+	rt_fprintf(stderr, "bela_setTrill format is wrong. Should be:\n"
+		"[mode <sensor_id> <prescaler_value>(\n"
+		" or\n"
+		"[threshold <sensor_id> <threshold_value>(\n"
+		" or\n"
+		"[prescaler <sensor_id> <prescaler_value>(\n");
+}
+#endif // BELA_LIBPD_TRILL
+
+static void belaSystem(const char* first, int argc, t_atom* argv)
+{
+	printf("belaSystem %s, %d\n", first, argc);
+	std::string cmd = first ? first : "";
+	for(size_t n = 0; n < argc; ++n)
+	{
+		if(0 != n || first)
+			cmd += " ";
+		if(libpd_is_float(argv + n)) {
+			float arg = libpd_get_float(argv + n);
+			if(arg == (int)arg)
+				cmd += std::to_string((int)arg);
+			else
+				cmd += std::to_string(arg);
+		} else if(libpd_is_symbol(argv + n)) {
+			cmd += libpd_get_symbol(argv + n);
+		} else {
+			fprintf(stderr, "Error: argument %d of bela_system is not a float or symbol. Command so far: '%s', this will be discarded\n", n, cmd.c_str());
+			return;
+		}
+	}
+	printf("system(\"%s\");\n", cmd.c_str());
+	system(cmd.c_str());
+}
+
+void Bela_listHook(const char *source, int argc, t_atom *argv)
+{
+#ifdef BELA_LIBPD_GUI
+	if(0 == strcmp(source, "bela_guiOut"))
+	{
+		if(!libpd_is_float(&argv[0]))
+		{
+			rt_fprintf(stderr, "Wrong format for bela_gui, the first element should be a float\n");
+			return;
+		}
+		unsigned int bufNum = libpd_get_float(&argv[0]);
+		if(libpd_is_float(&argv[1])) // if the first element is a float, we send an array of floats
+		{
+			float buf[argc - 1];
+			for(int n = 1; n < argc; ++n)
+			{
+				t_atom *a = &argv[n];
+				if(!libpd_is_float(a))
+				{
+					rt_fprintf(stderr, "Wrong format for bela_gui\n"); // this should never happen, because then the selector would've not been "float"
+					return;
+				}
+				buf[n - 1] = libpd_get_float(a);
+			}
+			gui.sendBuffer(bufNum, buf, argc - 1);
+			return;
+		} else { // otherwise we send each element of the list separately
+			for(int n = 1; n < argc; ++n)
+			{
+				t_atom *a = &argv[n];
+				if (libpd_is_float(a)) {
+					float x = libpd_get_float(a);
+					gui.sendBuffer(bufNum, x);
+				} else if (libpd_is_symbol(a)) {
+					const char *s = libpd_get_symbol(a);
+					gui.sendBuffer(bufNum, s, strlen(s)); // TODO: should it be strlen(s)+1?
+				}
+			}
+		}
+		return;
+	}
+#endif // BELA_LIBPD_GUI
+	if(0 == strcmp(source, "bela_system"))
+	{
+		printf("list: %d\n", argc);
+		belaSystem(nullptr, argc, argv);
+		return;
+	}
+}
+void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *argv){
+#ifdef BELA_LIBPD_MIDI
+	if(strcmp(source, "bela_setMidi") == 0)
+	{
+		if(0 == strcmp("verbose", symbol))
+		{
+			if(1 != argc || !libpd_is_float(argv))
+			{
+				rt_fprintf(stderr, "Wrong format for bela_setMidi, expected: [verbose <n>(\n");
+			} else {
+				gMidiVerbose = libpd_get_float(argv);
+				rt_printf("MIDI verbose: %d\n", gMidiVerbose);
+			}
+			return;
+		}
+		int num[3] = {0, 0, 0};
+		for(int n = 0; n < argc && n < 3; ++n)
+		{
+			if(!libpd_is_float(&argv[n]))
+			{
+				fprintf(stderr, "Wrong format for bela_setMidi, expected:[hw 1 0 0(");
+				return;
+			}
+			num[n] = libpd_get_float(&argv[n]);
+		}
+		std::ostringstream deviceName;
+		deviceName << symbol << ":" << num[0] << "," << num[1] << "," << num[2];
+		printf("Adding Midi device: %s\n", deviceName.str().c_str());
+		Midi* newMidi = openMidiDevice(deviceName.str(), false, true);
+		if(newMidi)
+		{
+			midi.push_back(newMidi);
+			gMidiPortNames.push_back(deviceName.str());
+		}
+		dumpMidi();
+		return;
+	}
+#endif // BELA_LIBPD_MIDI
+	if(strcmp(source, "bela_setDigital") == 0){
+		// symbol is the direction, argv[0] is the channel, argv[1] (optional)
+		// is signal("sig" or "~") or message("message", default) rate
+		bool isMessageRate = true; // defaults to message rate
+		bool direction = 0; // initialize it just to avoid the compiler's warning
+		bool disable = false;
+		if(strcmp(symbol, "in") == 0){
+			direction = INPUT;
+		} else if(strcmp(symbol, "out") == 0){
+			direction = OUTPUT;
+		} else if(strcmp(symbol, "disable") == 0){
+			disable = true;
+		} else {
+			return;
+		}
+		if(argc == 0){
+			return;
+		} else if (libpd_is_float(&argv[0]) == false){
+			return;
+		}
+		int channel = libpd_get_float(&argv[0]) - gLibpdDigitalChannelOffset;
+		if(disable == true){
+			dcm.unmanage(channel);
+			return;
+		}
+		if(argc >= 2){
+			t_atom* a = &argv[1];
+			if(libpd_is_symbol(a)){
+				const char *s = libpd_get_symbol(a);
+				if(strcmp(s, "~") == 0  || strncmp(s, "sig", 3) == 0){
+					isMessageRate = false;
+				}
+			}
+		}
+		dcm.manage(channel, direction, isMessageRate);
+		return;
+	}
+	if(strcmp(source, "bela_system") == 0){
+		printf("msg: %s %d\n", symbol, argc);
+		belaSystem(symbol, argc, argv);
+	}
+	if(strcmp(source, "bela_control") == 0){
+		if(strcmp("stop", symbol) == 0){
+			rt_printf("bela_control: stop\n");
+			Bela_requestStop();
+		}
+		return;
+	}
+#ifdef BELA_LIBPD_GUI
+	if(0 == strcmp(source, "bela_setGui"))
+	{
+		if(0 == strcmp(symbol, "new"))
+		{
+			if(
+				argc < 2
+				|| !libpd_is_symbol(argv)
+				|| !libpd_is_symbol(argv + 1)
+			)
+			{
+				return;
+			}
+			const char* mode = libpd_get_symbol(argv);
+			const char* name = libpd_get_symbol(argv + 1);
+			if(0 == strcmp(mode, "control"))
+			{
+				gGuiControlBuffers.emplace_back(name);
+				return;
+			}
+			if(0 == strcmp(mode, "array"))
+			{
+				// because of
+				// https://github.com/libpd/libpd/issues/274
+				// (again), we cannot access the arrays right
+				// here (as it would deadlock on loadbang), so
+				// we have to defer creation of the Gui
+				// buffers until render() runs
+				gGuiDataBuffers.emplace_back(bufferDescription{.name = name, .id = -1, .size = 0});
+				return;
+			}
+			return;
+		}
+	}
+#endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	if(0 == strcmp(source, "bela_setSerial"))
+	{
+		if(0 == strcmp(symbol, "new"))
+		{
+			if(
+				argc < 5
+				|| !libpd_is_symbol(argv + 0) // serial_id
+				|| !libpd_is_symbol(argv + 1) // device
+				|| !libpd_is_float(argv + 2) // baudrate
+				|| !(libpd_is_symbol(argv + 3) || libpd_is_float(argv + 3)) // EOM
+				|| !libpd_is_symbol(argv + 4) // type
+			)
+			{
+				fprintf(stderr, "Invalid bela_setSerial arguments. Should be:\n"
+				"`new serial_id device baudrate EOM type`,\n"
+				"where `EOM` is one of `newline` or `none` or a character (expressed as an integer"
+				"       between 0 and 255)\n"
+				"and `type` is one of `bytes`, `floats`, `symbol`, `symbols`\n");
+				return;
+			}
+			gSerialId = libpd_get_symbol(argv + 0);
+			const char* device = libpd_get_symbol(argv + 1);
+			unsigned int baudrate = libpd_get_float(argv + 2);
+			gSerialEom = -1;
+			if(libpd_is_symbol(argv + 3)) {
+				const char* eom = libpd_get_symbol(argv + 3);
+				if(0 == strcmp(eom, "newline"))
+					gSerialEom = '\n';
+			} else if(libpd_is_float(argv + 3)) {
+				gSerialEom = libpd_get_float(argv + 3);
+			}
+			const char* type = libpd_get_symbol(argv + 4);
+			if(0 == strcmp("floats", type))
+				gSerialType = kSerialFloats;
+			else if(0 == strcmp("bytes", type))
+				gSerialType = kSerialBytes;
+			else if(0 == strcmp("symbol", type))
+				gSerialType = kSerialSymbol;
+			else if(0 == strcmp("symbols", type))
+				gSerialType = kSerialSymbols;
+
+			if(gSerial.setup(device, baudrate))
+				return;
+			gSerialInputTask = Bela_runAuxiliaryTask(serialInputLoop, 0);
+			gSerialOutputTask = Bela_runAuxiliaryTask(serialOutputLoop, 0);
+		}
+	}
+	if(0 == strcmp(source, "bela_serialOut"))
+	{
+		if(!argc) {
+			fprintf(stderr, "Invalid bela_serialOut arguments. Should be:\n"
+			"`serial_id firstByte <other bytes>`\n");
+			return;
+		}
+		const char* id = symbol;
+		// convert floats to bytes
+		char data[argc];
+		for(size_t n = 0; n < argc; ++n)
+		{
+			t_atom *a = argv + n;
+			if(libpd_is_float(a))
+			{
+				data[n] = libpd_get_float(a);
+			} else {
+				fprintf(stderr, "bela_serialOut received non-float\n");
+				return;
+			}
+		}
+		struct serialMessageHeader h;
+		h.idSize = strlen(id);
+		h.dataSize = sizeof(data);
+		gSerialPipe.writeRt(h);
+		gSerialPipe.writeRt(id, h.idSize);
+		gSerialPipe.writeRt(data, h.dataSize);
+	}
+#endif // BELA_LIBPD_SERIAL
+#ifdef BELA_LIBPD_TRILL
+	if(0 == strcmp(source, "bela_setTrill"))
+	{
+		if(0 == strcmp(symbol, "new"))
+		{
+			bool err = false;
+
+			uint8_t address = 0xff;
+			if(argc < 3)
+				err = true;
+			else if (!libpd_is_symbol(argv) // sensor_id
+				|| !libpd_is_float(argv + 1) // bus
+				|| !libpd_is_symbol(argv + 2) // device
+			)
+				err = true;
+			if(argc >= 4)
+			{
+				if(libpd_is_float(argv + 3))
+					address = libpd_get_float(argv + 3);
+				else
+					err = true;
+			}
+			if(err)
+			{
+				rt_fprintf(stderr, "bela_setTrill wrong format. Should be:\n"
+					"[new <sensor_id> <bus> <device> <address>(\n");
+				return;
+			}
+			const char* name = libpd_get_symbol(argv);
+			unsigned int bus = libpd_get_float(argv + 1);
+			const char* deviceString = libpd_get_symbol(argv + 2);
+			Trill::Device device = Trill::getDeviceFromName(deviceString);
+
+			Trill* trill = new Trill(bus, device, address);
+			if(Trill::NONE == trill->deviceType())
+			{
+				rt_fprintf(stderr, "Unable to create Trill %s device `%s` on bus %u at ", deviceString, name, bus);
+				if(128 < address)
+					rt_fprintf(stderr, "default address. ");
+				else
+					rt_fprintf(stderr, "address: %#x (%d). ", address, address);
+				rt_fprintf(stderr, "Is the device connected?\n");
+				return;
+			}
+			gTouchSensors.emplace_back(std::string(name), trill);
+			gTrillAcks.push_back(name);
+			//an ack is sent to Pd during the next audio callback because of https://github.com/libpd/libpd/issues/274
+			return;
+		}
+		if(argc < 1 || !libpd_is_symbol(argv))
+		{
+			rt_fprintf(stderr, "bela_setTrill: wrong format. It should be\n"
+					"[<command> <sensor_id> ...(");
+			return;
+		}
+		const char* sensorId = libpd_get_symbol(argv);
+		int idx = getIdxFromId(sensorId, gTouchSensors);
+		if(idx < 0)
+		{
+			rt_fprintf(stderr, "bela_setTrill sensor_id unknown: %s\n", sensorId);
+			return;
+		}
+		if(0 == strcmp(symbol, "updateBaseline"))
+		{
+			gTouchSensors[idx].second->updateBaseline();
+			return;
+		}
+		if(0 == strcmp(symbol, "mode"))
+		{
+			if(argc < 2
+				|| !libpd_is_symbol(argv)
+				|| !libpd_is_symbol(argv + 1)
+			) {
+				setTrillPrintError();
+				return;
+			}
+			const char* modeString = libpd_get_symbol(argv + 1);
+			Trill::Mode mode = Trill::getModeFromName(modeString);
+			gTouchSensors[idx].second->setMode(mode);
+		}
+		if(
+			0 == strcmp(symbol, "threshold")
+			|| 0 == strcmp(symbol, "prescaler")
+		)
+		{
+			if(
+				argc < 2
+				|| !libpd_is_symbol(argv)
+				|| !libpd_is_float(argv + 1)
+			  ) {
+				setTrillPrintError();
+				return;
+			}
+			float value = libpd_get_float(argv + 1);
+			if(0 == strcmp(symbol, "threshold"))
+			{
+				gTouchSensors[idx].second->setNoiseThreshold(value);
+			}
+			if(0 == strcmp(symbol, "prescaler"))
+			{
+				if(Trill::prescalerMax < value || 0 > value)
+				{
+					if(0 == value)
+						value = 0;
+					if(Trill::prescalerMax < value)
+						value = Trill::prescalerMax;
+					rt_printf("bela_setTrill prescaler value out of range, clipping to %.0f\n", value);
+				}
+				gTouchSensors[idx].second->setPrescaler(value);
+			}
+			return;
+		}
+		return;
+	}
+#endif // BELA_LIBPD_TRILL
+}
+
+void Bela_floatHook(const char *source, float value){
+	// let's make this as optimized as possible for built-in digital Out parsing
+	// the built-in digital receivers are of the form "bela_digitalOutXX" where XX is between gLibpdDigitalChannelOffset and (gLibpdDigitalCHannelOffset+gDigitalChannelsInUse)
+	static int prefixLength = strlen("bela_digitalOut");
+	if(strncmp(source, "bela_digitalOut", prefixLength)==0){
+		if(source[prefixLength] != 0){ //the two ifs are used instead of if(strlen(source) >= prefixLength+2)
+			if(source[prefixLength + 1] != 0){
+				// quickly convert the suffix to integer, assuming they are numbers, avoiding to call atoi
+				int receiver = ((source[prefixLength] - 48) * 10);
+				receiver += (source[prefixLength+1] - 48);
+				unsigned int channel = receiver - gLibpdDigitalChannelOffset; // go back to the actual Bela digital channel number
+				if(channel < gDigitalChannelsInUse){ //number of digital channels
+					dcm.setValue(channel, value);
+				}
+			}
+		}
+		return;
+	}
+}
+
+
+
+std::vector<std::string> gReceiverInputNames;
+std::vector<std::string> gReceiverOutputNames;
+void generateDigitalNames(unsigned int numDigitals, unsigned int libpdOffset, std::vector<std::string>& receiverInputNames, std::vector<std::string>& receiverOutputNames)
+{
+	std::string inBaseString = "bela_digitalIn";
+	std::string outBaseString = "bela_digitalOut";
+	for(unsigned int i = 0; i<numDigitals; i++)
+	{
+		receiverInputNames.push_back(inBaseString + std::to_string(i+libpdOffset));
+		receiverOutputNames.push_back(outBaseString + std::to_string(i+libpdOffset));
+	}
+}
+
+void printDigitalNames(std::vector<std::string>& receiverInputNames, std::vector<std::string>& receiverOutputNames)
+{
+	printf("DIGITAL INPUTS\n");
+	for(unsigned int i=0; i<gDigitalChannelsInUse; i++)
+		printf("%s\n", receiverInputNames[i].c_str());
+	printf("DIGITAL OUTPUTS\n");
+	for(unsigned int i=0; i<gDigitalChannelsInUse; i++)
+		printf("%s\n", receiverOutputNames[i].c_str());
+}
+
+static char multiplexerArray[] = {"bela_multiplexer"};
+static int multiplexerArraySize = 0;
+static bool pdMultiplexerActive = false;
+
+#ifdef PD_THREADED_IO
+void fdLoop(void* arg){
+	while(!Bela_stopRequested()){
+		if(!sys_doio(pd_this))
+			usleep(3000);
+	}
+}
+#endif /* PD_THREADED_IO */
+
+#ifdef BELA_LIBPD_SCOPE
+Scope scope;
+std::vector<float> gScopeOut;
+#endif // BELA_LIBPD_SCOPE
+void* gPatch;
+bool gDigitalEnabled = 0;
+
+bool setup(BelaContext *context, void *userData)
+{
+#ifdef BELA_LIBPD_GUI
+	gui.setup(context->projectName);
+	gui.setControlDataCallback(guiControlDataCallback, nullptr);
+	gGuiPipe.setup("guiControlPipe", 16384);
+#endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	gSerialPipe.setup("serialPipe", 16384);
+#endif // BELA_LIBPD_SERIAL
+	// Check Pd's version
+	int major, minor, bugfix;
+	sys_getversion(&major, &minor, &bugfix);
+	printf("Running Pd %d.%d-%d\n", major, minor, bugfix);
+	// We requested in Bela_userSettings() to have uniform sampling rate for audio
+	// and analog and non-interleaved buffers.
+	// So let's check this actually happened
+	if(context->analogSampleRate != context->audioSampleRate)
+	{
+		fprintf(stderr, "The sample rate of analog and audio must match. Try running with --uniform-sample-rate\n");
+		return false;
+	}
+	if(context->flags & BELA_FLAG_INTERLEAVED)
+	{
+		fprintf(stderr, "The audio and analog channels must be interleaved.\n");
+		return false;
+	}
+
+	if(context->digitalFrames > 0 && context->digitalChannels > 0)
+		gDigitalEnabled = 1;
+
+#ifdef BELA_LIBPD_MIDI
+	// add here other devices you need 
+	gMidiPortNames.push_back("hw:1,0,0");
+	//gMidiPortNames.push_back("hw:0,0,0");
+	//gMidiPortNames.push_back("hw:1,0,1");
+#endif // BELA_LIBPD_MIDI
+#ifdef BELA_LIBPD_SCOPE
+	scope.setup(gScopeChannelsInUse, context->audioSampleRate);
+	gScopeOut.resize(gScopeChannelsInUse);
+#endif // BELA_LIBPD_SCOPE
+
+	// Check first of all if the patch file exists. Will actually open it later.
+	char file[] = "_main.pd";
+	char folder[] = "./";
+	std::string path = std::string(folder) + file;
+	if(access(path.c_str(), F_OK) == -1 ) {
+		printf("Error file %s not found. The %s file should be your main patch.\n", path.c_str(), file);
+		return false;
+	}
+
+	// analog setup
+	gAnalogChannelsInUse = context->analogInChannels;
+	gDigitalChannelsInUse = context->digitalChannels;
+	printf("Audio channels in use: %d\n", context->audioOutChannels);
+	printf("Analog channels in use: %d\n", gAnalogChannelsInUse);
+	printf("Digital channels in use: %d\n", gDigitalChannelsInUse);
+
+	// Channel distribution
+	gFirstAnalogInChannel = std::max(context->audioInChannels, context->audioOutChannels);
+	gFirstAnalogOutChannel = gFirstAnalogInChannel;
+	gFirstDigitalChannel = gFirstAnalogInChannel + std::max(context->analogInChannels, context->analogOutChannels);
+	if(gFirstDigitalChannel < minFirstDigitalChannel)
+		gFirstDigitalChannel = minFirstDigitalChannel; //for backwards compatibility
+	gLibpdDigitalChannelOffset = gFirstDigitalChannel + 1;
+	gFirstScopeChannel = gFirstDigitalChannel + gDigitalChannelsInUse;
+
+	gChannelsInUse = gFirstScopeChannel + gScopeChannelsInUse;
+	
+	// Create receiverNames for digital channels
+	generateDigitalNames(gDigitalChannelsInUse, gLibpdDigitalChannelOffset, gReceiverInputNames, gReceiverOutputNames);
+	
+	// digital setup
+	if(gDigitalEnabled)
+	{
+		dcm.setCallback(sendDigitalMessage);
+		if(gDigitalChannelsInUse > 0){
+			for(unsigned int ch = 0; ch < gDigitalChannelsInUse; ++ch){
+				dcm.setCallbackArgument(ch, (void*) gReceiverInputNames[ch].c_str());
+			}
+		}
+	}
+
+#ifdef BELA_LIBPD_MIDI
+	unsigned int n = 0;
+	while(n < gMidiPortNames.size())
+	{
+		Midi* newMidi = openMidiDevice(gMidiPortNames[n], false, false);
+		if(newMidi)
+		{
+			midi.push_back(newMidi);
+			++n;
+		} else {
+			gMidiPortNames.erase(gMidiPortNames.begin() + n);
+		}
+	}
+	dumpMidi();
+#endif // BELA_LIBPD_MIDI
+
+	// check that we are not running with a blocksize smaller than gLibPdBlockSize
+	gLibpdBlockSize = libpd_blocksize();
+	if(context->audioFrames < gLibpdBlockSize){
+		fprintf(stderr, "Error: minimum block size must be %d\n", gLibpdBlockSize);
+		return false;
+	}
+
+	// set hooks before calling libpd_init
+	libpd_set_printhook(Bela_printHook);
+	libpd_set_floathook(Bela_floatHook);
+	libpd_set_listhook(Bela_listHook);
+	libpd_set_messagehook(Bela_messageHook);
+#ifdef BELA_LIBPD_MIDI
+	libpd_set_noteonhook(Bela_MidiOutNoteOn);
+	libpd_set_controlchangehook(Bela_MidiOutControlChange);
+	libpd_set_programchangehook(Bela_MidiOutProgramChange);
+	libpd_set_pitchbendhook(Bela_MidiOutPitchBend);
+	libpd_set_aftertouchhook(Bela_MidiOutAftertouch);
+	libpd_set_polyaftertouchhook(Bela_MidiOutPolyAftertouch);
+	libpd_set_midibytehook(Bela_MidiOutByte);
+#endif // BELA_LIBPD_MIDI
+
+	//initialize libpd. This clears the search path
+	libpd_init();
+	//Add the current folder to the search path for externals
+	libpd_add_to_search_path(".");
+	libpd_add_to_search_path("../pd-externals");
+
+	libpd_init_audio(gChannelsInUse, gChannelsInUse, context->audioSampleRate);
+	gInBuf = get_sys_soundin();
+	gOutBuf = get_sys_soundout();
+
+	// start DSP:
+	// [; pd dsp 1(
+	libpd_start_message(1);
+	libpd_add_float(1.0f);
+	libpd_finish_message("pd", "dsp");
+
+	// Bind your receivers here
+	for(unsigned int i = 0; i < gDigitalChannelsInUse; i++)
+		libpd_bind(gReceiverOutputNames[i].c_str());
+	libpd_bind("bela_setDigital");
+	libpd_bind("bela_control");
+	libpd_bind("bela_system");
+#ifdef BELA_LIBPD_MIDI
+	libpd_bind("bela_setMidi");
+#endif // BELA_LIBPD_MIDI
+#ifdef BELA_LIBPD_GUI
+	libpd_bind("bela_guiOut");
+	libpd_bind("bela_setGui");
+#endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	libpd_bind("bela_serialOut");
+	libpd_bind("bela_setSerial");
+#endif // BELA_LIBPD_SERIAL
+#ifdef BELA_LIBPD_TRILL
+	libpd_bind("bela_setTrill");
+#endif // BELA_LIBPD_TRILL
+
+	// open patch:
+	gPatch = libpd_openfile(file, folder);
+	if(gPatch == NULL){
+		printf("Error: file %s/%s is corrupted.\n", folder, file); 
+		return false;
+	}
+
+	// If the user wants to use the multiplexer capelet,
+	// the patch will have to contain an array called "bela_multiplexer"
+	// and a receiver [r bela_multiplexerChannels]
+	if(context->multiplexerChannels > 0 && libpd_arraysize(multiplexerArray) >= 0){
+		pdMultiplexerActive = true;
+		multiplexerArraySize = context->multiplexerChannels * context->analogInChannels;
+		// [; bela_multiplexer ` multiplexerArraySize` resize(
+		libpd_start_message(1);
+		libpd_add_float(multiplexerArraySize);
+		libpd_finish_message(multiplexerArray, "resize");
+		// [; bela_multiplexerChannels `context->multiplexerChannels`(
+		libpd_float("bela_multiplexerChannels", context->multiplexerChannels);
+	}
+
+	// Tell Pd that we will manage the io loop,
+	// and we do so in an Auxiliary Task
+#ifdef PD_THREADED_IO
+	sys_dontmanageio(1);
+	AuxiliaryTask fdTask;
+	fdTask = Bela_createAuxiliaryTask(fdLoop, 50, "libpd-fdTask", NULL);
+	Bela_scheduleAuxiliaryTask(fdTask);
+#endif /* PD_THREADED_IO */
+
+	dcm.setVerbose(false);
+#ifdef BELA_LIBPD_TRILL
+	gTrillTask = Bela_createAuxiliaryTask(readTouchSensors, 51, "touchSensorRead", NULL);
+	gTrillPipe.setup("trillPipe", 1024);
+#endif // BELA_LIBPD_TRILL
+#ifdef ADXL345
+	if(adxl345_init(I2C_DEVICE_1, ADXL345_ADDR_LOW, ADXL345_DATARATE_12_5_HZ))
+	{
+		usleep(100000); // let outstanding rt_printf text print before us
+		fprintf(stderr, "ADXL345 failed to initialise\n");
+	} else {
+		Bela_runAuxiliaryTask(readAdxl345, 0);
+	}
+#endif // ADXL345
+	return true;
+}
+
+void render(BelaContext *context, void *userData)
+{
+#ifdef ADXL345
+	static size_t accelerationCount = 0;
+	if(accelerationCount != gAccelerationUpdated)
+	{
+		accelerationCount = gAccelerationUpdated;
+		libpd_start_message(gAcceleration.size());
+		for(auto& a : gAcceleration)
+			libpd_add_float(a);
+		libpd_finish_list("bela_adxl345");
+	}
+#endif // ADXL345
+#ifdef BELA_LIBPD_GUI
+	while(gGuiControlBuffers.size()) // this won't change within the loop, but it's good not to have to use a separate flag
+	{
+		static struct guiControlMessageHeader header;
+		static bool waitingForHeader = true;
+		if(waitingForHeader)
+		{
+			int ret = gGuiPipe.readRt(header);
+			if(1 != ret)
+				break;
+			else
+				waitingForHeader = false;
+		}
+		if(!waitingForHeader)
+		{
+			char payload[header.size + ('s' == header.type)]; // + 1 to add null termination if needed
+			int ret = gGuiPipe.readRt(&payload[0], header.size);
+			if(int(header.size) != ret)
+			{
+				break;
+			}
+			const char* name = gGuiControlBuffers[header.id].c_str();
+			if('f' == header.type)
+			{
+				if(header.size != sizeof(float))
+				{
+					rt_fprintf(stderr, "Unexpected message length for float: %u\n", header.size);
+					continue;
+				}
+				float value;
+				memcpy(&value, payload, sizeof(value));
+				libpd_start_message(1);
+				libpd_add_float(value);
+				libpd_finish_message("bela_guiControl", name);
+			}
+			if('s' == header.type)
+			{
+				// add null termination
+				payload[header.size] = '\0';
+				// send to Pd
+				libpd_start_message(1);
+				libpd_add_symbol(payload);
+				libpd_finish_message("bela_guiControl", name);
+			}
+			waitingForHeader = true;
+		}
+	}
+	for(auto& b : gGuiDataBuffers)
+	{
+		int id = b.id;
+		int size = b.size;
+		const char* name = b.name.c_str();
+		if(id < 0)
+		{
+			// initialize
+			size = libpd_arraysize(name);
+			if(size <= 0)
+			{
+				continue;
+			} else {
+				// this is thread-unsafe: what happens if this causes reallocation while the Gui thread is writing to a buffer?
+				id = gui.setBuffer('f', size);
+				b.id = id;
+				b.size = size;
+				DataBuffer& dataBuffer = gui.getDataBuffer(id);
+				// initialize gui buffer with the initial content of the array
+				libpd_read_array(dataBuffer.getAsFloat(), b.name.c_str(), 0, size);
+			}
+		}
+		DataBuffer& dataBuffer = gui.getDataBuffer(b.id);
+		libpd_write_array(b.name.c_str(), 0, dataBuffer.getAsFloat(), dataBuffer.getNumElements());
+	}
+#endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	static SerialPipeState serialPipeStateRt {};
+	if(gSerialInputTask)
+		processSerialPipe(true, serialPipeStateRt);
+#endif // BELA_LIBPD_SERIAL
+#ifdef BELA_LIBPD_TRILL
+	for(auto& name : gTrillAcks)
+	{
+		unsigned int idx = getIdxFromId(name.c_str(), gTouchSensors);
+		libpd_start_message(3);
+		libpd_add_symbol(Trill::getNameFromDevice(gTouchSensors[idx].second->deviceType()).c_str());
+		libpd_add_float(gTouchSensors[idx].second->getAddress());
+		libpd_add_symbol(Trill::getNameFromMode(gTouchSensors[idx].second->getMode()).c_str());
+		libpd_finish_message("bela_trillCreated", name.c_str());
+	}
+	gTrillAcks.resize(0);
+	bool doTrill = false;
+	for(auto& t : gTouchSensors)
+	{
+		if(Trill::NONE != t.second->deviceType())
+		{
+			doTrill = true;
+			break;
+		}
+	}
+	if(doTrill)
+	{
+		int idx;
+		while(gTrillPipe.readRt(idx) > 0)
+		{
+			Trill& touchSensor = *gTouchSensors[idx].second;
+			const char* sensorId = gTouchSensors[idx].first.c_str();
+			if(Trill::Device::NONE == touchSensor.deviceType())
+				continue;
+
+			const Trill::Mode mode = touchSensor.getMode();
+			if(Trill::DIFF == mode || Trill::RAW == mode || Trill::BASELINE == mode)
+			{
+				libpd_start_message(touchSensor.getNumChannels());
+				for(unsigned int n = 0; n < touchSensor.getNumChannels(); ++n)
+				{
+					libpd_add_float(touchSensor.rawData[n]);
+				}
+			} else if(Trill::CENTROID == mode)
+			{
+				if(touchSensor.is1D()) {
+					libpd_start_message(2 * touchSensor.getNumTouches() + 1);
+					libpd_add_float(touchSensor.getNumTouches());
+					for(unsigned int i = 0; i < touchSensor.getNumTouches(); i++) {
+						libpd_add_float(touchSensor.touchLocation(i));
+						libpd_add_float(touchSensor.touchSize(i));
+					}
+				} else if (touchSensor.is2D()) {
+					int numTouches = touchSensor.compoundTouchSize() > 0;
+					libpd_start_message(2 * numTouches + 1);
+					libpd_add_float(numTouches > 0);
+					if(numTouches)
+					{
+						libpd_add_float(touchSensor.compoundTouchHorizontalLocation());
+						libpd_add_float(touchSensor.compoundTouchLocation());
+						libpd_add_float(touchSensor.compoundTouchSize());
+					}
+				}
+			}
+			else
+				continue;
+			libpd_finish_message("bela_trill", sensorId);
+		}
+
+		static unsigned int count = 0;
+		unsigned int readIntervalSamples = touchSensorSleepInterval * context->audioSampleRate;
+		count += context->audioFrames;
+		if(count > readIntervalSamples)
+		{
+			Bela_scheduleAuxiliaryTask(gTrillTask);
+			count -= readIntervalSamples;
+		}
+	}
+#endif // BELA_LIBPD_TRILL
+#ifdef BELA_LIBPD_MIDI
+#ifdef PARSE_MIDI
+	int num;
+	for(unsigned int port = 0; port < midi.size(); ++port){
+		while((num = midi[port]->getParser()->numAvailableMessages()) > 0){
+			static MidiChannelMessage message;
+			message = midi[port]->getParser()->getNextChannelMessage();
+			if(gMidiVerbose >= kMidiVerbosePrintLevel)
+			{
+				rt_printf("On port %d (%s): ", port, gMidiPortNames[port].c_str());
+				message.prettyPrint(); // use this to print beautified message (channel, data bytes)
+			}
+			switch(message.getType()){
+				case kmmNoteOn:
+				{
+					int noteNumber = message.getDataByte(0);
+					int velocity = message.getDataByte(1);
+					int channel = message.getChannel();
+					libpd_noteon(channel + port * 16, noteNumber, velocity);
+					break;
+				}
+				case kmmNoteOff:
+				{
+					/* PureData does not seem to handle noteoff messages as per the MIDI specs,
+					 * so that the noteoff velocity is ignored. Here we convert them to noteon
+					 * with a velocity of 0.
+					 */
+					int noteNumber = message.getDataByte(0);
+	//				int velocity = message.getDataByte(1); // would be ignored by Pd
+					int channel = message.getChannel();
+					libpd_noteon(channel + port * 16, noteNumber, 0);
+					break;
+				}
+				case kmmControlChange:
+				{
+					int channel = message.getChannel();
+					int controller = message.getDataByte(0);
+					int value = message.getDataByte(1);
+					libpd_controlchange(channel + port * 16, controller, value);
+					break;
+				}
+				case kmmProgramChange:
+				{
+					int channel = message.getChannel();
+					int program = message.getDataByte(0);
+					libpd_programchange(channel + port * 16, program);
+					break;
+				}
+				case kmmPolyphonicKeyPressure:
+				{
+					int channel = message.getChannel();
+					int pitch = message.getDataByte(0);
+					int value = message.getDataByte(1);
+					libpd_polyaftertouch(channel + port * 16, pitch, value);
+					break;
+				}
+				case kmmChannelPressure:
+				{
+					int channel = message.getChannel();
+					int value = message.getDataByte(0);
+					libpd_aftertouch(channel + port * 16, value);
+					break;
+				}
+				case kmmPitchBend:
+				{
+					int channel = message.getChannel();
+					int value =  ((message.getDataByte(1) << 7)| message.getDataByte(0)) - 8192;
+					libpd_pitchbend(channel + port * 16, value);
+					break;
+				}
+				case kmmSystem:
+				// currently Bela only handles sysrealtime, and it does so pretending it is a channel message with no data bytes, so we have to re-assemble the status byte
+				{
+					int channel = message.getChannel();
+					int status = message.getStatusByte();
+					int byte = channel | status;
+					libpd_sysrealtime(port, byte);
+					break;
+				}
+				case kmmNone:
+				case kmmAny:
+					break;
+			}
+		}
+	}
+#else
+	int input;
+	for(unsigned int port = 0; port < NUM_MIDI_PORTS; ++port){
+		while((input = midi[port].getInput()) >= 0){
+			libpd_midibyte(port, input);
+		}
+	}
+#endif /* PARSE_MIDI */
+#endif // BELA_LIBPD_MIDI
+	unsigned int numberOfPdBlocksToProcess = context->audioFrames / gLibpdBlockSize;
+
+	// Remember: we have non-interleaved buffers and the same sampling rate for
+	// analogs, audio and digitals
+	for(unsigned int tick = 0; tick < numberOfPdBlocksToProcess; ++tick)
+	{
+		//audio input
+		for(unsigned int n = 0; n < context->audioInChannels; ++n)
+		{
+			memcpy(
+				gInBuf + n * gLibpdBlockSize,
+				context->audioIn + tick * gLibpdBlockSize + n * context->audioFrames, 
+				sizeof(context->audioIn[0]) * gLibpdBlockSize
+			);
+		}
+
+		// analog input
+		for(unsigned int n = 0; n < context->analogInChannels; ++n)
+		{
+			memcpy(
+				gInBuf + gLibpdBlockSize * gFirstAnalogInChannel + n * gLibpdBlockSize,
+				context->analogIn + tick * gLibpdBlockSize + n * context->analogFrames, 
+				sizeof(context->analogIn[0]) * gLibpdBlockSize
+			);
+		}
+		// multiplexed analog input
+		if(pdMultiplexerActive)
+		{
+			// we do not disable regular analog inputs if muxer is active, because user may have bridged them on the board and
+			// they may be using half of them at a high sampling-rate
+			static int lastMuxerUpdate = 0;
+			if(++lastMuxerUpdate == multiplexerArraySize){
+				lastMuxerUpdate = 0;
+				libpd_write_array(multiplexerArray, 0, (float *const)context->multiplexerAnalogIn, multiplexerArraySize);
+			}
+		}
+
+		unsigned int digitalFrameBase = gLibpdBlockSize * tick;
+		unsigned int j;
+		unsigned int k;
+		float* p0;
+		float* p1;
+		// digital input
+		if(gDigitalEnabled)
+		{
+			// digital in at message-rate
+			dcm.processInput(&context->digital[digitalFrameBase], gLibpdBlockSize);
+
+			// digital in at signal-rate
+			for (j = 0, p0 = gInBuf; j < gLibpdBlockSize; j++, p0++) {
+				unsigned int digitalFrame = digitalFrameBase + j;
+				for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstDigitalChannel;
+						k < 16; ++k, p1 += gLibpdBlockSize) {
+					if(dcm.isSignalRate(k) && dcm.isInput(k)){ // only process input channels that are handled at signal rate
+						*p1 = digitalRead(context, digitalFrame, k);
+					}
+				}
+			}
+		}
+
+		libpd_process_sys(); // process the block
+
+		// digital outputs
+		if(gDigitalEnabled)
+		{
+			// digital out at signal-rate
+			for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) {
+				unsigned int digitalFrame = (digitalFrameBase + j);
+				for (k = 0, p1 = p0  + gLibpdBlockSize * gFirstDigitalChannel;
+					k < context->digitalChannels; k++, p1 += gLibpdBlockSize)
+				{
+					if(dcm.isSignalRate(k) && dcm.isOutput(k)){ // only process output channels that are handled at signal rate
+						digitalWriteOnce(context, digitalFrame, k, *p1 > 0.5);
+					}
+				}
+			}
+
+			// digital out at message-rate
+			dcm.processOutput(&context->digital[digitalFrameBase], gLibpdBlockSize);
+		}
+
+#ifdef BELA_LIBPD_SCOPE
+		// scope output
+		for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) {
+			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstScopeChannel; k < gScopeOut.size(); k++, p1 += gLibpdBlockSize) {
+				gScopeOut[k] = *p1;
+			}
+			scope.log(gScopeOut.data());
+		}
+#endif // BELA_LIBPD_SCOPE
+
+		// audio output
+		for(unsigned int n = 0; n < context->audioOutChannels; ++n)
+		{
+			memcpy(
+				context->audioOut + tick * gLibpdBlockSize + n * context->audioFrames, 
+				gOutBuf + n * gLibpdBlockSize,
+				sizeof(context->audioOut[0]) * gLibpdBlockSize
+			);
+		}
+
+		//analog output
+		for(unsigned int n = 0; n < context->analogOutChannels; ++n)
+		{
+			memcpy(
+				context->analogOut + tick * gLibpdBlockSize + n * context->analogFrames, 
+				gOutBuf + gLibpdBlockSize * gFirstAnalogOutChannel + n * gLibpdBlockSize,
+				sizeof(context->analogOut[0]) * gLibpdBlockSize
+			);
+		}
+	}
+}
+
+void cleanup(BelaContext *context, void *userData)
+{
+#ifdef ADXL345
+	adxl345_finish();
+#endif // ADXL345
+#ifdef BELA_LIBPD_MIDI
+	for(auto a : midi)
+	{
+		delete a;
+	}
+#endif // BELA_LIBPD_MIDI
+#ifdef BELA_LIBPD_TRILL
+	for(auto t : gTouchSensors)
+	{
+		// t.first is a std::string, so the memory will be deallocated automatically
+		delete t.second;
+	}
+#endif // BELA_LIBPD_TRILL
+	libpd_closefile(gPatch);
+}

From e10cdc22741008654dcd62cfa2ba62462291f0f1 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 27 Oct 2023 00:05:26 +0000
Subject: [PATCH 141/188] NIT: Gui: Removed unused code mistakenly added in
 3aa8b3ebaa164c6117e11edaa2fa11cbf9e06bc2

---
 IDE/public/gui/js/GuiHandler.js | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/IDE/public/gui/js/GuiHandler.js b/IDE/public/gui/js/GuiHandler.js
index d328ac9bc..ed31d9e93 100644
--- a/IDE/public/gui/js/GuiHandler.js
+++ b/IDE/public/gui/js/GuiHandler.js
@@ -1,18 +1,5 @@
 import * as utils from './utils.js'
 import GuiCreator from './GuiCreator.js'
-function setup() {
-	console.log("P5 setup");
-}
-
-function draw() {
-	console.log("DRAW")
-	background(0); // Set the background to black
-	y = y - 1;
-	if (y < 0) {
-		y = height;
-	}
-	line(0, y, width, y);
-}
 
 export default class GuiHandler {
 	constructor(control, parentId='gui') {

From c8bb72ff401c7091f05538abb68b509153b5f44a Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 27 Oct 2023 13:07:12 +0000
Subject: [PATCH 142/188] Gui: removed duplicated defaults

---
 IDE/public/gui/js/BelaControl.js   | 2 +-
 IDE/public/gui/js/BelaData.js      | 2 +-
 IDE/public/gui/js/BelaWebSocket.js | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/IDE/public/gui/js/BelaControl.js b/IDE/public/gui/js/BelaControl.js
index d6da67cab..6ab281bf7 100644
--- a/IDE/public/gui/js/BelaControl.js
+++ b/IDE/public/gui/js/BelaControl.js
@@ -3,7 +3,7 @@ import GuiHandler from './GuiHandler.js'
 import * as utils from './utils.js'
 
 export default class BelaControl extends BelaWebSocket {
-	constructor(port=5555, address='gui_control', ip=location.hostname) {
+	constructor(port, address, ip) {
 		super(port, address, ip)
 
 		this.projectName = null;
diff --git a/IDE/public/gui/js/BelaData.js b/IDE/public/gui/js/BelaData.js
index 5898f845f..b2f5e2de0 100644
--- a/IDE/public/gui/js/BelaData.js
+++ b/IDE/public/gui/js/BelaData.js
@@ -1,7 +1,7 @@
 import BelaWebSocket from './BelaWebSocket.js'
 
 export default class BelaData extends BelaWebSocket {
-	constructor(port=5555, address='gui_data', ip=location.hostname) {
+	constructor(port, address, ip) {
 		super(port, address, ip)
 
         this.buffers = new Array();
diff --git a/IDE/public/gui/js/BelaWebSocket.js b/IDE/public/gui/js/BelaWebSocket.js
index 7863e4372..a084aadb1 100644
--- a/IDE/public/gui/js/BelaWebSocket.js
+++ b/IDE/public/gui/js/BelaWebSocket.js
@@ -1,5 +1,5 @@
 export default class BelaWebSocket {
-    constructor(port, address, ip = location.hostname) {
+    constructor(port, address, ip) {
         this.port = port;
         this.address = address;
         this.ip = ip;

From 955f3735bf91a78b996261dea2fbf1a852e3b8b7 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 27 Oct 2023 13:08:08 +0000
Subject: [PATCH 143/188] Gui: allow the fronted to override sketchName,
 wsPort, and { wsPrefix | {wsData, wsControl} }

---
 IDE/public/gui/js/Bela.js       | 10 +++++++---
 IDE/public/gui/js/GuiHandler.js | 15 ++++++++-------
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/IDE/public/gui/js/Bela.js b/IDE/public/gui/js/Bela.js
index bba75bd8f..c7ed95038 100644
--- a/IDE/public/gui/js/Bela.js
+++ b/IDE/public/gui/js/Bela.js
@@ -3,10 +3,14 @@ import BelaControl from './BelaControl.js'
 
 export default class Bela {
 	constructor(ip=location.hostname) {
-		this.port = 5555
+		let qs = new URLSearchParams(window.location.search);
+		this.port = qs.has('wsPort') ? qs.get('wsPort') : 5555;
+		let prefix = qs.has('wsPrefix') ? qs.get('wsPrefix') : 'gui_';
+		let data = qs.has('wsData') ? qs.get('wsData') : prefix + 'data';
+		let control = qs.has('wsControl') ? qs.get('wsControl') : prefix + 'control';
 		this.addresses = {
-			data:    'gui_data',
-			control: 'gui_control'
+			data: data,
+			control: control,
 		}
 		this.ip = ip
 		this.data    = new BelaData    (this.port, this.addresses.data,    this.ip)
diff --git a/IDE/public/gui/js/GuiHandler.js b/IDE/public/gui/js/GuiHandler.js
index ed31d9e93..79eb808b0 100644
--- a/IDE/public/gui/js/GuiHandler.js
+++ b/IDE/public/gui/js/GuiHandler.js
@@ -1,6 +1,7 @@
 import * as utils from './utils.js'
 import GuiCreator from './GuiCreator.js'
 
+let qs = new URLSearchParams(window.location.search);
 export default class GuiHandler {
 	constructor(control, parentId='gui') {
 		this.control = control;
@@ -69,9 +70,8 @@ export default class GuiHandler {
 			let projName = null;
 			history.replaceState(null, null, ' ');
 
-			let queryString = new URLSearchParams(window.location.search);
-			if(queryString.has('project'))
-				projName = queryString.get('project');
+			if(qs.has('project'))
+				projName = qs.get('project');
 
 			projName = projName || that.control.projectName;
 
@@ -178,15 +178,16 @@ export default class GuiHandler {
 		that.control.target.resolve = null;
 	}
 
-	loadSketch(projectName, parentSection, dom, sketchName='sketch', resources=null, defaultSource = "/gui/p5-sketches/sketch.js") {
+	loadSketch(projectName, parentSection, dom, sketchName='sketch.js', resources=null, defaultSource = "/gui/p5-sketches/sketch.js") {
 		resources = (resources == null || Array.isArray(resources)) ? resources : [resources];
 		let resourcePromises = [];
 		if(resources != null)
 			resources.forEach(r => resourcePromises.push(this.control.loadResource("/projects/"+projectName+"/"+r)) );
 
-		console.log("Loading "+projectName+" ...");
-
-		let sketchSource = "/projects/"+projectName+"/"+sketchName+".js";
+		if(qs.has("sketchName"))
+			sketchName = qs.get("sketchName");
+		let sketchSource = "/projects/"+projectName+"/"+sketchName;
+		console.log("Loading project: "+projectName+", file: " + sketchSource);
 
 		let sketch = utils.loadScript(sketchSource, parentSection, dom);
 

From 4698e1f43d323dd630f02d6ce58881c51679793d Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 29 Oct 2023 14:23:00 +0000
Subject: [PATCH 144/188] WSServer: add port to ws pipe name, so we can have
 multiple websockets with same path each on a different port

---
 libraries/WSServer/WSServer.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/WSServer/WSServer.cpp b/libraries/WSServer/WSServer.cpp
index 599e205fe..8742e72b2 100644
--- a/libraries/WSServer/WSServer.cpp
+++ b/libraries/WSServer/WSServer.cpp
@@ -110,7 +110,7 @@ void WSServer::addAddress(const std::string& _address,
 	// See possible pitfalls here
 	// https://floating.io/2017/07/lambda-shared_ptr-memory-leak/
 	std::weak_ptr<WSServerDataHandler> wkHdl(handler);
-	address_book[_address].thread->create(std::string("WSClient_")+_address,
+	address_book[_address].thread->create(std::string("WSClient_")+_address+std::to_string(port),
 		[this,wkHdl](void* buf, int size){
 			auto handler = wkHdl.lock();
 			if(handler)

From 39d4a02feb06094f3108e58d4380751eee4eb26f Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 29 Oct 2023 16:25:38 +0000
Subject: [PATCH 145/188] Gui: on the frontend, interpret projectName as either
 projectName or absolute path to sketch

---
 IDE/public/gui/js/GuiHandler.js | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/IDE/public/gui/js/GuiHandler.js b/IDE/public/gui/js/GuiHandler.js
index 79eb808b0..ad222bfb7 100644
--- a/IDE/public/gui/js/GuiHandler.js
+++ b/IDE/public/gui/js/GuiHandler.js
@@ -178,16 +178,23 @@ export default class GuiHandler {
 		that.control.target.resolve = null;
 	}
 
-	loadSketch(projectName, parentSection, dom, sketchName='sketch.js', resources=null, defaultSource = "/gui/p5-sketches/sketch.js") {
+	loadSketch(projectName, parentSection, dom, resources=null, defaultSource = "/gui/p5-sketches/sketch.js") {
 		resources = (resources == null || Array.isArray(resources)) ? resources : [resources];
 		let resourcePromises = [];
+		let projectPath;
+		let sketchSource;
+		if("/" === projectName[0])
+		{
+			// an absolute path: take it at face value
+			sketchSource = projectName;
+		} else {
+			sketchSource = "/projects/" + projectName + "/sketch.js";
+		}
+		let projectDir = sketchSource.split("/").slice(0, -1).join("/");
 		if(resources != null)
-			resources.forEach(r => resourcePromises.push(this.control.loadResource("/projects/"+projectName+"/"+r)) );
+			resources.forEach(r => resourcePromises.push(this.control.loadResource(projectDir + "/" + r)) );
 
-		if(qs.has("sketchName"))
-			sketchName = qs.get("sketchName");
-		let sketchSource = "/projects/"+projectName+"/"+sketchName;
-		console.log("Loading project: "+projectName+", file: " + sketchSource);
+		console.log("Loading 'project': " + projectName + ", file: " + sketchSource, ", from:" + projectDir);
 
 		let sketch = utils.loadScript(sketchSource, parentSection, dom);
 

From 1a4843e5a7d76895d0a35744f4f760f6298f6a40 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Sun, 29 Oct 2023 16:26:27 +0000
Subject: [PATCH 146/188] Gui: docs and using const&

---
 libraries/Gui/Gui.cpp |  2 +-
 libraries/Gui/Gui.h   | 13 +++++++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/libraries/Gui/Gui.cpp b/libraries/Gui/Gui.cpp
index 463ec1fd4..eb6c0f54f 100644
--- a/libraries/Gui/Gui.cpp
+++ b/libraries/Gui/Gui.cpp
@@ -46,7 +46,7 @@ int Gui::setup(unsigned int port, std::string address)
 	return 0;
 }
 
-int Gui::setup(std::string projectName, unsigned int port, std::string address)
+int Gui::setup(const std::string& projectName, unsigned int port, const std::string& address)
 {
 	_projectName = std::wstring(projectName.begin(), projectName.end());
 	setup(port, address);
diff --git a/libraries/Gui/Gui.h b/libraries/Gui/Gui.h
index 81749e7a2..50b59ddec 100644
--- a/libraries/Gui/Gui.h
+++ b/libraries/Gui/Gui.h
@@ -48,12 +48,17 @@ class Gui
 		/**
 		 * Sets the web socket communication between server and client.
 		 * Two different web socket connections will be configured, one for control data and the other one for raw binary data. 
-		 * @param port Port on which to stablish the the web socket communication.
-		 * @param address Base address used to stalish the web socket communication.
-		 * @param projectName Project name to be sent to via the web-socket to the client.
+		 * @param projectName Project name to be sent to via the
+		 * websocket to the client. If it starts with a "/" it is
+		 * interpreted as a full path to the .js file to be loaded and
+		 * it has to be a valid path on the webserver. Otherwise, it is
+		 * used to build the path assuming the js file to be called
+		 * sketch.js and located in the project folder.
+		 * @param port Port on which to establish the web socket communication.
+		 * @param address Base address used to establish the web socket communication.
 		 * @returns 0 if web sockets have been configured.
 		 **/
-		int setup(std::string projectName, unsigned int port = 5555, std::string address = "gui");
+		int setup(const std::string& projectName, unsigned int port = 5555, const std::string& address = "gui");
 		void cleanup();
 
 		size_t numConnections(){ return wsConnections.size(); };

From 69cca22bead104a0bb08709ee2ce031c1738977a Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 2 Nov 2023 13:46:36 +0000
Subject: [PATCH 147/188] default_libpd_render: added BELA_SYSTEM_THREADED in
 order to make bela_system calls mostly RT-safe

---
 core/default_libpd_render.cpp | 33 ++++++++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index 6a0e1c975..ab7822ac9 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -11,6 +11,7 @@
 #define BELA_LIBPD_TRILL
 #define BELA_LIBPD_GUI
 #define BELA_LIBPD_SERIAL
+#define BELA_LIBPD_SYSTEM_THREADED
 
 #ifdef BELA_LIBPD_DISABLE_SCOPE
 #undef BELA_LIBPD_SCOPE
@@ -27,6 +28,9 @@
 #ifdef BELA_LIBPD_DISABLE_SERIAL
 #undef BELA_LIBPD_SERIAL
 #endif // BELA_LIBPD_DISABLE_SERIAL
+#ifdef BELA_LIBPD_DISABLE_SYSTEM_THREADD
+#undef BELA_LIBPD_SYSTEM_THREADED
+#endif // BELA_LIBPD_DISABLE_SYSTEM_THREADD
 
 #define PD_THREADED_IO
 #include <libraries/libpd/libpd.h>
@@ -573,10 +577,23 @@ void setTrillPrintError()
 }
 #endif // BELA_LIBPD_TRILL
 
+static void systemDoSystem(const char* cmd)
+{
+	rt_printf("system(\"%s\");\n", cmd);
+	system(cmd);
+}
+#ifdef BELA_LIBPD_SYSTEM_THREADED
+#include <AuxTaskNonRT.h>
+static AuxTaskNonRT systemTask("systemTask", [](void* buf, int size) {
+	systemDoSystem((const char*)buf);
+});
+
+#endif // BELA_LIBPD_SYSTEM_THREADED
+
 static void belaSystem(const char* first, int argc, t_atom* argv)
 {
-	printf("belaSystem %s, %d\n", first, argc);
-	std::string cmd = first ? first : "";
+	static std::string cmd; // make it static to try and avoid repeated allocations
+	cmd = first ? first : "";
 	for(size_t n = 0; n < argc; ++n)
 	{
 		if(0 != n || first)
@@ -590,12 +607,15 @@ static void belaSystem(const char* first, int argc, t_atom* argv)
 		} else if(libpd_is_symbol(argv + n)) {
 			cmd += libpd_get_symbol(argv + n);
 		} else {
-			fprintf(stderr, "Error: argument %d of bela_system is not a float or symbol. Command so far: '%s', this will be discarded\n", n, cmd.c_str());
+			rt_fprintf(stderr, "Error: argument %d of bela_system is not a float or symbol. Command so far: '%s', this will be discarded\n", n, cmd.c_str());
 			return;
 		}
 	}
-	printf("system(\"%s\");\n", cmd.c_str());
-	system(cmd.c_str());
+#ifdef BELA_LIBPD_SYSTEM_THREADED
+	systemTask.schedule(cmd.c_str(), cmd.size());
+#else // BELA_LIBPD_SYSTEM_THREADED
+	systemDoSystem(cmd.c_str());
+#endif // // BELA_LIBPD_SYSTEM_THREADED
 }
 
 void Bela_listHook(const char *source, int argc, t_atom *argv)
@@ -642,7 +662,6 @@ void Bela_listHook(const char *source, int argc, t_atom *argv)
 #endif // BELA_LIBPD_GUI
 	if(0 == strcmp(source, "bela_system"))
 	{
-		printf("list: %d\n", argc);
 		belaSystem(nullptr, argc, argv);
 		return;
 	}
@@ -723,8 +742,8 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 		return;
 	}
 	if(strcmp(source, "bela_system") == 0){
-		printf("msg: %s %d\n", symbol, argc);
 		belaSystem(symbol, argc, argv);
+		return;
 	}
 	if(strcmp(source, "bela_control") == 0){
 		if(strcmp("stop", symbol) == 0){

From c6707862f02281885c0c74c5cde114d90e9b00bc Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 7 Nov 2023 15:34:04 +0000
Subject: [PATCH 148/188] Makefile.libraries: ensure they are built with -fPIC

---
 Makefile.libraries | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Makefile.libraries b/Makefile.libraries
index 8afec3279..2316f898f 100644
--- a/Makefile.libraries
+++ b/Makefile.libraries
@@ -13,7 +13,8 @@ AT?=@
 BELA_USE_DEFINE:=BELA_USE_RTDM
 DEBIAN_VERSION :=stretch
 BASE_DIR:=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
-DEFAULT_COMMON_FLAGS ?= -O3 -g -march=armv7-a -mtune=cortex-a8 -mfloat-abi=hard -mfpu=neon -ftree-vectorize -ffast-math -fPIC
+DEFAULT_COMMON_FLAGS ?= -O3 -g -march=armv7-a -mtune=cortex-a8 -mfloat-abi=hard -mfpu=neon -ftree-vectorize -ffast-math
+DEFAULT_COMMON_FLAGS += -fPIC # ensure it's always set
 LIBRARY_CXXFLAGS := $(DEFAULT_COMMON_FLAGS) -std=c++11
 LIBRARY_CFLAGS := $(DEFAULT_COMMON_FLAGS) -std=gnu11
 

From 0ee360818cd2fe3790b85a3fccb16bd79f9e82be Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 7 Nov 2023 16:42:55 +0000
Subject: [PATCH 149/188] Makefile: EXPORT_ALL_VARIABLES twice because once
 doesn't seem to suffice

---
 Makefile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile
index 80e9fdb01..92aa70c80 100644
--- a/Makefile
+++ b/Makefile
@@ -143,7 +143,7 @@ endif # heavy-unzip-archive
 ifeq ($(filter $(SUPERCOLLIDER_FILE),$(FILE_LIST)),$(SUPERCOLLIDER_FILE))
 PROJECT_TYPE=sc
 SHOULD_BUILD=false
-RUN_PREREQUISITES+=lib/libbela.so lib/libbelaextra.so
+RUN_PREREQUISITES+=lib
 else
 ifeq ($(filter $(LIBPD_FILE),$(FILE_LIST)),$(LIBPD_FILE))
 ifeq (,$(strip $(filter %.c,$(FILE_LIST)) $(filter %.cc,$(FILE_LIST)) $(filter %.cpp,$(FILE_LIST))))
@@ -551,13 +551,12 @@ ifeq ($(SHOULD_BUILD),false)
 $(OUTPUT_FILE):
 else
 
-.EXPORT_ALL_VARIABLES:
-
 PROJECT_LIBRARIES_MAKEFILE := $(PROJECT_DIR)/build/Makefile.inc
 
 # the actual dependency is on the .d files, but as we have no rule for making
 # those .d files (and we don't want one, see above) and they are made as a side
 # effect of the .o, we depend here on the .o instead of the .d
+.EXPORT_ALL_VARIABLES:
 $(PROJECT_LIBRARIES_MAKEFILE): $(PROJECT_OBJS_NO_P) $(DEFAULT_PD_OBJS)
 	$(AT)./resources/tools/detectlibraries.sh --path $(PROJECT_DIR)/build $(LIBPD_DETECT_LIBRARES_FLAGS)
 
@@ -787,6 +786,7 @@ LIB_EXTRA_SO = libbelaextra.so
 LIB_EXTRA_A = libbelaextra.a
 # some library objects are required by libbelaextra.
 LIB_EXTRA_OBJS = $(EXTRA_CORE_OBJS) build/core/GPIOcontrol.o libraries/Scope/build/Scope.o libraries/WSServer/build/WSServer.o libraries/UdpClient/build/UdpClient.o libraries/UdpServer/build/UdpServer.o libraries/Midi/build/Midi.o libraries/Midi/build/Midi_c.o
+.EXPORT_ALL_VARIABLES:
 libraries/%.o: # how to build those objects needed by libbelaextra
 	$(AT) $(MAKE) -f Makefile.linkbela --no-print-directory $@
 

From 36c6e4f39c6001724ab0621e58c1a6514b985489 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 23 Oct 2023 22:45:57 +0000
Subject: [PATCH 150/188] Spi_Codec: set _shouldPinmux first thing

---
 core/Spi_Codec.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/core/Spi_Codec.cpp b/core/Spi_Codec.cpp
index f6b00f808..d695ea2f1 100644
--- a/core/Spi_Codec.cpp
+++ b/core/Spi_Codec.cpp
@@ -21,8 +21,12 @@ const int RESET_PIN = 81; // GPIO2(17) P8.34
 
 Spi_Codec::Spi_Codec(const char* spidev_gpio_cs0, const char* spidev_gpio_cs1, bool isVerbose /* = false */)
 {
-
 	_verbose = isVerbose;
+	// if BelaRevC is used in combination with CTAG, there is a pin conflict
+	// between MOSI and the McASP data line used by BelaRevC.
+	// We check here whether the pin's function can be set at runtime so
+	// that in that case we can set it before using it in writeRegister().
+	_shouldPinmux = (PinmuxUtils::get(mosiPin).size() > 0);
 	// Open SPI devices
 	if ((_fd_master = open(spidev_gpio_cs0, O_RDWR)) < 0)
 		_verbose && fprintf(stderr, "Failed to open spidev device for master codec.\n");
@@ -54,11 +58,6 @@ Spi_Codec::Spi_Codec(const char* spidev_gpio_cs0, const char* spidev_gpio_cs1, b
 	// now we can detect if there is a slave codec
 	_isBeast = slaveIsDetected();
 	_dacVolumethreeEighthsDbs.resize(_isBeast ? 16 : 8);
-	// if BelaRevC is used in combination with CTAG, there is a pin conflict
-	// between MOSI and the McASP data line used by BelaRevC.
-	// We check here whether the pin's function can be set at runtime so
-	// that in that case we can set it before using it in writeRegister().
-	_shouldPinmux = (PinmuxUtils::get(mosiPin).size() > 0);
 }
 
 Spi_Codec::~Spi_Codec(){

From b877e9f5a0a3d3873ad72a612e17ca514faac2c9 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 23 Oct 2023 22:53:31 +0000
Subject: [PATCH 151/188] Spi_Codec: export and set direction for all relevant
 pins. This seems to fix things if you set one of the pins to inputs.

---
 core/Spi_Codec.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/core/Spi_Codec.cpp b/core/Spi_Codec.cpp
index d695ea2f1..c1a27ceb2 100644
--- a/core/Spi_Codec.cpp
+++ b/core/Spi_Codec.cpp
@@ -27,6 +27,19 @@ Spi_Codec::Spi_Codec(const char* spidev_gpio_cs0, const char* spidev_gpio_cs1, b
 	// We check here whether the pin's function can be set at runtime so
 	// that in that case we can set it before using it in writeRegister().
 	_shouldPinmux = (PinmuxUtils::get(mosiPin).size() > 0);
+	// export SPI pins
+	// P8.14
+	for(auto pin : {
+			26, // P8.14 MISO
+			27, // P8.17 CS0
+			10, // P8.31 CS1
+			11, // P8.32 CLK
+			9, // P8.33 MOSI
+		})
+	{
+		gpio_export(pin);
+		gpio_set_dir(pin, 26 == pin ? INPUT_PIN : OUTPUT_PIN);
+	}
 	// Open SPI devices
 	if ((_fd_master = open(spidev_gpio_cs0, O_RDWR)) < 0)
 		_verbose && fprintf(stderr, "Failed to open spidev device for master codec.\n");

From 19d5e7e4938845850fcdea21fc4fb58876828823 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 23 Oct 2023 23:08:17 +0000
Subject: [PATCH 152/188] NIT: board_detect: factored out detectBelaRevC() to a
 single call

---
 core/board_detect.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/core/board_detect.cpp b/core/board_detect.cpp
index 0804db6cb..ead49467b 100644
--- a/core/board_detect.cpp
+++ b/core/board_detect.cpp
@@ -161,6 +161,7 @@ BelaHw Bela_detectHw(const BelaHwDetectMode mode)
 		else
 			return Bela_detectHw(BelaHwDetectMode_Scan);
 	}
+	bool hasBelaRevC = detectBelaRevC();
 
 	BelaHw hw = BelaHw_NoHw;
 	if(is_belamini())
@@ -195,7 +196,7 @@ BelaHw Bela_detectHw(const BelaHwDetectMode mode)
 				hw = BelaHw_CtagBeast;
 		}
 		else {
-			if(detectBelaRevC())
+			if(hasBelaRevC)
 				hw = BelaHw_BelaRevC;
 			else if(hasTlv32)
 				hw = BelaHw_Bela;

From 8562fb46ce3ed2e4ce58a9e1db5823381f3894eb Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 28 Nov 2023 20:50:07 +0000
Subject: [PATCH 153/188] I2c: inheriting classes should use writeBytes() and
 readBytes() where possible

---
 core/Es9080_Codec.cpp | 6 +++---
 core/I2c_Codec.cpp    | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/Es9080_Codec.cpp b/core/Es9080_Codec.cpp
index 53eb14234..0818596f9 100644
--- a/core/Es9080_Codec.cpp
+++ b/core/Es9080_Codec.cpp
@@ -684,7 +684,7 @@ int Es9080_Codec::writeRegister(unsigned int reg, unsigned int value)
 		return 1;
 
 	char buf[2] = { static_cast<char>(reg & 0xFF), static_cast<char>(value & 0xFF) };
-	if(write(i2C_file, buf, sizeof(buf)) != sizeof(buf))
+	if(writeBytes(buf, sizeof(buf)) != sizeof(buf))
 	{
 		verbose && fprintf(stderr, "Failed to write register %d on Es9080 codec\n", reg);
 		return 1;
@@ -699,7 +699,7 @@ int Es9080_Codec::readRegister(unsigned char reg)
 		return 1;
 
 	// first, write the address of the register you want to read
-	int ret = write(i2C_file, &reg, sizeof(reg));
+	int ret = writeBytes(&reg, sizeof(reg));
 	if(sizeof(reg) != ret)
 	{
 		verbose && fprintf(stderr, "Failed to write register %d on Es9080 codec\n", reg);
@@ -707,7 +707,7 @@ int Es9080_Codec::readRegister(unsigned char reg)
 	}
 	// then read the content of the address you specified
 	unsigned char value;
-	ret = read(i2C_file, &value, sizeof(value));
+	ret = readBytes(&value, sizeof(value));
 	if(sizeof(value) != ret)
 	{
 		verbose && fprintf(stderr, "Failed to read register %d on Es9080 codec\n", reg);
diff --git a/core/I2c_Codec.cpp b/core/I2c_Codec.cpp
index 4eaca2621..edb05e60c 100644
--- a/core/I2c_Codec.cpp
+++ b/core/I2c_Codec.cpp
@@ -1019,7 +1019,7 @@ int I2c_Codec::writeRegister(unsigned int reg, unsigned int value)
 {
 	char buf[2] = { static_cast<char>(reg & 0xFF), static_cast<char>(value & 0xFF) };
 
-	if(write(i2C_file, buf, 2) != 2)
+	if(writeBytes(buf, 2) != 2)
 	{
 		verbose && fprintf(stderr, "Failed to write register %d on I2c codec\n", reg);
 		return 1;

From bdc28ca53b2c79f8b2e4e621f878aec1ac780563 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 28 Nov 2023 20:50:32 +0000
Subject: [PATCH 154/188] I2c: specify that we are using the global namespace
 for read() and write()

---
 include/I2c.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/I2c.h b/include/I2c.h
index cde8be272..b1d65c72e 100644
--- a/include/I2c.h
+++ b/include/I2c.h
@@ -79,12 +79,12 @@ inline int I2c::closeI2C()
 
 inline ssize_t I2c::readBytes(void *buf, size_t count)
 {
-	return read(i2C_file, buf, count);
+	return ::read(i2C_file, buf, count);
 }
 
 inline ssize_t I2c::writeBytes(const void *buf, size_t count)
 {
-	return write(i2C_file, buf, count);
+	return ::write(i2C_file, buf, count);
 }
 
 inline I2c::~I2c(){

From a2fd26032d5f2ba52fbeedc28666e39dc5436a05 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 29 Nov 2023 10:01:30 +0000
Subject: [PATCH 155/188] I2c.h: add readRaw / writeRaw

---
 include/I2c.h | 36 +++++++++++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/include/I2c.h b/include/I2c.h
index b1d65c72e..f6ea6ad7f 100644
--- a/include/I2c.h
+++ b/include/I2c.h
@@ -27,6 +27,7 @@ class I2c
 	int i2C_bus;
 	int i2C_address;
 	int i2C_file;
+	ssize_t doIoctl(int address, i2c_char_t* data, int length, unsigned int flags);
 public:
 	ssize_t readBytes(void* buf, size_t count);
 	ssize_t writeBytes(const void* buf, size_t count);
@@ -34,7 +35,8 @@ class I2c
 	I2c(I2c&&) = delete;
 	int initI2C_RW(int bus, int address, int file);
 	int closeI2C();
-
+	ssize_t readRaw(int address, i2c_char_t *data, int length, bool repeated = false);
+	ssize_t writeRaw(int address, const i2c_char_t *data, int length, bool repeated = false);
 	virtual ~I2c();
 };
 
@@ -87,6 +89,38 @@ inline ssize_t I2c::writeBytes(const void *buf, size_t count)
 	return ::write(i2C_file, buf, count);
 }
 
+inline ssize_t I2c::doIoctl(int address, i2c_char_t* data, int length, unsigned int flags)
+{
+	struct i2c_rdwr_ioctl_data packets;
+	struct i2c_msg message;
+	message.addr = address;
+	message.flags = flags;
+	message.len = length;
+	message.buf = data;
+	packets.msgs = &message;
+	packets.nmsgs = 1;
+	int ret;
+	if((ret = ioctl(i2C_file, I2C_RDWR, &packets)) < 0)
+	{
+		fprintf(stderr, "Failed to do ioctl for %d bytes on I2C at addr %d with flags %d: %d\n", length, address, flags, ret);
+		return -1;
+	} else
+		fprintf(stderr, "Successful to do ioctl for %d bytes on I2C at addr %d with flags %d: %d\n", length, address, flags, ret);
+	return  length;
+
+}
+inline ssize_t I2c::readRaw(int address, i2c_char_t *data, int length, bool repeated)
+{
+	unsigned int flags = I2C_M_RD | (repeated ? I2C_M_NOSTART : 0);
+	return doIoctl(address, data, length, flags);
+}
+
+inline ssize_t I2c::writeRaw(int address, const i2c_char_t *data, int length, bool repeated)
+{
+	unsigned int flags = (repeated ? I2C_M_NOSTART : 0);
+	return doIoctl(address, (i2c_char_t*)data, length, flags);
+}
+
 inline I2c::~I2c(){
 	if(i2C_file >= 0)
 		close(i2C_file);

From 5b7e0c0b8e47944af62abb1163716d51e5c9a9ca Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 29 Nov 2023 10:02:04 +0000
Subject: [PATCH 156/188] Es9080_Codec: fixed print

---
 core/Es9080_Codec.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/Es9080_Codec.cpp b/core/Es9080_Codec.cpp
index 0818596f9..72ce4cedb 100644
--- a/core/Es9080_Codec.cpp
+++ b/core/Es9080_Codec.cpp
@@ -702,7 +702,7 @@ int Es9080_Codec::readRegister(unsigned char reg)
 	int ret = writeBytes(&reg, sizeof(reg));
 	if(sizeof(reg) != ret)
 	{
-		verbose && fprintf(stderr, "Failed to write register %d on Es9080 codec\n", reg);
+		verbose && fprintf(stderr, "Failed to read register %d on Es9080 codec\n", reg);
 		return -1;
 	}
 	// then read the content of the address you specified

From 9e4525ce859dca1a22fd3d79eb7e75f3e7475a1c Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 5 Dec 2023 22:32:38 +0000
Subject: [PATCH 157/188] NIT: gXenomaiInited where it's used

---
 core/RTAudio.cpp    | 2 --
 core/RtWrappers.cpp | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/core/RTAudio.cpp b/core/RTAudio.cpp
index ff67b3cac..6929b29e7 100644
--- a/core/RTAudio.cpp
+++ b/core/RTAudio.cpp
@@ -31,8 +31,6 @@
 #include "../include/BelaContextFifo.h"
 #include "../include/MiscUtilities.h"
 
-int gXenomaiInited = 0;
-
 #include <pthread.h>
 
 #include "../include/RtWrappers.h"
diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index 6c9e437a8..a9087e691 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -279,6 +279,7 @@ bool turnIntoRtThread()
 #endif
 }
 
+int gXenomaiInited = 0;
 void Bela_initRtBackend()
 {
 	static std::once_flag flag;
@@ -327,7 +328,6 @@ void Bela_initRtBackend()
 #endif // __COBALT__
 		// this is no longer required, but we keep it for backward
 		// compatibility
-		extern int gXenomaiInited;
 		gXenomaiInited = 1;
 	});
 }

From fb615e891793d80c4ec793984e07201ba5b6a428 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 5 Dec 2023 22:33:01 +0000
Subject: [PATCH 158/188] NIT: missing include

---
 core/RtWrappers.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index a9087e691..8520181b9 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -333,6 +333,7 @@ void Bela_initRtBackend()
 }
 
 #include <Bela.h>
+#include <stdarg.h>
 #define var_num_to_va_list(stream, fmt, dest) \
 { \
 	ssize_t ret; \

From 0e980afa5e8123a44441b184808b500d21db2242 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 7 Dec 2023 16:31:51 +0000
Subject: [PATCH 159/188] examples/Audio/variable-filter

---
 examples/Audio/variable-filter/render.cpp | 67 +++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 examples/Audio/variable-filter/render.cpp

diff --git a/examples/Audio/variable-filter/render.cpp b/examples/Audio/variable-filter/render.cpp
new file mode 100644
index 000000000..ac6a5d6d1
--- /dev/null
+++ b/examples/Audio/variable-filter/render.cpp
@@ -0,0 +1,67 @@
+/*
+ ____  _____ _        _
+| __ )| ____| |      / \
+|  _ \|  _| | |     / _ \
+| |_) | |___| |___ / ___ \
+|____/|_____|_____/_/   \_\
+http://bela.io
+*/
+/**
+\example Audio/variable-filter/render.cpp
+
+Variable filter
+================
+
+This sketch demonstrates how to use the Biquad library to filter an audio
+signal, controlling the cutoff frequency of the filter with an analog input.
+
+As updating the filter coefficients is a rather expensive operation, we do it
+once per block.
+We also filter the analog input signals before using them in order to minimise their noise.
+
+*/
+
+#include <Bela.h>
+#include <libraries/Biquad/Biquad.h>
+#include <libraries/OnePole/OnePole.h>
+#include <stdlib.h>
+#include <math.h>
+
+Biquad lpFilter;
+OnePole analogSmooth;
+
+bool setup(BelaContext *context, void *userData)
+{
+	analogSmooth.setup(50, context->analogSampleRate);
+	return true;
+}
+
+void render(BelaContext *context, void *userData) {
+	// smooth analog input signals
+	float analogIn = 0;
+	for(unsigned int n = 0; n < context->analogFrames; ++n)
+		analogIn = analogSmooth.process(analogRead(context, n, 0));
+	// once per block update the audio filter cutoff
+	// analog in 0 controls cutoff with exponential scaling:
+	// the analog input is mapped between 200 Hz and 200 + 2^13 = 8392 Hz
+	float cutoff = powf(2, analogIn * 13) + 200;
+	lpFilter.setup({
+		.fs = context->audioSampleRate,
+		.type = BiquadCoeff::lowpass,
+		.cutoff = cutoff,
+		.q = 0.707,
+		.peakGainDb = 3,
+	});
+	for(unsigned int n = 0; n < context->audioFrames; ++n)
+	{
+		float in = rand() / float(RAND_MAX) * 2.f - 1.f; // a noise source
+		float out = lpFilter.process(in);
+		for(unsigned int c = 0; c < context->audioOutChannels; c++)
+			audioWrite(context, n, c, out);
+	}
+}
+
+void cleanup(BelaContext *context, void *userData)
+{
+
+}

From bc18c3bac719e2fa2a5ba1be4584134c82edf953 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 8 Dec 2023 22:12:49 +0000
Subject: [PATCH 160/188] PureData/custom-render*: updated to latest
 default_libpd_render

---
 .../render.cpp                                | 435 +++++++++++++++++-
 examples/PureData/custom-render/render.cpp    | 432 ++++++++++++++++-
 2 files changed, 827 insertions(+), 40 deletions(-)

diff --git a/examples/PureData/custom-render-ultrasonic-distance-sensor/render.cpp b/examples/PureData/custom-render-ultrasonic-distance-sensor/render.cpp
index f376bbea4..dc4337401 100644
--- a/examples/PureData/custom-render-ultrasonic-distance-sensor/render.cpp
+++ b/examples/PureData/custom-render-ultrasonic-distance-sensor/render.cpp
@@ -18,7 +18,6 @@
  * using libpd.
  */
 #include <Bela.h>
-#include <libraries/libpd/libpd.h>
 
 // Enable features here. These may be undef'ed below if the corresponding
 // BELA_LIBPD_DISABLE_* flag is passed
@@ -26,6 +25,8 @@
 #define BELA_LIBPD_MIDI
 #define BELA_LIBPD_TRILL
 #define BELA_LIBPD_GUI
+#define BELA_LIBPD_SERIAL
+#define BELA_LIBPD_SYSTEM_THREADED
 
 #ifdef BELA_LIBPD_DISABLE_SCOPE
 #undef BELA_LIBPD_SCOPE
@@ -39,6 +40,12 @@
 #ifdef BELA_LIBPD_DISABLE_GUI
 #undef BELA_LIBPD_GUI
 #endif // BELA_LIBPD_DISABLE_GUI
+#ifdef BELA_LIBPD_DISABLE_SERIAL
+#undef BELA_LIBPD_SERIAL
+#endif // BELA_LIBPD_DISABLE_SERIAL
+#ifdef BELA_LIBPD_DISABLE_SYSTEM_THREADD
+#undef BELA_LIBPD_SYSTEM_THREADED
+#endif // BELA_LIBPD_DISABLE_SYSTEM_THREADD
 
 #define PD_THREADED_IO
 #include <libraries/libpd/libpd.h>
@@ -49,7 +56,7 @@
 #include <libraries/Midi/Midi.h>
 #endif // BELA_LIBPD_MIDI
 #ifdef BELA_LIBPD_SCOPE
- #include <libraries/Scope/Scope.h>
+#include <libraries/Scope/Scope.h>
 #endif // BELA_LIBPD_SCOPE
 #include <string>
 #include <sstream>
@@ -188,6 +195,243 @@ bool guiControlDataCallback(JSONObject& root, void* arg)
 }
 
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+#include <libraries/Serial/Serial.h>
+#include <libraries/Pipe/Pipe.h>
+#include <string>
+
+Pipe gSerialPipe;
+Serial gSerial;
+std::string gSerialId;
+int gSerialEom;
+enum SerialType {
+	kSerialFloats,
+	kSerialBytes,
+	kSerialSymbol,
+	kSerialSymbols,
+} gSerialType = kSerialFloats;
+AuxiliaryTask gSerialInputTask;
+AuxiliaryTask gSerialOutputTask;
+
+struct serialMessageHeader
+{
+	uint32_t idSize = 0;
+	uint32_t dataSize = 0;
+};
+enum WaitingFor {
+	kHeader,
+	kId,
+	kData,
+};
+
+struct SerialPipeState {
+	struct serialMessageHeader h;
+	enum WaitingFor waitingFor = kHeader;
+	char id[100];
+};
+
+static void processSerialPipe(bool rt, SerialPipeState& s)
+{
+	// Not sure we actually need while() below. We were using it earlier
+	// when this was coded inside render() in order to be able to perform early returns
+	while(1)
+	{
+		auto& h = s.h;
+		auto& waitingFor = s.waitingFor;
+		auto& id = s.id;
+		if(kHeader == waitingFor)
+		{
+			int ret = rt ? gSerialPipe.readRt(h) : gSerialPipe.readNonRt(h);
+			if(ret <= 0)
+				break;
+			waitingFor = kId;
+		}
+		if(kId == waitingFor)
+		{
+			if(h.idSize > sizeof(id) - 1)
+				rt_fprintf(stderr, "Serial: ID too large\n");
+			else
+			{
+				int ret = rt ? gSerialPipe.readRt(id, h.idSize) : gSerialPipe.readNonRt(id, h.idSize);
+				if(ret <= 0)
+					break;
+				if(int(h.idSize) != ret)
+				{
+					rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.idSize, ret);
+					break;
+				}
+				id[ret] = '\0'; // ensure it's null-terminated
+				waitingFor = kData;
+			}
+		}
+		if(kData == waitingFor)
+		{
+			char data[h.dataSize + 1];
+			int ret = rt ? gSerialPipe.readRt(data, h.dataSize) : gSerialPipe.readNonRt(data, h.dataSize);
+			if(ret <= 0)
+				break;
+			if(int(h.dataSize) != ret)
+			{
+				rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.dataSize, ret);
+				break;
+			}
+			if(rt)
+			{
+				// rt: forward data from pipe to Pd
+				data[h.dataSize] = '\0'; // ensure it's null-terminated
+				if(h.dataSize)
+				{
+					const char* rec = "bela_serialIn";
+					if(kSerialSymbol == gSerialType)
+					{
+						libpd_symbol(rec, data);
+					} else if(kSerialBytes == gSerialType) {
+						if(gSerialEom >= 0) {
+							// messages are separated: send as a list
+							libpd_start_message(h.dataSize);
+							for(size_t n = 0; n < h.dataSize; ++n)
+								libpd_add_float(data[n]);
+							libpd_finish_message(rec, id);
+						} else {
+							// messages are not separated: send one byte at a time
+							for(size_t n = 0; n < h.dataSize; ++n)
+							{
+								libpd_start_message(h.dataSize);
+								libpd_add_float(data[n]);
+								libpd_finish_message(rec, id);
+							}
+						}
+					} else {
+						unsigned int nTokens = 1;
+						const uint8_t separators[] = { ' ', '\0'};
+						// find number of delimiters
+						size_t start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n] && n != start) // exclude empty tokens
+								{
+									start = n + 1;
+									nTokens++;
+								}
+							}
+						}
+						libpd_start_message(nTokens);
+						start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							bool end = false;
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n])
+								{
+									if(start == n)
+										start++; // remove empty tokens
+									else
+										end = true;
+									break; // no need to check for more separators
+								}
+							}
+							if(end)
+							{
+								data[n] = '\0'; // ensure the string is null-terminated so the next line works
+								if(kSerialSymbols == gSerialType)
+									libpd_add_symbol(data + start);
+								else if (kSerialFloats == gSerialType)
+									libpd_add_float(atof(data + start));
+								start = n + 1;
+							}
+						}
+						libpd_finish_message(rec, id);
+					}
+				}
+			} else {
+				// non-rt: forward data from pipe to serial
+				if(h.dataSize)
+					gSerial.write(data, h.dataSize);
+			}
+			waitingFor = kHeader;
+		}
+	}
+}
+
+static void serialOutputLoop(void* arg) {
+	// blocking read with timeout
+	gSerialPipe.setBlockingNonRt(true);
+	gSerialPipe.setTimeoutMsNonRt(100);
+	std::vector<uint8_t> rec(1024);
+	std::vector<uint8_t> id(100);
+
+	SerialPipeState serialStateNonRt {};
+	while(!Bela_stopRequested())
+	{
+		processSerialPipe(false, serialStateNonRt);
+	}
+}
+
+static void serialInputLoop(void* arg) {
+	char serialBuffer[10000];
+	unsigned int i = 0;
+	serialMessageHeader h;
+	h.idSize = strlen(gSerialId.c_str()) + 1;
+	while(!Bela_stopRequested())
+	{
+		// read from the serial port with a timeout of 100ms
+		int ret = gSerial.read(serialBuffer + i, sizeof(serialBuffer) - i, 100);
+		if (ret > 0) {
+			if(gSerialEom < 0)
+			{
+				h.dataSize = ret;
+				// send everything immediately
+				gSerialPipe.writeNonRt(h);
+				gSerialPipe.writeNonRt(gSerialId.c_str(), h.idSize);
+				gSerialPipe.writeNonRt(serialBuffer, h.dataSize);
+			} else {
+				// find EOM in new data
+				unsigned int searchStart = i;
+				unsigned int searchStop = searchStart + ret;
+				unsigned int n;
+				unsigned int lastSent = 0;
+				bool found;
+				do
+				{
+					found = false;
+					for(n = searchStart; n < searchStop; ++n)
+					{
+						if(serialBuffer[n] == gSerialEom)
+						{
+							found = true;
+							break;
+						}
+					}
+					// if found, send all data till that point
+					if(found)
+					{
+						h.dataSize = n - lastSent;
+						if(h.dataSize)
+						{
+							gSerialPipe.writeNonRt(h);
+							gSerialPipe.writeNonRt(gSerialId.c_str(), h.idSize);
+							gSerialPipe.writeNonRt(serialBuffer + lastSent, h.dataSize);
+						}
+						searchStart = n + 1;
+						lastSent += 1 + h.dataSize;
+					}
+				}
+				while(found);
+				// if we are left with any data, move it to the beginning of the buffer.
+				// TODO: avoid this and use it as a circular buffer
+				if(searchStart != i)
+					memmove(serialBuffer, serialBuffer + searchStart, searchStop - searchStart);
+				i = searchStop - searchStart;
+			}
+		}
+	}
+}
+
+#endif // BELA_LIBPD_SERIAL
+
 enum { minFirstDigitalChannel = 10 };
 static unsigned int gAnalogChannelsInUse;
 static unsigned int gDigitalChannelsInUse;
@@ -367,6 +611,47 @@ void setTrillPrintError()
 }
 #endif // BELA_LIBPD_TRILL
 
+static void systemDoSystem(const char* cmd)
+{
+	rt_printf("system(\"%s\");\n", cmd);
+	system(cmd);
+}
+#ifdef BELA_LIBPD_SYSTEM_THREADED
+#include <AuxTaskNonRT.h>
+static AuxTaskNonRT systemTask("systemTask", [](void* buf, int size) {
+	systemDoSystem((const char*)buf);
+});
+
+#endif // BELA_LIBPD_SYSTEM_THREADED
+
+static void belaSystem(const char* first, int argc, t_atom* argv)
+{
+	static std::string cmd; // make it static to try and avoid repeated allocations
+	cmd = first ? first : "";
+	for(size_t n = 0; n < argc; ++n)
+	{
+		if(0 != n || first)
+			cmd += " ";
+		if(libpd_is_float(argv + n)) {
+			float arg = libpd_get_float(argv + n);
+			if(arg == (int)arg)
+				cmd += std::to_string((int)arg);
+			else
+				cmd += std::to_string(arg);
+		} else if(libpd_is_symbol(argv + n)) {
+			cmd += libpd_get_symbol(argv + n);
+		} else {
+			rt_fprintf(stderr, "Error: argument %d of bela_system is not a float or symbol. Command so far: '%s', this will be discarded\n", n, cmd.c_str());
+			return;
+		}
+	}
+#ifdef BELA_LIBPD_SYSTEM_THREADED
+	systemTask.schedule(cmd.c_str(), cmd.size());
+#else // BELA_LIBPD_SYSTEM_THREADED
+	systemDoSystem(cmd.c_str());
+#endif // // BELA_LIBPD_SYSTEM_THREADED
+}
+
 void Bela_listHook(const char *source, int argc, t_atom *argv)
 {
 #ifdef BELA_LIBPD_GUI
@@ -377,7 +662,7 @@ void Bela_listHook(const char *source, int argc, t_atom *argv)
 			rt_fprintf(stderr, "Wrong format for bela_gui, the first element should be a float\n");
 			return;
 		}
-		unsigned int bufNum = libpd_get_float(&argv[1]);
+		unsigned int bufNum = libpd_get_float(&argv[0]);
 		if(libpd_is_float(&argv[1])) // if the first element is a float, we send an array of floats
 		{
 			float buf[argc - 1];
@@ -409,6 +694,11 @@ void Bela_listHook(const char *source, int argc, t_atom *argv)
 		return;
 	}
 #endif // BELA_LIBPD_GUI
+	if(0 == strcmp(source, "bela_system"))
+	{
+		belaSystem(nullptr, argc, argv);
+		return;
+	}
 }
 void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *argv){
 #ifdef BELA_LIBPD_MIDI
@@ -485,6 +775,17 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 		dcm.manage(channel, direction, isMessageRate);
 		return;
 	}
+	if(strcmp(source, "bela_system") == 0){
+		belaSystem(symbol, argc, argv);
+		return;
+	}
+	if(strcmp(source, "bela_control") == 0){
+		if(strcmp("stop", symbol) == 0){
+			rt_printf("bela_control: stop\n");
+			Bela_requestStop();
+		}
+		return;
+	}
 #ifdef BELA_LIBPD_GUI
 	if(0 == strcmp(source, "bela_setGui"))
 	{
@@ -520,6 +821,83 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 		}
 	}
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	if(0 == strcmp(source, "bela_setSerial"))
+	{
+		if(0 == strcmp(symbol, "new"))
+		{
+			if(
+				argc < 5
+				|| !libpd_is_symbol(argv + 0) // serial_id
+				|| !libpd_is_symbol(argv + 1) // device
+				|| !libpd_is_float(argv + 2) // baudrate
+				|| !(libpd_is_symbol(argv + 3) || libpd_is_float(argv + 3)) // EOM
+				|| !libpd_is_symbol(argv + 4) // type
+			)
+			{
+				fprintf(stderr, "Invalid bela_setSerial arguments. Should be:\n"
+				"`new serial_id device baudrate EOM type`,\n"
+				"where `EOM` is one of `newline` or `none` or a character (expressed as an integer"
+				"       between 0 and 255)\n"
+				"and `type` is one of `bytes`, `floats`, `symbol`, `symbols`\n");
+				return;
+			}
+			gSerialId = libpd_get_symbol(argv + 0);
+			const char* device = libpd_get_symbol(argv + 1);
+			unsigned int baudrate = libpd_get_float(argv + 2);
+			gSerialEom = -1;
+			if(libpd_is_symbol(argv + 3)) {
+				const char* eom = libpd_get_symbol(argv + 3);
+				if(0 == strcmp(eom, "newline"))
+					gSerialEom = '\n';
+			} else if(libpd_is_float(argv + 3)) {
+				gSerialEom = libpd_get_float(argv + 3);
+			}
+			const char* type = libpd_get_symbol(argv + 4);
+			if(0 == strcmp("floats", type))
+				gSerialType = kSerialFloats;
+			else if(0 == strcmp("bytes", type))
+				gSerialType = kSerialBytes;
+			else if(0 == strcmp("symbol", type))
+				gSerialType = kSerialSymbol;
+			else if(0 == strcmp("symbols", type))
+				gSerialType = kSerialSymbols;
+
+			if(gSerial.setup(device, baudrate))
+				return;
+			gSerialInputTask = Bela_runAuxiliaryTask(serialInputLoop, 0);
+			gSerialOutputTask = Bela_runAuxiliaryTask(serialOutputLoop, 0);
+		}
+	}
+	if(0 == strcmp(source, "bela_serialOut"))
+	{
+		if(!argc) {
+			fprintf(stderr, "Invalid bela_serialOut arguments. Should be:\n"
+			"`serial_id firstByte <other bytes>`\n");
+			return;
+		}
+		const char* id = symbol;
+		// convert floats to bytes
+		char data[argc];
+		for(size_t n = 0; n < argc; ++n)
+		{
+			t_atom *a = argv + n;
+			if(libpd_is_float(a))
+			{
+				data[n] = libpd_get_float(a);
+			} else {
+				fprintf(stderr, "bela_serialOut received non-float\n");
+				return;
+			}
+		}
+		struct serialMessageHeader h;
+		h.idSize = strlen(id);
+		h.dataSize = sizeof(data);
+		gSerialPipe.writeRt(h);
+		gSerialPipe.writeRt(id, h.idSize);
+		gSerialPipe.writeRt(data, h.dataSize);
+	}
+#endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	if(0 == strcmp(source, "bela_setTrill"))
 	{
@@ -626,7 +1004,7 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 						value = 0;
 					if(Trill::prescalerMax < value)
 						value = Trill::prescalerMax;
-					rt_printf("bela_setTrill prescaler value out of range, clipping to %u\n", value);
+					rt_printf("bela_setTrill prescaler value out of range, clipping to %.0f\n", value);
 				}
 				gTouchSensors[idx].second->setPrescaler(value);
 			}
@@ -640,7 +1018,7 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 void Bela_floatHook(const char *source, float value){
 	// let's make this as optimized as possible for built-in digital Out parsing
 	// the built-in digital receivers are of the form "bela_digitalOutXX" where XX is between gLibpdDigitalChannelOffset and (gLibpdDigitalCHannelOffset+gDigitalChannelsInUse)
-	static int prefixLength = 15; // strlen("bela_digitalOut")
+	static int prefixLength = strlen("bela_digitalOut");
 	if(strncmp(source, "bela_digitalOut", prefixLength)==0){
 		if(source[prefixLength] != 0){ //the two ifs are used instead of if(strlen(source) >= prefixLength+2)
 			if(source[prefixLength + 1] != 0){
@@ -653,6 +1031,7 @@ void Bela_floatHook(const char *source, float value){
 				}
 			}
 		}
+		return;
 	}
 }
 
@@ -696,7 +1075,7 @@ void fdLoop(void* arg){
 
 #ifdef BELA_LIBPD_SCOPE
 Scope scope;
-float* gScopeOut;
+std::vector<float> gScopeOut;
 #endif // BELA_LIBPD_SCOPE
 void* gPatch;
 bool gDigitalEnabled = 0;
@@ -708,6 +1087,9 @@ bool setup(BelaContext *context, void *userData)
 	gui.setControlDataCallback(guiControlDataCallback, nullptr);
 	gGuiPipe.setup("guiControlPipe", 16384);
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	gSerialPipe.setup("serialPipe", 16384);
+#endif // BELA_LIBPD_SERIAL
 	// Check Pd's version
 	int major, minor, bugfix;
 	sys_getversion(&major, &minor, &bugfix);
@@ -737,20 +1119,17 @@ bool setup(BelaContext *context, void *userData)
 #endif // BELA_LIBPD_MIDI
 #ifdef BELA_LIBPD_SCOPE
 	scope.setup(gScopeChannelsInUse, context->audioSampleRate);
-	gScopeOut = new float[gScopeChannelsInUse];
+	gScopeOut.resize(gScopeChannelsInUse);
 #endif // BELA_LIBPD_SCOPE
 
 	// Check first of all if the patch file exists. Will actually open it later.
 	char file[] = "_main.pd";
 	char folder[] = "./";
-	unsigned int strSize = strlen(file) + strlen(folder) + 1;
-	char* str = (char*)malloc(sizeof(char) * strSize);
-	snprintf(str, strSize, "%s%s", folder, file);
-	if(access(str, F_OK) == -1 ) {
-		printf("Error file %s/%s not found. The %s file should be your main patch.\n", folder, file, file);
+	std::string path = std::string(folder) + file;
+	if(access(path.c_str(), F_OK) == -1 ) {
+		printf("Error file %s not found. The %s file should be your main patch.\n", path.c_str(), file);
 		return false;
 	}
-	free(str);
 
 	// analog setup
 	gAnalogChannelsInUse = context->analogInChannels;
@@ -842,6 +1221,8 @@ bool setup(BelaContext *context, void *userData)
 	for(unsigned int i = 0; i < gDigitalChannelsInUse; i++)
 		libpd_bind(gReceiverOutputNames[i].c_str());
 	libpd_bind("bela_setDigital");
+	libpd_bind("bela_control");
+	libpd_bind("bela_system");
 #ifdef BELA_LIBPD_MIDI
 	libpd_bind("bela_setMidi");
 #endif // BELA_LIBPD_MIDI
@@ -849,6 +1230,10 @@ bool setup(BelaContext *context, void *userData)
 	libpd_bind("bela_guiOut");
 	libpd_bind("bela_setGui");
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	libpd_bind("bela_serialOut");
+	libpd_bind("bela_setSerial");
+#endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	libpd_bind("bela_setTrill");
 #endif // BELA_LIBPD_TRILL
@@ -919,7 +1304,7 @@ void render(BelaContext *context, void *userData)
 		}
 		if(!waitingForHeader)
 		{
-			char payload[header.size];
+			char payload[header.size + ('s' == header.type)]; // + 1 to add null termination if needed
 			int ret = gGuiPipe.readRt(&payload[0], header.size);
 			if(int(header.size) != ret)
 			{
@@ -933,14 +1318,20 @@ void render(BelaContext *context, void *userData)
 					rt_fprintf(stderr, "Unexpected message length for float: %u\n", header.size);
 					continue;
 				}
-				float value = ((float*)payload)[0];
+				float value;
+				memcpy(&value, payload, sizeof(value));
 				libpd_start_message(1);
 				libpd_add_float(value);
 				libpd_finish_message("bela_guiControl", name);
 			}
 			if('s' == header.type)
 			{
-				libpd_symbol(name, payload);
+				// add null termination
+				payload[header.size] = '\0';
+				// send to Pd
+				libpd_start_message(1);
+				libpd_add_symbol(payload);
+				libpd_finish_message("bela_guiControl", name);
 			}
 			waitingForHeader = true;
 		}
@@ -971,6 +1362,11 @@ void render(BelaContext *context, void *userData)
 		libpd_write_array(b.name.c_str(), 0, dataBuffer.getAsFloat(), dataBuffer.getNumElements());
 	}
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	static SerialPipeState serialPipeStateRt {};
+	if(gSerialInputTask)
+		processSerialPipe(true, serialPipeStateRt);
+#endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	for(auto& name : gTrillAcks)
 	{
@@ -1223,10 +1619,10 @@ void render(BelaContext *context, void *userData)
 #ifdef BELA_LIBPD_SCOPE
 		// scope output
 		for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) {
-			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstScopeChannel; k < gScopeChannelsInUse; k++, p1 += gLibpdBlockSize) {
+			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstScopeChannel; k < gScopeOut.size(); k++, p1 += gLibpdBlockSize) {
 				gScopeOut[k] = *p1;
 			}
-			scope.log(gScopeOut[0], gScopeOut[1], gScopeOut[2], gScopeOut[3]);
+			scope.log(gScopeOut.data());
 		}
 #endif // BELA_LIBPD_SCOPE
 
@@ -1303,7 +1699,4 @@ void cleanup(BelaContext *context, void *userData)
 	}
 #endif // BELA_LIBPD_TRILL
 	libpd_closefile(gPatch);
-#ifdef BELA_LIBPD_SCOPE
-	delete [] gScopeOut;
-#endif // BELA_LIBPD_SCOPE
 }
diff --git a/examples/PureData/custom-render/render.cpp b/examples/PureData/custom-render/render.cpp
index a6bb595f2..e4e4fec16 100644
--- a/examples/PureData/custom-render/render.cpp
+++ b/examples/PureData/custom-render/render.cpp
@@ -38,6 +38,8 @@ The Bela software is distributed under the GNU Lesser General Public License
 #define BELA_LIBPD_MIDI
 #define BELA_LIBPD_TRILL
 #define BELA_LIBPD_GUI
+#define BELA_LIBPD_SERIAL
+#define BELA_LIBPD_SYSTEM_THREADED
 
 #ifdef BELA_LIBPD_DISABLE_SCOPE
 #undef BELA_LIBPD_SCOPE
@@ -51,6 +53,12 @@ The Bela software is distributed under the GNU Lesser General Public License
 #ifdef BELA_LIBPD_DISABLE_GUI
 #undef BELA_LIBPD_GUI
 #endif // BELA_LIBPD_DISABLE_GUI
+#ifdef BELA_LIBPD_DISABLE_SERIAL
+#undef BELA_LIBPD_SERIAL
+#endif // BELA_LIBPD_DISABLE_SERIAL
+#ifdef BELA_LIBPD_DISABLE_SYSTEM_THREADD
+#undef BELA_LIBPD_SYSTEM_THREADED
+#endif // BELA_LIBPD_DISABLE_SYSTEM_THREADD
 
 #define PD_THREADED_IO
 #include <libraries/libpd/libpd.h>
@@ -181,6 +189,243 @@ bool guiControlDataCallback(JSONObject& root, void* arg)
 }
 
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+#include <libraries/Serial/Serial.h>
+#include <libraries/Pipe/Pipe.h>
+#include <string>
+
+Pipe gSerialPipe;
+Serial gSerial;
+std::string gSerialId;
+int gSerialEom;
+enum SerialType {
+	kSerialFloats,
+	kSerialBytes,
+	kSerialSymbol,
+	kSerialSymbols,
+} gSerialType = kSerialFloats;
+AuxiliaryTask gSerialInputTask;
+AuxiliaryTask gSerialOutputTask;
+
+struct serialMessageHeader
+{
+	uint32_t idSize = 0;
+	uint32_t dataSize = 0;
+};
+enum WaitingFor {
+	kHeader,
+	kId,
+	kData,
+};
+
+struct SerialPipeState {
+	struct serialMessageHeader h;
+	enum WaitingFor waitingFor = kHeader;
+	char id[100];
+};
+
+static void processSerialPipe(bool rt, SerialPipeState& s)
+{
+	// Not sure we actually need while() below. We were using it earlier
+	// when this was coded inside render() in order to be able to perform early returns
+	while(1)
+	{
+		auto& h = s.h;
+		auto& waitingFor = s.waitingFor;
+		auto& id = s.id;
+		if(kHeader == waitingFor)
+		{
+			int ret = rt ? gSerialPipe.readRt(h) : gSerialPipe.readNonRt(h);
+			if(ret <= 0)
+				break;
+			waitingFor = kId;
+		}
+		if(kId == waitingFor)
+		{
+			if(h.idSize > sizeof(id) - 1)
+				rt_fprintf(stderr, "Serial: ID too large\n");
+			else
+			{
+				int ret = rt ? gSerialPipe.readRt(id, h.idSize) : gSerialPipe.readNonRt(id, h.idSize);
+				if(ret <= 0)
+					break;
+				if(int(h.idSize) != ret)
+				{
+					rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.idSize, ret);
+					break;
+				}
+				id[ret] = '\0'; // ensure it's null-terminated
+				waitingFor = kData;
+			}
+		}
+		if(kData == waitingFor)
+		{
+			char data[h.dataSize + 1];
+			int ret = rt ? gSerialPipe.readRt(data, h.dataSize) : gSerialPipe.readNonRt(data, h.dataSize);
+			if(ret <= 0)
+				break;
+			if(int(h.dataSize) != ret)
+			{
+				rt_fprintf(stderr, "Invalid number of bytes read from gSerialPipe. Expected: %u, got %u\n", h.dataSize, ret);
+				break;
+			}
+			if(rt)
+			{
+				// rt: forward data from pipe to Pd
+				data[h.dataSize] = '\0'; // ensure it's null-terminated
+				if(h.dataSize)
+				{
+					const char* rec = "bela_serialIn";
+					if(kSerialSymbol == gSerialType)
+					{
+						libpd_symbol(rec, data);
+					} else if(kSerialBytes == gSerialType) {
+						if(gSerialEom >= 0) {
+							// messages are separated: send as a list
+							libpd_start_message(h.dataSize);
+							for(size_t n = 0; n < h.dataSize; ++n)
+								libpd_add_float(data[n]);
+							libpd_finish_message(rec, id);
+						} else {
+							// messages are not separated: send one byte at a time
+							for(size_t n = 0; n < h.dataSize; ++n)
+							{
+								libpd_start_message(h.dataSize);
+								libpd_add_float(data[n]);
+								libpd_finish_message(rec, id);
+							}
+						}
+					} else {
+						unsigned int nTokens = 1;
+						const uint8_t separators[] = { ' ', '\0'};
+						// find number of delimiters
+						size_t start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n] && n != start) // exclude empty tokens
+								{
+									start = n + 1;
+									nTokens++;
+								}
+							}
+						}
+						libpd_start_message(nTokens);
+						start = 0;
+						for(size_t n = 0; n < sizeof(data); ++n)
+						{
+							bool end = false;
+							for(size_t c = 0; c < sizeof(separators); ++c)
+							{
+								if(separators[c] == data[n])
+								{
+									if(start == n)
+										start++; // remove empty tokens
+									else
+										end = true;
+									break; // no need to check for more separators
+								}
+							}
+							if(end)
+							{
+								data[n] = '\0'; // ensure the string is null-terminated so the next line works
+								if(kSerialSymbols == gSerialType)
+									libpd_add_symbol(data + start);
+								else if (kSerialFloats == gSerialType)
+									libpd_add_float(atof(data + start));
+								start = n + 1;
+							}
+						}
+						libpd_finish_message(rec, id);
+					}
+				}
+			} else {
+				// non-rt: forward data from pipe to serial
+				if(h.dataSize)
+					gSerial.write(data, h.dataSize);
+			}
+			waitingFor = kHeader;
+		}
+	}
+}
+
+static void serialOutputLoop(void* arg) {
+	// blocking read with timeout
+	gSerialPipe.setBlockingNonRt(true);
+	gSerialPipe.setTimeoutMsNonRt(100);
+	std::vector<uint8_t> rec(1024);
+	std::vector<uint8_t> id(100);
+
+	SerialPipeState serialStateNonRt {};
+	while(!Bela_stopRequested())
+	{
+		processSerialPipe(false, serialStateNonRt);
+	}
+}
+
+static void serialInputLoop(void* arg) {
+	char serialBuffer[10000];
+	unsigned int i = 0;
+	serialMessageHeader h;
+	h.idSize = strlen(gSerialId.c_str()) + 1;
+	while(!Bela_stopRequested())
+	{
+		// read from the serial port with a timeout of 100ms
+		int ret = gSerial.read(serialBuffer + i, sizeof(serialBuffer) - i, 100);
+		if (ret > 0) {
+			if(gSerialEom < 0)
+			{
+				h.dataSize = ret;
+				// send everything immediately
+				gSerialPipe.writeNonRt(h);
+				gSerialPipe.writeNonRt(gSerialId.c_str(), h.idSize);
+				gSerialPipe.writeNonRt(serialBuffer, h.dataSize);
+			} else {
+				// find EOM in new data
+				unsigned int searchStart = i;
+				unsigned int searchStop = searchStart + ret;
+				unsigned int n;
+				unsigned int lastSent = 0;
+				bool found;
+				do
+				{
+					found = false;
+					for(n = searchStart; n < searchStop; ++n)
+					{
+						if(serialBuffer[n] == gSerialEom)
+						{
+							found = true;
+							break;
+						}
+					}
+					// if found, send all data till that point
+					if(found)
+					{
+						h.dataSize = n - lastSent;
+						if(h.dataSize)
+						{
+							gSerialPipe.writeNonRt(h);
+							gSerialPipe.writeNonRt(gSerialId.c_str(), h.idSize);
+							gSerialPipe.writeNonRt(serialBuffer + lastSent, h.dataSize);
+						}
+						searchStart = n + 1;
+						lastSent += 1 + h.dataSize;
+					}
+				}
+				while(found);
+				// if we are left with any data, move it to the beginning of the buffer.
+				// TODO: avoid this and use it as a circular buffer
+				if(searchStart != i)
+					memmove(serialBuffer, serialBuffer + searchStart, searchStop - searchStart);
+				i = searchStop - searchStart;
+			}
+		}
+	}
+}
+
+#endif // BELA_LIBPD_SERIAL
+
 enum { minFirstDigitalChannel = 10 };
 static unsigned int gAnalogChannelsInUse;
 static unsigned int gDigitalChannelsInUse;
@@ -373,6 +618,47 @@ void setTrillPrintError()
 }
 #endif // BELA_LIBPD_TRILL
 
+static void systemDoSystem(const char* cmd)
+{
+	rt_printf("system(\"%s\");\n", cmd);
+	system(cmd);
+}
+#ifdef BELA_LIBPD_SYSTEM_THREADED
+#include <AuxTaskNonRT.h>
+static AuxTaskNonRT systemTask("systemTask", [](void* buf, int size) {
+	systemDoSystem((const char*)buf);
+});
+
+#endif // BELA_LIBPD_SYSTEM_THREADED
+
+static void belaSystem(const char* first, int argc, t_atom* argv)
+{
+	static std::string cmd; // make it static to try and avoid repeated allocations
+	cmd = first ? first : "";
+	for(size_t n = 0; n < argc; ++n)
+	{
+		if(0 != n || first)
+			cmd += " ";
+		if(libpd_is_float(argv + n)) {
+			float arg = libpd_get_float(argv + n);
+			if(arg == (int)arg)
+				cmd += std::to_string((int)arg);
+			else
+				cmd += std::to_string(arg);
+		} else if(libpd_is_symbol(argv + n)) {
+			cmd += libpd_get_symbol(argv + n);
+		} else {
+			rt_fprintf(stderr, "Error: argument %d of bela_system is not a float or symbol. Command so far: '%s', this will be discarded\n", n, cmd.c_str());
+			return;
+		}
+	}
+#ifdef BELA_LIBPD_SYSTEM_THREADED
+	systemTask.schedule(cmd.c_str(), cmd.size());
+#else // BELA_LIBPD_SYSTEM_THREADED
+	systemDoSystem(cmd.c_str());
+#endif // // BELA_LIBPD_SYSTEM_THREADED
+}
+
 void Bela_listHook(const char *source, int argc, t_atom *argv)
 {
 #ifdef BELA_LIBPD_GUI
@@ -383,7 +669,7 @@ void Bela_listHook(const char *source, int argc, t_atom *argv)
 			rt_fprintf(stderr, "Wrong format for bela_gui, the first element should be a float\n");
 			return;
 		}
-		unsigned int bufNum = libpd_get_float(&argv[1]);
+		unsigned int bufNum = libpd_get_float(&argv[0]);
 		if(libpd_is_float(&argv[1])) // if the first element is a float, we send an array of floats
 		{
 			float buf[argc - 1];
@@ -415,6 +701,11 @@ void Bela_listHook(const char *source, int argc, t_atom *argv)
 		return;
 	}
 #endif // BELA_LIBPD_GUI
+	if(0 == strcmp(source, "bela_system"))
+	{
+		belaSystem(nullptr, argc, argv);
+		return;
+	}
 }
 void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *argv){
 #ifdef BELA_LIBPD_MIDI
@@ -491,6 +782,17 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 		dcm.manage(channel, direction, isMessageRate);
 		return;
 	}
+	if(strcmp(source, "bela_system") == 0){
+		belaSystem(symbol, argc, argv);
+		return;
+	}
+	if(strcmp(source, "bela_control") == 0){
+		if(strcmp("stop", symbol) == 0){
+			rt_printf("bela_control: stop\n");
+			Bela_requestStop();
+		}
+		return;
+	}
 #ifdef BELA_LIBPD_GUI
 	if(0 == strcmp(source, "bela_setGui"))
 	{
@@ -526,6 +828,83 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 		}
 	}
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	if(0 == strcmp(source, "bela_setSerial"))
+	{
+		if(0 == strcmp(symbol, "new"))
+		{
+			if(
+				argc < 5
+				|| !libpd_is_symbol(argv + 0) // serial_id
+				|| !libpd_is_symbol(argv + 1) // device
+				|| !libpd_is_float(argv + 2) // baudrate
+				|| !(libpd_is_symbol(argv + 3) || libpd_is_float(argv + 3)) // EOM
+				|| !libpd_is_symbol(argv + 4) // type
+			)
+			{
+				fprintf(stderr, "Invalid bela_setSerial arguments. Should be:\n"
+				"`new serial_id device baudrate EOM type`,\n"
+				"where `EOM` is one of `newline` or `none` or a character (expressed as an integer"
+				"       between 0 and 255)\n"
+				"and `type` is one of `bytes`, `floats`, `symbol`, `symbols`\n");
+				return;
+			}
+			gSerialId = libpd_get_symbol(argv + 0);
+			const char* device = libpd_get_symbol(argv + 1);
+			unsigned int baudrate = libpd_get_float(argv + 2);
+			gSerialEom = -1;
+			if(libpd_is_symbol(argv + 3)) {
+				const char* eom = libpd_get_symbol(argv + 3);
+				if(0 == strcmp(eom, "newline"))
+					gSerialEom = '\n';
+			} else if(libpd_is_float(argv + 3)) {
+				gSerialEom = libpd_get_float(argv + 3);
+			}
+			const char* type = libpd_get_symbol(argv + 4);
+			if(0 == strcmp("floats", type))
+				gSerialType = kSerialFloats;
+			else if(0 == strcmp("bytes", type))
+				gSerialType = kSerialBytes;
+			else if(0 == strcmp("symbol", type))
+				gSerialType = kSerialSymbol;
+			else if(0 == strcmp("symbols", type))
+				gSerialType = kSerialSymbols;
+
+			if(gSerial.setup(device, baudrate))
+				return;
+			gSerialInputTask = Bela_runAuxiliaryTask(serialInputLoop, 0);
+			gSerialOutputTask = Bela_runAuxiliaryTask(serialOutputLoop, 0);
+		}
+	}
+	if(0 == strcmp(source, "bela_serialOut"))
+	{
+		if(!argc) {
+			fprintf(stderr, "Invalid bela_serialOut arguments. Should be:\n"
+			"`serial_id firstByte <other bytes>`\n");
+			return;
+		}
+		const char* id = symbol;
+		// convert floats to bytes
+		char data[argc];
+		for(size_t n = 0; n < argc; ++n)
+		{
+			t_atom *a = argv + n;
+			if(libpd_is_float(a))
+			{
+				data[n] = libpd_get_float(a);
+			} else {
+				fprintf(stderr, "bela_serialOut received non-float\n");
+				return;
+			}
+		}
+		struct serialMessageHeader h;
+		h.idSize = strlen(id);
+		h.dataSize = sizeof(data);
+		gSerialPipe.writeRt(h);
+		gSerialPipe.writeRt(id, h.idSize);
+		gSerialPipe.writeRt(data, h.dataSize);
+	}
+#endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	if(0 == strcmp(source, "bela_setTrill"))
 	{
@@ -632,7 +1011,7 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 						value = 0;
 					if(Trill::prescalerMax < value)
 						value = Trill::prescalerMax;
-					rt_printf("bela_setTrill prescaler value out of range, clipping to %u\n", value);
+					rt_printf("bela_setTrill prescaler value out of range, clipping to %.0f\n", value);
 				}
 				gTouchSensors[idx].second->setPrescaler(value);
 			}
@@ -658,7 +1037,7 @@ void Bela_floatHook(const char *source, float value){
 
 	// let's make this as optimized as possible for built-in digital Out parsing
 	// the built-in digital receivers are of the form "bela_digitalOutXX" where XX is between gLibpdDigitalChannelOffset and (gLibpdDigitalCHannelOffset+gDigitalChannelsInUse)
-	static int prefixLength = 15; // strlen("bela_digitalOut")
+	static int prefixLength = strlen("bela_digitalOut");
 	if(strncmp(source, "bela_digitalOut", prefixLength)==0){
 		if(source[prefixLength] != 0){ //the two ifs are used instead of if(strlen(source) >= prefixLength+2)
 			if(source[prefixLength + 1] != 0){
@@ -671,6 +1050,7 @@ void Bela_floatHook(const char *source, float value){
 				}
 			}
 		}
+		return;
 	}
 }
 
@@ -714,7 +1094,7 @@ void fdLoop(void* arg){
 
 #ifdef BELA_LIBPD_SCOPE
 Scope scope;
-float* gScopeOut;
+std::vector<float> gScopeOut;
 #endif // BELA_LIBPD_SCOPE
 void* gPatch;
 bool gDigitalEnabled = 0;
@@ -726,6 +1106,9 @@ bool setup(BelaContext *context, void *userData)
 	gui.setControlDataCallback(guiControlDataCallback, nullptr);
 	gGuiPipe.setup("guiControlPipe", 16384);
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	gSerialPipe.setup("serialPipe", 16384);
+#endif // BELA_LIBPD_SERIAL
 	// Check Pd's version
 	int major, minor, bugfix;
 	sys_getversion(&major, &minor, &bugfix);
@@ -755,20 +1138,17 @@ bool setup(BelaContext *context, void *userData)
 #endif // BELA_LIBPD_MIDI
 #ifdef BELA_LIBPD_SCOPE
 	scope.setup(gScopeChannelsInUse, context->audioSampleRate);
-	gScopeOut = new float[gScopeChannelsInUse];
+	gScopeOut.resize(gScopeChannelsInUse);
 #endif // BELA_LIBPD_SCOPE
 
 	// Check first of all if the patch file exists. Will actually open it later.
 	char file[] = "_main.pd";
 	char folder[] = "./";
-	unsigned int strSize = strlen(file) + strlen(folder) + 1;
-	char* str = (char*)malloc(sizeof(char) * strSize);
-	snprintf(str, strSize, "%s%s", folder, file);
-	if(access(str, F_OK) == -1 ) {
-		printf("Error file %s/%s not found. The %s file should be your main patch.\n", folder, file, file);
+	std::string path = std::string(folder) + file;
+	if(access(path.c_str(), F_OK) == -1 ) {
+		printf("Error file %s not found. The %s file should be your main patch.\n", path.c_str(), file);
 		return false;
 	}
-	free(str);
 
 	// analog setup
 	gAnalogChannelsInUse = context->analogInChannels;
@@ -870,6 +1250,8 @@ bool setup(BelaContext *context, void *userData)
 	for(unsigned int i = 0; i < gDigitalChannelsInUse; i++)
 		libpd_bind(gReceiverOutputNames[i].c_str());
 	libpd_bind("bela_setDigital");
+	libpd_bind("bela_control");
+	libpd_bind("bela_system");
 #ifdef BELA_LIBPD_MIDI
 	libpd_bind("bela_setMidi");
 #endif // BELA_LIBPD_MIDI
@@ -877,6 +1259,10 @@ bool setup(BelaContext *context, void *userData)
 	libpd_bind("bela_guiOut");
 	libpd_bind("bela_setGui");
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	libpd_bind("bela_serialOut");
+	libpd_bind("bela_setSerial");
+#endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	libpd_bind("bela_setTrill");
 #endif // BELA_LIBPD_TRILL
@@ -936,7 +1322,7 @@ void render(BelaContext *context, void *userData)
 		}
 		if(!waitingForHeader)
 		{
-			char payload[header.size];
+			char payload[header.size + ('s' == header.type)]; // + 1 to add null termination if needed
 			int ret = gGuiPipe.readRt(&payload[0], header.size);
 			if(int(header.size) != ret)
 			{
@@ -950,14 +1336,20 @@ void render(BelaContext *context, void *userData)
 					rt_fprintf(stderr, "Unexpected message length for float: %u\n", header.size);
 					continue;
 				}
-				float value = ((float*)payload)[0];
+				float value;
+				memcpy(&value, payload, sizeof(value));
 				libpd_start_message(1);
 				libpd_add_float(value);
 				libpd_finish_message("bela_guiControl", name);
 			}
 			if('s' == header.type)
 			{
-				libpd_symbol(name, payload);
+				// add null termination
+				payload[header.size] = '\0';
+				// send to Pd
+				libpd_start_message(1);
+				libpd_add_symbol(payload);
+				libpd_finish_message("bela_guiControl", name);
 			}
 			waitingForHeader = true;
 		}
@@ -988,6 +1380,11 @@ void render(BelaContext *context, void *userData)
 		libpd_write_array(b.name.c_str(), 0, dataBuffer.getAsFloat(), dataBuffer.getNumElements());
 	}
 #endif // BELA_LIBPD_GUI
+#ifdef BELA_LIBPD_SERIAL
+	static SerialPipeState serialPipeStateRt {};
+	if(gSerialInputTask)
+		processSerialPipe(true, serialPipeStateRt);
+#endif // BELA_LIBPD_SERIAL
 #ifdef BELA_LIBPD_TRILL
 	for(auto& name : gTrillAcks)
 	{
@@ -1240,10 +1637,10 @@ void render(BelaContext *context, void *userData)
 #ifdef BELA_LIBPD_SCOPE
 		// scope output
 		for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) {
-			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstScopeChannel; k < gScopeChannelsInUse; k++, p1 += gLibpdBlockSize) {
+			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstScopeChannel; k < gScopeOut.size(); k++, p1 += gLibpdBlockSize) {
 				gScopeOut[k] = *p1;
 			}
-			scope.log(gScopeOut[0], gScopeOut[1], gScopeOut[2], gScopeOut[3]);
+			scope.log(gScopeOut.data());
 		}
 #endif // BELA_LIBPD_SCOPE
 
@@ -1310,7 +1707,4 @@ void cleanup(BelaContext *context, void *userData)
 	}
 #endif // BELA_LIBPD_TRILL
 	libpd_closefile(gPatch);
-#ifdef BELA_LIBPD_SCOPE
-	delete [] gScopeOut;
-#endif // BELA_LIBPD_SCOPE
 }

From 2ed2edec224e8cfe9897aa4bace0dfb3c92490bd Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 8 Dec 2023 22:15:42 +0000
Subject: [PATCH 161/188] examples: misc printfs fixes

---
 examples/Extras/gpio-analog-loopback-test/render.cpp | 8 ++++----
 examples/Salt/pink-trombone/render.cpp               | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/Extras/gpio-analog-loopback-test/render.cpp b/examples/Extras/gpio-analog-loopback-test/render.cpp
index bb964bc92..1134d5123 100644
--- a/examples/Extras/gpio-analog-loopback-test/render.cpp
+++ b/examples/Extras/gpio-analog-loopback-test/render.cpp
@@ -192,11 +192,11 @@ void render(BelaContext *context, void *userData)
 void cleanup(BelaContext *context, void *userData)
 {
 	if(anaErrorCount == 0 && digErrorCount == 0){
-		rt_printf("Test was succesful with %d analog channels and a buffer size of %d\n", context->analogInChannels, context->audioFrames);
+		printf("Test was succesful with %d analog channels and a buffer size of %d\n", context->analogInChannels, context->audioFrames);
 	} else {
-		rt_printf("------------------------\n%danalog %ddigital errors over %dsamples while running test with ",
-				anaErrorCount, digErrorCount, context->audioFramesElapsed);
-		rt_printf("%d analog channels and a buffer size of %d \n\n\n",
+		printf("------------------------\n%danalog %ddigital errors over %u samples while running test with ",
+				anaErrorCount, digErrorCount, (unsigned)context->audioFramesElapsed);
+		printf("%d analog channels and a buffer size of %d \n\n\n",
 				context->analogInChannels, context->audioFrames);
 		exit(1);
 	}
diff --git a/examples/Salt/pink-trombone/render.cpp b/examples/Salt/pink-trombone/render.cpp
index 94e47e923..db01759ed 100644
--- a/examples/Salt/pink-trombone/render.cpp
+++ b/examples/Salt/pink-trombone/render.cpp
@@ -1637,7 +1637,7 @@ void render(BelaContext* context, void*)
 	static int numStates = 2;
 	if(0)
 	if((int)context->audioFramesElapsed - lastChange > 70000){
-		rt_printf("last: %d, current: %d\n", lastChange, context->audioFramesElapsed);
+		rt_printf("last: %d, current: %u\n", lastChange, (unsigned)context->audioFramesElapsed);
 		lastChange = context->audioFramesElapsed;
 		state++;
 		static int count = -1;

From 259312dbd61aa5dd1a8179241d9eb7a59748235b Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Fri, 8 Dec 2023 22:16:18 +0000
Subject: [PATCH 162/188] Instruments/d-box: removed support for different
 Xenomai skins

---
 examples/Instruments/d-box/render.cpp | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/examples/Instruments/d-box/render.cpp b/examples/Instruments/d-box/render.cpp
index f6b388507..79659bad8 100644
--- a/examples/Instruments/d-box/render.cpp
+++ b/examples/Instruments/d-box/render.cpp
@@ -19,15 +19,8 @@
 #include <algorithm>
 #include <vector>
 
-#ifdef XENOMAI_SKIN_native
-#include <native/timer.h>
-// xenomai timer
-SRTIME prevChangeNs = 0;
-#endif
-#ifdef XENOMAI_SKIN_posix
 // xenomai timer
 long long int prevChangeNs = 0;
-#endif
 
 #undef DBOX_CAPE_TEST
 
@@ -649,17 +642,11 @@ void render_medium_prio(void*)
 		}
 #endif
 
-#ifdef XENOMAI_SKIN_native
-		RTIME ticks		= rt_timer_read();
-		SRTIME ns		= rt_timer_tsc2ns(ticks);
-		SRTIME delta 	= ns-prevChangeNs;
-#endif
 		long long int deltaMinThreshold = 100000000;
-#ifdef XENOMAI_SKIN_posix
 		long long int ns = 0;
 		long long int delta;
 		struct timespec tp;
-		int ret = __wrap_clock_gettime(CLOCK_REALTIME, &tp);
+		int ret = BELA_RT_WRAP(clock_gettime(CLOCK_REALTIME, &tp));
 		if(ret){
 			// if something goes wrong reading the clock, let's not
 			// make that stop us
@@ -669,7 +656,6 @@ void render_medium_prio(void*)
 			ns = tp.tv_sec * 1000000000ULL + tp.tv_nsec;
 			delta = ns - prevChangeNs;
 		}
-#endif
 
 		// switch to next bank cannot be too frequent, to avoid segfault! [for example segfault happens when removing both VDD and GND from breadboard]
 		if(gNextOscBank != gCurrentOscBank && delta > deltaMinThreshold) {

From c95ea36fb4dda14dc04f5aa14ece6db9891d54aa Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 9 Jan 2024 14:00:20 +0000
Subject: [PATCH 163/188] default_libpd_render: fixed serial input buffer

---
 core/default_libpd_render.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index ab7822ac9..e3a356819 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -389,8 +389,11 @@ static void serialInputLoop(void* arg) {
 				// if we are left with any data, move it to the beginning of the buffer.
 				// TODO: avoid this and use it as a circular buffer
 				if(searchStart != i)
+				{
 					memmove(serialBuffer, serialBuffer + searchStart, searchStop - searchStart);
-				i = searchStop - searchStart;
+					i = searchStop - searchStart;
+				} else
+					i = i + searchStop - searchStart;
 			}
 		}
 	}

From 47c54fea16a2989bf876c7ad274656b5d060c928 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 9 Jan 2024 22:56:08 +0000
Subject: [PATCH 164/188] Sensors/DHT11-temperature-sensor example

---
 .../DHT11-temperature-humidity/DHT.cpp        | 338 ++++++++++++++++++
 .../Sensors/DHT11-temperature-humidity/DHT.h  |  92 +++++
 .../DHT11-temperature-humidity/render.cpp     |  59 +++
 3 files changed, 489 insertions(+)
 create mode 100644 examples/Sensors/DHT11-temperature-humidity/DHT.cpp
 create mode 100644 examples/Sensors/DHT11-temperature-humidity/DHT.h
 create mode 100644 examples/Sensors/DHT11-temperature-humidity/render.cpp

diff --git a/examples/Sensors/DHT11-temperature-humidity/DHT.cpp b/examples/Sensors/DHT11-temperature-humidity/DHT.cpp
new file mode 100644
index 000000000..6b597ace9
--- /dev/null
+++ b/examples/Sensors/DHT11-temperature-humidity/DHT.cpp
@@ -0,0 +1,338 @@
+/*!
+ *  @file DHT.cpp
+ *
+ *  @mainpage DHT series of low cost temperature/humidity sensors.
+ *
+ *  @section intro_sec Introduction
+ *
+ *  This is a library for DHT series of low cost temperature/humidity sensors.
+ *
+ *  You must have Adafruit Unified Sensor Library library installed to use this
+ * class.
+ *
+ *  Adafruit invests time and resources providing this open source code,
+ *  please support Adafruit andopen-source hardware by purchasing products
+ *  from Adafruit!
+ *
+ *  @section author Author
+ *
+ *  Written by Adafruit Industries.
+ *
+ *  @section license License
+ *
+ *  MIT license, all text above must be included in any redistribution
+ */
+
+#include "DHT.h"
+#include <math.h>
+#include <string.h>
+typedef uint16_t word;
+
+#define MIN_INTERVAL 2000 /**< min interval value */
+#define TIMEOUT                                                                \
+  UINT32_MAX /**< Used programmatically for timeout.                           \
+                   Not a timeout duration. Type: uint32_t. */
+
+/*!
+ *  @brief  Instantiates a new DHT class
+ *  @param  pin
+ *          pin number that sensor is connected
+ *  @param  type
+ *          type of sensor
+ *  @param  count
+ *          number of sensors
+ */
+DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) {
+  (void)count; // Workaround to avoid compiler warning.
+  _pin = pin;
+  _type = type;
+}
+
+/*!
+ *  @brief  Setup sensor pins and set pull timings
+ *  @param  usec
+ *          Optionally pass pull-up time (in microseconds) before DHT reading
+ *starts. Default is 55 (see function declaration in DHT.h).
+ */
+void DHT::begin(uint8_t usec) {
+  DEBUG_PRINT("DHT max clock cycles: ");
+  DEBUG_PRINTLN(_maxcycles, DEC);
+  pullTime = usec;
+}
+
+/*!
+ *  @brief  Read temperature
+ *  @param  S
+ *          Scale. Boolean value:
+ *					- true = Fahrenheit
+ *					- false = Celcius
+ *  @param  force
+ *          true if in force mode
+ *	@return Temperature value in selected scale
+ */
+float DHT::readTemperature(bool S, bool force) {
+  float f = NAN;
+
+  if (read(force)) {
+    switch (_type) {
+    case DHT11:
+      f = data[2];
+      if (data[3] & 0x80) {
+        f = -1 - f;
+      }
+      f += (data[3] & 0x0f) * 0.1;
+      if (S) {
+        f = convertCtoF(f);
+      }
+      break;
+    case DHT12:
+      f = data[2];
+      f += (data[3] & 0x0f) * 0.1;
+      if (data[2] & 0x80) {
+        f *= -1;
+      }
+      if (S) {
+        f = convertCtoF(f);
+      }
+      break;
+    case DHT22:
+    case DHT21:
+      f = ((word)(data[2] & 0x7F)) << 8 | data[3];
+      f *= 0.1;
+      if (data[2] & 0x80) {
+        f *= -1;
+      }
+      if (S) {
+        f = convertCtoF(f);
+      }
+      break;
+    }
+  }
+  return f;
+}
+
+/*!
+ *  @brief  Converts Celcius to Fahrenheit
+ *  @param  c
+ *					value in Celcius
+ *	@return float value in Fahrenheit
+ */
+float DHT::convertCtoF(float c) { return c * 1.8 + 32; }
+
+/*!
+ *  @brief  Converts Fahrenheit to Celcius
+ *  @param  f
+ *					value in Fahrenheit
+ *	@return float value in Celcius
+ */
+float DHT::convertFtoC(float f) { return (f - 32) * 0.55555; }
+
+/*!
+ *  @brief  Read Humidity
+ *  @param  force
+ *					force read mode
+ *	@return float value - humidity in percent
+ */
+float DHT::readHumidity(bool force) {
+  float f = NAN;
+  if (read(force)) {
+    switch (_type) {
+    case DHT11:
+    case DHT12:
+      f = data[0] + data[1] * 0.1;
+      break;
+    case DHT22:
+    case DHT21:
+      f = ((word)data[0]) << 8 | data[1];
+      f *= 0.1;
+      break;
+    }
+  }
+  return f;
+}
+
+/*!
+ *  @brief  Compute Heat Index
+ *          Simplified version that reads temp and humidity from sensor
+ *  @param  isFahrenheit
+ * 					true if fahrenheit, false if celcius
+ *(default true)
+ *	@return float heat index
+ */
+float DHT::computeHeatIndex(bool isFahrenheit) {
+  float hi = computeHeatIndex(readTemperature(isFahrenheit), readHumidity(),
+                              isFahrenheit);
+  return hi;
+}
+
+/*!
+ *  @brief  Compute Heat Index
+ *  				Using both Rothfusz and Steadman's equations
+ *					(http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml)
+ *  @param  temperature
+ *          temperature in selected scale
+ *  @param  percentHumidity
+ *          humidity in percent
+ *  @param  isFahrenheit
+ * 					true if fahrenheit, false if celcius
+ *	@return float heat index
+ */
+float DHT::computeHeatIndex(float temperature, float percentHumidity,
+                            bool isFahrenheit) {
+  float hi;
+
+  if (!isFahrenheit)
+    temperature = convertCtoF(temperature);
+
+  hi = 0.5 * (temperature + 61.0 + ((temperature - 68.0) * 1.2) +
+              (percentHumidity * 0.094));
+
+  if (hi > 79) {
+    hi = -42.379 + 2.04901523 * temperature + 10.14333127 * percentHumidity +
+         -0.22475541 * temperature * percentHumidity +
+         -0.00683783 * pow(temperature, 2) +
+         -0.05481717 * pow(percentHumidity, 2) +
+         0.00122874 * pow(temperature, 2) * percentHumidity +
+         0.00085282 * temperature * pow(percentHumidity, 2) +
+         -0.00000199 * pow(temperature, 2) * pow(percentHumidity, 2);
+
+    if ((percentHumidity < 13) && (temperature >= 80.0) &&
+        (temperature <= 112.0))
+      hi -= ((13.0 - percentHumidity) * 0.25) *
+            sqrt((17.0 - abs(temperature - 95.0)) * 0.05882);
+
+    else if ((percentHumidity > 85.0) && (temperature >= 80.0) &&
+             (temperature <= 87.0))
+      hi += ((percentHumidity - 85.0) * 0.1) * ((87.0 - temperature) * 0.2);
+  }
+
+  return isFahrenheit ? hi : convertFtoC(hi);
+}
+
+
+void DHT::switchState(DHT::State newState)
+{
+  state = newState;
+  count = 0;
+}
+
+void DHT::process(BelaContext* context)
+{
+  float tus = 1000.f * 1000.f / context->digitalSampleRate;
+  for(size_t n = 0; n < context->digitalFrames; ++n)
+  {
+    bool in = digitalRead(context, n, _pin);
+    switch(state)
+    {
+      case kDisabled:
+        break;
+      case kShouldStart:
+        switchState(kHostStartSignal);
+        // nobreak;
+      case kHostStartSignal:
+        {
+          pinModeOnce(context, n, _pin, OUTPUT);
+          digitalWriteOnce(context, n, _pin, 0);
+	  float target;
+          switch (_type) {
+          case DHT22:
+          case DHT21:
+            // data sheet says "at least 1ms"
+	    target = 1100;
+            break;
+          case DHT11:
+          default:
+            // data sheet says at least 18ms, 20ms just to be safe
+	    target = 20000;
+            break;
+          }
+          if(count * tus > target)
+            switchState(kHostPullUp);
+        }
+        break;
+      case kHostPullUp:
+        pinModeOnce(context, n, _pin, OUTPUT);
+        digitalWriteOnce(context, n, _pin, 1);
+        if(count * tus > 40)
+          switchState(kWaitForInput);
+        break;
+      case kWaitForInput:
+        pinModeOnce(context, n, _pin, INPUT);
+        if(count >= context->digitalFrames * 2 + 1)
+          switchState(kWaitForSensorRising);
+        break;
+      case kWaitForSensorRising:
+        if(in && !pastIn)
+          switchState(kWaitForSensorFalling);
+        break;
+      case kWaitForSensorFalling:
+        if(!in && pastIn) // falling edge
+        {
+          switchState(kBit);
+          inIdx = 0;
+	  memset(data, 0, sizeof(data));
+	  inWord = 0;
+        }
+        break;
+      case kBit:
+        if(in && !pastIn) // rising edge
+          count = 0;
+        if(!in && pastIn) // falling edge
+        {
+          bool val = count > 2;//(count * tus > 42);
+#ifdef DHT_DEBUG
+          rt_printf("[%d]%d(%d)  ", 40 - inIdx - 1, count, val);
+#endif // DHT_DEBUG
+	  data[inIdx / 8] <<= 1;
+	  data[inIdx / 8] |= val;
+	  inWord |= uint64_t(val) << (40 - inIdx - 1);
+          inIdx++;
+          if(40 == inIdx)
+          {
+#ifdef DHT_DEBUG
+            rt_printf("\n");
+#endif // DHT_DEBUG
+            switchState(kTxEnd);
+          }
+        }
+        break;
+      case kTxEnd:
+#ifdef DHT_DEBUG
+        rt_printf("INPUT: %010llx----\n", inWord);
+#endif // DHT_DEBUG
+        switchState(kDisabled);
+        break;
+    }
+    count++;
+    pastIn = in;
+  }
+}
+
+/*!
+ *  @brief  Read value from sensor or return last one from less than two
+ *seconds.
+ *  @param  force
+ *          true if using force mode
+ *	@return float value
+ */
+bool DHT::read(bool force) {
+  DEBUG_PRINTLN(F("Received from DHT:"));
+  for(size_t n = 0; n < 4; ++n)
+  {
+	  DEBUG_PRINT(int(data[n]), HEX);
+	  DEBUG_PRINT(F(", "));
+  }
+  DEBUG_PRINT(F(" =? "));
+  DEBUG_PRINTLN((data[0] + data[1] + data[2] + data[3]) & 0xFF, HEX);
+
+  // Check we read 40 bits and that the checksum matches.
+  if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
+    _lastresult = true;
+    DEBUG_PRINTLN(F("DHT checksum OK"));
+  } else {
+    _lastresult = false;
+    DEBUG_PRINTLN(F("DHT checksum failure!"));
+  }
+  _lastresult = true;
+  return _lastresult;
+}
diff --git a/examples/Sensors/DHT11-temperature-humidity/DHT.h b/examples/Sensors/DHT11-temperature-humidity/DHT.h
new file mode 100644
index 000000000..29e3266b3
--- /dev/null
+++ b/examples/Sensors/DHT11-temperature-humidity/DHT.h
@@ -0,0 +1,92 @@
+/*!
+ *  @file DHT.h
+ *
+ *  This is a library for DHT series of low cost temperature/humidity sensors.
+ *
+ *  You must have Adafruit Unified Sensor Library library installed to use this
+ * class.
+ *
+ *  Adafruit invests time and resources providing this open source code,
+ *  please support Adafruit andopen-source hardware by purchasing products
+ *  from Adafruit!
+ *
+ *  Written by Adafruit Industries.
+ *
+ *  MIT license, all text above must be included in any redistribution
+ */
+
+#ifndef DHT_H
+#define DHT_H
+
+#include <Bela.h>
+
+/* Uncomment to enable printing out nice debug messages. */
+//#define DHT_DEBUG
+
+#define DEBUG_PRINTER                                                          \
+  Serial /**< Define where debug output will be printed.                       \
+          */
+
+/* Setup debug printing macros. */
+#ifdef DHT_DEBUG
+#define DEBUG_PRINT(...)                                                       \
+  { DEBUG_PRINTER.print(__VA_ARGS__); }
+#define DEBUG_PRINTLN(...)                                                     \
+  { DEBUG_PRINTER.println(__VA_ARGS__); }
+#else
+#define DEBUG_PRINT(...)                                                       \
+  {} /**< Debug Print Placeholder if Debug is disabled */
+#define DEBUG_PRINTLN(...)                                                     \
+  {} /**< Debug Print Line Placeholder if Debug is disabled */
+#endif
+
+/* Define types of sensors. */
+static const uint8_t DHT11{11};  /**< DHT TYPE 11 */
+static const uint8_t DHT12{12};  /**< DHY TYPE 12 */
+static const uint8_t DHT21{21};  /**< DHT TYPE 21 */
+static const uint8_t DHT22{22};  /**< DHT TYPE 22 */
+static const uint8_t AM2301{21}; /**< AM2301 */
+
+/*!
+ *  @brief  Class that stores state and functions for DHT
+ */
+class DHT {
+public:
+  DHT(uint8_t pin, uint8_t type, uint8_t count = 6);
+  void begin(uint8_t usec = 55);
+  void process(BelaContext* context);
+  float readTemperature(bool S = false, bool force = false);
+  float convertCtoF(float);
+  float convertFtoC(float);
+  float computeHeatIndex(bool isFahrenheit = true);
+  float computeHeatIndex(float temperature, float percentHumidity,
+                         bool isFahrenheit = true);
+  float readHumidity(bool force = false);
+  bool read(bool force = false);
+
+private:
+  uint8_t data[5];
+  uint8_t _pin, _type;
+  bool _lastresult;
+  uint8_t pullTime; // Time (in usec) to pull up data line before reading
+
+  uint32_t expectPulse(bool level);
+public:
+  enum State {
+    kDisabled,
+    kShouldStart,
+    kHostStartSignal,
+    kHostPullUp,
+    kWaitForInput,
+    kWaitForSensorRising,
+    kWaitForSensorFalling,
+    kBit,
+    kTxEnd,
+  } state = kDisabled;
+  void switchState(State newState);
+  int count;
+  int inIdx;
+  uint64_t inWord;
+  bool pastIn = false;
+};
+#endif
diff --git a/examples/Sensors/DHT11-temperature-humidity/render.cpp b/examples/Sensors/DHT11-temperature-humidity/render.cpp
new file mode 100644
index 000000000..bc392de5f
--- /dev/null
+++ b/examples/Sensors/DHT11-temperature-humidity/render.cpp
@@ -0,0 +1,59 @@
+/*
+ ____  _____ _        _
+| __ )| ____| |      / \
+|  _ \|  _| | |     / _ \
+| |_) | |___| |___ / ___ \
+|____/|_____|_____/_/   \_\
+http://bela.io
+*/
+/**
+\example Sensors/DHT-11-temperature-humidity/render.cpp
+
+Measuring temperature and humidity
+---------------------------
+
+The DHT-11 temperature and humidity sensor uses a 1-wire bidirectional serial
+communication protocol. On most platform, this involves bit-banging the
+protocol on a single pin and running chunks of code with interrupts disabled in
+order to respect the timing requirements of the device. The library provided
+here, based on the one developed by Adafruit for the Arduino boards, instead
+uses Bela's digital I/Os high sampling rate and tri-state capabilities to
+perform the same from the audio thread with high accuracy.
+
+Connect the sensor as follows:
+- VCC to 3v3 on Bela
+- GND to GND on Bela
+- DATA to the Bela digital pin set in `digitalPin` below. Also connect it to VCC via a 4k7 pull-up resistor.
+
+Datasheet: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-1143054.pdf
+*/
+#include <Bela.h>
+#include "DHT.h"
+
+const unsigned digitalPin = 0;
+
+DHT dht(digitialPin, DHT11);
+bool setup(BelaContext *context, void *userData)
+{
+	return true;
+}
+
+void render(BelaContext *context, void *userData) {
+	static int count = 0;
+	for(size_t n = 0; n < context->digitalFrames; ++n)
+	{
+		if(count > 2 * context->digitalSampleRate)
+			count = 0;
+		if(0 == count)
+			dht.state = DHT::kShouldStart;
+		if(count == 0.5f * context->digitalSampleRate)
+			rt_printf("========%.1f C, %.1f %%=======\n", dht.readTemperature(), dht.readHumidity());
+		count++;
+	}
+	dht.process(context);
+}
+
+void cleanup(BelaContext *context, void *userData)
+{
+
+}

From 38444ce5210fef445a1565c1c782767232c96940 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 29 Jan 2024 12:54:49 +0000
Subject: [PATCH 165/188] AuxTaskNonRT: allow to set priority

---
 core/AuxTaskNonRT.cpp  | 10 ++++++----
 core/RtWrappers.cpp    |  2 ++
 include/AuxTaskNonRT.h | 12 ++++++------
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/core/AuxTaskNonRT.cpp b/core/AuxTaskNonRT.cpp
index e2857905e..99e8eb1b3 100644
--- a/core/AuxTaskNonRT.cpp
+++ b/core/AuxTaskNonRT.cpp
@@ -14,22 +14,25 @@ bool AuxTaskNonRT::shouldStop(){
 	return (Bela_stopRequested() || lShouldStop);
 }
 
-void AuxTaskNonRT::create(std::string _name, std::function<void()> callback){
+void AuxTaskNonRT::create(std::string _name, std::function<void()> callback, int prio){
 	name = _name;
 	empty_callback = callback;
 	mode = 0;
+	priority = prio;
 	__create();
 }
-void AuxTaskNonRT::create(std::string _name, std::function<void(std::string str)> callback){
+void AuxTaskNonRT::create(std::string _name, std::function<void(std::string str)> callback, int prio){
 	name = _name;
 	str_callback = callback;
 	mode = 1;
+	priority = prio;
 	__create();
 }
-void AuxTaskNonRT::create(std::string _name, std::function<void(void* buf, int size)> callback){
+void AuxTaskNonRT::create(std::string _name, std::function<void(void* buf, int size)> callback, int prio){
 	name = _name;
 	buf_callback = callback;
 	mode = 2;
+	priority = prio;
 	__create();
 }
 
@@ -41,7 +44,6 @@ void AuxTaskNonRT::__create(){
 			c = '_';
 	
 	// create the xenomai task
-	int priority = 0;
 	int stackSize = 65536 * 4;
 
 	// create an rt_pipe
diff --git a/core/RtWrappers.cpp b/core/RtWrappers.cpp
index 8520181b9..f79ace11e 100644
--- a/core/RtWrappers.cpp
+++ b/core/RtWrappers.cpp
@@ -118,6 +118,8 @@ int create_and_start_thread(pthread_t* task, const char* taskName, int priority,
 		fprintf(stderr, "Error: unable to init thread attributes\n");
 		return -1;
 	}
+	if(!stackSize)
+		stackSize = 1024 * 1024; // 1 MiB default
 	if(int ret = set_thread_stack_and_priority(&attr, stackSize, priority))
 	{
 		return ret;
diff --git a/include/AuxTaskNonRT.h b/include/AuxTaskNonRT.h
index 41b036477..57344fd89 100644
--- a/include/AuxTaskNonRT.h
+++ b/include/AuxTaskNonRT.h
@@ -11,14 +11,13 @@
 class AuxTaskNonRT{
 	public:
 		AuxTaskNonRT(){}
-		AuxTaskNonRT(std::string _name, std::function<void()> callback){ create(_name, callback); }
-		AuxTaskNonRT(std::string _name, std::function<void(std::string str)> callback){ create(_name, callback); }
-		AuxTaskNonRT(std::string _name, std::function<void(void* buf, int size)> callback){ create(_name, callback); }
+		template <typename T>
+		AuxTaskNonRT(std::string _name, T callback, int prio = 0){ create(_name, callback, prio); }
 		~AuxTaskNonRT(){ cleanup(); }
 		
-		void create(std::string _name, std::function<void()> callback);
-		void create(std::string _name, std::function<void(std::string str)> callback);
-		void create(std::string _name, std::function<void(void* buf, int size)> callback);
+		void create(std::string _name, std::function<void()> callback, int prio = 0);
+		void create(std::string _name, std::function<void(std::string str)> callback, int prio = 0);
+		void create(std::string _name, std::function<void(void* buf, int size)> callback, int prio = 0);
 		
 		int schedule(const void* ptr, size_t size);
 		int schedule(const char* str);
@@ -26,6 +25,7 @@ class AuxTaskNonRT{
 		
 	private:
 		bool lShouldStop = false;
+		int priority = 0;
 		bool shouldStop();
 		void cleanup();
 		

From 08c7620befc8116474f7c9a1fcaf698220d74ef1 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Wed, 17 Jan 2024 16:21:53 +0000
Subject: [PATCH 166/188] Midi: modernised, using string and AuxTaskNonRT,
 removed dependency on Bela's AuxiliaryTask.

---
 libraries/Midi/Midi.cpp | 190 ++++++++++++++++------------------------
 libraries/Midi/Midi.h   |  20 ++---
 2 files changed, 83 insertions(+), 127 deletions(-)

diff --git a/libraries/Midi/Midi.cpp b/libraries/Midi/Midi.cpp
index 11e805ab7..77475d63e 100644
--- a/libraries/Midi/Midi.cpp
+++ b/libraries/Midi/Midi.cpp
@@ -12,6 +12,8 @@
 #include "../include/RtWrappers.h"
 #include <alsa/asoundlib.h>
 
+static const std::string defaultPort = "hw:1,0,0";
+
 #define kMidiInput 0
 #define kMidiOutput 1
 
@@ -100,37 +102,40 @@ int MidiParser::parse(midi_byte_t* input, unsigned int length){
 };
 
 
-Midi::Midi() : 
-alsaIn(NULL), alsaOut(NULL),
-inputParser(NULL), parserEnabled(false), inputEnabled(false), outputEnabled(false),
-inId(NULL), outId(NULL), outPipeName(NULL)
-	, sock(0)
+Midi::Midi()
 {
 	setup();
 }
 void Midi::setup() {
-	sprintf(defaultPort, "%s", "hw:1,0,0"); // a bug in gcc<4.10 prevents initialization with defaultPort("hw:1,0,0") in the initialization list
-	inputParser = 0;
 	size_t inputBytesInitialSize = 1000;
 	inputBytes.resize(inputBytesInitialSize);
-	outputBytes.resize(inputBytesInitialSize);
 	inputBytesWritePointer = 0;
 	inputBytesReadPointer = inputBytes.size() - 1;
+	alsaIn = nullptr;
+	alsaOut = nullptr;
+	inputParser = nullptr;
+	midiOutputTask = nullptr;
+	parserEnabled = false;
+	inputEnabled = false;
+	outputEnabled = false;
+	shouldStop = false;
 }
+
 void Midi::cleanup() {
-	free(inId);
-	free(outId);
-	free(outPipeName);
-	// dummy write so that `poll` stops polling ! 
-	//rt_pipe_write(&outPipe, NULL, 0, P_NORMAL); // does not work :(
-	close(sock);
+	shouldStop = true;
+	if(inputEnabled)
+		BELA_RT_WRAP(pthread_join(midiInputThread, NULL));
+	delete midiOutputTask;
+	midiOutputTask = nullptr;
 	if(alsaOut){
 		snd_rawmidi_drain(alsaOut);
 		snd_rawmidi_close(alsaOut);
+		alsaOut = nullptr;
 	}
 	if(alsaIn){
 		snd_rawmidi_drain(alsaIn);
 		snd_rawmidi_close(alsaIn);
+		alsaIn = nullptr;
 	}
 }
 
@@ -154,7 +159,7 @@ int Midi::attemptRecoveryRead()
 	snd_rawmidi_close(alsaIn);
 	alsaIn = NULL;
 	printf("MIDI: attempting to reopen input %s\n", inPort.c_str());
-	while(!Bela_stopRequested())
+	while(!shouldStop)
 	{
 		int err = snd_rawmidi_open(&alsaIn, NULL, inPort.c_str(), SND_RAWMIDI_NONBLOCK);
 		if (err) {
@@ -167,23 +172,28 @@ int Midi::attemptRecoveryRead()
 	return -1;
 }
 
-void Midi::readInputLoop(void* obj){
+void* Midi::readInputLoopStatic(void* obj){
 	Midi* that = (Midi*)obj;
-	while(!Bela_stopRequested()){
+	that->readInputLoop();
+	return NULL;
+}
+
+void Midi::readInputLoop(){
+	while(!shouldStop){
 		unsigned short revents;
-		int npfds = snd_rawmidi_poll_descriptors_count(that->alsaIn);
-		struct pollfd* pfds = (struct pollfd*)alloca(npfds * sizeof(struct pollfd));
-		snd_rawmidi_poll_descriptors(that->alsaIn, pfds, npfds);
+		int npfds = snd_rawmidi_poll_descriptors_count(alsaIn);
+		struct pollfd pfds[npfds];
+		snd_rawmidi_poll_descriptors(alsaIn, pfds, npfds);
 
-		while(!Bela_stopRequested()){
-			int maxBytesToRead = that->inputBytes.size() - that->inputBytesWritePointer;
+		while(!shouldStop){
+			int maxBytesToRead = inputBytes.size() - inputBytesWritePointer;
 			int timeout = 50; // ms
 			int err = poll(pfds, npfds, timeout);
 			if (err < 0) {
 				fprintf(stderr, "poll failed: %s", strerror(errno));
 				break;
 			}
-			if ((err = snd_rawmidi_poll_descriptors_revents(that->alsaIn, pfds, npfds, &revents)) < 0) {
+			if ((err = snd_rawmidi_poll_descriptors_revents(alsaIn, pfds, npfds, &revents)) < 0) {
 				fprintf(stderr, "cannot get poll events: %s", snd_strerror(-err));
 				break;
 			}
@@ -197,8 +207,8 @@ void Midi::readInputLoop(void* obj){
 			}
 			// else some data is available!
 			int ret = snd_rawmidi_read(
-				that->alsaIn,
-				&that->inputBytes[that->inputBytesWritePointer],
+				alsaIn,
+				&inputBytes[inputBytesWritePointer],
 				sizeof(midi_byte_t)*maxBytesToRead
 			);
 			if(ret < 0){
@@ -209,21 +219,21 @@ void Midi::readInputLoop(void* obj){
 				}
 				continue;
 			}
-			that->inputBytesWritePointer += ret;
-			if(that->inputBytesWritePointer == that->inputBytes.size()){ //wrap pointer around
-				that->inputBytesWritePointer = 0;
+			inputBytesWritePointer += ret;
+			if(inputBytesWritePointer == inputBytes.size()){ //wrap pointer around
+				inputBytesWritePointer = 0;
 			}
 
-			if(that->parserEnabled == true && ret > 0){ // if the parser is enabled and there is new data, send the data to it
+			if(parserEnabled == true && ret > 0){ // if the parser is enabled and there is new data, send the data to it
 				int input;
-				while((input=that->_getInput()) >= 0){
+				while((input = _getInput()) >= 0){
 					midi_byte_t inputByte = (midi_byte_t)(input);
-					that->inputParser->parse(&inputByte, 1);
+					inputParser->parse(&inputByte, 1);
 				}
 			}
 		}
-		if(!Bela_stopRequested())
-			that->attemptRecoveryRead();
+		if(!shouldStop)
+			attemptRecoveryRead();
 	}
 }
 
@@ -232,7 +242,7 @@ int Midi::attemptRecoveryWrite()
 	snd_rawmidi_close(alsaOut);
 	alsaOut = NULL;
 	printf("MIDI: attempting to reopen output %s\n", outPort.c_str());
-	while(!Bela_stopRequested())
+	while(!shouldStop)
 	{
 		int err = snd_rawmidi_open(NULL, &alsaOut, outPort.c_str(), SND_RAWMIDI_NONBLOCK);
 		if (err) {
@@ -245,102 +255,47 @@ int Midi::attemptRecoveryWrite()
 	return -1;
 }
 
-void Midi::writeOutputLoop(void* obj){
-	Midi* that = (Midi*)obj;
-	//printf("Opening outPipe %s\n", that->outPipeName);
-	int pipe_fd = open(that->outPipeName, O_RDWR);
-	if (pipe_fd < 0){
-		fprintf(stderr, "could not open out pipe %s: %s\n", that->outPipeName, strerror(-pipe_fd));
-		return;
-	}
-	void* data = &that->outputBytes.front();
-	while(!Bela_stopRequested()){
-		struct pollfd fds = {
-			pipe_fd,
-			POLLIN,
-			0
-		}; 
-		while(!Bela_stopRequested()){
-			//TODO: C++11 would allow to use outputBytes.data() instead of &outputBytes.front()
-			int timeout = 50; //ms
-			int ret = poll(&fds, 1, timeout);
-			unsigned int revents = fds.revents;
-			if (revents & (POLLERR | POLLHUP))
-				break;
-			if (!(revents & POLLIN))
-				continue;	
-			// else some data is available!
-			if(revents & POLLIN){
-				// there is data available
-				ret = read(pipe_fd, data, that->outputBytes.size());
-				if(ret > 0){
-					//printf("obtained %d bytes: writing\n", ret);
-					// write the received message to the output
-					ret = snd_rawmidi_write(that->alsaOut, data, ret);
-					if(ret < 0)
-						break;
-					// make sure it is written
-					// NOTE:using _drain actually increases the latency
-					// under heavy load, so we leave it out and
-					// leave it to the driver to figure out.
-					//snd_rawmidi_drain(that->alsaOut);
-				}
-			}
-		}
-		if(!Bela_stopRequested())
-			that->attemptRecoveryWrite();
-	}
-	close(pipe_fd);
+void Midi::doWriteOutput(const void* data, int size) {
+	int ret = snd_rawmidi_write(alsaOut, data, size);
+	if(ret < 0)
+		attemptRecoveryWrite();
 }
 
+#include <RtWrappers.h>
+
 int Midi::readFrom(const char* port){
 	if(port == NULL){
-		port = defaultPort;
+		port = defaultPort.c_str();
 	}
 	inPort = port;
-	int size = snprintf(inId, 0, "bela-midiIn_%s", port);
-	inId = (char*)malloc((size + 1) * sizeof(char));
-	snprintf(inId, size + 1, "bela-midiIn_%s", port);
+	inId = "bela-midiIn_" + inPort;
 
 	int err = snd_rawmidi_open(&alsaIn, NULL, inPort.c_str(), SND_RAWMIDI_NONBLOCK);
 	if (err) {
 		return err;
 	}
-	midiInputTask = Bela_createAuxiliaryTask(Midi::readInputLoop, 50, inId, (void*)this);
-	Bela_scheduleAuxiliaryTask(midiInputTask);
+	int ret = create_and_start_thread(&midiInputThread, inId.c_str(), 50, 0, NULL, Midi::readInputLoopStatic, (void*)this);
+	if(ret)
+		return 0;
 	inputEnabled = true;
 	return 1;
 }
 
 int Midi::writeTo(const char* port){
 	if(port == NULL){
-		port = defaultPort;
+		port = defaultPort.c_str();
 	}
 	outPort = port;
-	int size = snprintf(outId, 0, "bela-midiOut_%s", port);
-	outId = (char*)malloc((size + 1) * sizeof(char));
-	snprintf(outId, size + 1, "bela-midiOut_%s", port);
-
-	char outPipeNameTemplateString[] = "/proc/xenomai/registry/rtipc/xddp/%s";
-	size = snprintf(outPipeName, 0, outPipeNameTemplateString, outId);
-	outPipeName = (char*)malloc((size + 1)*sizeof(char));
-	snprintf(outPipeName, size + 1, outPipeNameTemplateString, outId);
-	int ret;
-	ret = createBelaRtPipe(outId, 0);
-	sock = ret;
-	if(ret <= 0){
-		fprintf(stderr, "Error while creating pipe %s: %s\n", outId, strerror(-ret));
-		return -1;
-	}
+	outId = "bela-midiOut_" + outPort;
+
 	int err = snd_rawmidi_open(NULL, &alsaOut, outPort.c_str(), 0);
 	if (err) {
 		return err;
 	}
-	midiOutputTask = Bela_createAuxiliaryTask(writeOutputLoop, 45, outId, (void*)this);
-	if(midiOutputTask == 0){
-		return -1;
-	}
-	Bela_scheduleAuxiliaryTask(midiOutputTask);
+	midiOutputTask = new AuxTaskNonRT();
+	midiOutputTask->create(outId, [this](void* buf, int size) {
+		this->doWriteOutput(buf, size);
+	}, 45);
 	outputEnabled = true;
 	return 1;
 }
@@ -463,17 +418,20 @@ int Midi::writeOutput(midi_byte_t* bytes, unsigned int length){
 	if(!outputEnabled){
 		return 0;
 	}
+	int tries = 0;
 	do {
-		// we make sure the message length does not exceed outputBytes.size(), 
-		// which would result in incomplete messages being retrieved at
-		// the other end of the pipe.
-		ssize_t size = length < outputBytes.size() ? length : outputBytes.size();
-		int ret = BELA_RT_WRAP(sendto(sock, bytes, size, 0, NULL, 0));
-		if (ret != size){
-			rt_fprintf(stderr, "Error while streaming to pipe %s: %s\n", outPipeName, strerror(-ret));
-			return -1;
+		ssize_t size = length;
+		int ret = midiOutputTask->schedule(bytes, size);
+		tries++;
+		if(ret){
+			// pipe is full, sleep and try again in the attempt to
+			// avoid losing data
+			rt_fprintf(stderr, "Error while sending %u MIDI bytes out to thread %s: %d %s\n", length, outId.c_str(), ret, strerror(ret));
+			usleep(10000);
+			if(tries > 5)
+				return -1;
 		} else {
-			length -= ret;
+			length -= size;
 		}
 	} while (length > 0);
 	return 1;
diff --git a/libraries/Midi/Midi.h b/libraries/Midi/Midi.h
index e680ff3f7..4f567bc99 100644
--- a/libraries/Midi/Midi.h
+++ b/libraries/Midi/Midi.h
@@ -1,7 +1,7 @@
 #pragma once
-#include <Bela.h>
 #include <vector>
 #include <string>
+#include <AuxTaskNonRT.h>
 
 typedef unsigned char midi_byte_t;
 
@@ -385,27 +385,25 @@ class Midi {
 	 */
 	static void destroyPorts(std::vector<Midi*>& ports);
 private:
-	char defaultPort[9];
 	std::string inPort;
 	std::string outPort;
 	int _getInput();
 	int attemptRecoveryRead();
-	static void readInputLoop(void* obj);
+	static void* readInputLoopStatic(void* obj);
+	void readInputLoop();
 	int attemptRecoveryWrite();
-	static void writeOutputLoop(void* obj);
+	void doWriteOutput(const void* data, int size);
 	snd_rawmidi_t *alsaIn,*alsaOut;
 	std::vector<midi_byte_t> inputBytes;
 	unsigned int inputBytesWritePointer;
 	unsigned int inputBytesReadPointer;
-	std::vector<midi_byte_t> outputBytes;
 	MidiParser* inputParser;
 	bool parserEnabled;
 	bool inputEnabled;
 	bool outputEnabled;
-	AuxiliaryTask midiInputTask;
-	AuxiliaryTask midiOutputTask;
-	char* inId;
-	char* outId;
-	char* outPipeName;
-	int sock;
+	volatile bool shouldStop;
+	pthread_t midiInputThread;
+	AuxTaskNonRT* midiOutputTask;
+	std::string inId;
+	std::string outId;
 };

From d37ca2663537142c444e9dc4938b143499d14bc3 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Tue, 30 Jan 2024 01:07:29 +0000
Subject: [PATCH 167/188] Added gui option theme switch

---
 IDE/public/index.html | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/IDE/public/index.html b/IDE/public/index.html
index bb18c8851..ac952978d 100644
--- a/IDE/public/index.html
+++ b/IDE/public/index.html
@@ -506,6 +506,13 @@ <h1>Settings<hr /></h1>
                     </td>
                   </tr>
 
+                  <tr>
+                    <td class="left-choice">Dark Theme:</td>
+                    <td class="right-choice">
+                      <input type="checkbox" id="darkTheme" class="settingsManager checkbox-slider" data-func="setIDESetting" data-key="darkTheme" value="1" >
+                    </td>
+                  </tr>
+
                 </table>
                 <button class="settingsManager settings-button" data-func="restoreDefaultIDESettings">Restore default IDE settings</button>
               </div>

From 69bd93ecc9e2093138881b4220596b05a6d33651 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Tue, 30 Jan 2024 23:37:38 +0000
Subject: [PATCH 168/188] implemented callback to switch code editor theme

---
 IDE/public/js/bundle.js | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/IDE/public/js/bundle.js b/IDE/public/js/bundle.js
index d2e0ae943..acda4b13a 100644
--- a/IDE/public/js/bundle.js
+++ b/IDE/public/js/bundle.js
@@ -417,7 +417,7 @@ settingsView.on('project-settings', function (data) {
 
 settingsView.on('IDE-settings', function (data) {
 	data.currentProject = models.project.getKey('currentProject');
-	//console.log('IDE-settings', data);
+	// console.log('IDE-settings', data);
 	socket.emit('IDE-settings', data);
 });
 settingsView.on('run-on-boot', function (project) {
@@ -2179,9 +2179,20 @@ var EditorView = function (_View) {
 				this.__focus(opts.focus);
 			}
 		}
-		// editor focus has changed
+		// editor theme has changed
 
 	}, {
+		key: '_darkTheme',
+		value: function _darkTheme(value) {
+			if (parseInt(value)) {
+				this.editor.setTheme("ace/theme/xcode_dark");
+			} else {
+				this.editor.setTheme("ace/theme/chrome");
+			}
+		}
+		// editor focus has changed
+
+  	}, {
 		key: '__focus',
 		value: function __focus(data) {
 

From 33d3ecf1777d1a527a9154f89321fe1ea104ee44 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Tue, 30 Jan 2024 23:53:57 +0000
Subject: [PATCH 169/188] implemented callback to switch code editor theme

---
 IDE/public/js/bundle.js | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/IDE/public/js/bundle.js b/IDE/public/js/bundle.js
index acda4b13a..b22568c27 100644
--- a/IDE/public/js/bundle.js
+++ b/IDE/public/js/bundle.js
@@ -2185,7 +2185,8 @@ var EditorView = function (_View) {
 		key: '_darkTheme',
 		value: function _darkTheme(value) {
 			if (parseInt(value)) {
-				this.editor.setTheme("ace/theme/xcode_dark");
+				// this.editor.setTheme("ace/theme/xcode_dark");
+				this.editor.setTheme("ace/theme/monokai");
 			} else {
 				this.editor.setTheme("ace/theme/chrome");
 			}
@@ -4595,6 +4596,20 @@ var SettingsView = function (_View) {
 				}
 			});
 		}
+	// }, {
+	// 	key: '_darkTheme',
+	// 	value: function _darkTheme(func, key, value) {
+	// 		console.log("in _darkTheme")
+	// 		var app = document.querySelector(".app");
+	// 		// editor theme has changed
+	// 		if (parseInt(func)) {
+	// 			app.classList.remove('light');
+	// 			app.classList.add('dark');
+	// 		} else {
+	// 			app.classList.remove('dark');
+	// 			app.classList.add('light');
+    //   		}
+    // 	}
 	}, {
 		key: '_boardString',
 		value: function _boardString(data) {

From 6d14b7c3d754330db3b9332db647ed56ab4980f0 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Wed, 31 Jan 2024 00:00:53 +0000
Subject: [PATCH 170/188] added switchable dark theme to default IDE settings

---
 IDE/dist/IDESettings.js | 3 ++-
 IDE/src/IDESettings.ts  | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/IDE/dist/IDESettings.js b/IDE/dist/IDESettings.js
index 008ab7b2e..1260051ac 100644
--- a/IDE/dist/IDESettings.js
+++ b/IDE/dist/IDESettings.js
@@ -168,6 +168,7 @@ function default_IDE_settings() {
         'cpuMonitoring': 1,
         'cpuMonitoringVerbose': 0,
         'consoleDelete': 0,
-        'viewHiddenFiles': 0
+        'viewHiddenFiles': 0,
+        'darkTheme': 0
     };
 }
diff --git a/IDE/src/IDESettings.ts b/IDE/src/IDESettings.ts
index cda2a67b9..c6fe04a05 100644
--- a/IDE/src/IDESettings.ts
+++ b/IDE/src/IDESettings.ts
@@ -71,6 +71,7 @@ function default_IDE_settings(){
 		'cpuMonitoring'		: 1,
 		'cpuMonitoringVerbose'	: 0,
 		'consoleDelete'		: 0,
-		'viewHiddenFiles'	: 0
+		'viewHiddenFiles'	: 0,
+		'darkTheme'			: 0
 	};
 }

From b66b12c2c8be58bdef0c8d6bb58658a9c03f7d83 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Fri, 2 Feb 2024 02:00:24 +0000
Subject: [PATCH 171/188]  implemented css class switch

---
 IDE/public/js/bundle.js | 31 ++++++++++++-------------------
 1 file changed, 12 insertions(+), 19 deletions(-)

diff --git a/IDE/public/js/bundle.js b/IDE/public/js/bundle.js
index b22568c27..3324b3a1a 100644
--- a/IDE/public/js/bundle.js
+++ b/IDE/public/js/bundle.js
@@ -417,7 +417,7 @@ settingsView.on('project-settings', function (data) {
 
 settingsView.on('IDE-settings', function (data) {
 	data.currentProject = models.project.getKey('currentProject');
-	// console.log('IDE-settings', data);
+	//console.log('IDE-settings', data);
 	socket.emit('IDE-settings', data);
 });
 settingsView.on('run-on-boot', function (project) {
@@ -2184,16 +2184,23 @@ var EditorView = function (_View) {
 	}, {
 		key: '_darkTheme',
 		value: function _darkTheme(value) {
-			if (parseInt(value)) {
-				// this.editor.setTheme("ace/theme/xcode_dark");
-				this.editor.setTheme("ace/theme/monokai");
+			var isDarkTheme = parseInt(value)
+			var body = $('body');
+
+			if (isDarkTheme) {
+				this.editor.setTheme("ace/theme/xcode_dark");
+				// this.editor.setTheme("ace/theme/monokai");
+				body.toggleClass('light-theme', Boolean(false));
+				body.toggleClass('dark-theme', Boolean(true));
 			} else {
 				this.editor.setTheme("ace/theme/chrome");
+				body.toggleClass('dark-theme', Boolean(false));
+				body.toggleClass('light-theme', Boolean(true));
 			}
 		}
 		// editor focus has changed
 
-  	}, {
+	}, {
 		key: '__focus',
 		value: function __focus(data) {
 
@@ -4596,20 +4603,6 @@ var SettingsView = function (_View) {
 				}
 			});
 		}
-	// }, {
-	// 	key: '_darkTheme',
-	// 	value: function _darkTheme(func, key, value) {
-	// 		console.log("in _darkTheme")
-	// 		var app = document.querySelector(".app");
-	// 		// editor theme has changed
-	// 		if (parseInt(func)) {
-	// 			app.classList.remove('light');
-	// 			app.classList.add('dark');
-	// 		} else {
-	// 			app.classList.remove('dark');
-	// 			app.classList.add('light');
-    //   		}
-    // 	}
 	}, {
 		key: '_boardString',
 		value: function _boardString(data) {

From 1ad3467423707e9c937e6a333326cf60a1768046 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Fri, 2 Feb 2024 02:04:38 +0000
Subject: [PATCH 172/188] added css variables

---
 IDE/public/css/theme-variables.css | 62 ++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 IDE/public/css/theme-variables.css

diff --git a/IDE/public/css/theme-variables.css b/IDE/public/css/theme-variables.css
new file mode 100644
index 000000000..741b2c21f
--- /dev/null
+++ b/IDE/public/css/theme-variables.css
@@ -0,0 +1,62 @@
+:root {
+    --main-background-color: #ffffff;
+    --tabs-color: #c9c9c9;
+    --selected-tab-color: #ffffff;
+    --top-file-status-color: #e1e1e1;
+    --accordion-background-color: #f1f1f1;
+    --hovered-accordion-color: #bdbdbd;
+    --accordion-font-color: rgba(0, 0, 0, 0.6);
+    --accordion-font-color-accent: rgba(0, 0, 0, 0.8);
+    --main-font-color: #000000;
+    --hovered-accordion-color-two: #f9f9f9;
+    --main-font-color-accent: #000000;
+    --cursor-color: #f1f1f1;
+}
+
+/* Light Theme */
+.light-theme {
+    --main-background-color: #ffffff;
+    --tabs-color: #c9c9c9;
+    --selected-tab-color: #ffffff;
+    --top-file-status-color: #e1e1e1;
+    --accordion-background-color: #f1f1f1;
+    --hovered-accordion-color: #bdbdbd;
+    --accordion-font-color: rgba(0, 0, 0, 0.6);
+    --accordion-font-color-accent: rgba(0, 0, 0, 0.8);
+    --main-font-color: #000000;
+    --hovered-accordion-color-two: #f9f9f9;
+    --main-font-color-accent: #000000;
+    --cursor-color: #f1f1f1;
+}
+
+/* Dark Theme */
+.dark-theme {
+    --main-background-color: #292a2f;
+    --tab-color: #252729;
+    --selected-tab-color: #252729;
+    --top-file-status-color: #252729;
+    --accordion-background-color: #3f4045;
+    --hovered-accordion-color: #3e4d5c;
+    --accordion-font-color: #dfdfe0;
+    --accordion-font-color-accent: #ededf2;
+    --main-font-color: #dfdfe0;
+    --hovered-accordion-color-two: #3f4045;
+    --main-font-color-accent: #ededf2;
+    --cursor-color: rgb(44,44,44);
+}
+
+
+/*$theme: (*/
+/*    "white-to-dark-bg-color": map-get($shades, "shade-0"),*/
+/*    "grey-to-dark-toolbar-color": map-get($shades, "shade-1"),*/
+/*    "white-to-dark-toolbar-color": map-get($shades, "shade-2"),*/
+/*    "grey-to-dark-top-bar-color": map-get($shades, "shade-3"),*/
+/*    "grey-light-to-dark-accordion-color": map-get($shades, "shade-4"),*/
+/*    "grey-mid-to-dark-hov-accordion-color": map-get($shades, "shade-5"),*/
+/*    "accordion-font-color": map-get($shades, "shade-6"),*/
+/*    "accordion-highlight-font-color": map-get($shades, "shade-7"),*/
+/*    "black-to-light-text-color": map-get($shades, "shade-8"),*/
+/*    "light-to-dark-dropdown-color": map-get($shades, "shade-9"),*/
+/*    "black-to-highlight-text-color": map-get($shades, "shade-10"),*/
+/*    "cursor-highlight-color": map-get($shades, "shade-11"),*/
+/*  );*/
\ No newline at end of file

From 92782c8d1e5d9019a73c4382add2e60d58314b25 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Fri, 2 Feb 2024 02:05:51 +0000
Subject: [PATCH 173/188] implemented custom ACE xcode dark theme

---
 IDE/public/js/ace/theme-xcode_dark.js | 154 ++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 IDE/public/js/ace/theme-xcode_dark.js

diff --git a/IDE/public/js/ace/theme-xcode_dark.js b/IDE/public/js/ace/theme-xcode_dark.js
new file mode 100644
index 000000000..55ad74580
--- /dev/null
+++ b/IDE/public/js/ace/theme-xcode_dark.js
@@ -0,0 +1,154 @@
+ace.define("ace/theme/xcode_dark",["require","exports","module","ace/lib/dom"], function(require, exports, module) {
+
+exports.isDark = true;
+exports.cssClass = "ace-xcode-dark";
+exports.cssText = "\
+.ace-xcode-dark .ace_gutter {\
+background: #292A2F;\
+color: #8F908A;\
+overflow : hidden;\
+}\
+.ace-xcode-dark .ace_print-margin {\
+width: 1px;\
+background: #292A2F;\
+}\
+.ace-xcode-dark {\
+display: block;\
+overflow-x: auto;\
+padding: .5em;\
+color: #DFDFE0;\
+background-color: #292A2F;\
+}\
+.ace-xcode-dark .ace_invisible {\
+color: #656f81;\
+}\
+.ace-xcode-dark .ace_constant.ace_buildin {\
+color: #EF81B0;\
+}\
+.ace-xcode-dark .ace_constant.ace_language {\
+color: #AB83E4;\
+}\
+.ace-xcode-dark .ace_constant.ace_library {\
+color: #E57668;\
+}\
+.ace-xcode-dark .ace_invalid {\
+color: #F8F8F0;\
+background-color: #F92672;\
+}\
+.ace-xcode-dark .ace_fold {\
+background-color: #A6E22E;\
+border-color: #F8F8F2;\
+}\
+.ace-xcode-dark .ace_support.ace_function {\
+color: #4EB0CC;\
+}\
+.ace-xcode-dark .ace_support.ace_constant {\
+color: #4EB0CC;\
+}\
+.ace-xcode-dark .ace_support.ace_other,\
+.ace-xcode-dark .ace_storage.ace_type,\
+.ace-xcode-dark .ace_support.ace_class,\
+.ace-xcode-dark .ace_support.ace_type {\
+font-style: italic;\
+color: #66D9EF;\
+}\
+.ace-xcode-dark .ace_variable.ace_parameter {\
+font-style:italic;\
+color: #FD971F;\
+}\
+.ace-xcode-dark .ace_keyword.ace_operator {\
+color: #DFDFE0;\
+}\
+.ace-xcode-dark .ace_comment {\
+color: #A5B0BD;\
+}\
+.ace-xcode-dark .ace_comment.ace_doc {\
+color: #75715E;\
+}\
+.ace-xcode-dark .ace_comment.ace_doc.ace_tag {\
+color: #EF81B0;\
+}\
+.ace-xcode-dark .ace_constant.ace_numeric {\
+color: #D5CA86;\
+}\
+.ace-xcode-dark .ace_variable {\
+color: #BBF0E4;\
+}\
+.ace-xcode-dark .ace_xml-pe {\
+color: rgb(104, 104, 91);\
+}\
+.ace-xcode-dark .ace_entity.ace_name.ace_function {\
+color: #4Eb0CC;\
+}\
+.ace-xcode-dark .ace_heading {\
+color: #DFDFE0;\
+}\
+.ace-xcode-dark .ace_list {\
+color: #4EB0CC;\
+}\
+.ace-xcode-dark .ace_marker-layer .ace_selection {\
+background: #49483E;\
+}\
+.ace-xcode-dark .ace_marker-layer .ace_step {\
+background: rgb(102, 82, 0);\
+}\
+.ace-xcode-dark .ace_marker-layer .ace_stack {\
+background: rgb(164, 229, 101);\
+}\
+.ace-xcode-dark .ace_marker-layer .ace_bracket {\
+margin: -1px 0 0 -1px;\
+border: 1px solid #828C97;\
+}\
+.ace-xcode-dark .ace_marker-layer .ace_active-line {\
+background: #202020;\
+}\
+.ace-xcode-dark .ace_gutter-active-line {\
+background-color: #2F113239;\
+}\
+.ace-xcode-dark .ace_marker-layer .ace_selected-word {\
+border: 1px solid #656F81;\
+}\
+.ace-xcode-dark .ace_storage,\
+.ace-xcode-dark .ace_keyword,\
+.ace-xcode-dark .ace_meta.ace_tag {\
+color: #EF81B0;\
+}\
+.ace-xcode-dark .ace_string.ace_regex {\
+color: #F08875;\
+}\
+.ace-xcode-dark .ace_string {\
+color: #F08875;\
+}\
+.ace-xcode-dark .ace_entity.ace_other.ace_attribute-name {\
+color: #F08875;\
+}\
+.ace-xcode-dark .ace_indent-guide {\
+background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWPQ0FD0ZXBzd/wPAAjVAoxeSgNeAAAAAElFTkSuQmCC) right repeat-y;\
+}\
+.ace-xcode-dark .ace_entity.ace_other{\
+color: #DFDFE0;\
+}\
+.ace-xcode-dark.ace_multiselect .ace_selection.ace_start {\
+box-shadow: 0 0 3px 0px #646F83;\
+}\
+.ace-content{\
+  border-top:1px solid #43464a;\
+}\
+";
+
+var dom = require("../lib/dom");
+dom.importCssString(exports.cssText, exports.cssClass);
+});                (function() {
+                    ace.require(["ace/theme/xcode_dark"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+
+
+
+
+
+
+

From fe60e74f27439986456bda8691e53dd30dbab93d Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 1 Feb 2024 21:08:43 +0000
Subject: [PATCH 174/188] Trill: do not print errors when probing

---
 libraries/Trill/Trill.cpp | 11 ++++++++---
 libraries/Trill/Trill.h   |  1 +
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/libraries/Trill/Trill.cpp b/libraries/Trill/Trill.cpp
index 62182fca1..5b208f0e3 100644
--- a/libraries/Trill/Trill.cpp
+++ b/libraries/Trill/Trill.cpp
@@ -224,6 +224,7 @@ int Trill::setup(unsigned int i2c_bus, Device device, uint8_t i2c_address)
 Trill::Device Trill::probe(unsigned int i2c_bus, uint8_t i2c_address)
 {
 	Trill t;
+	t.quiet = true;
 	if(t.initI2C_RW(i2c_bus, i2c_address, -1)) {
 		return Trill::NONE;
 	}
@@ -329,7 +330,8 @@ int Trill::writeCommandAndHandle(const i2c_char_t* data, size_t size, const char
 	int ret = writeBytes(buf, bytesToWrite);
 	if(ret != bytesToWrite)
 	{
-		fprintf(stderr, "Trill: failed to write command \"%s\"; ret: %d, errno: %d, %s.\n", name, ret, errno, strerror(errno));
+		if(!quiet)
+			fprintf(stderr, "Trill: failed to write command \"%s\"; ret: %d, errno: %d, %s.\n", name, ret, errno, strerror(errno));
 		return 1;
 	}
 	currentReadOffset = buf[0];
@@ -351,8 +353,11 @@ int Trill::readBytesFrom(const uint8_t offset, i2c_char_t* data, size_t size, co
 		int ret = writeBytes(&offset, sizeof(offset));
 		if(ret != sizeof(offset))
 		{
-			fprintf(stderr, "%s: error while setting read offset\n", name);
-			printErrno(ret);
+			if(!quiet)
+			{
+				fprintf(stderr, "%s: error while setting read offset\n", name);
+				printErrno(ret);
+			}
 			return 1;
 		}
 		currentReadOffset = offset;
diff --git a/libraries/Trill/Trill.h b/libraries/Trill/Trill.h
index c7115985c..5fc68d6f2 100644
--- a/libraries/Trill/Trill.h
+++ b/libraries/Trill/Trill.h
@@ -70,6 +70,7 @@ class Trill : public I2c
 		uint8_t firmware_version_ = 0; // Firmware version running on the device
 		uint8_t num_touches_; // Number of touches on last read
 		bool dataBufferIncludesStatusByte = false;
+		bool quiet = false;
 		std::vector<uint8_t> dataBuffer;
 		uint16_t commandSleepTime = 1000;
 		size_t currentReadOffset = -1;

From 78b9fd724adf059229bab32e7730dc244b67f10f Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Mon, 5 Feb 2024 22:57:34 +0000
Subject: [PATCH 175/188] Trill: re-enable kScanTriggerI2c for rev 3 sensors.
 This issue has been around since 28e2c3fcb9f3e4f9042565734c9b326ef7d05de3

---
 libraries/Trill/Trill.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/Trill/Trill.cpp b/libraries/Trill/Trill.cpp
index 5b208f0e3..b46a65d68 100644
--- a/libraries/Trill/Trill.cpp
+++ b/libraries/Trill/Trill.cpp
@@ -213,7 +213,7 @@ int Trill::setup(unsigned int i2c_bus, Device device, uint8_t i2c_address)
 	address = i2c_address;
 	readErrorOccurred = false;
 
-	if(firmware_version_ > 3)
+	if(firmware_version_ >= 3)
 	{
 		if(setScanTrigger(kScanTriggerI2c))
 			return 1;

From f98d815526b4a5ed1ac7c83705f5e7f2f9aa3cc0 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 6 Feb 2024 00:14:19 +0000
Subject: [PATCH 176/188] Trill: added probeRange() and allow to pass
 Trill::UNKNOWN to setup() to automatically probe the whole range if needed

---
 libraries/Trill/Trill.cpp | 26 ++++++++++++++++++++++++++
 libraries/Trill/Trill.h   | 36 ++++++++++++++++++++++++++++--------
 2 files changed, 54 insertions(+), 8 deletions(-)

diff --git a/libraries/Trill/Trill.cpp b/libraries/Trill/Trill.cpp
index b46a65d68..f8e761225 100644
--- a/libraries/Trill/Trill.cpp
+++ b/libraries/Trill/Trill.cpp
@@ -2,6 +2,7 @@
 #include <map>
 #include <vector>
 #include <string.h>
+#include <limits>
 
 constexpr uint8_t Trill::speedValues[4];
 #define MAX_TOUCH_1D_OR_2D (((device_type_ == SQUARE || device_type_ == HEX) ? kMaxTouchNum2D : kMaxTouchNum1D))
@@ -130,6 +131,17 @@ int Trill::setup(unsigned int i2c_bus, Device device, uint8_t i2c_address)
 	frameId = 0;
 	device_type_ = NONE;
 	TrillDefaults defaults = trillDefaults.at(device);
+	if(UNKNOWN == device && 255 == i2c_address) {
+		auto devs = probeRange(i2c_bus, 1);
+		if(devs.size()) {
+			const auto& d = devs[0];
+			device = d.first;
+			i2c_address = d.second;
+		} else {
+			fprintf(stderr, "No Trill device found on I2C bus %d\n", i2c_bus);
+			return 2;
+		}
+	}
 
 	if(128 <= i2c_address)
 		i2c_address = defaults.address;
@@ -234,6 +246,20 @@ Trill::Device Trill::probe(unsigned int i2c_bus, uint8_t i2c_address)
 	return t.device_type_;
 }
 
+std::vector<std::pair<Trill::Device,uint8_t> > Trill::probeRange(unsigned int i2c_bus, size_t maxCount)
+{
+	std::vector< std::pair<Device,uint8_t> > devs;
+	if(0 == maxCount)
+		maxCount = std::numeric_limits<size_t>::max();
+	// probe the valid address range on the bus to find a valid device
+	for(uint8_t n = 0x20; n <= 0x50 && devs.size() <= maxCount; ++n) {
+		Device device = probe(i2c_bus, n);
+		if(device != NONE)
+			devs.push_back({device, n});
+	}
+	return devs;
+}
+
 Trill::~Trill() {
 	closeI2C();
 }
diff --git a/libraries/Trill/Trill.h b/libraries/Trill/Trill.h
index 5fc68d6f2..563e4dbc8 100644
--- a/libraries/Trill/Trill.h
+++ b/libraries/Trill/Trill.h
@@ -154,15 +154,21 @@ class Trill : public I2c
 		 * Initialise the device.
 		 *
 		 * @param i2c_bus the bus that the device is connected to.
-		 * @param device the device type. If #UNKNOWN is passed, then
-		 * the \p i2c_address parameter has to be a valid address, and
-		 * any detected device type will be accepted. If something else
-		 * than #UNKNOWN is passed, and the detected device type is
-		 * different from the requested one, the function will fail and
-		 * the object will be left uninitialised.
+		 * @param device the device type.
+		 *
 		 * @param i2c_address the address at which the device can be
-		 * found. If `255` or no value is passed, the default address
-		 * for the specified device type will be used.
+		 * found.
+		 *
+		 * If @p device is #UNKNOWN then:
+		 * -  if \p i2c_address is a valid address, then
+		 * any device detected at that addres will be accepted
+		 * - if \p i2c_address is `255` or unspecified, then the range of
+		 *   valid addresses will be scanned, stopping at the first
+		 *   valid device encountered. Use this with caution as it may
+		 *   affect the behaviour of non-Trill devices on the I2C bus.
+		 *
+		 * Otherwise, if @p i2c_address is `255` or unspecified,
+		 * the default address for the specified device type will be used.
 		 */
 		Trill(unsigned int i2c_bus, Device device, uint8_t i2c_address = 255);
 		/**
@@ -180,6 +186,20 @@ class Trill : public I2c
 		 */
 		static Device probe(unsigned int i2c_bus, uint8_t i2c_address);
 
+		/**
+		 * Probe the bus for a device at any valid address.
+		 * \warning Use with caution as it may affect the behaviour of
+		 * non-Trill devices on the I2C bus.
+		 *
+		 * @param i2c_bus the I2C bus to scan
+		 * @param maxCount stop discovering new devices after this many
+		 * have been discovered. Use 0 to find all possible devices.
+		 *
+		 * @return A vector containing the #Device and address pairs
+		 * identified.
+		 */
+		static std::vector<std::pair<Device,uint8_t> > probeRange(unsigned int i2c_bus, size_t maxCount = 0);
+
 		/**
 		 * Update the baseline value on the device.
 		 */

From 77e3f02792655a007d99c876f92f6d5aa5ca6691 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 6 Feb 2024 00:31:04 +0000
Subject: [PATCH 177/188] Trill: use ANY instead of UNKNOWN

---
 libraries/Trill/Trill.cpp | 12 ++++++------
 libraries/Trill/Trill.h   |  5 +++--
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/libraries/Trill/Trill.cpp b/libraries/Trill/Trill.cpp
index f8e761225..24be4a6dc 100644
--- a/libraries/Trill/Trill.cpp
+++ b/libraries/Trill/Trill.cpp
@@ -67,7 +67,7 @@ struct TrillDefaults
 const float defaultThreshold = 0x28 / 4096.f;
 static const std::map<Trill::Device, struct TrillDefaults> trillDefaults = {
 	{Trill::NONE, TrillDefaults("No device", Trill::AUTO, 0, 0xFF, -1)},
-	{Trill::UNKNOWN, TrillDefaults("Unknown device", Trill::AUTO, 0, 0xFF, -1)},
+	{Trill::ANY, TrillDefaults("Unknown device", Trill::AUTO, 0, 0xFF, -1)},
 	{Trill::BAR, TrillDefaults("Bar", Trill::CENTROID, defaultThreshold, 0x20, 2)},
 	{Trill::SQUARE, TrillDefaults("Square", Trill::CENTROID, defaultThreshold, 0x28, 1)},
 	{Trill::CRAFT, TrillDefaults("Craft", Trill::DIFF, defaultThreshold, 0x30, 1)},
@@ -91,7 +91,7 @@ struct trillRescaleFactors_t {
 };
 
 static const std::vector<struct trillRescaleFactors_t> trillRescaleFactors ={
-	{.pos = 1, .posH = 0, .size = 1}, // UNKNOWN = 0,
+	{.pos = 1, .posH = 0, .size = 1}, // ANY = 0,
 	{.pos = 3200, .posH = 0, .size = 4566}, // BAR = 1,
 	{.pos = 1792, .posH = 1792, .size = 3780}, // SQUARE = 2,
 	{.pos = 4096, .posH = 0, .size = 1}, // CRAFT = 3,
@@ -131,7 +131,7 @@ int Trill::setup(unsigned int i2c_bus, Device device, uint8_t i2c_address)
 	frameId = 0;
 	device_type_ = NONE;
 	TrillDefaults defaults = trillDefaults.at(device);
-	if(UNKNOWN == device && 255 == i2c_address) {
+	if(ANY == device && 255 == i2c_address) {
 		auto devs = probeRange(i2c_bus, 1);
 		if(devs.size()) {
 			const auto& d = devs[0];
@@ -168,7 +168,7 @@ int Trill::setup(unsigned int i2c_bus, Device device, uint8_t i2c_address)
 		fprintf(stderr, "Unable to identify device\n");
 		return 2;
 	}
-	if(UNKNOWN != device && device_type_ != device) {
+	if(ANY != device && device_type_ != device) {
 		fprintf(stderr, "Wrong device type detected. `%s` was requested "
 				"but `%s` was detected on bus %d at address %#x(%d).\n",
 				defaults.name.c_str(),
@@ -269,7 +269,7 @@ const std::string& Trill::getNameFromDevice(Device device)
 	__try {
 		return trillDefaults.at(device).name;
 	} __catch (std::exception e) {
-		return trillDefaults.at(Device::UNKNOWN).name;
+		return trillDefaults.at(Device::ANY).name;
 	}
 }
 
@@ -297,7 +297,7 @@ Trill::Device Trill::getDeviceFromName(const std::string& name)
 		if(strCmpIns(name, str2))
 			return Device(device);
 	}
-	return Trill::UNKNOWN;
+	return Trill::ANY;
 }
 
 const std::string& Trill::getNameFromMode(Mode mode)
diff --git a/libraries/Trill/Trill.h b/libraries/Trill/Trill.h
index 563e4dbc8..a6ab57f6a 100644
--- a/libraries/Trill/Trill.h
+++ b/libraries/Trill/Trill.h
@@ -30,13 +30,14 @@ class Trill : public I2c
 		 */
 		typedef enum {
 			NONE = -1, ///< No device
-			UNKNOWN = 0, ///< A valid device of unknown type
+			ANY = 0, ///< A valid device of unknown type
 			BAR = 1, ///< %Trill Bar
 			SQUARE = 2, ///< %Trill Square
 			CRAFT = 3, ///< %Trill Craft
 			RING = 4, ///< %Trill Ring
 			HEX = 5, ///< %Trill Hex
 			FLEX = 6, ///< %Trill Flex
+			UNKNOWN = ANY, ///< same as ANY, for backwards compatibility
 		} Device;
 		/**
 		 * Controls when the EVT pin will be set when a new frame is
@@ -159,7 +160,7 @@ class Trill : public I2c
 		 * @param i2c_address the address at which the device can be
 		 * found.
 		 *
-		 * If @p device is #UNKNOWN then:
+		 * If @p device is #ANY then:
 		 * -  if \p i2c_address is a valid address, then
 		 * any device detected at that addres will be accepted
 		 * - if \p i2c_address is `255` or unspecified, then the range of

From 08bef7783fb9e5640f8420d26153c0f4f51cab36 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 6 Feb 2024 22:22:32 +0000
Subject: [PATCH 178/188] NIT: typo

---
 examples/Sensors/DHT11-temperature-humidity/render.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/Sensors/DHT11-temperature-humidity/render.cpp b/examples/Sensors/DHT11-temperature-humidity/render.cpp
index bc392de5f..244fd1aa2 100644
--- a/examples/Sensors/DHT11-temperature-humidity/render.cpp
+++ b/examples/Sensors/DHT11-temperature-humidity/render.cpp
@@ -32,7 +32,7 @@ Datasheet: https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Tra
 
 const unsigned digitalPin = 0;
 
-DHT dht(digitialPin, DHT11);
+DHT dht(digitalPin, DHT11);
 bool setup(BelaContext *context, void *userData)
 {
 	return true;

From ab8cecdf4dd93cf09b11a06f2ddcbbffb84e4925 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 6 Feb 2024 23:05:58 +0000
Subject: [PATCH 179/188] Trill: default to ANY in setup()

---
 libraries/Trill/Trill.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/Trill/Trill.h b/libraries/Trill/Trill.h
index a6ab57f6a..39cccdb96 100644
--- a/libraries/Trill/Trill.h
+++ b/libraries/Trill/Trill.h
@@ -177,7 +177,7 @@ class Trill : public I2c
 		 *
 		 * \copydoc TAGS_canonical_return
 		 */
-		int setup(unsigned int i2c_bus, Device device, uint8_t i2c_address = 255);
+		int setup(unsigned int i2c_bus, Device device = ANY, uint8_t i2c_address = 255);
 
 		/**
 		 * Probe the bus for a device at the specified address.

From cdda35b4bffb45bd65433e134d765b5caff37452 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Tue, 6 Feb 2024 23:06:51 +0000
Subject: [PATCH 180/188] Trill/{detect-all-devices,general-*}: take advantage
 of new API

---
 examples/Trill/detect-all-devices/render.cpp | 14 ++++++--------
 examples/Trill/general-print/render.cpp      |  6 ++----
 examples/Trill/general-settings/render.cpp   |  5 ++---
 examples/Trill/general-visual/render.cpp     |  5 ++---
 4 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/examples/Trill/detect-all-devices/render.cpp b/examples/Trill/detect-all-devices/render.cpp
index 3043745a9..f8faaf380 100644
--- a/examples/Trill/detect-all-devices/render.cpp
+++ b/examples/Trill/detect-all-devices/render.cpp
@@ -34,15 +34,13 @@ bool setup(BelaContext *context, void *userData)
 	unsigned int i2cBus = 1;
 	printf("Trill devices detected on bus %d\n", i2cBus);
 	printf("Address    | Type\n");
-	unsigned int total = 0;
-	for(uint8_t n = 0x20; n <= 0x50; ++n) {
-		Trill::Device device = Trill::probe(i2cBus, n);
-		if(device != Trill::NONE) {
-			printf("%#4x (%3d) | %s\n", n, n, Trill::getNameFromDevice(device).c_str());
-			++total;
-		}
+	auto devices = Trill::probeRange(i2cBus);
+	for(auto& d : devices) {
+		const std::string& device = Trill::getNameFromDevice(d.first);
+		int addr = d.second;
+		printf("%#4x (%2d) | %s\n", addr, addr, device.c_str());
 	}
-	printf("Total: %d devices\n", total);
+	printf("Total: %d devices\n", devices.size());
 	return true;
 }
 
diff --git a/examples/Trill/general-print/render.cpp b/examples/Trill/general-print/render.cpp
index 206d14d54..47c181a13 100644
--- a/examples/Trill/general-print/render.cpp
+++ b/examples/Trill/general-print/render.cpp
@@ -49,10 +49,8 @@ void loop(void*)
 
 bool setup(BelaContext *context, void *userData)
 {
-	// Setup a Trill Craft on i2c bus 1, using the default address.
-	// Set it to differential mode for bargraph display
-	if(touchSensor.setup(1, Trill::CRAFT) != 0) {
-		fprintf(stderr, "Unable to initialise Trill Craft\n");
+	// Look for a connected Trill on I2C bus 1
+	if(touchSensor.setup(1) != 0) {
 		return false;
 	}
 	// ensure the device is in DIFF mode for printing raw values
diff --git a/examples/Trill/general-settings/render.cpp b/examples/Trill/general-settings/render.cpp
index 4c88bf8a0..ce449cbaf 100644
--- a/examples/Trill/general-settings/render.cpp
+++ b/examples/Trill/general-settings/render.cpp
@@ -287,9 +287,8 @@ void loop(void*)
 
 bool setup(BelaContext *context, void *userData)
 {
-	// Setup a Trill Craft on i2c bus 1, using the default address.
-	if(touchSensor.setup(1, Trill::CRAFT) != 0) {
-		fprintf(stderr, "Unable to initialise Trill Craft\n");
+	// Look for a connected Trill on I2C bus 1
+	if(touchSensor.setup(1) != 0) {
 		return false;
 	}
 	touchSensor.printDetails();
diff --git a/examples/Trill/general-visual/render.cpp b/examples/Trill/general-visual/render.cpp
index 582082009..7460a6174 100644
--- a/examples/Trill/general-visual/render.cpp
+++ b/examples/Trill/general-visual/render.cpp
@@ -55,9 +55,8 @@ void loop(void*)
 
 bool setup(BelaContext *context, void *userData)
 {
-	// Setup a Trill Craft on i2c bus 1, using the default address.
-	if(touchSensor.setup(1, Trill::CRAFT) != 0) {
-		fprintf(stderr, "Unable to initialise Trill Craft\n");
+	// Look for a connected Trill on I2C bus 1
+	if(touchSensor.setup(1) != 0) {
 		return false;
 	}
 	// ensure the device is in DIFF mode for printing raw values

From c954b747fe1daf3ab731f4dc6231370d5d98b0f3 Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 8 Feb 2024 21:15:31 +0000
Subject: [PATCH 181/188] Midi: add more information on port, retrievabble

---
 libraries/Midi/Midi.cpp | 115 ++++++++++++++++++++++++++++++++--------
 libraries/Midi/Midi.h   |  28 +++++++++-
 2 files changed, 118 insertions(+), 25 deletions(-)

diff --git a/libraries/Midi/Midi.cpp b/libraries/Midi/Midi.cpp
index 77475d63e..bdaa64fdd 100644
--- a/libraries/Midi/Midi.cpp
+++ b/libraries/Midi/Midi.cpp
@@ -263,6 +263,47 @@ void Midi::doWriteOutput(const void* data, int size) {
 
 #include <RtWrappers.h>
 
+static Midi::Port getPort(snd_rawmidi_info_t* info)
+{
+#if 0
+	printf("==========\n");
+	printf("device: %d\n", snd_rawmidi_info_get_device(info));
+	printf("subdevice: %d\n", snd_rawmidi_info_get_subdevice(info));
+	printf("stream: %d\n", snd_rawmidi_info_get_stream(info));
+	printf("card: %d\n", snd_rawmidi_info_get_card(info));
+	printf("flags: %d\n", snd_rawmidi_info_get_flags(info));
+	printf("id: %s\n", snd_rawmidi_info_get_id(info));
+	printf("name: %s\n", snd_rawmidi_info_get_name(info));
+	printf("subdevice_name: %s\n", snd_rawmidi_info_get_subdevice_name(info));
+	printf("subdevices_count: %d\n", snd_rawmidi_info_get_subdevices_count(info));
+	printf("subdevices_avail: %d\n", snd_rawmidi_info_get_subdevices_avail(info));
+#endif
+	int card = snd_rawmidi_info_get_card(info);
+	int sub = snd_rawmidi_info_get_subdevice(info);
+	int device = snd_rawmidi_info_get_device(info);
+	std::string name = "hw:" + std::to_string(card) + "," + std::to_string(device) + "," + std::to_string(sub);
+	std::string desc = std::string(snd_rawmidi_info_get_id(info)) + " " + snd_rawmidi_info_get_name(info) + " [  " + snd_rawmidi_info_get_subdevice_name(info) + " ]";
+	return {
+		.name = name,
+		.desc = desc,
+		.card = card,
+		.device = device,
+		.sub = (int)sub,
+		.hasInput = false, // TODO: fill these in, see is_input()/is_output()
+		.hasOutput = false,
+	};
+}
+
+static int getPort(snd_rawmidi_t* rmidi, Midi::Port& port) {
+	snd_rawmidi_info_t *info;
+	snd_rawmidi_info_alloca(&info);
+	int ret = snd_rawmidi_info(rmidi, info);
+	if(ret)
+		return ret;
+	port = getPort(info);
+	return 0;
+}
+
 int Midi::readFrom(const char* port){
 	if(port == NULL){
 		port = defaultPort.c_str();
@@ -274,7 +315,13 @@ int Midi::readFrom(const char* port){
 	if (err) {
 		return err;
 	}
-	int ret = create_and_start_thread(&midiInputThread, inId.c_str(), 50, 0, NULL, Midi::readInputLoopStatic, (void*)this);
+	int ret = getPort(alsaIn, inPortFull);
+	inPortFull.hasInput = true;
+	if(ret) {
+		fprintf(stderr, "Unable to retrieve input port information for %s\n", port);
+		return 0;
+	}
+	ret = create_and_start_thread(&midiInputThread, inId.c_str(), 50, 0, NULL, Midi::readInputLoopStatic, (void*)this);
 	if(ret)
 		return 0;
 	inputEnabled = true;
@@ -292,6 +339,12 @@ int Midi::writeTo(const char* port){
 	if (err) {
 		return err;
 	}
+	int ret = getPort(alsaOut, outPortFull);
+	inPortFull.hasOutput = true;
+	if(ret) {
+		fprintf(stderr, "Unable to retrieve output port information for %s\n", port);
+		return 0;
+	}
 	midiOutputTask = new AuxTaskNonRT();
 	midiOutputTask->create(outId, [this](void* buf, int size) {
 		this->doWriteOutput(buf, size);
@@ -300,7 +353,8 @@ int Midi::writeTo(const char* port){
 	return 1;
 }
 
-void Midi::createAllPorts(std::vector<Midi*>& ports, bool useParser){
+std::vector<Midi::Port> Midi::listAllPorts(){
+	std::vector<Port> ports;
 	int card = -1;
 	int status;
 	while((status = snd_card_next(&card)) == 0){
@@ -314,7 +368,7 @@ void Midi::createAllPorts(std::vector<Midi*>& ports, bool useParser){
 		sprintf(name, "hw:%d", card);
 		if ((status = snd_ctl_open(&ctl, name, 0)) < 0) {
 			error("cannot open control for card %d: %s\n", card, snd_strerror(status));
-			return;
+			return ports;
 		}
 		do {
 			status = snd_ctl_rawmidi_next_device(ctl, &device);
@@ -342,7 +396,7 @@ void Midi::createAllPorts(std::vector<Midi*>& ports, bool useParser){
 					if ((status = is_output(ctl, card, device, sub)) < 0) {
 						error("cannot get rawmidi information %d:%d: %s",
 						card, device, snd_strerror(status));
-						return;
+						return ports;
 					} else if (status){
 						out = true;
 						// writeTo
@@ -352,7 +406,7 @@ void Midi::createAllPorts(std::vector<Midi*>& ports, bool useParser){
 						if ((status = is_input(ctl, card, device, sub)) < 0) {
 							error("cannot get rawmidi information %d:%d: %s",
 							card, device, snd_strerror(status));
-							return;
+							return ports;
 						}
 					} else if (status) {
 						in = true;
@@ -360,27 +414,43 @@ void Midi::createAllPorts(std::vector<Midi*>& ports, bool useParser){
 					}
 
 					if(in || out){
-						ports.resize(ports.size() + 1);
-						unsigned int index = ports.size() - 1;
-						ports[index] = new Midi();
-						const char* myName = snd_rawmidi_info_get_name(info);
-						const char* mySubName =  snd_rawmidi_info_get_subdevice_name(info);
-						sprintf(name, "hw:%d,%d,%d", card, device, sub);
-						if(in){
-							printf("Port %d, Reading from: %s, %s %s\n", index, name, myName, mySubName);
-							ports[index]->readFrom(name);
-							ports[index]->enableParser(useParser);
-						}
-						if(out){
-							printf("Port %d, Writing to: %s %s %s\n", index, name, myName, mySubName);
-							ports[index]->writeTo(name);
-						}
+						Port port = getPort(info);
+						port.hasInput = in;
+						port.hasOutput = out;
+						ports.push_back(port);
 					}
 				}
 			}
 		} while (device >= 0);
 		snd_ctl_close(ctl);
 	}
+	return ports;
+}
+
+void Midi::createAllPorts(std::vector<Midi*>& ports, bool useParser){
+	auto list = listAllPorts();
+	ports.reserve(list.size());
+	for(size_t n = 0; n < list.size(); ++n) {
+		auto& l = list[n];
+		if(!(l.hasInput || l.hasOutput))
+			continue;
+		Midi* m = new Midi();
+		if(l.hasInput) {
+			std::string str = "reading from " + l.name + ": " + l.desc;
+			if(1 == m->readFrom(l.name.c_str()))
+				printf("Port %d, %s\n", n, str.c_str());
+			else
+				fprintf(stderr, "Port %d, ERROR %s\n", n, str.c_str());
+		}
+		if(l.hasOutput) {
+			std::string str = "writing to " + l.name + ": " + l.desc;
+			if(1 == m->writeTo(l.name.c_str()))
+				printf("Port %d, %s\n", n, str.c_str());
+			else
+				fprintf(stderr, "Port %d, ERROR %s\n", n, str.c_str());
+		}
+		ports.push_back(m);
+	}
 }
 
 int Midi::_getInput(){
@@ -437,12 +507,12 @@ int Midi::writeOutput(midi_byte_t* bytes, unsigned int length){
 	return 1;
 }
 
-bool Midi::isInputEnabled()
+bool Midi::isInputEnabled() const
 {
 	return inputEnabled;
 }
 
-bool Midi::isOutputEnabled()
+bool Midi::isOutputEnabled() const
 {
 	return outputEnabled;
 }
@@ -761,7 +831,6 @@ static int is_input(snd_ctl_t *ctl, int card, int device, int sub) {
 }
 
 
-
 //////////////////////////////
 //
 // is_output -- returns true if specified card/device/sub can output MIDI data.
diff --git a/libraries/Midi/Midi.h b/libraries/Midi/Midi.h
index 4f567bc99..d4ae89def 100644
--- a/libraries/Midi/Midi.h
+++ b/libraries/Midi/Midi.h
@@ -2,6 +2,7 @@
 #include <vector>
 #include <string>
 #include <AuxTaskNonRT.h>
+#include <tuple>
 
 typedef unsigned char midi_byte_t;
 
@@ -370,10 +371,31 @@ class Midi {
 	MidiParser* getMidiParser();
 	virtual ~Midi();
 
-	bool isInputEnabled();
+	bool isInputEnabled() const;
 
-	bool isOutputEnabled();
+	bool isOutputEnabled() const;
 
+	struct Port {
+		std::string name;
+		std::string desc;
+		int card;
+		int device;
+		int sub;
+		bool hasInput;
+		bool hasOutput;
+		bool operator== (const Port& o) const {
+			return name == o.name &&
+				desc == o.desc &&
+				card == o.card &&
+				device == o.device &&
+				sub == o.sub &&
+				hasInput == o.hasInput &&
+				hasOutput == o.hasOutput;
+		}
+	};
+	const Port& getInputPort() const { return inPortFull; }
+	const Port& getOutputPort() const { return outPortFull; }
+	static std::vector<Port> listAllPorts();
 	/**
 	 * Opens all the existing MIDI ports, in the same order returned by the filesystem or Alsa.
 	 * Ports open with this method should be closed with destroyPorts()
@@ -387,6 +409,8 @@ class Midi {
 private:
 	std::string inPort;
 	std::string outPort;
+	Port inPortFull;
+	Port outPortFull;
 	int _getInput();
 	int attemptRecoveryRead();
 	static void* readInputLoopStatic(void* obj);

From 0434fd7e654308527dc53cbc0c14f079c76220af Mon Sep 17 00:00:00 2001
From: Giulio Moro <giuliomoro@yahoo.it>
Date: Thu, 8 Feb 2024 21:13:50 +0000
Subject: [PATCH 182/188] default_libpd_render: overhauled MIDI initialisation,
 using dedicated thread. Send 'auto' to automatically discover new MIDI
 devices.

---
 core/default_libpd_render.cpp | 196 +++++++++++++++++++++++++++++-----
 1 file changed, 169 insertions(+), 27 deletions(-)

diff --git a/core/default_libpd_render.cpp b/core/default_libpd_render.cpp
index e3a356819..ef27abc78 100644
--- a/core/default_libpd_render.cpp
+++ b/core/default_libpd_render.cpp
@@ -32,13 +32,15 @@
 #undef BELA_LIBPD_SYSTEM_THREADED
 #endif // BELA_LIBPD_DISABLE_SYSTEM_THREADD
 
-#define PD_THREADED_IO
+//#define PD_THREADED_IO
 #include <libraries/libpd/libpd.h>
 #include <DigitalChannelManager.h>
 #include <stdio.h>
 
 #ifdef BELA_LIBPD_MIDI
+#include <algorithm>
 #include <libraries/Midi/Midi.h>
+#include <libraries/Pipe/Pipe.h>
 #endif // BELA_LIBPD_MIDI
 #ifdef BELA_LIBPD_SCOPE
 #include <libraries/Scope/Scope.h>
@@ -429,10 +431,125 @@ float* gInBuf;
 float* gOutBuf;
 #ifdef BELA_LIBPD_MIDI
 #define PARSE_MIDI
-static std::vector<Midi*> midi;
-std::vector<std::string> gMidiPortNames;
 int gMidiVerbose = 1;
 const int kMidiVerbosePrintLevel = 1;
+#include <thread>
+
+static Midi* openMidiDevice(const std::string& name, bool verboseSuccess = false, bool verboseError = false);
+static const std::string& midiName(const Midi* m)
+{
+	// assumes input and output are the same subdevice
+	if(m) {
+		if(m->isInputEnabled())
+			return m->getInputPort().name;
+		else if(m->isOutputEnabled())
+			return m->getOutputPort().name;
+	}
+	static const std::string none("NONE");
+	return none;
+}
+
+static std::thread gMidiDiscoveryThread;
+static volatile bool gMidiDiscoveryThreadShouldStop;
+static volatile bool gMidiDiscoveryThreadAuto;
+Pipe gMidiDiscoveryPipe("midiDiscoveryPipe");
+enum MidiDiscoveryCmd {
+	kMidiAdd,
+	kMidiAck,
+};
+struct MidiDiscoveryMsgFromNonRt {
+	MidiDiscoveryCmd cmd;
+	Midi* ptr;
+};
+struct MidiDiscoveryMsgFromRt {
+	MidiDiscoveryCmd cmd;
+	Midi* ptr;
+	char name[32];
+};
+
+static void midiDiscovery()
+{
+	gMidiDiscoveryPipe.setBlockingNonRt(true);
+	gMidiDiscoveryPipe.setTimeoutMsNonRt(100);
+	// it's hard to use inotify meaningfully, so we poll instead
+	auto shouldStop = []() {
+		return Bela_stopRequested() || gMidiDiscoveryThreadShouldStop;
+	};
+
+	std::vector<std::string> toOpen;
+	std::vector<Midi*> localMidi;
+	std::vector<MidiDiscoveryMsgFromNonRt> msgs;
+	int count = 1;
+	unsigned int numDevices = 0;
+	bool doDiscovery = false;
+	while(!shouldStop())
+	{
+		msgs.resize(0);
+		if(numDevices == localMidi.size())
+		{
+			//printf("We are equal: %d\n", numDevices);
+			// when we are fully synced up:
+			if(doDiscovery && !toOpen.size() && gMidiDiscoveryThreadAuto)
+			{
+				doDiscovery = false;
+				// do discovery
+				auto list = Midi::listAllPorts();
+				for(auto& l : list)
+				{
+					// Check if there are new devices that are not open yet.
+					toOpen.push_back(l.name);
+					// NOTE: devices that are unplugged and plugged back in
+					// that were previously initialised will be automatically reopened,
+					// so we are only concerned with new devices here.
+				}
+				count = 0;
+			}
+			while(toOpen.size())
+			{
+				std::string name = toOpen[0];
+				toOpen.erase(toOpen.begin());
+				bool found = false;
+				for(const auto m : localMidi)
+				{
+					if(midiName(m) == name)
+					{
+						found = true;
+						break;
+					}
+				}
+				if(!found)
+				{
+					printf("New device %s, opening it\n", name.c_str());
+					Midi* midi = openMidiDevice(name);
+					if(midi) {
+						MidiDiscoveryMsgFromNonRt msg =  {
+							.cmd = kMidiAdd,
+							.ptr = midi,
+						};
+						msgs.push_back(msg);
+						numDevices++;
+						break;
+					}
+				}
+			}
+		}
+		if(count++ > 20)
+			doDiscovery = true;
+		for(auto& msg : msgs)
+			gMidiDiscoveryPipe.writeNonRt(msg);
+		MidiDiscoveryMsgFromRt msg;
+		// potentially blocking read
+		int ret = gMidiDiscoveryPipe.readNonRt(msg);
+		if(1 == ret)
+		{
+			if(kMidiAck == msg.cmd)
+				localMidi.push_back(msg.ptr);
+			if(kMidiAdd == msg.cmd)
+				toOpen.push_back(msg.name);
+		}
+	}
+}
+static std::vector<Midi*> midi;
 
 void dumpMidi()
 {
@@ -453,7 +570,7 @@ void dumpMidi()
 	{
 		printf("[%2d]%20s %3s %3s (%d-%d)\n", 
 			n,
-			gMidiPortNames[n].c_str(),
+			midiName(midi[n]).c_str(),
 			midi[n]->isInputEnabled() ? "x" : "_",
 			midi[n]->isOutputEnabled() ? "x" : "_",
 			n * 16 + 1,
@@ -462,7 +579,7 @@ void dumpMidi()
 	}
 }
 
-Midi* openMidiDevice(std::string name, bool verboseSuccess = false, bool verboseError = false)
+static Midi* openMidiDevice(const std::string& name, bool verboseSuccess, bool verboseError)
 {
 	Midi* newMidi;
 	newMidi = new Midi();
@@ -684,6 +801,14 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 			}
 			return;
 		}
+		if(0 == strcmp("auto", symbol))
+		{
+			rt_printf("Automatically discover new MIDI devices\n");
+			if(!gMidiDiscoveryThread.joinable())
+				gMidiDiscoveryThread = std::thread(midiDiscovery);
+			gMidiDiscoveryThreadAuto = true;
+			return;
+		}
 		int num[3] = {0, 0, 0};
 		for(int n = 0; n < argc && n < 3; ++n)
 		{
@@ -694,16 +819,19 @@ void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *
 			}
 			num[n] = libpd_get_float(&argv[n]);
 		}
+		// TODO: this string/stream business is not actually realtime-safe.
 		std::ostringstream deviceName;
 		deviceName << symbol << ":" << num[0] << "," << num[1] << "," << num[2];
-		printf("Adding Midi device: %s\n", deviceName.str().c_str());
-		Midi* newMidi = openMidiDevice(deviceName.str(), false, true);
-		if(newMidi)
-		{
-			midi.push_back(newMidi);
-			gMidiPortNames.push_back(deviceName.str());
+		MidiDiscoveryMsgFromRt msg = {
+				.cmd = kMidiAdd,
+			};
+		std::string name = deviceName.str();
+		if(name.size() + 1 > sizeof(msg.name)) {
+			fprintf(stderr, "MIDI name too long: %s\n", name.c_str());
+			return;
 		}
-		dumpMidi();
+		strncpy(msg.name, deviceName.str().c_str(), sizeof(msg.name));
+		gMidiDiscoveryPipe.writeRt(msg);
 		return;
 	}
 #endif // BELA_LIBPD_MIDI
@@ -1082,9 +1210,9 @@ bool setup(BelaContext *context, void *userData)
 
 #ifdef BELA_LIBPD_MIDI
 	// add here other devices you need 
-	gMidiPortNames.push_back("hw:1,0,0");
-	//gMidiPortNames.push_back("hw:0,0,0");
-	//gMidiPortNames.push_back("hw:1,0,1");
+	std::vector<std::string> midiPortNames;
+	midiPortNames.push_back("hw:1,0,0");
+	//midiPortNames.push_back("hw:0,0,0");
 #endif // BELA_LIBPD_MIDI
 #ifdef BELA_LIBPD_SCOPE
 	scope.setup(gScopeChannelsInUse, context->audioSampleRate);
@@ -1133,19 +1261,15 @@ bool setup(BelaContext *context, void *userData)
 	}
 
 #ifdef BELA_LIBPD_MIDI
-	unsigned int n = 0;
-	while(n < gMidiPortNames.size())
+	gMidiDiscoveryThread = std::thread(midiDiscovery);
+	for(const auto & name : midiPortNames)
 	{
-		Midi* newMidi = openMidiDevice(gMidiPortNames[n], false, false);
-		if(newMidi)
-		{
-			midi.push_back(newMidi);
-			++n;
-		} else {
-			gMidiPortNames.erase(gMidiPortNames.begin() + n);
-		}
+		MidiDiscoveryMsgFromRt msg;
+		msg.cmd = kMidiAdd;
+		strncpy(msg.name, name.c_str(), sizeof(msg.name));
+		gMidiDiscoveryPipe.writeRt(msg);
 	}
-	dumpMidi();
+	midi.reserve(midiPortNames.size() + 10); // hope we can avoid reallocation for a while
 #endif // BELA_LIBPD_MIDI
 
 	// check that we are not running with a blocksize smaller than gLibPdBlockSize
@@ -1400,6 +1524,22 @@ void render(BelaContext *context, void *userData)
 	}
 #endif // BELA_LIBPD_TRILL
 #ifdef BELA_LIBPD_MIDI
+	if(gMidiDiscoveryThread.joinable())
+	{
+		MidiDiscoveryMsgFromNonRt msg;
+		while(1 == gMidiDiscoveryPipe.readRt(msg))
+		{
+			if(kMidiAdd == msg.cmd)
+			{
+				rt_printf("Midi pointer created %p\n", msg.ptr);
+				midi.push_back(msg.ptr);
+				MidiDiscoveryMsgFromRt res;
+				res.cmd = kMidiAck;
+				res.ptr = msg.ptr;
+				gMidiDiscoveryPipe.writeRt(res);
+			}
+		}
+	}
 #ifdef PARSE_MIDI
 	int num;
 	for(unsigned int port = 0; port < midi.size(); ++port){
@@ -1408,7 +1548,7 @@ void render(BelaContext *context, void *userData)
 			message = midi[port]->getParser()->getNextChannelMessage();
 			if(gMidiVerbose >= kMidiVerbosePrintLevel)
 			{
-				rt_printf("On port %d (%s): ", port, gMidiPortNames[port].c_str());
+				rt_printf("On port %d (%s): ", port, midiName(midi[port]).c_str());
 				message.prettyPrint(); // use this to print beautified message (channel, data bytes)
 			}
 			switch(message.getType()){
@@ -1609,6 +1749,8 @@ void render(BelaContext *context, void *userData)
 void cleanup(BelaContext *context, void *userData)
 {
 #ifdef BELA_LIBPD_MIDI
+	if(gMidiDiscoveryThread.joinable())
+		gMidiDiscoveryThread.join();
 	for(auto a : midi)
 	{
 		delete a;

From dbbcd3fa88d1644c01ad742d3b3494a1e19331b5 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Wed, 14 Feb 2024 23:20:00 +0000
Subject: [PATCH 183/188] implemented theme switching for color-themed elements

---
 IDE/frontend-dev/scss/_accordion-menu.scss | 64 ++++++++++++++------
 IDE/frontend-dev/scss/_buttons.scss        | 17 +++++-
 IDE/frontend-dev/scss/_console.scss        |  9 ++-
 IDE/frontend-dev/scss/_dropdown-mini.scss  |  7 +++
 IDE/frontend-dev/scss/_dropdown.scss       | 33 ++++++++---
 IDE/frontend-dev/scss/_editor.scss         |  6 +-
 IDE/frontend-dev/scss/_library-list.scss   | 12 +++-
 IDE/frontend-dev/scss/_popup.scss          | 13 ++++-
 IDE/frontend-dev/scss/_tab-content.scss    | 28 ++++++++-
 IDE/frontend-dev/scss/_tab-menu.scss       | 68 +++++++++++++++-------
 IDE/frontend-dev/scss/_tabs.scss           | 26 +++++++--
 IDE/frontend-dev/scss/_text-input.scss     | 10 +++-
 IDE/frontend-dev/scss/_toolbar.scss        | 14 ++++-
 IDE/frontend-dev/scss/_upper.scss          | 11 +++-
 14 files changed, 252 insertions(+), 66 deletions(-)

diff --git a/IDE/frontend-dev/scss/_accordion-menu.scss b/IDE/frontend-dev/scss/_accordion-menu.scss
index 06fdc51ef..1499ff5ca 100644
--- a/IDE/frontend-dev/scss/_accordion-menu.scss
+++ b/IDE/frontend-dev/scss/_accordion-menu.scss
@@ -1,8 +1,50 @@
+// color-themed accordion menu elements
+@include themify($themes) {
+  button.accordion {
+    background-color: themed('accordion-background-color');
+    border-bottom: 2px solid themed('main-background-color');
+    color: themed('accordion-font-color');
+
+    &:hover {
+      background: themed('hovered-accordion-color');
+    }
+
+    &.active {
+      background-color: themed('accordion-background-color');
+      color: themed('accordion-font-color-accent');
+
+      &:hover {
+        color: themed('accordion-font-color-accent');
+      }
+    }
+    &:after {
+      color: themed('accordion-font-color');
+    }
+  }
+  button.accordion-sub {
+    border-bottom: 1px solid themed('tabs-color');
+    color: themed('accordion-font-color-accent');
+    &:hover {
+      color: themed('accordion-font-color-accent');
+    }
+    &.active {
+      color: themed('accordion-font-color-accent');
+      &:hover {
+        color: themed('accordion-font-color-accent');
+      }
+    }
+  }
+  .docs-content {
+    color: themed('main-font-color');
+  }
+  .panel.show {
+    color: themed('main-font-color');
+  }
+}
+
+
 button.accordion {
-  background-color: $grey-light;
   border: none;
-  border-bottom: 2px solid #fff;
-  color: rgba(0, 0, 0, 0.6);
   cursor: pointer;
   font-family: poppins_regular;
   font-size: 16px;
@@ -13,23 +55,16 @@ button.accordion {
   transition: 0.25s ease-in-out;
   width: 100%;
   &:hover {
-    background: $grey-mid;
     border-bottom: 2px solid $teal-main;
   }
   &.active {
-    background-color: $grey-light;
     border-bottom: 2px solid $teal-main;
-    color: $grey-dark;
     padding: 8px 14px;
-    &:hover {
-      color: $grey-dark;
-    }
     &:after {
       content: "\2796"; /* Unicode character for "minus" sign (-) */
     }
   }
   &:after {
-    color: rgba(0, 0, 0, 0.6);
     content: '\02795'; /* Unicode character for "plus" sign (+) */
     float: right;
     font-size: 14px;
@@ -39,12 +74,10 @@ button.accordion {
 
 button.accordion-sub {
   background: transparent;
-  border-bottom: 1px solid $grey-toolbar;
   border-top: 0;
   border-left: 0;
   border-right: 0;
   border-radius: 0;
-  color: $grey-dark;
   font-size: 1em;
   font-family: 'poppins_regular';
   padding: .4em .8em .25em;
@@ -52,17 +85,12 @@ button.accordion-sub {
   width: 100%;
   &:hover {
     background: rgba($grey-toolbar,0.2);
-    color: $grey-dark;
   }
   &.active {
     background: transparent;
     border-bottom: 2px solid $teal-01;
-    color: $grey-dark;
     padding-bottom: .2em;
     margin-top: .2em;
-    &:hover {
-      color: $grey-dark;
-    }
     &:after {
       content: "\2796"; /* Unicode character for "minus" sign (-) */
       font-size: .75em;
@@ -101,4 +129,4 @@ button.accordion-sub {
 .panel.show {
   max-height: 100000px; /* Whatever you like, as long as its more than the height of the content (on all screen sizes) */
   opacity: 1;
-}
+}
\ No newline at end of file
diff --git a/IDE/frontend-dev/scss/_buttons.scss b/IDE/frontend-dev/scss/_buttons.scss
index 76334cbc1..fa0b7c316 100644
--- a/IDE/frontend-dev/scss/_buttons.scss
+++ b/IDE/frontend-dev/scss/_buttons.scss
@@ -1,3 +1,17 @@
+// color-themed button elements
+@include themify($themes) {
+  button,
+  .button {
+    background-color: themed('main-background-color');
+    color: themed('main-font-color');
+    &.create-project {
+      &:before {
+      color: themed('accordion-font-color-accent');
+      }
+    }
+  }
+}
+
 a.button {
   color: black;
   font-size: 11px;
@@ -10,9 +24,7 @@ a.button {
 button,
 .button {
   border: 1px solid $teal-main;
-  background-color: $white;
   border-radius: 3px;
-  color: $black;
   font-size: .8em;
   cursor: pointer;
   font-family: poppins_light;
@@ -36,7 +48,6 @@ button,
       color: $white;
     }
     &:before {
-      color: $grey-dark;
       content: '+'; /* Unicode character for "plus" sign (+) */
       font-family: space_bold;
       font-size: 36px;
diff --git a/IDE/frontend-dev/scss/_console.scss b/IDE/frontend-dev/scss/_console.scss
index 5f2ebdb13..5ec33daa2 100644
--- a/IDE/frontend-dev/scss/_console.scss
+++ b/IDE/frontend-dev/scss/_console.scss
@@ -1,5 +1,12 @@
+// color-themed console elements
+@include themify($themes) {
+  #beaglert-console {
+    background-color: themed('main-background-color');
+    color: themed('main-font-color');
+  }
+}
+
 #beaglert-console {
-  background-color: white;
   box-sizing: border-box;
   font-family: inconsolata, monospace;
   font-size: 12px;
diff --git a/IDE/frontend-dev/scss/_dropdown-mini.scss b/IDE/frontend-dev/scss/_dropdown-mini.scss
index 2dd776bdc..edd34fae4 100644
--- a/IDE/frontend-dev/scss/_dropdown-mini.scss
+++ b/IDE/frontend-dev/scss/_dropdown-mini.scss
@@ -1,3 +1,10 @@
+// color-themed sub-accordion elements
+@include themify($themes) {
+  .mini-dropdown select{
+    color: themed('accordion-font-color');
+  }
+}
+
 .mini-dropdown select {
   -moz-appearance: none;
   -webkit-appearance: none;
diff --git a/IDE/frontend-dev/scss/_dropdown.scss b/IDE/frontend-dev/scss/_dropdown.scss
index e50574677..3e2d16a3d 100644
--- a/IDE/frontend-dev/scss/_dropdown.scss
+++ b/IDE/frontend-dev/scss/_dropdown.scss
@@ -1,7 +1,29 @@
-/* Dropdown Button */
+// color-themed dropdown button elements
+@include themify($themes) {
+  button.dropbtn {
+    background-color: themed('selected-tab-color');
+  }
+  .dropdown-content {
+    background-color: themed('hovered-accordion-color-two');
+    select {
+      option {
+        color: themed('main-font-color');
+      }
+    }
+    ul {
+      > li, span, a {
+        color: themed('main-font-color');
+        &:hover {
+          background-color: themed('cursor-color');
+          color: themed('main-font-color-accent');
+        }
+      }
+    }
+  }
+}
 
+/* Dropdown Button */
 button.dropbtn {
-  background-color: #fff;
   border: 1px solid $teal-main;
   color: $teal-main;
   cursor: pointer;
@@ -75,7 +97,6 @@ select.dropdown-num {
 
 /* Dropdown content (hidden by default) */
 .dropdown-content {
-  background-color: #f9f9f9;
   box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2);
   display: none;
   min-width: 160px;
@@ -92,7 +113,6 @@ select.dropdown-num {
     padding-top: 0;
     width: 200px;
     option {
-      color: black;
       cursor: pointer;
       display: block;
       font-family: poppins_regular;
@@ -123,7 +143,6 @@ select.dropdown-num {
       user-select: none;
     }
     > li, span, a {
-      color: black;
       cursor: pointer;
       display: block;
       font-family: poppins_regular;
@@ -131,10 +150,6 @@ select.dropdown-num {
       opacity: 1;
       padding: 8px 16px;
       text-decoration: none;
-      &:hover {
-        background-color: $grey-light;
-        color: rgba(0, 0, 0, 0.9);
-      }
     }
   }
   &.show {
diff --git a/IDE/frontend-dev/scss/_editor.scss b/IDE/frontend-dev/scss/_editor.scss
index 7201705f3..6ff7b8b88 100644
--- a/IDE/frontend-dev/scss/_editor.scss
+++ b/IDE/frontend-dev/scss/_editor.scss
@@ -1,5 +1,9 @@
+// color-themed editor elements
+@include themify($themes) {
+  background: themed('main-background-color');
+}
+
 #editor {
-  background: #fff;
   display: none;
   float: left;
   height: calc(100% - 70px);
diff --git a/IDE/frontend-dev/scss/_library-list.scss b/IDE/frontend-dev/scss/_library-list.scss
index 4bffad8c6..27766faea 100644
--- a/IDE/frontend-dev/scss/_library-list.scss
+++ b/IDE/frontend-dev/scss/_library-list.scss
@@ -1,3 +1,14 @@
+// color-themed library list elements
+@include themify($themes) {
+  ul {
+    .libraries-list {
+      li {
+        color: themed('accordion-font-color-accent');
+      }
+    }
+  }
+}
+
 ul {
   &.libraries-list-parent {
     list-style: none;
@@ -68,7 +79,6 @@ ul {
     }
     .libraries-list {
       li {
-        color: rgba(0, 0, 0, 0.8);
         cursor: pointer;
         font-family: inconsolata;
       	font-size: 14px;
diff --git a/IDE/frontend-dev/scss/_popup.scss b/IDE/frontend-dev/scss/_popup.scss
index 4bcec16f0..5483cc4fc 100644
--- a/IDE/frontend-dev/scss/_popup.scss
+++ b/IDE/frontend-dev/scss/_popup.scss
@@ -1,3 +1,15 @@
+// color-themed popup elements
+@include themify($themes) {
+  #popup {
+    background: themed('selected-tab-color');
+  }
+  button {
+    &.cancel {
+      background: themed('selected-tab-color');
+    }
+  }
+}
+
 #popup-nointeraction {
   display: none;
   height: 100vh;
@@ -134,7 +146,6 @@
       }
     }
     &.cancel {
-      background: $white;
       border: 1px solid $grey-mid;
       &:hover {
         background: $grey-light-mid;
diff --git a/IDE/frontend-dev/scss/_tab-content.scss b/IDE/frontend-dev/scss/_tab-content.scss
index 0478d785b..ce4b66961 100644
--- a/IDE/frontend-dev/scss/_tab-content.scss
+++ b/IDE/frontend-dev/scss/_tab-content.scss
@@ -1,5 +1,29 @@
+// color-themed tab elements
+@include themify($themes) {
+  .choice {
+    color: themed('accordion-font-color');
+  }
+  p.project {
+    color: themed('main-font-color')
+  }
+  .project-actions {
+    >.project-text {
+      color: themed('accordion-font-color-accent');
+    }
+  }
+  input[type="checkbox"].checkbox-slider,
+  .checkbox-slider input[type="checkbox"] {
+    &::before {
+      background: themed('checkbox-slider-color');
+    }
+  }
+  textarea {
+    background-color: themed('text-area-color');
+    color: themed('main-font-color');
+  }
+}
+
 .choice {
-  color: rgba(0, 0, 0, 0.6);
   font-family: poppins_light;
   font-size: 12px;
   padding-bottom: 10px;
@@ -82,7 +106,6 @@ input[type="checkbox"].checkbox-slider,
   }
 
   &::before {
-    background: #ccc;
     border-radius: 18px;
     height: 18px;
     transition: background-color 200ms;
@@ -161,7 +184,6 @@ p.project {
   >.project-text {
     display: inline;
     font-family: 'inconsolata';
-    color: $grey-dark;
     font-size: .85em;
     position: absolute;
     top: 0;
diff --git a/IDE/frontend-dev/scss/_tab-menu.scss b/IDE/frontend-dev/scss/_tab-menu.scss
index d69dfad42..b98af5720 100644
--- a/IDE/frontend-dev/scss/_tab-menu.scss
+++ b/IDE/frontend-dev/scss/_tab-menu.scss
@@ -1,15 +1,60 @@
+// color-themed tab menu elements
+@include themify($themes) {
+  #tab-menu {
+    li#open-tab {
+      background-color: themed('tabs-color');
+    }
+    li {
+      background: themed('tabs-color');
+      &.explorer {
+        &.active{
+          background: themed('selected-tab-color') url('../images/icons/folder_active.svg') no-repeat center;
+        }
+      }
+      &.examples {
+        &.active {
+          background: themed('selected-tab-color') url('../images/icons/examples_active.svg') no-repeat center;
+        }
+      }
+      &.settings {
+        &.active {
+          background: themed('selected-tab-color') url('../images/icons/settings_active.svg') no-repeat center;
+        }
+      }
+      &.pins {
+        &.active {
+          background: themed('selected-tab-color') url('../images/icons/pins_active.svg') no-repeat center;
+        }
+      }
+      &.refs {
+        &.active {
+          background: themed('selected-tab-color') url('../images/icons/refs_active.svg') no-repeat center;
+        }
+      }
+      &.libraries {
+        &.active {
+          background: themed('selected-tab-color') url('../images/icons/library_green.svg') no-repeat center;
+        }
+      }
+      &.feedback {
+        &.active {
+          background: themed('selected-tab-color') url('../images/icons/feedback_active.svg') no-repeat center;
+        }
+      }
+    }
+  }
+}
+
 /*
  * Make each label stack on top of one another.
  *
  */
 #tab-menu {
   li#open-tab {
-    background-color: $grey-tabs;
     max-width: 40px;
     padding-left: 10px;
   }
   li {
-    background: $grey-tabs;
     cursor: pointer;
     height: 50px;
     padding: 0;
@@ -31,54 +76,36 @@
       &:hover {
         background: url('../images/icons/folder_active.svg') no-repeat center;
       }
-      &.active{
-        background: $white url('../images/icons/folder_active.svg') no-repeat center;
-      }
     }
     &.examples {
       background: url('../images/icons/examples_inactive.svg') no-repeat center;
         &:hover {
           background: url('../images/icons/examples_active.svg') no-repeat center;
         }
-        &.active {
-          background: $white url('../images/icons/examples_active.svg') no-repeat center;
-        }
       }
       &.settings {
         background: url('../images/icons/settings_inactive.svg') no-repeat center;
       &:hover {
         background: url('../images/icons/settings_active.svg') no-repeat center;
       }
-      &.active {
-        background: $white url('../images/icons/settings_active.svg') no-repeat center;
-      }
     }
     &.pins {
         background: url('../images/icons/pins_inactive.svg') no-repeat center;
       &:hover {
         background: url('../images/icons/pins_active.svg') no-repeat center;
       }
-      &.active {
-        background: $white url('../images/icons/pins_active.svg') no-repeat center;
-      }
     }
     &.refs {
       background: url('../images/icons/refs_inactive.svg') no-repeat center;
       &:hover {
         background: url('../images/icons/refs_active.svg') no-repeat center;
       }
-      &.active {
-        background: $white url('../images/icons/refs_active.svg') no-repeat center;
-      }
     }
     &.libraries {
       background: url('../images/icons/library_white.svg') no-repeat center;
       &:hover {
         background: url('../images/icons/library_green.svg') no-repeat center;
       }
-      &.active {
-        background: $white url('../images/icons/library_green.svg') no-repeat center;
-      }
     }
     &.feedback {
       background: url('../images/icons/feedback_inactive.svg') no-repeat center;
@@ -86,7 +113,6 @@
         background: url('../images/icons/feedback_active.svg') no-repeat center;
       }
       &.active {
-        background: $white url('../images/icons/feedback_active.svg') no-repeat center;
         border-left: 5px solid $accent-red;
       }
     }
diff --git a/IDE/frontend-dev/scss/_tabs.scss b/IDE/frontend-dev/scss/_tabs.scss
index babf9bd14..65e2bda63 100644
--- a/IDE/frontend-dev/scss/_tabs.scss
+++ b/IDE/frontend-dev/scss/_tabs.scss
@@ -1,8 +1,28 @@
+// color-themed tabs elements
+@include themify($themes) {
+  //.tabs {
+	//background-color: themed('tabs-color');
+  //}
+  #tab-menu {
+    background-color: themed('tabs-color');
+  }
+  #tab-content-area {
+    background-color: themed('main-background-color');
+  }
+  section#tab-content {
+    .title-container {
+      background-color: themed('main-background-color');
+      h1 {
+        color: themed('accordion-font-color-accent');
+      }
+    }
+  }
+}
+
 $tab-width: 450px;
 
 /* Tabbed content */
 .tabs {
-	background-color: white;
 	height: calc(100% + 35px);
   left: calc(100% - 50px);
   position: absolute;
@@ -23,14 +43,12 @@ $tab-width: 450px;
 }
 
 #tab-menu {
-  background-color: $grey-tabs;
   float: left;
   height: 100%;
   width: 50px;
 }
 
 #tab-content-area {
-  background-color: #fff;
   height: calc(100% - 76px);
   overflow: auto;
 }
@@ -43,7 +61,6 @@ section#tab-content {
     display: none;
   }
   .title-container {
-    background-color: $white;
     height: 75px;
     position: sticky;
     position: -webkit-sticky; /* Required for Safari */
@@ -56,7 +73,6 @@ section#tab-content {
     }
     h1 {
       border-bottom: 10px solid $teal-01;
-      color: rgba(0, 0, 0, 0.8);
       display: inline-block;
       font-family: space_bold;
       font-size: 24px;
diff --git a/IDE/frontend-dev/scss/_text-input.scss b/IDE/frontend-dev/scss/_text-input.scss
index 0d358ecbb..0797ad114 100644
--- a/IDE/frontend-dev/scss/_text-input.scss
+++ b/IDE/frontend-dev/scss/_text-input.scss
@@ -1,9 +1,17 @@
+// color-themed text input elements
+@include themify($themes) {
+	input[type="text"],
+	input[type="number"] {
+		background: themed('main-background-color');
+		color: themed('main-font-color-accent');
+	}
+}
+
 // INPUTS
 input[type="text"],
 input[type="number"] {
 	height: 25px;
 	border: 1px solid $grey-mid;
-	background: $white;
 	&.number-picker {
 		border-radius: 0;
 		width: 5em;
diff --git a/IDE/frontend-dev/scss/_toolbar.scss b/IDE/frontend-dev/scss/_toolbar.scss
index 7231df15a..fdaf3e139 100644
--- a/IDE/frontend-dev/scss/_toolbar.scss
+++ b/IDE/frontend-dev/scss/_toolbar.scss
@@ -1,3 +1,16 @@
+// color-themed toolbar elements
+@include themify($themes) {
+  .toolbar {
+    background: themed('tabs-color');
+    .tool-text {
+      color: themed('main-font-color');
+    }
+    .system-status-text {
+      color: themed('main-font-color') !important;
+    }
+  }
+}
+
 @keyframes running-button {
   from {
     transform: rotate(0deg);
@@ -17,7 +30,6 @@
 
 
 .toolbar {
-  background: $grey-toolbar;
   bottom: 0;
   box-shadow: 5px 5px #eee;
   display: block;
diff --git a/IDE/frontend-dev/scss/_upper.scss b/IDE/frontend-dev/scss/_upper.scss
index bb651ffda..379fcefaa 100644
--- a/IDE/frontend-dev/scss/_upper.scss
+++ b/IDE/frontend-dev/scss/_upper.scss
@@ -1,3 +1,13 @@
+// color-themed top bar elements
+@include themify($themes) {
+  .file-status {
+    .current {
+      color: themed('accordion-font-color');
+      background-color: themed('top-file-status-color');
+    }
+  }
+}
+
 .file-status {
   margin-left: 60px;
   white-space: nowrap;
@@ -30,7 +40,6 @@
   }
   .current {
     font-family: poppins_regular;
-    color: rgba(0, 0, 0, 0.7);
     padding-right: 20px;
     font-size: 12px;
   }

From 51f33d30a981f76e8e1d4dc01aa8cb83d220905c Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Wed, 14 Feb 2024 23:22:50 +0000
Subject: [PATCH 184/188] implemented main logic for color-theme switching

---
 IDE/frontend-dev/scss/base.scss | 78 +++++++++++++++++++++++++++++++--
 1 file changed, 75 insertions(+), 3 deletions(-)

diff --git a/IDE/frontend-dev/scss/base.scss b/IDE/frontend-dev/scss/base.scss
index 26e061da4..55625b800 100644
--- a/IDE/frontend-dev/scss/base.scss
+++ b/IDE/frontend-dev/scss/base.scss
@@ -5,7 +5,7 @@ $black: #000;
 $white: #ffffff;
 
 // Base Material palette teal:
-$teal-base: #009587;
+$teal-base: #950000;
 
 // Main Bela color:
 $teal-main: #00bea4; //rgb(0,190,164)
@@ -38,6 +38,59 @@ $trans-reg: 0.1s;
 $yellow-accent: #fff07c;
 $yellow-accent-fade: #FFFFC9;
 
+$themes: (
+  light: (
+    main-background-color: $white,
+    tabs-color: $grey-toolbar,
+    selected-tab-color: $white,
+    top-file-status-color: #e1e1e1,
+    accordion-background-color: $grey-light,
+    hovered-accordion-color: $grey-mid,
+    accordion-font-color: rgba(0, 0, 0, 0.6),
+    accordion-font-color-accent: $grey-dark,
+    main-font-color: $black,
+    hovered-accordion-color-two: #f9f9f9,
+    main-font-color-accent: $black,
+    cursor-color: $grey-light,
+    console-dragger-color: #999,
+    console-dragger-opacity: 0.001,
+    console-dragged-color: #bbb,
+    checkbox-slider-color: #ccc,
+    text-area-color: $white,
+  ),
+  dark: (
+    main-background-color: #292a2f,
+    tabs-color: #252729,
+    selected-tab-color: #252729,
+    top-file-status-color: #252729,
+    accordion-background-color: #3f4045,
+    hovered-accordion-color: #3e4d5c,
+    accordion-font-color: #dfdfe0,
+    accordion-font-color-accent: #ededf2,
+    main-font-color: #dfdfe0,
+    hovered-accordion-color-two: #3f4045,
+    main-font-color-accent: #ededf2,
+    cursor-color: rgb(44,44,44),
+    console-dragger-color: #3f4045,
+    console-dragger-opacity: 1,
+    console-dragged-color: #5a5a62,
+    checkbox-slider-color: #5a5a62,
+    text-area-color: #292a2f,
+  )
+);
+
+@mixin themify($themes) {
+  @each $name, $values in $themes {
+    .#{$name}-theme {
+      $theme-map: $values !global;
+      @content;
+    }
+  }
+}
+@function themed($key) {
+  @return map-get($theme-map, $key);
+}
+
 @import 'reset';
 @import 'fonts';
 
@@ -61,9 +114,28 @@ img {
   display: none;
 }
 
+// color-themed top bar elements
+@include themify($themes) {
+  .upper {
+    background-color: themed('top-file-status-color');
+  }
+  .lm_content {
+    border: 1px solid themed('tabs-color');
+  }
+  .lm_splitter {
+    background-color: themed('console-dragger-color') !important;
+    opacity: themed('console-dragger-opacity');
+    &:hover {
+      background-color: themed('console-dragged-color') !important;
+    }
+  }
+
+
+}
+
 .upper {
-	height: 100%;
-	position: relative;
+  height: 100%;
+  position: relative;
   z-index: 96;
 }
 

From f7c020b5d84698bc996f22215b58d0894d78d606 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Wed, 14 Feb 2024 23:24:37 +0000
Subject: [PATCH 185/188] implemented function to switch editor & css class
 themes

---
 IDE/frontend-dev/src/Views/EditorView.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/IDE/frontend-dev/src/Views/EditorView.js b/IDE/frontend-dev/src/Views/EditorView.js
index 8cc7f5a63..0541902d0 100644
--- a/IDE/frontend-dev/src/Views/EditorView.js
+++ b/IDE/frontend-dev/src/Views/EditorView.js
@@ -338,6 +338,20 @@ class EditorView extends View {
 		currentFile = name;
 	}
 
+	// switch between light and dark theme
+	_darkTheme(isDarkTheme){
+		var body = $('body');
+		if (isDarkTheme) {
+			this.editor.setTheme("ace/theme/xcode_dark");
+			body.toggleClass('light-theme', Boolean(false));
+			body.toggleClass('dark-theme', Boolean(true));
+		} else {
+			this.editor.setTheme("ace/theme/chrome");
+			body.toggleClass('dark-theme', Boolean(false));
+			body.toggleClass('light-theme', Boolean(true));
+		}
+	}
+
 	getCurrentWord(){
 		var pos = this.editor.getCursorPosition();
 		//var range = this.editor.session.getAWordRange(pos.row, pos.column);

From 01d4c9ae53155b0ec1174907e69678f59a4cfcb1 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Wed, 14 Feb 2024 23:25:48 +0000
Subject: [PATCH 186/188] implemented custom xcode dark theme editor

---
 IDE/public/js/ace/theme-xcode_dark.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/IDE/public/js/ace/theme-xcode_dark.js b/IDE/public/js/ace/theme-xcode_dark.js
index 55ad74580..53fcf4d45 100644
--- a/IDE/public/js/ace/theme-xcode_dark.js
+++ b/IDE/public/js/ace/theme-xcode_dark.js
@@ -15,7 +15,6 @@ background: #292A2F;\
 .ace-xcode-dark {\
 display: block;\
 overflow-x: auto;\
-padding: .5em;\
 color: #DFDFE0;\
 background-color: #292A2F;\
 }\

From ac5085aef23e28a0e59b41e259c47e9febf404ec Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Wed, 14 Feb 2024 23:27:48 +0000
Subject: [PATCH 187/188] transpiled css from scss

---
 IDE/public/css/style.css | 353 ++++++++++++++++++++++++++++++++-------
 1 file changed, 295 insertions(+), 58 deletions(-)

diff --git a/IDE/public/css/style.css b/IDE/public/css/style.css
index 674045dff..06facdf6e 100644
--- a/IDE/public/css/style.css
+++ b/IDE/public/css/style.css
@@ -80,6 +80,30 @@ img {
 .hidden {
   display: none; }
 
+.light-theme .upper {
+  background-color: #e1e1e1; }
+
+.light-theme .lm_content {
+  border: 1px solid #c9c9c9; }
+
+.light-theme .lm_splitter {
+  background-color: #999 !important;
+  opacity: 0.001; }
+  .light-theme .lm_splitter:hover {
+    background-color: #bbb !important; }
+
+.dark-theme .upper {
+  background-color: #252729; }
+
+.dark-theme .lm_content {
+  border: 1px solid #252729; }
+
+.dark-theme .lm_splitter {
+  background-color: #3f4045 !important;
+  opacity: 1; }
+  .dark-theme .lm_splitter:hover {
+    background-color: #5a5a62 !important; }
+
 .upper {
   height: 100%;
   position: relative;
@@ -143,11 +167,68 @@ body.uploading {
 ul {
   font-family: inconsolata; }
 
-button.accordion {
+.light-theme button.accordion {
   background-color: #f1f1f1;
+  border-bottom: 2px solid #ffffff;
+  color: rgba(0, 0, 0, 0.6); }
+  .light-theme button.accordion:hover {
+    background: #bdbdbd; }
+  .light-theme button.accordion.active {
+    background-color: #f1f1f1;
+    color: rgba(0, 0, 0, 0.8); }
+    .light-theme button.accordion.active:hover {
+      color: rgba(0, 0, 0, 0.8); }
+  .light-theme button.accordion:after {
+    color: rgba(0, 0, 0, 0.6); }
+
+.light-theme button.accordion-sub {
+  border-bottom: 1px solid #c9c9c9;
+  color: rgba(0, 0, 0, 0.8); }
+  .light-theme button.accordion-sub:hover {
+    color: rgba(0, 0, 0, 0.8); }
+  .light-theme button.accordion-sub.active {
+    color: rgba(0, 0, 0, 0.8); }
+    .light-theme button.accordion-sub.active:hover {
+      color: rgba(0, 0, 0, 0.8); }
+
+.light-theme .docs-content {
+  color: #000; }
+
+.light-theme .panel.show {
+  color: #000; }
+
+.dark-theme button.accordion {
+  background-color: #3f4045;
+  border-bottom: 2px solid #292a2f;
+  color: #dfdfe0; }
+  .dark-theme button.accordion:hover {
+    background: #3e4d5c; }
+  .dark-theme button.accordion.active {
+    background-color: #3f4045;
+    color: #ededf2; }
+    .dark-theme button.accordion.active:hover {
+      color: #ededf2; }
+  .dark-theme button.accordion:after {
+    color: #dfdfe0; }
+
+.dark-theme button.accordion-sub {
+  border-bottom: 1px solid #252729;
+  color: #ededf2; }
+  .dark-theme button.accordion-sub:hover {
+    color: #ededf2; }
+  .dark-theme button.accordion-sub.active {
+    color: #ededf2; }
+    .dark-theme button.accordion-sub.active:hover {
+      color: #ededf2; }
+
+.dark-theme .docs-content {
+  color: #dfdfe0; }
+
+.dark-theme .panel.show {
+  color: #dfdfe0; }
+
+button.accordion {
   border: none;
-  border-bottom: 2px solid #fff;
-  color: rgba(0, 0, 0, 0.6);
   cursor: pointer;
   font-family: poppins_regular;
   font-size: 16px;
@@ -159,20 +240,14 @@ button.accordion {
   transition: 0.25s ease-in-out;
   width: 100%; }
   button.accordion:hover {
-    background: #bdbdbd;
     border-bottom: 2px solid #00bea4; }
   button.accordion.active {
-    background-color: #f1f1f1;
     border-bottom: 2px solid #00bea4;
-    color: rgba(0, 0, 0, 0.8);
     padding: 8px 14px; }
-    button.accordion.active:hover {
-      color: rgba(0, 0, 0, 0.8); }
     button.accordion.active:after {
       content: "\2796";
       /* Unicode character for "minus" sign (-) */ }
   button.accordion:after {
-    color: rgba(0, 0, 0, 0.6);
     content: '\02795';
     /* Unicode character for "plus" sign (+) */
     float: right;
@@ -181,28 +256,22 @@ button.accordion {
 
 button.accordion-sub {
   background: transparent;
-  border-bottom: 1px solid #c9c9c9;
   border-top: 0;
   border-left: 0;
   border-right: 0;
   border-radius: 0;
-  color: rgba(0, 0, 0, 0.8);
   font-size: 1em;
   font-family: 'poppins_regular';
   padding: .4em .8em .25em;
   text-align: left;
   width: 100%; }
   button.accordion-sub:hover {
-    background: rgba(201, 201, 201, 0.2);
-    color: rgba(0, 0, 0, 0.8); }
+    background: rgba(201, 201, 201, 0.2); }
   button.accordion-sub.active {
     background: transparent;
     border-bottom: 2px solid #1ce8b5;
-    color: rgba(0, 0, 0, 0.8);
     padding-bottom: .2em;
     margin-top: .2em; }
-    button.accordion-sub.active:hover {
-      color: rgba(0, 0, 0, 0.8); }
     button.accordion-sub.active:after {
       content: "\2796";
       /* Unicode character for "minus" sign (-) */
@@ -240,6 +309,22 @@ button.accordion-sub {
   /* Whatever you like, as long as its more than the height of the content (on all screen sizes) */
   opacity: 1; }
 
+.light-theme button,
+.light-theme .button {
+  background-color: #ffffff;
+  color: #000; }
+  .light-theme button.create-project:before,
+  .light-theme .button.create-project:before {
+    color: rgba(0, 0, 0, 0.8); }
+
+.dark-theme button,
+.dark-theme .button {
+  background-color: #292a2f;
+  color: #dfdfe0; }
+  .dark-theme button.create-project:before,
+  .dark-theme .button.create-project:before {
+    color: #ededf2; }
+
 a.button {
   color: black;
   font-size: 11px;
@@ -250,9 +335,7 @@ a.button {
 button,
 .button {
   border: 1px solid #00bea4;
-  background-color: #ffffff;
   border-radius: 3px;
-  color: #000;
   font-size: .8em;
   cursor: pointer;
   font-family: poppins_light;
@@ -279,7 +362,6 @@ button,
       color: #ffffff; }
     button.create-project:before,
     .button.create-project:before {
-      color: rgba(0, 0, 0, 0.8);
       content: '+';
       /* Unicode character for "plus" sign (+) */
       font-family: space_bold;
@@ -339,8 +421,15 @@ input[type="range"].range-slider {
     -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.4);
             box-shadow: 0 1px 4px rgba(0, 0, 0, 0.4); }
 
+.light-theme #beaglert-console {
+  background-color: #ffffff;
+  color: #000; }
+
+.dark-theme #beaglert-console {
+  background-color: #292a2f;
+  color: #dfdfe0; }
+
 #beaglert-console {
-  background-color: white;
   -webkit-box-sizing: border-box;
           box-sizing: border-box;
   font-family: inconsolata, monospace;
@@ -608,14 +697,39 @@ input[type="range"].range-slider {
   margin: 0; }
 
 .subsections .examples-header {
-  color: #009587;
+  color: #950000;
   font-family: space_bold;
   font-size: 1.1em;
   margin: .5em; }
 
+.light-theme button.dropbtn {
+  background-color: #ffffff; }
+
+.light-theme .dropdown-content {
+  background-color: #f9f9f9; }
+  .light-theme .dropdown-content select option {
+    color: #000; }
+  .light-theme .dropdown-content ul > li, .light-theme .dropdown-content ul span, .light-theme .dropdown-content ul a {
+    color: #000; }
+    .light-theme .dropdown-content ul > li:hover, .light-theme .dropdown-content ul span:hover, .light-theme .dropdown-content ul a:hover {
+      background-color: #f1f1f1;
+      color: #000; }
+
+.dark-theme button.dropbtn {
+  background-color: #252729; }
+
+.dark-theme .dropdown-content {
+  background-color: #3f4045; }
+  .dark-theme .dropdown-content select option {
+    color: #dfdfe0; }
+  .dark-theme .dropdown-content ul > li, .dark-theme .dropdown-content ul span, .dark-theme .dropdown-content ul a {
+    color: #dfdfe0; }
+    .dark-theme .dropdown-content ul > li:hover, .dark-theme .dropdown-content ul span:hover, .dark-theme .dropdown-content ul a:hover {
+      background-color: #2c2c2c;
+      color: #ededf2; }
+
 /* Dropdown Button */
 button.dropbtn {
-  background-color: #fff;
   border: 1px solid #00bea4;
   color: #00bea4;
   cursor: pointer;
@@ -677,7 +791,6 @@ select.dropdown-num {
 
 /* Dropdown content (hidden by default) */
 .dropdown-content {
-  background-color: #f9f9f9;
   -webkit-box-shadow: 0px 8px 16px 0px rgba(0, 0, 0, 0.2);
           box-shadow: 0px 8px 16px 0px rgba(0, 0, 0, 0.2);
   display: none;
@@ -695,7 +808,6 @@ select.dropdown-num {
     padding-top: 0;
     width: 200px; }
     .dropdown-content select option {
-      color: black;
       cursor: pointer;
       display: block;
       font-family: poppins_regular;
@@ -724,7 +836,6 @@ select.dropdown-num {
           -ms-user-select: none;
               user-select: none; }
     .dropdown-content ul > li, .dropdown-content ul span, .dropdown-content ul a {
-      color: black;
       cursor: pointer;
       display: block;
       font-family: poppins_regular;
@@ -732,12 +843,15 @@ select.dropdown-num {
       opacity: 1;
       padding: 8px 16px;
       text-decoration: none; }
-      .dropdown-content ul > li:hover, .dropdown-content ul span:hover, .dropdown-content ul a:hover {
-        background-color: #f1f1f1;
-        color: rgba(0, 0, 0, 0.9); }
   .dropdown-content.show {
     display: block; }
 
+.light-theme .mini-dropdown select {
+  color: rgba(0, 0, 0, 0.6); }
+
+.dark-theme .mini-dropdown select {
+  color: #dfdfe0; }
+
 .mini-dropdown select {
   -moz-appearance: none;
   -webkit-appearance: none;
@@ -785,8 +899,13 @@ select.dropdown-num {
   .mini-dropdown.disabled:after {
     color: rgba(0, 0, 0, 0.4); }
 
+.light-theme {
+  background: #ffffff; }
+
+.dark-theme {
+  background: #292a2f; }
+
 #editor {
-  background: #fff;
   display: none;
   float: left;
   height: calc(100% - 70px);
@@ -982,6 +1101,12 @@ img.explorer {
   img.explorer:hover {
     background: url("images/icons/explorer_green.svg"); }
 
+.light-theme ul .libraries-list li {
+  color: rgba(0, 0, 0, 0.8); }
+
+.dark-theme ul .libraries-list li {
+  color: #ededf2; }
+
 ul.libraries-list-parent {
   list-style: none;
   margin: 0;
@@ -1044,7 +1169,6 @@ ul.libraries-list-parent {
             margin-block-end: 0;
     margin: .5em 0 0 .5em; }
   ul.libraries-list-parent .libraries-list li {
-    color: rgba(0, 0, 0, 0.8);
     cursor: pointer;
     font-family: inconsolata;
     font-size: 14px;
@@ -1183,6 +1307,18 @@ ul dl {
     fill: rgba(0, 255, 0, 0.6);
     stroke: none; }
 
+.light-theme #popup {
+  background: #ffffff; }
+
+.light-theme button.cancel {
+  background: #ffffff; }
+
+.dark-theme #popup {
+  background: #252729; }
+
+.dark-theme button.cancel {
+  background: #252729; }
+
 #popup-nointeraction {
   display: none;
   height: 100vh;
@@ -1294,7 +1430,6 @@ ul dl {
       #popup button.confirm.button-disabled {
         background: #bdbdbd; }
     #popup button.cancel {
-      background: #ffffff;
       border: 1px solid #bdbdbd; }
       #popup button.cancel:hover {
         background: #e5e5e5;
@@ -1329,9 +1464,30 @@ ul dl {
   border-radius: 10px;
   -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.5); }
 
+.light-theme #tab-menu {
+  background-color: #c9c9c9; }
+
+.light-theme #tab-content-area {
+  background-color: #ffffff; }
+
+.light-theme section#tab-content .title-container {
+  background-color: #ffffff; }
+  .light-theme section#tab-content .title-container h1 {
+    color: rgba(0, 0, 0, 0.8); }
+
+.dark-theme #tab-menu {
+  background-color: #252729; }
+
+.dark-theme #tab-content-area {
+  background-color: #292a2f; }
+
+.dark-theme section#tab-content .title-container {
+  background-color: #292a2f; }
+  .dark-theme section#tab-content .title-container h1 {
+    color: #ededf2; }
+
 /* Tabbed content */
 .tabs {
-  background-color: white;
   height: calc(100% + 35px);
   left: calc(100% - 50px);
   position: absolute;
@@ -1350,13 +1506,11 @@ ul dl {
   left: calc(100% - 438px); }
 
 #tab-menu {
-  background-color: #c9c9c9;
   float: left;
   height: 100%;
   width: 50px; }
 
 #tab-content-area {
-  background-color: #fff;
   height: calc(100% - 76px);
   overflow: auto; }
 
@@ -1367,7 +1521,6 @@ section#tab-content {
   section#tab-content .tab-info {
     display: none; }
   section#tab-content .title-container {
-    background-color: #ffffff;
     height: 75px;
     position: sticky;
     position: -webkit-sticky;
@@ -1380,7 +1533,6 @@ section#tab-content {
       background: transparent; }
     section#tab-content .title-container h1 {
       border-bottom: 10px solid #1ce8b5;
-      color: rgba(0, 0, 0, 0.8);
       display: inline-block;
       font-family: space_bold;
       font-size: 24px;
@@ -1389,8 +1541,41 @@ section#tab-content {
 .disabled {
   display: none; }
 
+.light-theme .choice {
+  color: rgba(0, 0, 0, 0.6); }
+
+.light-theme p.project {
+  color: #000; }
+
+.light-theme .project-actions > .project-text {
+  color: rgba(0, 0, 0, 0.8); }
+
+.light-theme input[type="checkbox"].checkbox-slider::before,
+.light-theme .checkbox-slider input[type="checkbox"]::before {
+  background: #ccc; }
+
+.light-theme textarea {
+  background-color: #ffffff;
+  color: #000; }
+
+.dark-theme .choice {
+  color: #dfdfe0; }
+
+.dark-theme p.project {
+  color: #dfdfe0; }
+
+.dark-theme .project-actions > .project-text {
+  color: #ededf2; }
+
+.dark-theme input[type="checkbox"].checkbox-slider::before,
+.dark-theme .checkbox-slider input[type="checkbox"]::before {
+  background: #5a5a62; }
+
+.dark-theme textarea {
+  background-color: #292a2f;
+  color: #dfdfe0; }
+
 .choice {
-  color: rgba(0, 0, 0, 0.6);
   font-family: poppins_light;
   font-size: 12px;
   padding-bottom: 10px; }
@@ -1461,7 +1646,6 @@ input[type="checkbox"].checkbox-slider,
     position: absolute; }
   input[type="checkbox"].checkbox-slider::before,
   .checkbox-slider input[type="checkbox"]::before {
-    background: #ccc;
     border-radius: 18px;
     height: 18px;
     -webkit-transition: background-color 200ms;
@@ -1530,7 +1714,6 @@ p.project {
   .project-actions > .project-text {
     display: inline;
     font-family: 'inconsolata';
-    color: rgba(0, 0, 0, 0.8);
     font-size: .85em;
     position: absolute;
     top: 0;
@@ -1619,17 +1802,55 @@ p.project {
     .tab-info button.feedback.bug:hover {
       background-color: #ff5e5b; }
 
+.light-theme #tab-menu li#open-tab {
+  background-color: #c9c9c9; }
+
+.light-theme #tab-menu li {
+  background: #c9c9c9; }
+  .light-theme #tab-menu li.explorer.active {
+    background: #ffffff url("../images/icons/folder_active.svg") no-repeat center; }
+  .light-theme #tab-menu li.examples.active {
+    background: #ffffff url("../images/icons/examples_active.svg") no-repeat center; }
+  .light-theme #tab-menu li.settings.active {
+    background: #ffffff url("../images/icons/settings_active.svg") no-repeat center; }
+  .light-theme #tab-menu li.pins.active {
+    background: #ffffff url("../images/icons/pins_active.svg") no-repeat center; }
+  .light-theme #tab-menu li.refs.active {
+    background: #ffffff url("../images/icons/refs_active.svg") no-repeat center; }
+  .light-theme #tab-menu li.libraries.active {
+    background: #ffffff url("../images/icons/library_green.svg") no-repeat center; }
+  .light-theme #tab-menu li.feedback.active {
+    background: #ffffff url("../images/icons/feedback_active.svg") no-repeat center; }
+
+.dark-theme #tab-menu li#open-tab {
+  background-color: #252729; }
+
+.dark-theme #tab-menu li {
+  background: #252729; }
+  .dark-theme #tab-menu li.explorer.active {
+    background: #252729 url("../images/icons/folder_active.svg") no-repeat center; }
+  .dark-theme #tab-menu li.examples.active {
+    background: #252729 url("../images/icons/examples_active.svg") no-repeat center; }
+  .dark-theme #tab-menu li.settings.active {
+    background: #252729 url("../images/icons/settings_active.svg") no-repeat center; }
+  .dark-theme #tab-menu li.pins.active {
+    background: #252729 url("../images/icons/pins_active.svg") no-repeat center; }
+  .dark-theme #tab-menu li.refs.active {
+    background: #252729 url("../images/icons/refs_active.svg") no-repeat center; }
+  .dark-theme #tab-menu li.libraries.active {
+    background: #252729 url("../images/icons/library_green.svg") no-repeat center; }
+  .dark-theme #tab-menu li.feedback.active {
+    background: #252729 url("../images/icons/feedback_active.svg") no-repeat center; }
+
 /*
  * Make each label stack on top of one another.
  *
  */
 #tab-menu li#open-tab {
-  background-color: #c9c9c9;
   max-width: 40px;
   padding-left: 10px; }
 
 #tab-menu li {
-  background: #c9c9c9;
   cursor: pointer;
   height: 50px;
   padding: 0;
@@ -1650,44 +1871,31 @@ p.project {
     background: url("../images/icons/folder_inactive.svg") no-repeat center; }
     #tab-menu li.explorer:hover {
       background: url("../images/icons/folder_active.svg") no-repeat center; }
-    #tab-menu li.explorer.active {
-      background: #ffffff url("../images/icons/folder_active.svg") no-repeat center; }
   #tab-menu li.examples {
     background: url("../images/icons/examples_inactive.svg") no-repeat center; }
     #tab-menu li.examples:hover {
       background: url("../images/icons/examples_active.svg") no-repeat center; }
-    #tab-menu li.examples.active {
-      background: #ffffff url("../images/icons/examples_active.svg") no-repeat center; }
   #tab-menu li.settings {
     background: url("../images/icons/settings_inactive.svg") no-repeat center; }
     #tab-menu li.settings:hover {
       background: url("../images/icons/settings_active.svg") no-repeat center; }
-    #tab-menu li.settings.active {
-      background: #ffffff url("../images/icons/settings_active.svg") no-repeat center; }
   #tab-menu li.pins {
     background: url("../images/icons/pins_inactive.svg") no-repeat center; }
     #tab-menu li.pins:hover {
       background: url("../images/icons/pins_active.svg") no-repeat center; }
-    #tab-menu li.pins.active {
-      background: #ffffff url("../images/icons/pins_active.svg") no-repeat center; }
   #tab-menu li.refs {
     background: url("../images/icons/refs_inactive.svg") no-repeat center; }
     #tab-menu li.refs:hover {
       background: url("../images/icons/refs_active.svg") no-repeat center; }
-    #tab-menu li.refs.active {
-      background: #ffffff url("../images/icons/refs_active.svg") no-repeat center; }
   #tab-menu li.libraries {
     background: url("../images/icons/library_white.svg") no-repeat center; }
     #tab-menu li.libraries:hover {
       background: url("../images/icons/library_green.svg") no-repeat center; }
-    #tab-menu li.libraries.active {
-      background: #ffffff url("../images/icons/library_green.svg") no-repeat center; }
   #tab-menu li.feedback {
     background: url("../images/icons/feedback_inactive.svg") no-repeat center; }
     #tab-menu li.feedback:hover {
       background: url("../images/icons/feedback_active.svg") no-repeat center; }
     #tab-menu li.feedback.active {
-      background: #ffffff url("../images/icons/feedback_active.svg") no-repeat center;
       border-left: 5px solid #ff5e5b; }
   #tab-menu li.active {
     background: #ffffff;
@@ -1718,11 +1926,20 @@ p.project {
 .tab-content-area {
   display: none; }
 
+.light-theme input[type="text"],
+.light-theme input[type="number"] {
+  background: #ffffff;
+  color: #000; }
+
+.dark-theme input[type="text"],
+.dark-theme input[type="number"] {
+  background: #292a2f;
+  color: #ededf2; }
+
 input[type="text"],
 input[type="number"] {
   height: 25px;
-  border: 1px solid #bdbdbd;
-  background: #ffffff; }
+  border: 1px solid #bdbdbd; }
   input[type="text"].number-picker,
   input[type="number"].number-picker {
     border-radius: 0;
@@ -1732,6 +1949,20 @@ input[type="number"] {
   input[type="number"]:disabled {
     background: #f1f1f1; }
 
+.light-theme .toolbar {
+  background: #c9c9c9; }
+  .light-theme .toolbar .tool-text {
+    color: #000; }
+  .light-theme .toolbar .system-status-text {
+    color: #000 !important; }
+
+.dark-theme .toolbar {
+  background: #252729; }
+  .dark-theme .toolbar .tool-text {
+    color: #dfdfe0; }
+  .dark-theme .toolbar .system-status-text {
+    color: #dfdfe0 !important; }
+
 @-webkit-keyframes running-button {
   from {
     -webkit-transform: rotate(0deg);
@@ -1757,7 +1988,6 @@ input[type="number"] {
           animation: running-button 2s linear infinite; }
 
 .toolbar {
-  background: #c9c9c9;
   bottom: 0;
   -webkit-box-shadow: 5px 5px #eee;
           box-shadow: 5px 5px #eee;
@@ -1864,6 +2094,14 @@ input[type="number"] {
       margin-top: -14px;
       padding-right: 2.3em; }
 
+.light-theme .file-status .current {
+  color: rgba(0, 0, 0, 0.6);
+  background-color: #e1e1e1; }
+
+.dark-theme .file-status .current {
+  color: #dfdfe0;
+  background-color: #252729; }
+
 .file-status {
   margin-left: 60px;
   white-space: nowrap; }
@@ -1898,7 +2136,6 @@ input[type="number"] {
         display: inline-block; }
   .file-status .current {
     font-family: poppins_regular;
-    color: rgba(0, 0, 0, 0.7);
     padding-right: 20px;
     font-size: 12px; }
 

From fe7dabbe6a658addcb3f20cf362151c60046f2f0 Mon Sep 17 00:00:00 2001
From: Laimonade <leo.aimone94500@gmail.com>
Date: Wed, 14 Feb 2024 23:28:18 +0000
Subject: [PATCH 188/188] transpiled js from gulp

---
 IDE/public/js/bundle.js | 37 ++++++++++++++++++-------------------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/IDE/public/js/bundle.js b/IDE/public/js/bundle.js
index 3324b3a1a..f16f8bc48 100644
--- a/IDE/public/js/bundle.js
+++ b/IDE/public/js/bundle.js
@@ -2179,25 +2179,6 @@ var EditorView = function (_View) {
 				this.__focus(opts.focus);
 			}
 		}
-		// editor theme has changed
-
-	}, {
-		key: '_darkTheme',
-		value: function _darkTheme(value) {
-			var isDarkTheme = parseInt(value)
-			var body = $('body');
-
-			if (isDarkTheme) {
-				this.editor.setTheme("ace/theme/xcode_dark");
-				// this.editor.setTheme("ace/theme/monokai");
-				body.toggleClass('light-theme', Boolean(false));
-				body.toggleClass('dark-theme', Boolean(true));
-			} else {
-				this.editor.setTheme("ace/theme/chrome");
-				body.toggleClass('dark-theme', Boolean(false));
-				body.toggleClass('light-theme', Boolean(true));
-			}
-		}
 		// editor focus has changed
 
 	}, {
@@ -2269,6 +2250,24 @@ var EditorView = function (_View) {
 		value: function _fileName(name, data) {
 			currentFile = name;
 		}
+
+		// switch between light and dark theme
+
+	}, {
+		key: '_darkTheme',
+		value: function _darkTheme(isDarkTheme) {
+			var body = $('body');
+			if (isDarkTheme) {
+				this.editor.setTheme("ace/theme/xcode_dark");
+				// this.editor.setTheme("ace/theme/monokai");
+				body.toggleClass('light-theme', Boolean(false));
+				body.toggleClass('dark-theme', Boolean(true));
+			} else {
+				this.editor.setTheme("ace/theme/chrome");
+				body.toggleClass('dark-theme', Boolean(false));
+				body.toggleClass('light-theme', Boolean(true));
+			}
+		}
 	}, {
 		key: 'getCurrentWord',
 		value: function getCurrentWord() {