sdfsdfs

node_modules/pixi.js/lib/assets/loader/Loader.d.ts

@@ -0,0 +1,67 @@
+import type { ResolvedAsset } from '../types';
+import type { LoaderParser } from './parsers/LoaderParser';
+import type { PromiseAndParser } from './types';
+/**
+ * The Loader is responsible for loading all assets, such as images, spritesheets, audio files, etc.
+ * It does not do anything clever with URLs - it just loads stuff!
+ * Behind the scenes all things are cached using promises. This means it's impossible to load an asset more than once.
+ * Through the use of LoaderParsers, the loader can understand how to load any kind of file!
+ *
+ * It is not intended that this class is created by developers - its part of the Asset class
+ * This is the second major system of PixiJS' main Assets class
+ * @memberof assets
+ */
+export declare class Loader {
+    private readonly _parsers;
+    private _parserHash;
+    private _parsersValidated;
+    /**
+     * All loader parsers registered
+     * @type {assets.LoaderParser[]}
+     */
+    parsers: LoaderParser<any, any, Record<string, any>>[];
+    /** Cache loading promises that ae currently active */
+    promiseCache: Record<string, PromiseAndParser>;
+    /** function used for testing */
+    reset(): void;
+    /**
+     * Used internally to generate a promise for the asset to be loaded.
+     * @param url - The URL to be loaded
+     * @param data - any custom additional information relevant to the asset being loaded
+     * @returns - a promise that will resolve to an Asset for example a Texture of a JSON object
+     */
+    private _getLoadPromiseAndParser;
+    /**
+     * Loads one or more assets using the parsers added to the Loader.
+     * @example
+     * // Single asset:
+     * const asset = await Loader.load('cool.png');
+     * console.log(asset);
+     *
+     * // Multiple assets:
+     * const assets = await Loader.load(['cool.png', 'cooler.png']);
+     * console.log(assets);
+     * @param assetsToLoadIn - urls that you want to load, or a single one!
+     * @param onProgress - For multiple asset loading only, an optional function that is called
+     * when progress on asset loading is made. The function is passed a single parameter, `progress`,
+     * which represents the percentage (0.0 - 1.0) of the assets loaded. Do not use this function
+     * to detect when assets are complete and available, instead use the Promise returned by this function.
+     */
+    load<T = any>(assetsToLoadIn: string | ResolvedAsset, onProgress?: (progress: number) => void): Promise<T>;
+    load<T = any>(assetsToLoadIn: string[] | ResolvedAsset[], onProgress?: (progress: number) => void): Promise<Record<string, T>>;
+    /**
+     * Unloads one or more assets. Any unloaded assets will be destroyed, freeing up memory for your app.
+     * The parser that created the asset, will be the one that unloads it.
+     * @example
+     * // Single asset:
+     * const asset = await Loader.load('cool.png');
+     *
+     * await Loader.unload('cool.png');
+     *
+     * console.log(asset.destroyed); // true
+     * @param assetsToUnloadIn - urls that you want to unload, or a single one!
+     */
+    unload(assetsToUnloadIn: string | string[] | ResolvedAsset | ResolvedAsset[]): Promise<void>;
+    /** validates our parsers, right now it only checks for name conflicts but we can add more here as required! */
+    private _validateParsers;
+}

node_modules/pixi.js/lib/assets/loader/Loader.js

@@ -0,0 +1,157 @@
+'use strict';
+
+var warn = require('../../utils/logging/warn.js');
+var path = require('../../utils/path.js');
+var convertToList = require('../utils/convertToList.js');
+var isSingleItem = require('../utils/isSingleItem.js');
+
+"use strict";
+class Loader {
+  constructor() {
+    this._parsers = [];
+    this._parsersValidated = false;
+    /**
+     * All loader parsers registered
+     * @type {assets.LoaderParser[]}
+     */
+    this.parsers = new Proxy(this._parsers, {
+      set: (target, key, value) => {
+        this._parsersValidated = false;
+        target[key] = value;
+        return true;
+      }
+    });
+    /** Cache loading promises that ae currently active */
+    this.promiseCache = {};
+  }
+  /** function used for testing */
+  reset() {
+    this._parsersValidated = false;
+    this.promiseCache = {};
+  }
+  /**
+   * Used internally to generate a promise for the asset to be loaded.
+   * @param url - The URL to be loaded
+   * @param data - any custom additional information relevant to the asset being loaded
+   * @returns - a promise that will resolve to an Asset for example a Texture of a JSON object
+   */
+  _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) {
+          warn.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) {
+          warn.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.isSingleItem(assetsToLoadIn);
+    const assetsToLoad = convertToList.convertToList(assetsToLoadIn, (item) => ({
+      alias: [item],
+      src: item,
+      data: {}
+    }));
+    const total = assetsToLoad.length;
+    const promises = assetsToLoad.map(async (asset) => {
+      const url = path.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;
+  }
+  /**
+   * Unloads one or more assets. Any unloaded assets will be destroyed, freeing up memory for your app.
+   * The parser that created the asset, will be the one that unloads it.
+   * @example
+   * // Single asset:
+   * const asset = await Loader.load('cool.png');
+   *
+   * await Loader.unload('cool.png');
+   *
+   * console.log(asset.destroyed); // true
+   * @param assetsToUnloadIn - urls that you want to unload, or a single one!
+   */
+  async unload(assetsToUnloadIn) {
+    const assetsToUnload = convertToList.convertToList(assetsToUnloadIn, (item) => ({
+      alias: [item],
+      src: item
+    }));
+    const promises = assetsToUnload.map(async (asset) => {
+      const url = path.path.toAbsolute(asset.src);
+      const loadPromise = this.promiseCache[url];
+      if (loadPromise) {
+        const loadedAsset = await loadPromise.promise;
+        delete this.promiseCache[url];
+        await loadPromise.parser?.unload?.(loadedAsset, asset, this);
+      }
+    });
+    await Promise.all(promises);
+  }
+  /** validates our parsers, right now it only checks for name conflicts but we can add more here as required! */
+  _validateParsers() {
+    this._parsersValidated = true;
+    this._parserHash = this._parsers.filter((parser) => parser.name).reduce((hash, parser) => {
+      if (!parser.name) {
+        warn.warn(`[Assets] loadParser should have a name`);
+      } else if (hash[parser.name]) {
+        warn.warn(`[Assets] loadParser name conflict "${parser.name}"`);
+      }
+      return { ...hash, [parser.name]: parser };
+    }, {});
+  }
+}
+
+exports.Loader = Loader;
+//# sourceMappingURL=Loader.js.map

node_modules/pixi.js/lib/assets/loader/Loader.mjs

@@ -0,0 +1,155 @@
+import { warn } from '../../utils/logging/warn.mjs';
+import { path } from '../../utils/path.mjs';
+import { convertToList } from '../utils/convertToList.mjs';
+import { isSingleItem } from '../utils/isSingleItem.mjs';
+
+"use strict";
+class Loader {
+  constructor() {
+    this._parsers = [];
+    this._parsersValidated = false;
+    /**
+     * All loader parsers registered
+     * @type {assets.LoaderParser[]}
+     */
+    this.parsers = new Proxy(this._parsers, {
+      set: (target, key, value) => {
+        this._parsersValidated = false;
+        target[key] = value;
+        return true;
+      }
+    });
+    /** Cache loading promises that ae currently active */
+    this.promiseCache = {};
+  }
+  /** function used for testing */
+  reset() {
+    this._parsersValidated = false;
+    this.promiseCache = {};
+  }
+  /**
+   * Used internally to generate a promise for the asset to be loaded.
+   * @param url - The URL to be loaded
+   * @param data - any custom additional information relevant to the asset being loaded
+   * @returns - a promise that will resolve to an Asset for example a Texture of a JSON object
+   */
+  _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) {
+          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) {
+          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) => ({
+      alias: [item],
+      src: item,
+      data: {}
+    }));
+    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;
+  }
+  /**
+   * Unloads one or more assets. Any unloaded assets will be destroyed, freeing up memory for your app.
+   * The parser that created the asset, will be the one that unloads it.
+   * @example
+   * // Single asset:
+   * const asset = await Loader.load('cool.png');
+   *
+   * await Loader.unload('cool.png');
+   *
+   * console.log(asset.destroyed); // true
+   * @param assetsToUnloadIn - urls that you want to unload, or a single one!
+   */
+  async unload(assetsToUnloadIn) {
+    const assetsToUnload = convertToList(assetsToUnloadIn, (item) => ({
+      alias: [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;
+        delete this.promiseCache[url];
+        await loadPromise.parser?.unload?.(loadedAsset, asset, this);
+      }
+    });
+    await Promise.all(promises);
+  }
+  /** validates our parsers, right now it only checks for name conflicts but we can add more here as required! */
+  _validateParsers() {
+    this._parsersValidated = true;
+    this._parserHash = this._parsers.filter((parser) => parser.name).reduce((hash, parser) => {
+      if (!parser.name) {
+        warn(`[Assets] loadParser should have a name`);
+      } else if (hash[parser.name]) {
+        warn(`[Assets] loadParser name conflict "${parser.name}"`);
+      }
+      return { ...hash, [parser.name]: parser };
+    }, {});
+  }
+}
+
+export { Loader };
+//# sourceMappingURL=Loader.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/LoaderParser.d.ts

@@ -0,0 +1,86 @@
+import type { ExtensionMetadata } from '../../../extensions/Extensions';
+import type { ResolvedAsset } from '../../types';
+import type { Loader } from '../Loader';
+/**
+ * The extension priority for loader parsers.
+ * Helpful when managing multiple parsers that share the same extension test.
+ * The higher priority parsers will be checked first.
+ * @enum {number}
+ */
+export declare enum LoaderParserPriority {
+    /** Generic parsers: txt, json, webfonts */
+    Low = 0,
+    /** PixiJS assets with generic extensions: spritesheets, bitmapfonts  */
+    Normal = 1,
+    /** Specific texture types: svg, png, ktx, dds, basis */
+    High = 2
+}
+/** A more verbose version of the LoaderParser, allowing you to set the loaded, parsed, and unloaded asset separately */
+export interface LoaderParserAdvanced<ASSET = any, PARSED_ASSET = ASSET, UNLOAD_ASSET = ASSET, META_DATA = any, CONFIG = Record<string, any>> {
+    /** Should be ExtensionType.LoaderParser */
+    extension?: ExtensionMetadata;
+    /** A config to adjust the parser */
+    config?: CONFIG;
+    /** The name of the parser (this can be used when specifying loadParser in a ResolvedAsset) */
+    name: string;
+    /**
+     * Each URL to load will be tested here,
+     * if the test is passed the assets are loaded using the load function below.
+     * Good place to test for things like file extensions!
+     * @param url - The URL to test
+     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded
+     * @param loader - The loader instance
+     */
+    test?: (url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => boolean;
+    /**
+     * This is the promise that loads the URL provided
+     * resolves with a loaded asset if returned by the parser.
+     * @param url - The URL to load
+     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded
+     * @param loader - The loader instance
+     */
+    load?: <T>(url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<ASSET | T>;
+    /**
+     * This function is used to test if the parse function should be run on the asset
+     * If this returns true then parse is called with the asset
+     * @param asset - The loaded asset data
+     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded
+     * @param loader - The loader instance
+     */
+    testParse?: (asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<boolean>;
+    /**
+     * Gets called on the asset it testParse passes. Useful to convert a raw asset into something more useful
+     * @param asset - The loaded asset data
+     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded
+     * @param loader - The loader instance
+     */
+    parse?: <T>(asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<PARSED_ASSET | T>;
+    /**
+     * If an asset is parsed using this parser, the unload function will be called when the user requests an asset
+     * to be unloaded. This is useful for things like sounds or textures that can be unloaded from memory
+     * @param asset - The asset to unload/destroy
+     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded
+     * @param loader - The loader instance
+     */
+    unload?: (asset: UNLOAD_ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<void> | void;
+}
+/**
+ * The interface to define a loader parser *(all functions are optional)*.
+ *
+ * When you create a `parser` object, the flow for every asset loaded is:
+ *
+ * 1. `parser.test()` - Each URL to load will be tested here, if the test is passed the assets are
+ * loaded using the load function below. Good place to test for things like file extensions!
+ * 2. `parser.load()` - This is the promise that loads the URL provided resolves with a loaded asset
+ * if returned by the parser.
+ * 3. `parser.testParse()` - This function is used to test if the parse function should be run on the
+ *  asset If this returns true then parse is called with the asset
+ * 4. `parse.parse()` - Gets called on the asset it testParse passes. Useful to convert a raw asset
+ *  into something more useful
+ *
+ * <br/>
+ * Some loaders may only be used for parsing, some only for loading, and some for both!
+ * @memberof assets
+ */
+export interface LoaderParser<ASSET = any, META_DATA = any, CONFIG = Record<string, any>> extends LoaderParserAdvanced<ASSET, ASSET, ASSET, META_DATA, CONFIG> {
+}

node_modules/pixi.js/lib/assets/loader/parsers/LoaderParser.js

@@ -0,0 +1,12 @@
+'use strict';
+
+"use strict";
+var LoaderParserPriority = /* @__PURE__ */ ((LoaderParserPriority2) => {
+  LoaderParserPriority2[LoaderParserPriority2["Low"] = 0] = "Low";
+  LoaderParserPriority2[LoaderParserPriority2["Normal"] = 1] = "Normal";
+  LoaderParserPriority2[LoaderParserPriority2["High"] = 2] = "High";
+  return LoaderParserPriority2;
+})(LoaderParserPriority || {});
+
+exports.LoaderParserPriority = LoaderParserPriority;
+//# sourceMappingURL=LoaderParser.js.map

node_modules/pixi.js/lib/assets/loader/parsers/LoaderParser.mjs

@@ -0,0 +1,10 @@
+"use strict";
+var LoaderParserPriority = /* @__PURE__ */ ((LoaderParserPriority2) => {
+  LoaderParserPriority2[LoaderParserPriority2["Low"] = 0] = "Low";
+  LoaderParserPriority2[LoaderParserPriority2["Normal"] = 1] = "Normal";
+  LoaderParserPriority2[LoaderParserPriority2["High"] = 2] = "High";
+  return LoaderParserPriority2;
+})(LoaderParserPriority || {});
+
+export { LoaderParserPriority };
+//# sourceMappingURL=LoaderParser.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/loadJson.d.ts

@@ -0,0 +1,15 @@
+import { ExtensionType } from '../../../extensions/Extensions';
+import { LoaderParserPriority } from './LoaderParser';
+/**
+ * A simple loader plugin for loading json data
+ * @memberof assets
+ */
+export declare const loadJson: {
+    extension: {
+        type: ExtensionType.LoadParser;
+        priority: LoaderParserPriority;
+    };
+    name: string;
+    test(url: string): boolean;
+    load<T>(url: string): Promise<T>;
+};

node_modules/pixi.js/lib/assets/loader/parsers/loadJson.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var adapter = require('../../../environment/adapter.js');
+var Extensions = require('../../../extensions/Extensions.js');
+var checkDataUrl = require('../../utils/checkDataUrl.js');
+var checkExtension = require('../../utils/checkExtension.js');
+var LoaderParser = require('./LoaderParser.js');
+
+"use strict";
+const validJSONExtension = ".json";
+const validJSONMIME = "application/json";
+const loadJson = {
+  extension: {
+    type: Extensions.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.Low
+  },
+  name: "loadJson",
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validJSONMIME) || checkExtension.checkExtension(url, validJSONExtension);
+  },
+  async load(url) {
+    const response = await adapter.DOMAdapter.get().fetch(url);
+    const json = await response.json();
+    return json;
+  }
+};
+
+exports.loadJson = loadJson;
+//# sourceMappingURL=loadJson.js.map

node_modules/pixi.js/lib/assets/loader/parsers/loadJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadJson.js","sources":["../../../../src/assets/loader/parsers/loadJson.ts"],"sourcesContent":["import { DOMAdapter } from '../../../environment/adapter';\nimport { ExtensionType } from '../../../extensions/Extensions';\nimport { checkDataUrl } from '../../utils/checkDataUrl';\nimport { checkExtension } from '../../utils/checkExtension';\nimport { LoaderParserPriority } from './LoaderParser';\n\nimport type { LoaderParser } from './LoaderParser';\n\nconst validJSONExtension = '.json';\nconst validJSONMIME = 'application/json';\n\n/**\n * A simple loader plugin for loading json data\n * @memberof assets\n */\nexport const loadJson = {\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.Low,\n    },\n\n    name: 'loadJson',\n\n    test(url: string): boolean\n    {\n        return checkDataUrl(url, validJSONMIME) || checkExtension(url, validJSONExtension);\n    },\n\n    async load<T>(url: string): Promise<T>\n    {\n        const response = await DOMAdapter.get().fetch(url);\n\n        const json = await response.json();\n\n        return json as T;\n    },\n} satisfies LoaderParser<string>;\n"],"names":["ExtensionType","LoaderParserPriority","checkDataUrl","checkExtension","DOMAdapter"],"mappings":";;;;;;;;;AAQA,MAAM,kBAAqB,GAAA,OAAA,CAAA;AAC3B,MAAM,aAAgB,GAAA,kBAAA,CAAA;AAMf,MAAM,QAAW,GAAA;AAAA,EACpB,SAAW,EAAA;AAAA,IACP,MAAMA,wBAAc,CAAA,UAAA;AAAA,IACpB,UAAUC,iCAAqB,CAAA,GAAA;AAAA,GACnC;AAAA,EAEA,IAAM,EAAA,UAAA;AAAA,EAEN,KAAK,GACL,EAAA;AACI,IAAA,OAAOC,0BAAa,GAAK,EAAA,aAAa,CAAK,IAAAC,6BAAA,CAAe,KAAK,kBAAkB,CAAA,CAAA;AAAA,GACrF;AAAA,EAEA,MAAM,KAAQ,GACd,EAAA;AACI,IAAA,MAAM,WAAW,MAAMC,kBAAA,CAAW,GAAI,EAAA,CAAE,MAAM,GAAG,CAAA,CAAA;AAEjD,IAAM,MAAA,IAAA,GAAO,MAAM,QAAA,CAAS,IAAK,EAAA,CAAA;AAEjC,IAAO,OAAA,IAAA,CAAA;AAAA,GACX;AACJ;;;;"}

node_modules/pixi.js/lib/assets/loader/parsers/loadJson.mjs

@@ -0,0 +1,27 @@
+import { DOMAdapter } from '../../../environment/adapter.mjs';
+import { ExtensionType } from '../../../extensions/Extensions.mjs';
+import { checkDataUrl } from '../../utils/checkDataUrl.mjs';
+import { checkExtension } from '../../utils/checkExtension.mjs';
+import { LoaderParserPriority } from './LoaderParser.mjs';
+
+"use strict";
+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 DOMAdapter.get().fetch(url);
+    const json = await response.json();
+    return json;
+  }
+};
+
+export { loadJson };
+//# sourceMappingURL=loadJson.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/loadJson.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadJson.mjs","sources":["../../../../src/assets/loader/parsers/loadJson.ts"],"sourcesContent":["import { DOMAdapter } from '../../../environment/adapter';\nimport { ExtensionType } from '../../../extensions/Extensions';\nimport { checkDataUrl } from '../../utils/checkDataUrl';\nimport { checkExtension } from '../../utils/checkExtension';\nimport { LoaderParserPriority } from './LoaderParser';\n\nimport type { LoaderParser } from './LoaderParser';\n\nconst validJSONExtension = '.json';\nconst validJSONMIME = 'application/json';\n\n/**\n * A simple loader plugin for loading json data\n * @memberof assets\n */\nexport const loadJson = {\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.Low,\n    },\n\n    name: 'loadJson',\n\n    test(url: string): boolean\n    {\n        return checkDataUrl(url, validJSONMIME) || checkExtension(url, validJSONExtension);\n    },\n\n    async load<T>(url: string): Promise<T>\n    {\n        const response = await DOMAdapter.get().fetch(url);\n\n        const json = await response.json();\n\n        return json as T;\n    },\n} satisfies LoaderParser<string>;\n"],"names":[],"mappings":";;;;;;;AAQA,MAAM,kBAAqB,GAAA,OAAA,CAAA;AAC3B,MAAM,aAAgB,GAAA,kBAAA,CAAA;AAMf,MAAM,QAAW,GAAA;AAAA,EACpB,SAAW,EAAA;AAAA,IACP,MAAM,aAAc,CAAA,UAAA;AAAA,IACpB,UAAU,oBAAqB,CAAA,GAAA;AAAA,GACnC;AAAA,EAEA,IAAM,EAAA,UAAA;AAAA,EAEN,KAAK,GACL,EAAA;AACI,IAAA,OAAO,aAAa,GAAK,EAAA,aAAa,CAAK,IAAA,cAAA,CAAe,KAAK,kBAAkB,CAAA,CAAA;AAAA,GACrF;AAAA,EAEA,MAAM,KAAQ,GACd,EAAA;AACI,IAAA,MAAM,WAAW,MAAM,UAAA,CAAW,GAAI,EAAA,CAAE,MAAM,GAAG,CAAA,CAAA;AAEjD,IAAM,MAAA,IAAA,GAAO,MAAM,QAAA,CAAS,IAAK,EAAA,CAAA;AAEjC,IAAO,OAAA,IAAA,CAAA;AAAA,GACX;AACJ;;;;"}

node_modules/pixi.js/lib/assets/loader/parsers/loadTxt.d.ts

@@ -0,0 +1,16 @@
+import { ExtensionType } from '../../../extensions/Extensions';
+import { LoaderParserPriority } from './LoaderParser';
+/**
+ * A simple loader plugin for loading text data
+ * @memberof assets
+ */
+export declare const loadTxt: {
+    name: string;
+    extension: {
+        type: ExtensionType.LoadParser;
+        priority: LoaderParserPriority;
+        name: string;
+    };
+    test(url: string): boolean;
+    load<T>(url: string): Promise<string>;
+};

node_modules/pixi.js/lib/assets/loader/parsers/loadTxt.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var adapter = require('../../../environment/adapter.js');
+var Extensions = require('../../../extensions/Extensions.js');
+var checkDataUrl = require('../../utils/checkDataUrl.js');
+var checkExtension = require('../../utils/checkExtension.js');
+var LoaderParser = require('./LoaderParser.js');
+
+"use strict";
+const validTXTExtension = ".txt";
+const validTXTMIME = "text/plain";
+const loadTxt = {
+  name: "loadTxt",
+  extension: {
+    type: Extensions.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.Low,
+    name: "loadTxt"
+  },
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validTXTMIME) || checkExtension.checkExtension(url, validTXTExtension);
+  },
+  async load(url) {
+    const response = await adapter.DOMAdapter.get().fetch(url);
+    const txt = await response.text();
+    return txt;
+  }
+};
+
+exports.loadTxt = loadTxt;
+//# sourceMappingURL=loadTxt.js.map

node_modules/pixi.js/lib/assets/loader/parsers/loadTxt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadTxt.js","sources":["../../../../src/assets/loader/parsers/loadTxt.ts"],"sourcesContent":["import { DOMAdapter } from '../../../environment/adapter';\nimport { ExtensionType } from '../../../extensions/Extensions';\nimport { checkDataUrl } from '../../utils/checkDataUrl';\nimport { checkExtension } from '../../utils/checkExtension';\nimport { LoaderParserPriority } from './LoaderParser';\n\nimport type { LoaderParser } from './LoaderParser';\n\nconst validTXTExtension = '.txt';\nconst validTXTMIME = 'text/plain';\n\n/**\n * A simple loader plugin for loading text data\n * @memberof assets\n */\nexport const loadTxt = {\n\n    name: 'loadTxt',\n\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.Low,\n        name: 'loadTxt',\n    },\n\n    test(url: string): boolean\n    {\n        return checkDataUrl(url, validTXTMIME) || checkExtension(url, validTXTExtension);\n    },\n\n    async load(url: string): Promise<string>\n    {\n        const response = await DOMAdapter.get().fetch(url);\n\n        const txt = await response.text();\n\n        return txt;\n    },\n} satisfies LoaderParser<string>;\n"],"names":["ExtensionType","LoaderParserPriority","checkDataUrl","checkExtension","DOMAdapter"],"mappings":";;;;;;;;;AAQA,MAAM,iBAAoB,GAAA,MAAA,CAAA;AAC1B,MAAM,YAAe,GAAA,YAAA,CAAA;AAMd,MAAM,OAAU,GAAA;AAAA,EAEnB,IAAM,EAAA,SAAA;AAAA,EAEN,SAAW,EAAA;AAAA,IACP,MAAMA,wBAAc,CAAA,UAAA;AAAA,IACpB,UAAUC,iCAAqB,CAAA,GAAA;AAAA,IAC/B,IAAM,EAAA,SAAA;AAAA,GACV;AAAA,EAEA,KAAK,GACL,EAAA;AACI,IAAA,OAAOC,0BAAa,GAAK,EAAA,YAAY,CAAK,IAAAC,6BAAA,CAAe,KAAK,iBAAiB,CAAA,CAAA;AAAA,GACnF;AAAA,EAEA,MAAM,KAAK,GACX,EAAA;AACI,IAAA,MAAM,WAAW,MAAMC,kBAAA,CAAW,GAAI,EAAA,CAAE,MAAM,GAAG,CAAA,CAAA;AAEjD,IAAM,MAAA,GAAA,GAAM,MAAM,QAAA,CAAS,IAAK,EAAA,CAAA;AAEhC,IAAO,OAAA,GAAA,CAAA;AAAA,GACX;AACJ;;;;"}

node_modules/pixi.js/lib/assets/loader/parsers/loadTxt.mjs

@@ -0,0 +1,28 @@
+import { DOMAdapter } from '../../../environment/adapter.mjs';
+import { ExtensionType } from '../../../extensions/Extensions.mjs';
+import { checkDataUrl } from '../../utils/checkDataUrl.mjs';
+import { checkExtension } from '../../utils/checkExtension.mjs';
+import { LoaderParserPriority } from './LoaderParser.mjs';
+
+"use strict";
+const validTXTExtension = ".txt";
+const validTXTMIME = "text/plain";
+const loadTxt = {
+  name: "loadTxt",
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.Low,
+    name: "loadTxt"
+  },
+  test(url) {
+    return checkDataUrl(url, validTXTMIME) || checkExtension(url, validTXTExtension);
+  },
+  async load(url) {
+    const response = await DOMAdapter.get().fetch(url);
+    const txt = await response.text();
+    return txt;
+  }
+};
+
+export { loadTxt };
+//# sourceMappingURL=loadTxt.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/loadTxt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadTxt.mjs","sources":["../../../../src/assets/loader/parsers/loadTxt.ts"],"sourcesContent":["import { DOMAdapter } from '../../../environment/adapter';\nimport { ExtensionType } from '../../../extensions/Extensions';\nimport { checkDataUrl } from '../../utils/checkDataUrl';\nimport { checkExtension } from '../../utils/checkExtension';\nimport { LoaderParserPriority } from './LoaderParser';\n\nimport type { LoaderParser } from './LoaderParser';\n\nconst validTXTExtension = '.txt';\nconst validTXTMIME = 'text/plain';\n\n/**\n * A simple loader plugin for loading text data\n * @memberof assets\n */\nexport const loadTxt = {\n\n    name: 'loadTxt',\n\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.Low,\n        name: 'loadTxt',\n    },\n\n    test(url: string): boolean\n    {\n        return checkDataUrl(url, validTXTMIME) || checkExtension(url, validTXTExtension);\n    },\n\n    async load(url: string): Promise<string>\n    {\n        const response = await DOMAdapter.get().fetch(url);\n\n        const txt = await response.text();\n\n        return txt;\n    },\n} satisfies LoaderParser<string>;\n"],"names":[],"mappings":";;;;;;;AAQA,MAAM,iBAAoB,GAAA,MAAA,CAAA;AAC1B,MAAM,YAAe,GAAA,YAAA,CAAA;AAMd,MAAM,OAAU,GAAA;AAAA,EAEnB,IAAM,EAAA,SAAA;AAAA,EAEN,SAAW,EAAA;AAAA,IACP,MAAM,aAAc,CAAA,UAAA;AAAA,IACpB,UAAU,oBAAqB,CAAA,GAAA;AAAA,IAC/B,IAAM,EAAA,SAAA;AAAA,GACV;AAAA,EAEA,KAAK,GACL,EAAA;AACI,IAAA,OAAO,aAAa,GAAK,EAAA,YAAY,CAAK,IAAA,cAAA,CAAe,KAAK,iBAAiB,CAAA,CAAA;AAAA,GACnF;AAAA,EAEA,MAAM,KAAK,GACX,EAAA;AACI,IAAA,MAAM,WAAW,MAAM,UAAA,CAAW,GAAI,EAAA,CAAE,MAAM,GAAG,CAAA,CAAA;AAEjD,IAAM,MAAA,GAAA,GAAM,MAAM,QAAA,CAAS,IAAK,EAAA,CAAA;AAEhC,IAAO,OAAA,GAAA,CAAA;AAAA,GACX;AACJ;;;;"}

node_modules/pixi.js/lib/assets/loader/parsers/loadWebFont.d.ts

@@ -0,0 +1,63 @@
+import { ExtensionType } from '../../../extensions/Extensions';
+import { LoaderParserPriority } from './LoaderParser';
+import type { ResolvedAsset } from '../../types';
+/**
+ * Data for loading a font
+ * @memberof assets
+ */
+export type LoadFontData = {
+    /** Font family name */
+    family: string;
+    /** A set of optional descriptors passed as an object. It can contain any of the descriptors available for @font-face: */
+    display: string;
+    /**
+     * The featureSettings property of the FontFace interface retrieves or sets infrequently used
+     * font features that are not available from a font's variant properties.
+     */
+    featureSettings: string;
+    /** The stretch property of the FontFace interface retrieves or sets how the font stretches. */
+    stretch: string;
+    /** The style property of the FontFace interface retrieves or sets the font's style. */
+    style: string;
+    /**
+     * The unicodeRange property of the FontFace interface retrieves or sets the range of
+     * unicode code points encompassing the font.
+     */
+    unicodeRange: string;
+    /** The variant property of the FontFace interface programmatically retrieves or sets font variant values. */
+    variant: string;
+    /** The weight property of the FontFace interface retrieves or sets the weight of the font. */
+    weights: string[];
+};
+/**
+ * Return font face name from a file name
+ * Ex.: 'fonts/titan-one.woff' turns into 'Titan One'
+ * @param url - File url
+ * @memberof assets
+ */
+export declare function getFontFamilyName(url: string): string;
+/**
+ * A loader plugin for handling web fonts
+ * @example
+ * import { Assets } from 'pixi.js';
+ *
+ * Assets.load({
+ *   alias: 'font',
+ *   src: 'fonts/titan-one.woff',
+ *   data: {
+ *     family: 'Titan One',
+ *     weights: ['normal', 'bold'],
+ *   }
+ * })
+ * @memberof assets
+ */
+export declare const loadWebFont: {
+    extension: {
+        type: ExtensionType.LoadParser;
+        priority: LoaderParserPriority;
+    };
+    name: string;
+    test(url: string): boolean;
+    load<T>(url: string, options?: ResolvedAsset<LoadFontData>): Promise<FontFace | FontFace[]>;
+    unload(font: FontFace | FontFace[]): void;
+};

node_modules/pixi.js/lib/assets/loader/parsers/loadWebFont.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var adapter = require('../../../environment/adapter.js');
+var Extensions = require('../../../extensions/Extensions.js');
+var warn = require('../../../utils/logging/warn.js');
+var path = require('../../../utils/path.js');
+var Cache = require('../../cache/Cache.js');
+var checkDataUrl = require('../../utils/checkDataUrl.js');
+var checkExtension = require('../../utils/checkExtension.js');
+var LoaderParser = require('./LoaderParser.js');
+
+"use strict";
+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.path.extname(url);
+  const name = path.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 validURICharactersRegex = /^[0-9A-Za-z%:/?#\[\]@!\$&'()\*\+,;=\-._~]*$/;
+function encodeURIWhenNeeded(uri) {
+  if (validURICharactersRegex.test(uri)) {
+    return uri;
+  }
+  return encodeURI(uri);
+}
+const loadWebFont = {
+  extension: {
+    type: Extensions.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.Low
+  },
+  name: "loadWebFont",
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validFontMIMEs) || checkExtension.checkExtension(url, validFontExtensions);
+  },
+  async load(url, options) {
+    const fonts = adapter.DOMAdapter.get().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(${encodeURIWhenNeeded(url)})`, {
+          ...data,
+          weight
+        });
+        await font.load();
+        fonts.add(font);
+        fontFaces.push(font);
+      }
+      Cache.Cache.set(`${name}-and-url`, {
+        url,
+        fontFaces
+      });
+      return fontFaces.length === 1 ? fontFaces[0] : fontFaces;
+    }
+    warn.warn("[loadWebFont] FontFace API is not supported. Skipping loading font");
+    return null;
+  },
+  unload(font) {
+    (Array.isArray(font) ? font : [font]).forEach((t) => {
+      Cache.Cache.remove(t.family);
+      adapter.DOMAdapter.get().getFontFaceSet().delete(t);
+    });
+  }
+};
+
+exports.getFontFamilyName = getFontFamilyName;
+exports.loadWebFont = loadWebFont;
+//# sourceMappingURL=loadWebFont.js.map

node_modules/pixi.js/lib/assets/loader/parsers/loadWebFont.mjs

@@ -0,0 +1,101 @@
+import { DOMAdapter } from '../../../environment/adapter.mjs';
+import { ExtensionType } from '../../../extensions/Extensions.mjs';
+import { warn } from '../../../utils/logging/warn.mjs';
+import { path } from '../../../utils/path.mjs';
+import { Cache } from '../../cache/Cache.mjs';
+import { checkDataUrl } from '../../utils/checkDataUrl.mjs';
+import { checkExtension } from '../../utils/checkExtension.mjs';
+import { LoaderParserPriority } from './LoaderParser.mjs';
+
+"use strict";
+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 validURICharactersRegex = /^[0-9A-Za-z%:/?#\[\]@!\$&'()\*\+,;=\-._~]*$/;
+function encodeURIWhenNeeded(uri) {
+  if (validURICharactersRegex.test(uri)) {
+    return uri;
+  }
+  return encodeURI(uri);
+}
+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 = DOMAdapter.get().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(${encodeURIWhenNeeded(url)})`, {
+          ...data,
+          weight
+        });
+        await font.load();
+        fonts.add(font);
+        fontFaces.push(font);
+      }
+      Cache.set(`${name}-and-url`, {
+        url,
+        fontFaces
+      });
+      return fontFaces.length === 1 ? fontFaces[0] : fontFaces;
+    }
+    warn("[loadWebFont] FontFace API is not supported. Skipping loading font");
+    return null;
+  },
+  unload(font) {
+    (Array.isArray(font) ? font : [font]).forEach((t) => {
+      Cache.remove(t.family);
+      DOMAdapter.get().getFontFaceSet().delete(t);
+    });
+  }
+};
+
+export { getFontFamilyName, loadWebFont };
+//# sourceMappingURL=loadWebFont.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadSVG.d.ts

@@ -0,0 +1,26 @@
+import { GraphicsContext } from '../../../../scene/graphics/shared/GraphicsContext';
+import { type LoaderParser } from '../LoaderParser';
+import type { TextureSourceOptions } from '../../../../rendering/renderers/shared/texture/sources/TextureSource';
+import type { Texture } from '../../../../rendering/renderers/shared/texture/Texture';
+/**
+ * Configuration for the [loadSVG]{@link assets.loadSVG} plugin.
+ * @see assets.loadSVG
+ * @memberof assets
+ */
+export interface LoadSVGConfig {
+    /**
+     * The crossOrigin value to use for loading the SVG as an image.
+     * @default 'anonymous'
+     */
+    crossOrigin: HTMLImageElement['crossOrigin'];
+    /**
+     * When set to `true`, loading and decoding images will happen with `new Image()`,
+     * @default false
+     */
+    parseAsGraphicsContext: boolean;
+}
+/**
+ * A simple loader plugin for loading json data
+ * @memberof assets
+ */
+export declare const loadSvg: LoaderParser<Texture | GraphicsContext, TextureSourceOptions & LoadSVGConfig, LoadSVGConfig>;

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadSVG.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var adapter = require('../../../../environment/adapter.js');
+var Extensions = require('../../../../extensions/Extensions.js');
+var ImageSource = require('../../../../rendering/renderers/shared/texture/sources/ImageSource.js');
+var GraphicsContext = require('../../../../scene/graphics/shared/GraphicsContext.js');
+var getResolutionOfUrl = require('../../../../utils/network/getResolutionOfUrl.js');
+var checkDataUrl = require('../../../utils/checkDataUrl.js');
+var checkExtension = require('../../../utils/checkExtension.js');
+var LoaderParser = require('../LoaderParser.js');
+var createTexture = require('./utils/createTexture.js');
+
+"use strict";
+const validSVGExtension = ".svg";
+const validSVGMIME = "image/svg+xml";
+const loadSvg = {
+  extension: {
+    type: Extensions.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.Low,
+    name: "loadSVG"
+  },
+  name: "loadSVG",
+  config: {
+    crossOrigin: "anonymous",
+    parseAsGraphicsContext: false
+  },
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validSVGMIME) || checkExtension.checkExtension(url, validSVGExtension);
+  },
+  async load(url, asset, loader) {
+    if (asset.data.parseAsGraphicsContext ?? this.config.parseAsGraphicsContext) {
+      return loadAsGraphics(url);
+    }
+    return loadAsTexture(url, asset, loader, this.config.crossOrigin);
+  },
+  unload(asset) {
+    asset.destroy(true);
+  }
+};
+async function loadAsTexture(url, asset, loader, crossOrigin) {
+  const response = await adapter.DOMAdapter.get().fetch(url);
+  const blob = await response.blob();
+  const blobUrl = URL.createObjectURL(blob);
+  const image = new Image();
+  image.src = blobUrl;
+  image.crossOrigin = crossOrigin;
+  await image.decode();
+  URL.revokeObjectURL(blobUrl);
+  const canvas = document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  const resolution = asset.data?.resolution || getResolutionOfUrl.getResolutionOfUrl(url);
+  const width = asset.data?.width ?? image.width;
+  const height = asset.data?.height ?? image.height;
+  canvas.width = width * resolution;
+  canvas.height = height * resolution;
+  context.drawImage(image, 0, 0, width * resolution, height * resolution);
+  const { parseAsGraphicsContext: _p, ...rest } = asset.data;
+  const base = new ImageSource.ImageSource({
+    resource: canvas,
+    alphaMode: "premultiply-alpha-on-upload",
+    resolution,
+    ...rest
+  });
+  return createTexture.createTexture(base, loader, url);
+}
+async function loadAsGraphics(url) {
+  const response = await adapter.DOMAdapter.get().fetch(url);
+  const svgSource = await response.text();
+  const context = new GraphicsContext.GraphicsContext();
+  context.svg(svgSource);
+  return context;
+}
+
+exports.loadSvg = loadSvg;
+//# sourceMappingURL=loadSVG.js.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadSVG.mjs

@@ -0,0 +1,73 @@
+import { DOMAdapter } from '../../../../environment/adapter.mjs';
+import { ExtensionType } from '../../../../extensions/Extensions.mjs';
+import { ImageSource } from '../../../../rendering/renderers/shared/texture/sources/ImageSource.mjs';
+import { GraphicsContext } from '../../../../scene/graphics/shared/GraphicsContext.mjs';
+import { getResolutionOfUrl } from '../../../../utils/network/getResolutionOfUrl.mjs';
+import { checkDataUrl } from '../../../utils/checkDataUrl.mjs';
+import { checkExtension } from '../../../utils/checkExtension.mjs';
+import { LoaderParserPriority } from '../LoaderParser.mjs';
+import { createTexture } from './utils/createTexture.mjs';
+
+"use strict";
+const validSVGExtension = ".svg";
+const validSVGMIME = "image/svg+xml";
+const loadSvg = {
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.Low,
+    name: "loadSVG"
+  },
+  name: "loadSVG",
+  config: {
+    crossOrigin: "anonymous",
+    parseAsGraphicsContext: false
+  },
+  test(url) {
+    return checkDataUrl(url, validSVGMIME) || checkExtension(url, validSVGExtension);
+  },
+  async load(url, asset, loader) {
+    if (asset.data.parseAsGraphicsContext ?? this.config.parseAsGraphicsContext) {
+      return loadAsGraphics(url);
+    }
+    return loadAsTexture(url, asset, loader, this.config.crossOrigin);
+  },
+  unload(asset) {
+    asset.destroy(true);
+  }
+};
+async function loadAsTexture(url, asset, loader, crossOrigin) {
+  const response = await DOMAdapter.get().fetch(url);
+  const blob = await response.blob();
+  const blobUrl = URL.createObjectURL(blob);
+  const image = new Image();
+  image.src = blobUrl;
+  image.crossOrigin = crossOrigin;
+  await image.decode();
+  URL.revokeObjectURL(blobUrl);
+  const canvas = document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  const resolution = asset.data?.resolution || getResolutionOfUrl(url);
+  const width = asset.data?.width ?? image.width;
+  const height = asset.data?.height ?? image.height;
+  canvas.width = width * resolution;
+  canvas.height = height * resolution;
+  context.drawImage(image, 0, 0, width * resolution, height * resolution);
+  const { parseAsGraphicsContext: _p, ...rest } = asset.data;
+  const base = new ImageSource({
+    resource: canvas,
+    alphaMode: "premultiply-alpha-on-upload",
+    resolution,
+    ...rest
+  });
+  return createTexture(base, loader, url);
+}
+async function loadAsGraphics(url) {
+  const response = await DOMAdapter.get().fetch(url);
+  const svgSource = await response.text();
+  const context = new GraphicsContext();
+  context.svg(svgSource);
+  return context;
+}
+
+export { loadSvg };
+//# sourceMappingURL=loadSVG.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadTextures.d.ts

@@ -0,0 +1,62 @@
+import type { TextureSourceOptions } from '../../../../rendering/renderers/shared/texture/sources/TextureSource';
+import type { Texture } from '../../../../rendering/renderers/shared/texture/Texture';
+import type { ResolvedAsset } from '../../../types';
+import type { LoaderParser } from '../LoaderParser';
+/**
+ * Configuration for the [loadTextures]{@link assets.loadTextures} plugin.
+ * @see assets.loadTextures
+ * @memberof assets
+ */
+export interface LoadTextureConfig {
+    /**
+     * When set to `true`, loading and decoding images will happen with Worker thread,
+     * if available on the browser. This is much more performant as network requests
+     * and decoding can be expensive on the CPU. However, not all environments support
+     * Workers, in some cases it can be helpful to disable by setting to `false`.
+     * @default true
+     */
+    preferWorkers: boolean;
+    /**
+     * When set to `true`, loading and decoding images will happen with `createImageBitmap`,
+     * otherwise it will use `new Image()`.
+     * @default true
+     */
+    preferCreateImageBitmap: boolean;
+    /**
+     * The crossOrigin value to use for images when `preferCreateImageBitmap` is `false`.
+     * @default 'anonymous'
+     */
+    crossOrigin: HTMLImageElement['crossOrigin'];
+}
+/**
+ * Returns a promise that resolves an ImageBitmaps.
+ * This function is designed to be used by a worker.
+ * Part of WorkerManager!
+ * @param url - The image to load an image bitmap for
+ * @ignore
+ */
+export declare function loadImageBitmap(url: string, asset?: ResolvedAsset<TextureSourceOptions<any>>): Promise<ImageBitmap>;
+/**
+ * A simple plugin to load our textures!
+ * This makes use of imageBitmaps where available.
+ * We load the `ImageBitmap` on a different thread using workers if possible.
+ * We can then use the `ImageBitmap` as a source for a Pixi texture
+ *
+ * You can customize the behavior of this loader by setting the `config` property.
+ * Which can be found [here]{@link assets.LoadTextureConfig}
+ * ```js
+ * // Set the config
+ * import { loadTextures } from 'pixi.js';
+ *
+ * loadTextures.config = {
+ *    // If true we will use a worker to load the ImageBitmap
+ *    preferWorkers: true,
+ *    // If false we will use new Image() instead of createImageBitmap,
+ *    // we'll also disable the use of workers as it requires createImageBitmap
+ *    preferCreateImageBitmap: true,
+ *    crossOrigin: 'anonymous',
+ * };
+ * ```
+ * @memberof assets
+ */
+export declare const loadTextures: LoaderParser<Texture, TextureSourceOptions, LoadTextureConfig>;

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadTextures.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var adapter = require('../../../../environment/adapter.js');
+var Extensions = require('../../../../extensions/Extensions.js');
+var ImageSource = require('../../../../rendering/renderers/shared/texture/sources/ImageSource.js');
+var getResolutionOfUrl = require('../../../../utils/network/getResolutionOfUrl.js');
+var checkDataUrl = require('../../../utils/checkDataUrl.js');
+var checkExtension = require('../../../utils/checkExtension.js');
+var WorkerManager = require('../../workers/WorkerManager.js');
+var LoaderParser = require('../LoaderParser.js');
+var createTexture = require('./utils/createTexture.js');
+
+"use strict";
+const validImageExtensions = [".jpeg", ".jpg", ".png", ".webp", ".avif"];
+const validImageMIMEs = [
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/avif"
+];
+async function loadImageBitmap(url, asset) {
+  const response = await adapter.DOMAdapter.get().fetch(url);
+  if (!response.ok) {
+    throw new Error(`[loadImageBitmap] Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  const imageBlob = await response.blob();
+  return asset?.data?.alphaMode === "premultiplied-alpha" ? createImageBitmap(imageBlob, { premultiplyAlpha: "none" }) : createImageBitmap(imageBlob);
+}
+const loadTextures = {
+  name: "loadTextures",
+  extension: {
+    type: Extensions.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.High,
+    name: "loadTextures"
+  },
+  config: {
+    preferWorkers: true,
+    preferCreateImageBitmap: true,
+    crossOrigin: "anonymous"
+  },
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validImageMIMEs) || checkExtension.checkExtension(url, validImageExtensions);
+  },
+  async load(url, asset, loader) {
+    let src = null;
+    if (globalThis.createImageBitmap && this.config.preferCreateImageBitmap) {
+      if (this.config.preferWorkers && await WorkerManager.WorkerManager.isImageBitmapSupported()) {
+        src = await WorkerManager.WorkerManager.loadImageBitmap(url, asset);
+      } else {
+        src = await loadImageBitmap(url, asset);
+      }
+    } 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 ImageSource.ImageSource({
+      resource: src,
+      alphaMode: "premultiply-alpha-on-upload",
+      resolution: asset.data?.resolution || getResolutionOfUrl.getResolutionOfUrl(url),
+      ...asset.data
+    });
+    return createTexture.createTexture(base, loader, url);
+  },
+  unload(texture) {
+    texture.destroy(true);
+  }
+};
+
+exports.loadImageBitmap = loadImageBitmap;
+exports.loadTextures = loadTextures;
+//# sourceMappingURL=loadTextures.js.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadTextures.mjs

@@ -0,0 +1,78 @@
+import { DOMAdapter } from '../../../../environment/adapter.mjs';
+import { ExtensionType } from '../../../../extensions/Extensions.mjs';
+import { ImageSource } from '../../../../rendering/renderers/shared/texture/sources/ImageSource.mjs';
+import { getResolutionOfUrl } from '../../../../utils/network/getResolutionOfUrl.mjs';
+import { checkDataUrl } from '../../../utils/checkDataUrl.mjs';
+import { checkExtension } from '../../../utils/checkExtension.mjs';
+import { WorkerManager } from '../../workers/WorkerManager.mjs';
+import { LoaderParserPriority } from '../LoaderParser.mjs';
+import { createTexture } from './utils/createTexture.mjs';
+
+"use strict";
+const validImageExtensions = [".jpeg", ".jpg", ".png", ".webp", ".avif"];
+const validImageMIMEs = [
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/avif"
+];
+async function loadImageBitmap(url, asset) {
+  const response = await DOMAdapter.get().fetch(url);
+  if (!response.ok) {
+    throw new Error(`[loadImageBitmap] Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  const imageBlob = await response.blob();
+  return asset?.data?.alphaMode === "premultiplied-alpha" ? createImageBitmap(imageBlob, { premultiplyAlpha: "none" }) : createImageBitmap(imageBlob);
+}
+const loadTextures = {
+  name: "loadTextures",
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.High,
+    name: "loadTextures"
+  },
+  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, asset);
+      } else {
+        src = await loadImageBitmap(url, asset);
+      }
+    } 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 ImageSource({
+      resource: src,
+      alphaMode: "premultiply-alpha-on-upload",
+      resolution: asset.data?.resolution || getResolutionOfUrl(url),
+      ...asset.data
+    });
+    return createTexture(base, loader, url);
+  },
+  unload(texture) {
+    texture.destroy(true);
+  }
+};
+
+export { loadImageBitmap, loadTextures };
+//# sourceMappingURL=loadTextures.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadVideoTextures.d.ts

@@ -0,0 +1,57 @@
+import { ExtensionType } from '../../../../extensions/Extensions';
+import type { VideoSourceOptions } from '../../../../rendering/renderers/shared/texture/sources/VideoSource';
+import type { Texture } from '../../../../rendering/renderers/shared/texture/Texture';
+import type { ResolvedAsset } from '../../../types';
+import type { Loader } from '../../Loader';
+/**
+ * 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
+ * @memberof assets
+ */
+export declare function crossOrigin(element: HTMLImageElement | HTMLVideoElement, url: string, crossorigin?: boolean | string): void;
+/**
+ * Preload a video element
+ * @param element - Video element to preload
+ */
+export declare function preloadVideo(element: HTMLVideoElement): Promise<void>;
+/**
+ * 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 url - The url to test.
+ * @param {object} [loc=window.location] - The location object to test against.
+ * @returns The crossOrigin value to use (or empty string for none).
+ * @memberof assets
+ */
+export declare function determineCrossOrigin(url: string, loc?: Location): string;
+/**
+ * A simple plugin to load video textures.
+ *
+ * You can pass VideoSource options to the loader via the .data property of the asset descriptor
+ * when using Asset.load().
+ * ```js
+ * // Set the data
+ * const texture = await Assets.load({
+ *     src: './assets/city.mp4',
+ *     data: {
+ *         preload: true,
+ *         autoPlay: true,
+ *     },
+ * });
+ * ```
+ * @memberof assets
+ */
+export declare const loadVideoTextures: {
+    name: string;
+    extension: {
+        type: ExtensionType.LoadParser;
+        name: string;
+    };
+    test(url: string): boolean;
+    load<T>(url: string, asset: ResolvedAsset<VideoSourceOptions>, loader: Loader): Promise<Texture>;
+    unload(texture: Texture): void;
+};

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadVideoTextures.js

@@ -0,0 +1,121 @@
+'use strict';
+
+var Extensions = require('../../../../extensions/Extensions.js');
+var VideoSource = require('../../../../rendering/renderers/shared/texture/sources/VideoSource.js');
+var detectVideoAlphaMode = require('../../../../utils/browser/detectVideoAlphaMode.js');
+var getResolutionOfUrl = require('../../../../utils/network/getResolutionOfUrl.js');
+var checkDataUrl = require('../../../utils/checkDataUrl.js');
+var checkExtension = require('../../../utils/checkExtension.js');
+var createTexture = require('./utils/createTexture.js');
+
+"use strict";
+const validVideoExtensions = [".mp4", ".m4v", ".webm", ".ogg", ".ogv", ".h264", ".avi", ".mov"];
+const validVideoMIMEs = validVideoExtensions.map((ext) => `video/${ext.substring(1)}`);
+function 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";
+  }
+}
+function preloadVideo(element) {
+  return new Promise((resolve, reject) => {
+    element.addEventListener("canplaythrough", loaded);
+    element.addEventListener("error", error);
+    element.load();
+    function loaded() {
+      cleanup();
+      resolve();
+    }
+    function error(err) {
+      cleanup();
+      reject(err);
+    }
+    function cleanup() {
+      element.removeEventListener("canplaythrough", loaded);
+      element.removeEventListener("error", error);
+    }
+  });
+}
+function determineCrossOrigin(url, loc = globalThis.location) {
+  if (url.startsWith("data:")) {
+    return "";
+  }
+  loc = loc || globalThis.location;
+  const parsedUrl = new URL(url, document.baseURI);
+  if (parsedUrl.hostname !== loc.hostname || parsedUrl.port !== loc.port || parsedUrl.protocol !== loc.protocol) {
+    return "anonymous";
+  }
+  return "";
+}
+const loadVideoTextures = {
+  name: "loadVideo",
+  extension: {
+    type: Extensions.ExtensionType.LoadParser,
+    name: "loadVideo"
+  },
+  test(url) {
+    const isValidDataUrl = checkDataUrl.checkDataUrl(url, validVideoMIMEs);
+    const isValidExtension = checkExtension.checkExtension(url, validVideoExtensions);
+    return isValidDataUrl || isValidExtension;
+  },
+  async load(url, asset, loader) {
+    const options = {
+      ...VideoSource.VideoSource.defaultOptions,
+      resolution: asset.data?.resolution || getResolutionOfUrl.getResolutionOfUrl(url),
+      alphaMode: asset.data?.alphaMode || await detectVideoAlphaMode.detectVideoAlphaMode(),
+      ...asset.data
+    };
+    const videoElement = document.createElement("video");
+    const attributeMap = {
+      preload: options.autoLoad !== false ? "auto" : void 0,
+      "webkit-playsinline": options.playsinline !== false ? "" : void 0,
+      playsinline: options.playsinline !== false ? "" : void 0,
+      muted: options.muted === true ? "" : void 0,
+      loop: options.loop === true ? "" : void 0,
+      autoplay: options.autoPlay !== false ? "" : void 0
+    };
+    Object.keys(attributeMap).forEach((key) => {
+      const value = attributeMap[key];
+      if (value !== void 0)
+        videoElement.setAttribute(key, value);
+    });
+    if (options.muted === true) {
+      videoElement.muted = true;
+    }
+    crossOrigin(videoElement, url, options.crossorigin);
+    const sourceElement = document.createElement("source");
+    let mime;
+    if (url.startsWith("data:")) {
+      mime = url.slice(5, url.indexOf(";"));
+    } else if (!url.startsWith("blob:")) {
+      const ext = url.split("?")[0].slice(url.lastIndexOf(".") + 1).toLowerCase();
+      mime = VideoSource.VideoSource.MIME_TYPES[ext] || `video/${ext}`;
+    }
+    sourceElement.src = url;
+    if (mime) {
+      sourceElement.type = mime;
+    }
+    return new Promise((resolve) => {
+      const onCanPlay = async () => {
+        const base = new VideoSource.VideoSource({ ...options, resource: videoElement });
+        videoElement.removeEventListener("canplay", onCanPlay);
+        if (asset.data.preload) {
+          await preloadVideo(videoElement);
+        }
+        resolve(createTexture.createTexture(base, loader, url));
+      };
+      videoElement.addEventListener("canplay", onCanPlay);
+      videoElement.appendChild(sourceElement);
+    });
+  },
+  unload(texture) {
+    texture.destroy(true);
+  }
+};
+
+exports.crossOrigin = crossOrigin;
+exports.determineCrossOrigin = determineCrossOrigin;
+exports.loadVideoTextures = loadVideoTextures;
+exports.preloadVideo = preloadVideo;
+//# sourceMappingURL=loadVideoTextures.js.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/loadVideoTextures.mjs

@@ -0,0 +1,116 @@
+import { ExtensionType } from '../../../../extensions/Extensions.mjs';
+import { VideoSource } from '../../../../rendering/renderers/shared/texture/sources/VideoSource.mjs';
+import { detectVideoAlphaMode } from '../../../../utils/browser/detectVideoAlphaMode.mjs';
+import { getResolutionOfUrl } from '../../../../utils/network/getResolutionOfUrl.mjs';
+import { checkDataUrl } from '../../../utils/checkDataUrl.mjs';
+import { checkExtension } from '../../../utils/checkExtension.mjs';
+import { createTexture } from './utils/createTexture.mjs';
+
+"use strict";
+const validVideoExtensions = [".mp4", ".m4v", ".webm", ".ogg", ".ogv", ".h264", ".avi", ".mov"];
+const validVideoMIMEs = validVideoExtensions.map((ext) => `video/${ext.substring(1)}`);
+function 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";
+  }
+}
+function preloadVideo(element) {
+  return new Promise((resolve, reject) => {
+    element.addEventListener("canplaythrough", loaded);
+    element.addEventListener("error", error);
+    element.load();
+    function loaded() {
+      cleanup();
+      resolve();
+    }
+    function error(err) {
+      cleanup();
+      reject(err);
+    }
+    function cleanup() {
+      element.removeEventListener("canplaythrough", loaded);
+      element.removeEventListener("error", error);
+    }
+  });
+}
+function determineCrossOrigin(url, loc = globalThis.location) {
+  if (url.startsWith("data:")) {
+    return "";
+  }
+  loc = loc || globalThis.location;
+  const parsedUrl = new URL(url, document.baseURI);
+  if (parsedUrl.hostname !== loc.hostname || parsedUrl.port !== loc.port || parsedUrl.protocol !== loc.protocol) {
+    return "anonymous";
+  }
+  return "";
+}
+const loadVideoTextures = {
+  name: "loadVideo",
+  extension: {
+    type: ExtensionType.LoadParser,
+    name: "loadVideo"
+  },
+  test(url) {
+    const isValidDataUrl = checkDataUrl(url, validVideoMIMEs);
+    const isValidExtension = checkExtension(url, validVideoExtensions);
+    return isValidDataUrl || isValidExtension;
+  },
+  async load(url, asset, loader) {
+    const options = {
+      ...VideoSource.defaultOptions,
+      resolution: asset.data?.resolution || getResolutionOfUrl(url),
+      alphaMode: asset.data?.alphaMode || await detectVideoAlphaMode(),
+      ...asset.data
+    };
+    const videoElement = document.createElement("video");
+    const attributeMap = {
+      preload: options.autoLoad !== false ? "auto" : void 0,
+      "webkit-playsinline": options.playsinline !== false ? "" : void 0,
+      playsinline: options.playsinline !== false ? "" : void 0,
+      muted: options.muted === true ? "" : void 0,
+      loop: options.loop === true ? "" : void 0,
+      autoplay: options.autoPlay !== false ? "" : void 0
+    };
+    Object.keys(attributeMap).forEach((key) => {
+      const value = attributeMap[key];
+      if (value !== void 0)
+        videoElement.setAttribute(key, value);
+    });
+    if (options.muted === true) {
+      videoElement.muted = true;
+    }
+    crossOrigin(videoElement, url, options.crossorigin);
+    const sourceElement = document.createElement("source");
+    let mime;
+    if (url.startsWith("data:")) {
+      mime = url.slice(5, url.indexOf(";"));
+    } else if (!url.startsWith("blob:")) {
+      const ext = url.split("?")[0].slice(url.lastIndexOf(".") + 1).toLowerCase();
+      mime = VideoSource.MIME_TYPES[ext] || `video/${ext}`;
+    }
+    sourceElement.src = url;
+    if (mime) {
+      sourceElement.type = mime;
+    }
+    return new Promise((resolve) => {
+      const onCanPlay = async () => {
+        const base = new VideoSource({ ...options, resource: videoElement });
+        videoElement.removeEventListener("canplay", onCanPlay);
+        if (asset.data.preload) {
+          await preloadVideo(videoElement);
+        }
+        resolve(createTexture(base, loader, url));
+      };
+      videoElement.addEventListener("canplay", onCanPlay);
+      videoElement.appendChild(sourceElement);
+    });
+  },
+  unload(texture) {
+    texture.destroy(true);
+  }
+};
+
+export { crossOrigin, determineCrossOrigin, loadVideoTextures, preloadVideo };
+//# sourceMappingURL=loadVideoTextures.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/utils/createTexture.d.ts

@@ -0,0 +1,11 @@
+import { Texture } from '../../../../../rendering/renderers/shared/texture/Texture';
+import type { TextureSource } from '../../../../../rendering/renderers/shared/texture/sources/TextureSource';
+import type { Loader } from '../../../Loader';
+/**
+ * Creates a texture from a source and adds it to the cache.
+ * @param source - source of the texture
+ * @param loader - loader
+ * @param url - url of the texture
+ * @ignore
+ */
+export declare function createTexture(source: TextureSource, loader: Loader, url: string): Texture<TextureSource<any>>;

node_modules/pixi.js/lib/assets/loader/parsers/textures/utils/createTexture.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var Texture = require('../../../../../rendering/renderers/shared/texture/Texture.js');
+var warn = require('../../../../../utils/logging/warn.js');
+var Cache = require('../../../../cache/Cache.js');
+
+"use strict";
+function createTexture(source, loader, url) {
+  source.label = url;
+  source._sourceOrigin = url;
+  const texture = new Texture.Texture({
+    source,
+    label: url
+  });
+  const unload = () => {
+    delete loader.promiseCache[url];
+    if (Cache.Cache.has(url)) {
+      Cache.Cache.remove(url);
+    }
+  };
+  texture.source.once("destroy", () => {
+    if (loader.promiseCache[url]) {
+      warn.warn("[Assets] A TextureSource managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the TextureSource.");
+      unload();
+    }
+  });
+  texture.once("destroy", () => {
+    if (!source.destroyed) {
+      warn.warn("[Assets] A Texture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the Texture.");
+      unload();
+    }
+  });
+  return texture;
+}
+
+exports.createTexture = createTexture;
+//# sourceMappingURL=createTexture.js.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/utils/createTexture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTexture.js","sources":["../../../../../../src/assets/loader/parsers/textures/utils/createTexture.ts"],"sourcesContent":["import { Texture } from '../../../../../rendering/renderers/shared/texture/Texture';\nimport { warn } from '../../../../../utils/logging/warn';\nimport { Cache } from '../../../../cache/Cache';\n\nimport type { TextureSource } from '../../../../../rendering/renderers/shared/texture/sources/TextureSource';\nimport type { Loader } from '../../../Loader';\n\n/**\n * Creates a texture from a source and adds it to the cache.\n * @param source - source of the texture\n * @param loader - loader\n * @param url - url of the texture\n * @ignore\n */\nexport function createTexture(source: TextureSource, loader: Loader, url: string)\n{\n    source.label = url;\n    source._sourceOrigin = url;\n\n    const texture = new Texture({\n        source,\n        label: url,\n    });\n\n    const unload = () =>\n    {\n        delete loader.promiseCache[url];\n\n        if (Cache.has(url))\n        {\n            Cache.remove(url);\n        }\n    };\n\n    // remove the promise from the loader and the url from the cache when the texture is destroyed\n    texture.source.once('destroy', () =>\n    {\n        if (loader.promiseCache[url])\n        {\n            // #if _DEBUG\n            warn('[Assets] A TextureSource managed by Assets was destroyed instead of unloaded! '\n           + 'Use Assets.unload() instead of destroying the TextureSource.');\n            // #endif\n\n            unload();\n        }\n    });\n\n    texture.once('destroy', () =>\n    {\n        if (!source.destroyed)\n        {\n            // #if _DEBUG\n            warn('[Assets] A Texture managed by Assets was destroyed instead of unloaded! '\n             + 'Use Assets.unload() instead of destroying the Texture.');\n            // #endif\n\n            unload();\n        }\n    });\n\n    return texture;\n}\n"],"names":["Texture","Cache","warn"],"mappings":";;;;;;;AAcgB,SAAA,aAAA,CAAc,MAAuB,EAAA,MAAA,EAAgB,GACrE,EAAA;AACI,EAAA,MAAA,CAAO,KAAQ,GAAA,GAAA,CAAA;AACf,EAAA,MAAA,CAAO,aAAgB,GAAA,GAAA,CAAA;AAEvB,EAAM,MAAA,OAAA,GAAU,IAAIA,eAAQ,CAAA;AAAA,IACxB,MAAA;AAAA,IACA,KAAO,EAAA,GAAA;AAAA,GACV,CAAA,CAAA;AAED,EAAA,MAAM,SAAS,MACf;AACI,IAAO,OAAA,MAAA,CAAO,aAAa,GAAG,CAAA,CAAA;AAE9B,IAAI,IAAAC,WAAA,CAAM,GAAI,CAAA,GAAG,CACjB,EAAA;AACI,MAAAA,WAAA,CAAM,OAAO,GAAG,CAAA,CAAA;AAAA,KACpB;AAAA,GACJ,CAAA;AAGA,EAAQ,OAAA,CAAA,MAAA,CAAO,IAAK,CAAA,SAAA,EAAW,MAC/B;AACI,IAAI,IAAA,MAAA,CAAO,YAAa,CAAA,GAAG,CAC3B,EAAA;AAEI,MAAAC,SAAA,CAAK,4IAC0D,CAAA,CAAA;AAG/D,MAAO,MAAA,EAAA,CAAA;AAAA,KACX;AAAA,GACH,CAAA,CAAA;AAED,EAAQ,OAAA,CAAA,IAAA,CAAK,WAAW,MACxB;AACI,IAAI,IAAA,CAAC,OAAO,SACZ,EAAA;AAEI,MAAAA,SAAA,CAAK,gIACsD,CAAA,CAAA;AAG3D,MAAO,MAAA,EAAA,CAAA;AAAA,KACX;AAAA,GACH,CAAA,CAAA;AAED,EAAO,OAAA,OAAA,CAAA;AACX;;;;"}

node_modules/pixi.js/lib/assets/loader/parsers/textures/utils/createTexture.mjs

@@ -0,0 +1,35 @@
+import { Texture } from '../../../../../rendering/renderers/shared/texture/Texture.mjs';
+import { warn } from '../../../../../utils/logging/warn.mjs';
+import { Cache } from '../../../../cache/Cache.mjs';
+
+"use strict";
+function createTexture(source, loader, url) {
+  source.label = url;
+  source._sourceOrigin = url;
+  const texture = new Texture({
+    source,
+    label: url
+  });
+  const unload = () => {
+    delete loader.promiseCache[url];
+    if (Cache.has(url)) {
+      Cache.remove(url);
+    }
+  };
+  texture.source.once("destroy", () => {
+    if (loader.promiseCache[url]) {
+      warn("[Assets] A TextureSource managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the TextureSource.");
+      unload();
+    }
+  });
+  texture.once("destroy", () => {
+    if (!source.destroyed) {
+      warn("[Assets] A Texture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the Texture.");
+      unload();
+    }
+  });
+  return texture;
+}
+
+export { createTexture };
+//# sourceMappingURL=createTexture.mjs.map

node_modules/pixi.js/lib/assets/loader/parsers/textures/utils/createTexture.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTexture.mjs","sources":["../../../../../../src/assets/loader/parsers/textures/utils/createTexture.ts"],"sourcesContent":["import { Texture } from '../../../../../rendering/renderers/shared/texture/Texture';\nimport { warn } from '../../../../../utils/logging/warn';\nimport { Cache } from '../../../../cache/Cache';\n\nimport type { TextureSource } from '../../../../../rendering/renderers/shared/texture/sources/TextureSource';\nimport type { Loader } from '../../../Loader';\n\n/**\n * Creates a texture from a source and adds it to the cache.\n * @param source - source of the texture\n * @param loader - loader\n * @param url - url of the texture\n * @ignore\n */\nexport function createTexture(source: TextureSource, loader: Loader, url: string)\n{\n    source.label = url;\n    source._sourceOrigin = url;\n\n    const texture = new Texture({\n        source,\n        label: url,\n    });\n\n    const unload = () =>\n    {\n        delete loader.promiseCache[url];\n\n        if (Cache.has(url))\n        {\n            Cache.remove(url);\n        }\n    };\n\n    // remove the promise from the loader and the url from the cache when the texture is destroyed\n    texture.source.once('destroy', () =>\n    {\n        if (loader.promiseCache[url])\n        {\n            // #if _DEBUG\n            warn('[Assets] A TextureSource managed by Assets was destroyed instead of unloaded! '\n           + 'Use Assets.unload() instead of destroying the TextureSource.');\n            // #endif\n\n            unload();\n        }\n    });\n\n    texture.once('destroy', () =>\n    {\n        if (!source.destroyed)\n        {\n            // #if _DEBUG\n            warn('[Assets] A Texture managed by Assets was destroyed instead of unloaded! '\n             + 'Use Assets.unload() instead of destroying the Texture.');\n            // #endif\n\n            unload();\n        }\n    });\n\n    return texture;\n}\n"],"names":[],"mappings":";;;;;AAcgB,SAAA,aAAA,CAAc,MAAuB,EAAA,MAAA,EAAgB,GACrE,EAAA;AACI,EAAA,MAAA,CAAO,KAAQ,GAAA,GAAA,CAAA;AACf,EAAA,MAAA,CAAO,aAAgB,GAAA,GAAA,CAAA;AAEvB,EAAM,MAAA,OAAA,GAAU,IAAI,OAAQ,CAAA;AAAA,IACxB,MAAA;AAAA,IACA,KAAO,EAAA,GAAA;AAAA,GACV,CAAA,CAAA;AAED,EAAA,MAAM,SAAS,MACf;AACI,IAAO,OAAA,MAAA,CAAO,aAAa,GAAG,CAAA,CAAA;AAE9B,IAAI,IAAA,KAAA,CAAM,GAAI,CAAA,GAAG,CACjB,EAAA;AACI,MAAA,KAAA,CAAM,OAAO,GAAG,CAAA,CAAA;AAAA,KACpB;AAAA,GACJ,CAAA;AAGA,EAAQ,OAAA,CAAA,MAAA,CAAO,IAAK,CAAA,SAAA,EAAW,MAC/B;AACI,IAAI,IAAA,MAAA,CAAO,YAAa,CAAA,GAAG,CAC3B,EAAA;AAEI,MAAA,IAAA,CAAK,4IAC0D,CAAA,CAAA;AAG/D,MAAO,MAAA,EAAA,CAAA;AAAA,KACX;AAAA,GACH,CAAA,CAAA;AAED,EAAQ,OAAA,CAAA,IAAA,CAAK,WAAW,MACxB;AACI,IAAI,IAAA,CAAC,OAAO,SACZ,EAAA;AAEI,MAAA,IAAA,CAAK,gIACsD,CAAA,CAAA;AAG3D,MAAO,MAAA,EAAA,CAAA;AAAA,KACX;AAAA,GACH,CAAA,CAAA;AAED,EAAO,OAAA,OAAA,CAAA;AACX;;;;"}

node_modules/pixi.js/lib/assets/loader/types.d.ts

@@ -0,0 +1,11 @@
+import type { LoaderParser } from './parsers/LoaderParser';
+/**
+ * A promise and parser pair
+ * @memberof assets
+ */
+export interface PromiseAndParser {
+    /** the promise that is loading the asset */
+    promise: Promise<any>;
+    /** the parser that is loading the asset */
+    parser: LoaderParser;
+}

node_modules/pixi.js/lib/assets/loader/types.js

@@ -0,0 +1,4 @@
+'use strict';
+
+"use strict";
+//# sourceMappingURL=types.js.map

node_modules/pixi.js/lib/assets/loader/types.js.map

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

node_modules/pixi.js/lib/assets/loader/types.mjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.mjs.map

node_modules/pixi.js/lib/assets/loader/types.mjs.map

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

node_modules/pixi.js/lib/assets/loader/workers/WorkerManager.d.ts

@@ -0,0 +1,22 @@
+import type { TextureSourceOptions } from '../../../rendering/renderers/shared/texture/sources/TextureSource';
+import type { ResolvedAsset } from '../../types';
+declare class WorkerManagerClass {
+    worker: Worker;
+    private _resolveHash;
+    private readonly _workerPool;
+    private readonly _queue;
+    private _initialized;
+    private _createdWorkers;
+    private _isImageBitmapSupported?;
+    constructor();
+    isImageBitmapSupported(): Promise<boolean>;
+    loadImageBitmap(src: string, asset?: ResolvedAsset<TextureSourceOptions<any>>): Promise<ImageBitmap>;
+    private _initWorkers;
+    private _getWorker;
+    private _returnWorker;
+    private _complete;
+    private _run;
+    private _next;
+}
+declare const WorkerManager: WorkerManagerClass;
+export { WorkerManager, };

node_modules/pixi.js/lib/assets/loader/workers/WorkerManager.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var checkImageBitmap_worker = require('../../../_virtual/checkImageBitmap.worker.js');
+var loadImageBitmap_worker = require('../../../_virtual/loadImageBitmap.worker.js');
+
+"use strict";
+let UUID = 0;
+let MAX_WORKERS;
+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 { worker } = new checkImageBitmap_worker.default();
+      worker.addEventListener("message", (event) => {
+        worker.terminate();
+        checkImageBitmap_worker.default.revokeObjectURL();
+        resolve(event.data);
+      });
+    });
+    return this._isImageBitmapSupported;
+  }
+  loadImageBitmap(src, asset) {
+    return this._run("loadImageBitmap", [src, asset?.data?.alphaMode]);
+  }
+  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) {
+      this._createdWorkers++;
+      worker = new loadImageBitmap_worker.default().worker;
+      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();
+
+exports.WorkerManager = WorkerManager;
+//# sourceMappingURL=WorkerManager.js.map

node_modules/pixi.js/lib/assets/loader/workers/WorkerManager.mjs

@@ -0,0 +1,91 @@
+import WorkerInstance from '../../../_virtual/checkImageBitmap.worker.mjs';
+import WorkerInstance$1 from '../../../_virtual/loadImageBitmap.worker.mjs';
+
+"use strict";
+let UUID = 0;
+let MAX_WORKERS;
+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 { worker } = new WorkerInstance();
+      worker.addEventListener("message", (event) => {
+        worker.terminate();
+        WorkerInstance.revokeObjectURL();
+        resolve(event.data);
+      });
+    });
+    return this._isImageBitmapSupported;
+  }
+  loadImageBitmap(src, asset) {
+    return this._run("loadImageBitmap", [src, asset?.data?.alphaMode]);
+  }
+  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) {
+      this._createdWorkers++;
+      worker = new WorkerInstance$1().worker;
+      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();
+
+export { WorkerManager };
+//# sourceMappingURL=WorkerManager.mjs.map

node_modules/pixi.js/lib/assets/loader/workers/checkImageBitmap.worker.d.ts

@@ -0,0 +1,2 @@
+declare const WHITE_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=";
+declare function checkImageBitmap(): Promise<boolean>;

node_modules/pixi.js/lib/assets/loader/workers/loadImageBitmap.worker.d.ts

@@ -0,0 +1,6 @@
+interface MessageData {
+    data: any[];
+    uuid: number;
+    id: string;
+}
+declare function loadImageBitmap(url: string, alphaMode?: string): Promise<ImageBitmap>;