Initial

resources/app/node_modules/@pixi/assets/lib/loader/Loader.js

@@ -0,0 +1,96 @@
+"use strict";
+var core = require("@pixi/core");
+require("../utils/index.js");
+var isSingleItem = require("../utils/isSingleItem.js"), convertToList = require("../utils/convertToList.js");
+class Loader {
+  constructor() {
+    this._parsers = [], this._parsersValidated = !1, this.parsers = new Proxy(this._parsers, {
+      set: (target, key, value) => (this._parsersValidated = !1, target[key] = value, !0)
+    }), this.promiseCache = {};
+  }
+  /** function used for testing */
+  reset() {
+    this._parsersValidated = !1, 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
+    };
+    return result.promise = (async () => {
+      let asset = null, parser = null;
+      if (data.loadParser && (parser = this._parserHash[data.loadParser], parser || console.warn(`[Assets] specified load parser "${data.loadParser}" not found while loading ${url}`)), !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)
+          return console.warn(`[Assets] ${url} could not be loaded as we don't know how to parse it, ensure the correct parser has been added`), 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];
+        parser2.parse && parser2.parse && await parser2.testParse?.(asset, data, this) && (asset = await parser2.parse(asset, data, this) || asset, result.parser = parser2);
+      }
+      return asset;
+    })(), result;
+  }
+  async load(assetsToLoadIn, onProgress) {
+    this._parsersValidated || this._validateParsers();
+    let count = 0;
+    const assets = {}, singleAsset = isSingleItem.isSingleItem(assetsToLoadIn), assetsToLoad = convertToList.convertToList(assetsToLoadIn, (item) => ({
+      alias: [item],
+      src: item
+    })), total = assetsToLoad.length, promises = assetsToLoad.map(async (asset) => {
+      const url = core.utils.path.toAbsolute(asset.src);
+      if (!assets[asset.src])
+        try {
+          this.promiseCache[url] || (this.promiseCache[url] = this._getLoadPromiseAndParser(url, asset)), assets[asset.src] = await this.promiseCache[url].promise, onProgress && onProgress(++count / total);
+        } catch (e) {
+          throw delete this.promiseCache[url], delete assets[asset.src], new Error(`[Loader.load] Failed to load ${url}.
+${e}`);
+        }
+    });
+    return await Promise.all(promises), 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 promises = convertToList.convertToList(assetsToUnloadIn, (item) => ({
+      alias: [item],
+      src: item
+    })).map(async (asset) => {
+      const url = core.utils.path.toAbsolute(asset.src), loadPromise = this.promiseCache[url];
+      if (loadPromise) {
+        const loadedAsset = await loadPromise.promise;
+        delete this.promiseCache[url], 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 = !0, this._parserHash = this._parsers.filter((parser) => parser.name).reduce((hash, parser) => (hash[parser.name] && console.warn(`[Assets] loadParser name conflict "${parser.name}"`), { ...hash, [parser.name]: parser }), {});
+  }
+}
+exports.Loader = Loader;
+//# sourceMappingURL=Loader.js.map

resources/app/node_modules/@pixi/assets/lib/loader/Loader.mjs

@@ -0,0 +1,98 @@
+import { utils } from "@pixi/core";
+import "../utils/index.mjs";
+import { isSingleItem } from "../utils/isSingleItem.mjs";
+import { convertToList } from "../utils/convertToList.mjs";
+class Loader {
+  constructor() {
+    this._parsers = [], this._parsersValidated = !1, this.parsers = new Proxy(this._parsers, {
+      set: (target, key, value) => (this._parsersValidated = !1, target[key] = value, !0)
+    }), this.promiseCache = {};
+  }
+  /** function used for testing */
+  reset() {
+    this._parsersValidated = !1, 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
+    };
+    return result.promise = (async () => {
+      let asset = null, parser = null;
+      if (data.loadParser && (parser = this._parserHash[data.loadParser], parser || console.warn(`[Assets] specified load parser "${data.loadParser}" not found while loading ${url}`)), !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)
+          return console.warn(`[Assets] ${url} could not be loaded as we don't know how to parse it, ensure the correct parser has been added`), 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];
+        parser2.parse && parser2.parse && await parser2.testParse?.(asset, data, this) && (asset = await parser2.parse(asset, data, this) || asset, result.parser = parser2);
+      }
+      return asset;
+    })(), result;
+  }
+  async load(assetsToLoadIn, onProgress) {
+    this._parsersValidated || this._validateParsers();
+    let count = 0;
+    const assets = {}, singleAsset = isSingleItem(assetsToLoadIn), assetsToLoad = convertToList(assetsToLoadIn, (item) => ({
+      alias: [item],
+      src: item
+    })), total = assetsToLoad.length, promises = assetsToLoad.map(async (asset) => {
+      const url = utils.path.toAbsolute(asset.src);
+      if (!assets[asset.src])
+        try {
+          this.promiseCache[url] || (this.promiseCache[url] = this._getLoadPromiseAndParser(url, asset)), assets[asset.src] = await this.promiseCache[url].promise, onProgress && onProgress(++count / total);
+        } catch (e) {
+          throw delete this.promiseCache[url], delete assets[asset.src], new Error(`[Loader.load] Failed to load ${url}.
+${e}`);
+        }
+    });
+    return await Promise.all(promises), 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 promises = convertToList(assetsToUnloadIn, (item) => ({
+      alias: [item],
+      src: item
+    })).map(async (asset) => {
+      const url = utils.path.toAbsolute(asset.src), loadPromise = this.promiseCache[url];
+      if (loadPromise) {
+        const loadedAsset = await loadPromise.promise;
+        delete this.promiseCache[url], 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 = !0, this._parserHash = this._parsers.filter((parser) => parser.name).reduce((hash, parser) => (hash[parser.name] && console.warn(`[Assets] loadParser name conflict "${parser.name}"`), { ...hash, [parser.name]: parser }), {});
+  }
+}
+export {
+  Loader
+};
+//# sourceMappingURL=Loader.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/index.js

@@ -0,0 +1,3 @@
+"use strict";
+require("./parsers/index.js");
+//# sourceMappingURL=index.js.map

resources/app/node_modules/@pixi/assets/lib/loader/index.js.map

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

resources/app/node_modules/@pixi/assets/lib/loader/index.mjs

@@ -0,0 +1,2 @@
+import "./parsers/index.mjs";
+//# sourceMappingURL=index.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/index.mjs.map

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/LoaderParser.js

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/LoaderParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoaderParser.js","sources":["../../../src/loader/parsers/LoaderParser.ts"],"sourcesContent":["import type { ExtensionMetadata } from '@pixi/core';\nimport type { ResolvedAsset } from '../../types';\nimport type { Loader } from '../Loader';\n\n/**\n * The extension priority for loader parsers.\n * Helpful when managing multiple parsers that share the same extension test.\n * The higher priority parsers will be checked first.\n * @memberof PIXI\n * @enum {number}\n */\nexport enum LoaderParserPriority\n// eslint-disable-next-line @typescript-eslint/indent\n{\n    /** Generic parsers: txt, json, webfonts */\n    Low = 0,\n    /** PixiJS assets with generic extensions: spritesheets, bitmapfonts  */\n    Normal = 1,\n    /** Specific texture types: svg, png, ktx, dds, basis */\n    High = 2,\n}\n\n/**\n * All functions are optional here. The flow:\n *\n * for every asset,\n *\n * 1. `parser.test()`: Test the asset url.\n * 2. `parser.load()`: If test passes call the load function with the url\n * 3. `parser.testParse()`: Test to see if the asset should be parsed by the plugin\n * 4. `parse.parse()`: If test is parsed, then run the parse function on the asset.\n *\n * some plugins may only be used for parsing,\n * some only for loading\n * and some for both!\n * @memberof PIXI\n */\nexport interface LoaderParser<ASSET = any, META_DATA = any, CONFIG = Record<string, any>>\n{\n    extension?: ExtensionMetadata;\n\n    /** A config to adjust the parser */\n    config?: CONFIG;\n\n    /** The name of the parser (this can be used when specifying loadParser in a ResolvedAsset) */\n    name?: string;\n\n    /**\n     * each URL to load will be tested here,\n     * if the test is passed the assets are loaded using the load function below.\n     * Good place to test for things like file extensions!\n     * @param url - The URL to test\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    test?: (url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => boolean;\n\n    /**\n     * This is the promise that loads the URL provided\n     * resolves with a loaded asset if returned by the parser.\n     * @param url - The URL to load\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    load?: <T>(url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<T>;\n\n    /**\n     * This function is used to test if the parse function should be run on the asset\n     * If this returns true then parse is called with the asset\n     * @param asset - The loaded asset data\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    testParse?: (asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<boolean>;\n\n    /**\n     * Gets called on the asset it testParse passes. Useful to convert a raw asset into something more useful than\n     * @param asset - The loaded asset data\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    parse?: <T>(asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<T>;\n\n    /**\n     * If an asset is parsed using this parser, the unload function will be called when the user requests an asset\n     * to be unloaded. This is useful for things like sounds or textures that can be unloaded from memory\n     * @param asset - The asset to unload/destroy\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    unload?: (asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => void;\n}\n"],"names":["LoaderParserPriority"],"mappings":";AAWO,IAAK,uBAAL,kBAAKA,2BAIRA,sBAAAA,sBAAA,MAAM,CAAN,IAAA,OAEAA,sBAAA,sBAAA,SAAS,KAAT,UAEAA,sBAAAA,sBAAA,OAAO,CAAA,IAAP,QARQA,wBAAA,wBAAA,CAAA,CAAA;;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/LoaderParser.mjs

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/LoaderParser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoaderParser.mjs","sources":["../../../src/loader/parsers/LoaderParser.ts"],"sourcesContent":["import type { ExtensionMetadata } from '@pixi/core';\nimport type { ResolvedAsset } from '../../types';\nimport type { Loader } from '../Loader';\n\n/**\n * The extension priority for loader parsers.\n * Helpful when managing multiple parsers that share the same extension test.\n * The higher priority parsers will be checked first.\n * @memberof PIXI\n * @enum {number}\n */\nexport enum LoaderParserPriority\n// eslint-disable-next-line @typescript-eslint/indent\n{\n    /** Generic parsers: txt, json, webfonts */\n    Low = 0,\n    /** PixiJS assets with generic extensions: spritesheets, bitmapfonts  */\n    Normal = 1,\n    /** Specific texture types: svg, png, ktx, dds, basis */\n    High = 2,\n}\n\n/**\n * All functions are optional here. The flow:\n *\n * for every asset,\n *\n * 1. `parser.test()`: Test the asset url.\n * 2. `parser.load()`: If test passes call the load function with the url\n * 3. `parser.testParse()`: Test to see if the asset should be parsed by the plugin\n * 4. `parse.parse()`: If test is parsed, then run the parse function on the asset.\n *\n * some plugins may only be used for parsing,\n * some only for loading\n * and some for both!\n * @memberof PIXI\n */\nexport interface LoaderParser<ASSET = any, META_DATA = any, CONFIG = Record<string, any>>\n{\n    extension?: ExtensionMetadata;\n\n    /** A config to adjust the parser */\n    config?: CONFIG;\n\n    /** The name of the parser (this can be used when specifying loadParser in a ResolvedAsset) */\n    name?: string;\n\n    /**\n     * each URL to load will be tested here,\n     * if the test is passed the assets are loaded using the load function below.\n     * Good place to test for things like file extensions!\n     * @param url - The URL to test\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    test?: (url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => boolean;\n\n    /**\n     * This is the promise that loads the URL provided\n     * resolves with a loaded asset if returned by the parser.\n     * @param url - The URL to load\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    load?: <T>(url: string, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<T>;\n\n    /**\n     * This function is used to test if the parse function should be run on the asset\n     * If this returns true then parse is called with the asset\n     * @param asset - The loaded asset data\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    testParse?: (asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<boolean>;\n\n    /**\n     * Gets called on the asset it testParse passes. Useful to convert a raw asset into something more useful than\n     * @param asset - The loaded asset data\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    parse?: <T>(asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => Promise<T>;\n\n    /**\n     * If an asset is parsed using this parser, the unload function will be called when the user requests an asset\n     * to be unloaded. This is useful for things like sounds or textures that can be unloaded from memory\n     * @param asset - The asset to unload/destroy\n     * @param resolvedAsset - Any custom additional information relevant to the asset being loaded\n     * @param loader - The loader instance\n     */\n    unload?: (asset: ASSET, resolvedAsset?: ResolvedAsset<META_DATA>, loader?: Loader) => void;\n}\n"],"names":["LoaderParserPriority"],"mappings":"AAWO,IAAK,uBAAL,kBAAKA,2BAIRA,sBAAAA,sBAAA,MAAM,CAAN,IAAA,OAEAA,sBAAA,sBAAA,SAAS,KAAT,UAEAA,sBAAAA,sBAAA,OAAO,CAAA,IAAP,QARQA,wBAAA,wBAAA,CAAA,CAAA;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/WorkerManager.js

@@ -0,0 +1,58 @@
+"use strict";
+var checkImageBitmap_worker = require("../../_virtual/checkImageBitmap.worker.js"), loadImageBitmap_worker = require("../../_virtual/loadImageBitmap.worker.js");
+let UUID = 0, MAX_WORKERS;
+class WorkerManagerClass {
+  constructor() {
+    this._initialized = !1, this._createdWorkers = 0, this.workerPool = [], this.queue = [], this.resolveHash = {};
+  }
+  isImageBitmapSupported() {
+    return this._isImageBitmapSupported !== void 0 ? 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);
+      });
+    }), this._isImageBitmapSupported);
+  }
+  loadImageBitmap(src) {
+    return this._run("loadImageBitmap", [src]);
+  }
+  async _initWorkers() {
+    this._initialized || (this._initialized = !0);
+  }
+  getWorker() {
+    MAX_WORKERS === void 0 && (MAX_WORKERS = navigator.hardwareConcurrency || 4);
+    let worker = this.workerPool.pop();
+    return !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();
+    })), worker;
+  }
+  returnWorker(worker) {
+    this.workerPool.push(worker);
+  }
+  complete(data) {
+    data.error !== void 0 ? this.resolveHash[data.uuid].reject(data.error) : 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 });
+    });
+    return this.next(), promise;
+  }
+  next() {
+    if (!this.queue.length)
+      return;
+    const worker = this.getWorker();
+    if (!worker)
+      return;
+    const toDo = this.queue.pop(), 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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/WorkerManager.mjs

@@ -0,0 +1,60 @@
+import WorkerInstance from "../../_virtual/checkImageBitmap.worker.mjs";
+import WorkerInstance$1 from "../../_virtual/loadImageBitmap.worker.mjs";
+let UUID = 0, MAX_WORKERS;
+class WorkerManagerClass {
+  constructor() {
+    this._initialized = !1, this._createdWorkers = 0, this.workerPool = [], this.queue = [], this.resolveHash = {};
+  }
+  isImageBitmapSupported() {
+    return this._isImageBitmapSupported !== void 0 ? this._isImageBitmapSupported : (this._isImageBitmapSupported = new Promise((resolve) => {
+      const { worker } = new WorkerInstance();
+      worker.addEventListener("message", (event) => {
+        worker.terminate(), WorkerInstance.revokeObjectURL(), resolve(event.data);
+      });
+    }), this._isImageBitmapSupported);
+  }
+  loadImageBitmap(src) {
+    return this._run("loadImageBitmap", [src]);
+  }
+  async _initWorkers() {
+    this._initialized || (this._initialized = !0);
+  }
+  getWorker() {
+    MAX_WORKERS === void 0 && (MAX_WORKERS = navigator.hardwareConcurrency || 4);
+    let worker = this.workerPool.pop();
+    return !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();
+    })), worker;
+  }
+  returnWorker(worker) {
+    this.workerPool.push(worker);
+  }
+  complete(data) {
+    data.error !== void 0 ? this.resolveHash[data.uuid].reject(data.error) : 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 });
+    });
+    return this.next(), promise;
+  }
+  next() {
+    if (!this.queue.length)
+      return;
+    const worker = this.getWorker();
+    if (!worker)
+      return;
+    const toDo = this.queue.pop(), 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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var LoaderParser = require("./LoaderParser.js"), loadJson = require("./loadJson.js"), loadTxt = require("./loadTxt.js"), loadWebFont = require("./loadWebFont.js");
+require("./textures/index.js");
+exports.LoaderParserPriority = LoaderParser.LoaderParserPriority;
+exports.loadJson = loadJson.loadJson;
+exports.loadTxt = loadTxt.loadTxt;
+exports.getFontFamilyName = loadWebFont.getFontFamilyName;
+exports.loadWebFont = loadWebFont.loadWebFont;
+//# sourceMappingURL=index.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/index.js.map

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/index.mjs

@@ -0,0 +1,13 @@
+import { LoaderParserPriority } from "./LoaderParser.mjs";
+import { loadJson } from "./loadJson.mjs";
+import { loadTxt } from "./loadTxt.mjs";
+import { getFontFamilyName, loadWebFont } from "./loadWebFont.mjs";
+import "./textures/index.mjs";
+export {
+  LoaderParserPriority,
+  getFontFamilyName,
+  loadJson,
+  loadTxt,
+  loadWebFont
+};
+//# sourceMappingURL=index.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/index.mjs.map

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadJson.js

@@ -0,0 +1,18 @@
+"use strict";
+var core = require("@pixi/core"), checkDataUrl = require("../../utils/checkDataUrl.js"), checkExtension = require("../../utils/checkExtension.js"), LoaderParser = require("./LoaderParser.js");
+const validJSONExtension = ".json", validJSONMIME = "application/json", loadJson = {
+  extension: {
+    type: core.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.Low
+  },
+  name: "loadJson",
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validJSONMIME) || checkExtension.checkExtension(url, validJSONExtension);
+  },
+  async load(url) {
+    return await (await core.settings.ADAPTER.fetch(url)).json();
+  }
+};
+core.extensions.add(loadJson);
+exports.loadJson = loadJson;
+//# sourceMappingURL=loadJson.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadJson.js","sources":["../../../src/loader/parsers/loadJson.ts"],"sourcesContent":["import { extensions, ExtensionType, settings } from '@pixi/core';\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/** simple loader plugin for loading json data */\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 settings.ADAPTER.fetch(url);\n\n        const json = await response.json();\n\n        return json as T;\n    },\n} as LoaderParser;\n\nextensions.add(loadJson);\n"],"names":["ExtensionType","LoaderParserPriority","checkDataUrl","checkExtension","settings","extensions"],"mappings":";;AAOA,MAAM,qBAAqB,SACrB,gBAAgB,oBAGT,WAAW;AAAA,EACpB,WAAW;AAAA,IACP,MAAMA,KAAc,cAAA;AAAA,IACpB,UAAUC,aAAqB,qBAAA;AAAA,EACnC;AAAA,EAEA,MAAM;AAAA,EAEN,KAAK,KACL;AACI,WAAOC,aAAAA,aAAa,KAAK,aAAa,KAAKC,eAAAA,eAAe,KAAK,kBAAkB;AAAA,EACrF;AAAA,EAEA,MAAM,KAAQ,KACd;AAKI,WAFa,OAFI,MAAMC,cAAS,QAAQ,MAAM,GAAG,GAErB;EAGhC;AACJ;AAEAC,KAAAA,WAAW,IAAI,QAAQ;;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadJson.mjs

@@ -0,0 +1,22 @@
+import { ExtensionType, settings, extensions } from "@pixi/core";
+import { checkDataUrl } from "../../utils/checkDataUrl.mjs";
+import { checkExtension } from "../../utils/checkExtension.mjs";
+import { LoaderParserPriority } from "./LoaderParser.mjs";
+const validJSONExtension = ".json", validJSONMIME = "application/json", loadJson = {
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.Low
+  },
+  name: "loadJson",
+  test(url) {
+    return checkDataUrl(url, validJSONMIME) || checkExtension(url, validJSONExtension);
+  },
+  async load(url) {
+    return await (await settings.ADAPTER.fetch(url)).json();
+  }
+};
+extensions.add(loadJson);
+export {
+  loadJson
+};
+//# sourceMappingURL=loadJson.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadJson.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadJson.mjs","sources":["../../../src/loader/parsers/loadJson.ts"],"sourcesContent":["import { extensions, ExtensionType, settings } from '@pixi/core';\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/** simple loader plugin for loading json data */\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 settings.ADAPTER.fetch(url);\n\n        const json = await response.json();\n\n        return json as T;\n    },\n} as LoaderParser;\n\nextensions.add(loadJson);\n"],"names":[],"mappings":";;;;AAOA,MAAM,qBAAqB,SACrB,gBAAgB,oBAGT,WAAW;AAAA,EACpB,WAAW;AAAA,IACP,MAAM,cAAc;AAAA,IACpB,UAAU,qBAAqB;AAAA,EACnC;AAAA,EAEA,MAAM;AAAA,EAEN,KAAK,KACL;AACI,WAAO,aAAa,KAAK,aAAa,KAAK,eAAe,KAAK,kBAAkB;AAAA,EACrF;AAAA,EAEA,MAAM,KAAQ,KACd;AAKI,WAFa,OAFI,MAAM,SAAS,QAAQ,MAAM,GAAG,GAErB;EAGhC;AACJ;AAEA,WAAW,IAAI,QAAQ;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadTxt.js

@@ -0,0 +1,18 @@
+"use strict";
+var core = require("@pixi/core"), checkDataUrl = require("../../utils/checkDataUrl.js"), checkExtension = require("../../utils/checkExtension.js"), LoaderParser = require("./LoaderParser.js");
+const validTXTExtension = ".txt", validTXTMIME = "text/plain", loadTxt = {
+  name: "loadTxt",
+  extension: {
+    type: core.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.Low
+  },
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validTXTMIME) || checkExtension.checkExtension(url, validTXTExtension);
+  },
+  async load(url) {
+    return await (await core.settings.ADAPTER.fetch(url)).text();
+  }
+};
+core.extensions.add(loadTxt);
+exports.loadTxt = loadTxt;
+//# sourceMappingURL=loadTxt.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadTxt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadTxt.js","sources":["../../../src/loader/parsers/loadTxt.ts"],"sourcesContent":["import { extensions, ExtensionType, settings } from '@pixi/core';\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/** Simple loader plugin for loading text data */\nexport const loadTxt = {\n\n    name: 'loadTxt',\n\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.Low,\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 settings.ADAPTER.fetch(url);\n\n        const txt = await response.text();\n\n        return txt;\n    },\n} as LoaderParser;\n\nextensions.add(loadTxt);\n"],"names":["ExtensionType","LoaderParserPriority","checkDataUrl","checkExtension","settings","extensions"],"mappings":";;AAOA,MAAM,oBAAoB,QACpB,eAAe,cAGR,UAAU;AAAA,EAEnB,MAAM;AAAA,EAEN,WAAW;AAAA,IACP,MAAMA,KAAc,cAAA;AAAA,IACpB,UAAUC,aAAqB,qBAAA;AAAA,EACnC;AAAA,EAEA,KAAK,KACL;AACI,WAAOC,aAAAA,aAAa,KAAK,YAAY,KAAKC,eAAAA,eAAe,KAAK,iBAAiB;AAAA,EACnF;AAAA,EAEA,MAAM,KAAK,KACX;AAKI,WAFY,OAFK,MAAMC,cAAS,QAAQ,MAAM,GAAG,GAEtB;EAG/B;AACJ;AAEAC,KAAAA,WAAW,IAAI,OAAO;;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadTxt.mjs

@@ -0,0 +1,22 @@
+import { ExtensionType, settings, extensions } from "@pixi/core";
+import { checkDataUrl } from "../../utils/checkDataUrl.mjs";
+import { checkExtension } from "../../utils/checkExtension.mjs";
+import { LoaderParserPriority } from "./LoaderParser.mjs";
+const validTXTExtension = ".txt", validTXTMIME = "text/plain", loadTxt = {
+  name: "loadTxt",
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.Low
+  },
+  test(url) {
+    return checkDataUrl(url, validTXTMIME) || checkExtension(url, validTXTExtension);
+  },
+  async load(url) {
+    return await (await settings.ADAPTER.fetch(url)).text();
+  }
+};
+extensions.add(loadTxt);
+export {
+  loadTxt
+};
+//# sourceMappingURL=loadTxt.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadTxt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadTxt.mjs","sources":["../../../src/loader/parsers/loadTxt.ts"],"sourcesContent":["import { extensions, ExtensionType, settings } from '@pixi/core';\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/** Simple loader plugin for loading text data */\nexport const loadTxt = {\n\n    name: 'loadTxt',\n\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.Low,\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 settings.ADAPTER.fetch(url);\n\n        const txt = await response.text();\n\n        return txt;\n    },\n} as LoaderParser;\n\nextensions.add(loadTxt);\n"],"names":[],"mappings":";;;;AAOA,MAAM,oBAAoB,QACpB,eAAe,cAGR,UAAU;AAAA,EAEnB,MAAM;AAAA,EAEN,WAAW;AAAA,IACP,MAAM,cAAc;AAAA,IACpB,UAAU,qBAAqB;AAAA,EACnC;AAAA,EAEA,KAAK,KACL;AACI,WAAO,aAAa,KAAK,YAAY,KAAK,eAAe,KAAK,iBAAiB;AAAA,EACnF;AAAA,EAEA,MAAM,KAAK,KACX;AAKI,WAFY,OAFK,MAAM,SAAS,QAAQ,MAAM,GAAG,GAEtB;EAG/B;AACJ;AAEA,WAAW,IAAI,OAAO;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadWebFont.js

@@ -0,0 +1,67 @@
+"use strict";
+var core = require("@pixi/core"), checkDataUrl = require("../../utils/checkDataUrl.js"), checkExtension = require("../../utils/checkExtension.js"), LoaderParser = require("./LoaderParser.js");
+const validWeights = [
+  "normal",
+  "bold",
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900"
+], validFontExtensions = [".ttf", ".otf", ".woff", ".woff2"], validFontMIMEs = [
+  "font/ttf",
+  "font/otf",
+  "font/woff",
+  "font/woff2"
+], CSS_IDENT_TOKEN_REGEX = /^(--|-?[A-Z_])[0-9A-Z_-]*$/i;
+function getFontFamilyName(url) {
+  const ext = core.utils.path.extname(url), nameTokens = core.utils.path.basename(url, ext).replace(/(-|_)/g, " ").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 = !1;
+      break;
+    }
+  let fontFamilyName = nameTokens.join(" ");
+  return valid || (fontFamilyName = `"${fontFamilyName.replace(/[\\"]/g, "\\$&")}"`), fontFamilyName;
+}
+const validURICharactersRegex = /^[0-9A-Za-z%:/?#\[\]@!\$&'()\*\+,;=\-._~]*$/;
+function encodeURIWhenNeeded(uri) {
+  return validURICharactersRegex.test(uri) ? uri : encodeURI(uri);
+}
+const loadWebFont = {
+  extension: {
+    type: core.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 = core.settings.ADAPTER.getFontFaceSet();
+    if (fonts) {
+      const fontFaces = [], name = options.data?.family ?? getFontFamilyName(url), weights = options.data?.weights?.filter((weight) => validWeights.includes(weight)) ?? ["normal"], data = options.data ?? {};
+      for (let i = 0; i < weights.length; i++) {
+        const weight = weights[i], font = new FontFace(name, `url(${encodeURIWhenNeeded(url)})`, {
+          ...data,
+          weight
+        });
+        await font.load(), fonts.add(font), fontFaces.push(font);
+      }
+      return fontFaces.length === 1 ? fontFaces[0] : fontFaces;
+    }
+    return console.warn("[loadWebFont] FontFace API is not supported. Skipping loading font"), null;
+  },
+  unload(font) {
+    (Array.isArray(font) ? font : [font]).forEach((t) => core.settings.ADAPTER.getFontFaceSet().delete(t));
+  }
+};
+core.extensions.add(loadWebFont);
+exports.getFontFamilyName = getFontFamilyName;
+exports.loadWebFont = loadWebFont;
+//# sourceMappingURL=loadWebFont.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/loadWebFont.mjs

@@ -0,0 +1,71 @@
+import { utils, ExtensionType, settings, extensions } from "@pixi/core";
+import { checkDataUrl } from "../../utils/checkDataUrl.mjs";
+import { checkExtension } from "../../utils/checkExtension.mjs";
+import { LoaderParserPriority } from "./LoaderParser.mjs";
+const validWeights = [
+  "normal",
+  "bold",
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900"
+], validFontExtensions = [".ttf", ".otf", ".woff", ".woff2"], validFontMIMEs = [
+  "font/ttf",
+  "font/otf",
+  "font/woff",
+  "font/woff2"
+], CSS_IDENT_TOKEN_REGEX = /^(--|-?[A-Z_])[0-9A-Z_-]*$/i;
+function getFontFamilyName(url) {
+  const ext = utils.path.extname(url), nameTokens = utils.path.basename(url, ext).replace(/(-|_)/g, " ").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 = !1;
+      break;
+    }
+  let fontFamilyName = nameTokens.join(" ");
+  return valid || (fontFamilyName = `"${fontFamilyName.replace(/[\\"]/g, "\\$&")}"`), fontFamilyName;
+}
+const validURICharactersRegex = /^[0-9A-Za-z%:/?#\[\]@!\$&'()\*\+,;=\-._~]*$/;
+function encodeURIWhenNeeded(uri) {
+  return validURICharactersRegex.test(uri) ? uri : 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 = settings.ADAPTER.getFontFaceSet();
+    if (fonts) {
+      const fontFaces = [], name = options.data?.family ?? getFontFamilyName(url), weights = options.data?.weights?.filter((weight) => validWeights.includes(weight)) ?? ["normal"], data = options.data ?? {};
+      for (let i = 0; i < weights.length; i++) {
+        const weight = weights[i], font = new FontFace(name, `url(${encodeURIWhenNeeded(url)})`, {
+          ...data,
+          weight
+        });
+        await font.load(), fonts.add(font), fontFaces.push(font);
+      }
+      return fontFaces.length === 1 ? fontFaces[0] : fontFaces;
+    }
+    return console.warn("[loadWebFont] FontFace API is not supported. Skipping loading font"), null;
+  },
+  unload(font) {
+    (Array.isArray(font) ? font : [font]).forEach((t) => settings.ADAPTER.getFontFaceSet().delete(t));
+  }
+};
+extensions.add(loadWebFont);
+export {
+  getFontFamilyName,
+  loadWebFont
+};
+//# sourceMappingURL=loadWebFont.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var loadSVG = require("./loadSVG.js"), loadTextures = require("./loadTextures.js"), loadVideo = require("./loadVideo.js");
+require("./utils/index.js");
+exports.loadSVG = loadSVG.loadSVG;
+exports.loadImageBitmap = loadTextures.loadImageBitmap;
+exports.loadTextures = loadTextures.loadTextures;
+exports.loadVideo = loadVideo.loadVideo;
+//# sourceMappingURL=index.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/index.js.map

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/index.mjs

@@ -0,0 +1,11 @@
+import { loadSVG } from "./loadSVG.mjs";
+import { loadImageBitmap, loadTextures } from "./loadTextures.mjs";
+import { loadVideo } from "./loadVideo.mjs";
+import "./utils/index.mjs";
+export {
+  loadImageBitmap,
+  loadSVG,
+  loadTextures,
+  loadVideo
+};
+//# sourceMappingURL=index.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/index.mjs.map

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadSVG.js

@@ -0,0 +1,31 @@
+"use strict";
+var core = require("@pixi/core"), checkDataUrl = require("../../../utils/checkDataUrl.js"), checkExtension = require("../../../utils/checkExtension.js"), LoaderParser = require("../LoaderParser.js"), loadTextures = require("./loadTextures.js"), createTexture = require("./utils/createTexture.js");
+const validSVGExtension = ".svg", validSVGMIME = "image/svg+xml", loadSVG = {
+  extension: {
+    type: core.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.High
+  },
+  name: "loadSVG",
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validSVGMIME) || checkExtension.checkExtension(url, validSVGExtension);
+  },
+  async testParse(data) {
+    return core.SVGResource.test(data);
+  },
+  async parse(asset, data, loader) {
+    const src = new core.SVGResource(asset, data?.data?.resourceOptions);
+    await src.load();
+    const base = new core.BaseTexture(src, {
+      resolution: core.utils.getResolutionOfUrl(asset),
+      ...data?.data
+    });
+    return base.resource.src = data.src, createTexture.createTexture(base, loader, data.src);
+  },
+  async load(url, _options) {
+    return (await core.settings.ADAPTER.fetch(url)).text();
+  },
+  unload: loadTextures.loadTextures.unload
+};
+core.extensions.add(loadSVG);
+exports.loadSVG = loadSVG;
+//# sourceMappingURL=loadSVG.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadSVG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadSVG.js","sources":["../../../../src/loader/parsers/textures/loadSVG.ts"],"sourcesContent":["import { BaseTexture, extensions, ExtensionType, settings, SVGResource, utils } from '@pixi/core';\nimport { checkDataUrl } from '../../../utils/checkDataUrl';\nimport { checkExtension } from '../../../utils/checkExtension';\nimport { LoaderParserPriority } from '../LoaderParser';\nimport { loadTextures } from './loadTextures';\nimport { createTexture } from './utils/createTexture';\n\nimport type { IBaseTextureOptions, Texture } from '@pixi/core';\nimport type { ResolvedAsset } from '../../../types';\nimport type { Loader } from '../../Loader';\nimport type { LoaderParser } from '../LoaderParser';\n\nconst validSVGExtension = '.svg';\nconst validSVGMIME = 'image/svg+xml';\n\n/**\n * Loads SVG's into Textures.\n * @memberof PIXI\n */\nexport const loadSVG = {\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.High,\n    },\n\n    name: 'loadSVG',\n\n    test(url: string): boolean\n    {\n        return checkDataUrl(url, validSVGMIME) || checkExtension(url, validSVGExtension);\n    },\n\n    async testParse(data: string): Promise<boolean>\n    {\n        return SVGResource.test(data);\n    },\n\n    async parse(asset: string, data: ResolvedAsset<IBaseTextureOptions>, loader: Loader): Promise<Texture>\n    {\n        const src = new SVGResource(asset, data?.data?.resourceOptions);\n\n        await src.load();\n\n        const base = new BaseTexture(src, {\n            resolution: utils.getResolutionOfUrl(asset),\n            ...data?.data,\n        });\n\n        base.resource.src = data.src;\n\n        const texture = createTexture(base, loader, data.src);\n\n        return texture;\n    },\n\n    async load(url: string, _options: ResolvedAsset): Promise<string>\n    {\n        const response = await settings.ADAPTER.fetch(url);\n\n        return response.text();\n    },\n\n    unload: loadTextures.unload,\n\n} as LoaderParser<Texture | string, IBaseTextureOptions>;\n\nextensions.add(loadSVG);\n"],"names":["ExtensionType","LoaderParserPriority","checkDataUrl","checkExtension","SVGResource","BaseTexture","utils","createTexture","settings","loadTextures","extensions"],"mappings":";;AAYA,MAAM,oBAAoB,QACpB,eAAe,iBAMR,UAAU;AAAA,EACnB,WAAW;AAAA,IACP,MAAMA,KAAc,cAAA;AAAA,IACpB,UAAUC,aAAqB,qBAAA;AAAA,EACnC;AAAA,EAEA,MAAM;AAAA,EAEN,KAAK,KACL;AACI,WAAOC,aAAAA,aAAa,KAAK,YAAY,KAAKC,eAAAA,eAAe,KAAK,iBAAiB;AAAA,EACnF;AAAA,EAEA,MAAM,UAAU,MAChB;AACW,WAAAC,KAAA,YAAY,KAAK,IAAI;AAAA,EAChC;AAAA,EAEA,MAAM,MAAM,OAAe,MAA0C,QACrE;AACI,UAAM,MAAM,IAAIA,iBAAY,OAAO,MAAM,MAAM,eAAe;AAE9D,UAAM,IAAI;AAEJ,UAAA,OAAO,IAAIC,KAAA,YAAY,KAAK;AAAA,MAC9B,YAAYC,KAAAA,MAAM,mBAAmB,KAAK;AAAA,MAC1C,GAAG,MAAM;AAAA,IAAA,CACZ;AAEI,WAAA,KAAA,SAAS,MAAM,KAAK,KAETC,4BAAc,MAAM,QAAQ,KAAK,GAAG;AAAA,EAGxD;AAAA,EAEA,MAAM,KAAK,KAAa,UACxB;AAGI,YAFiB,MAAMC,KAAAA,SAAS,QAAQ,MAAM,GAAG,GAEjC;EACpB;AAAA,EAEA,QAAQC,aAAa,aAAA;AAEzB;AAEAC,KAAAA,WAAW,IAAI,OAAO;;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadSVG.mjs

@@ -0,0 +1,37 @@
+import { ExtensionType, SVGResource, BaseTexture, utils, settings, extensions } from "@pixi/core";
+import { checkDataUrl } from "../../../utils/checkDataUrl.mjs";
+import { checkExtension } from "../../../utils/checkExtension.mjs";
+import { LoaderParserPriority } from "../LoaderParser.mjs";
+import { loadTextures } from "./loadTextures.mjs";
+import { createTexture } from "./utils/createTexture.mjs";
+const validSVGExtension = ".svg", validSVGMIME = "image/svg+xml", 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: utils.getResolutionOfUrl(asset),
+      ...data?.data
+    });
+    return base.resource.src = data.src, createTexture(base, loader, data.src);
+  },
+  async load(url, _options) {
+    return (await settings.ADAPTER.fetch(url)).text();
+  },
+  unload: loadTextures.unload
+};
+extensions.add(loadSVG);
+export {
+  loadSVG
+};
+//# sourceMappingURL=loadSVG.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadSVG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadSVG.mjs","sources":["../../../../src/loader/parsers/textures/loadSVG.ts"],"sourcesContent":["import { BaseTexture, extensions, ExtensionType, settings, SVGResource, utils } from '@pixi/core';\nimport { checkDataUrl } from '../../../utils/checkDataUrl';\nimport { checkExtension } from '../../../utils/checkExtension';\nimport { LoaderParserPriority } from '../LoaderParser';\nimport { loadTextures } from './loadTextures';\nimport { createTexture } from './utils/createTexture';\n\nimport type { IBaseTextureOptions, Texture } from '@pixi/core';\nimport type { ResolvedAsset } from '../../../types';\nimport type { Loader } from '../../Loader';\nimport type { LoaderParser } from '../LoaderParser';\n\nconst validSVGExtension = '.svg';\nconst validSVGMIME = 'image/svg+xml';\n\n/**\n * Loads SVG's into Textures.\n * @memberof PIXI\n */\nexport const loadSVG = {\n    extension: {\n        type: ExtensionType.LoadParser,\n        priority: LoaderParserPriority.High,\n    },\n\n    name: 'loadSVG',\n\n    test(url: string): boolean\n    {\n        return checkDataUrl(url, validSVGMIME) || checkExtension(url, validSVGExtension);\n    },\n\n    async testParse(data: string): Promise<boolean>\n    {\n        return SVGResource.test(data);\n    },\n\n    async parse(asset: string, data: ResolvedAsset<IBaseTextureOptions>, loader: Loader): Promise<Texture>\n    {\n        const src = new SVGResource(asset, data?.data?.resourceOptions);\n\n        await src.load();\n\n        const base = new BaseTexture(src, {\n            resolution: utils.getResolutionOfUrl(asset),\n            ...data?.data,\n        });\n\n        base.resource.src = data.src;\n\n        const texture = createTexture(base, loader, data.src);\n\n        return texture;\n    },\n\n    async load(url: string, _options: ResolvedAsset): Promise<string>\n    {\n        const response = await settings.ADAPTER.fetch(url);\n\n        return response.text();\n    },\n\n    unload: loadTextures.unload,\n\n} as LoaderParser<Texture | string, IBaseTextureOptions>;\n\nextensions.add(loadSVG);\n"],"names":[],"mappings":";;;;;;AAYA,MAAM,oBAAoB,QACpB,eAAe,iBAMR,UAAU;AAAA,EACnB,WAAW;AAAA,IACP,MAAM,cAAc;AAAA,IACpB,UAAU,qBAAqB;AAAA,EACnC;AAAA,EAEA,MAAM;AAAA,EAEN,KAAK,KACL;AACI,WAAO,aAAa,KAAK,YAAY,KAAK,eAAe,KAAK,iBAAiB;AAAA,EACnF;AAAA,EAEA,MAAM,UAAU,MAChB;AACW,WAAA,YAAY,KAAK,IAAI;AAAA,EAChC;AAAA,EAEA,MAAM,MAAM,OAAe,MAA0C,QACrE;AACI,UAAM,MAAM,IAAI,YAAY,OAAO,MAAM,MAAM,eAAe;AAE9D,UAAM,IAAI;AAEJ,UAAA,OAAO,IAAI,YAAY,KAAK;AAAA,MAC9B,YAAY,MAAM,mBAAmB,KAAK;AAAA,MAC1C,GAAG,MAAM;AAAA,IAAA,CACZ;AAEI,WAAA,KAAA,SAAS,MAAM,KAAK,KAET,cAAc,MAAM,QAAQ,KAAK,GAAG;AAAA,EAGxD;AAAA,EAEA,MAAM,KAAK,KAAa,UACxB;AAGI,YAFiB,MAAM,SAAS,QAAQ,MAAM,GAAG,GAEjC;EACpB;AAAA,EAEA,QAAQ,aAAa;AAEzB;AAEA,WAAW,IAAI,OAAO;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadTextures.js

@@ -0,0 +1,49 @@
+"use strict";
+var core = require("@pixi/core"), checkDataUrl = require("../../../utils/checkDataUrl.js"), checkExtension = require("../../../utils/checkExtension.js"), LoaderParser = require("../LoaderParser.js"), WorkerManager = require("../WorkerManager.js"), createTexture = require("./utils/createTexture.js");
+const validImageExtensions = [".jpeg", ".jpg", ".png", ".webp", ".avif"], validImageMIMEs = [
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/avif"
+];
+async function loadImageBitmap(url) {
+  const response = await core.settings.ADAPTER.fetch(url);
+  if (!response.ok)
+    throw new Error(`[loadImageBitmap] Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  const imageBlob = await response.blob();
+  return await createImageBitmap(imageBlob);
+}
+const loadTextures = {
+  name: "loadTextures",
+  extension: {
+    type: core.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.High
+  },
+  config: {
+    preferWorkers: !0,
+    preferCreateImageBitmap: !0,
+    crossOrigin: "anonymous"
+  },
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validImageMIMEs) || checkExtension.checkExtension(url, validImageExtensions);
+  },
+  async load(url, asset, loader) {
+    const useImageBitmap = globalThis.createImageBitmap && this.config.preferCreateImageBitmap;
+    let src;
+    useImageBitmap ? this.config.preferWorkers && await WorkerManager.WorkerManager.isImageBitmapSupported() ? src = await WorkerManager.WorkerManager.loadImageBitmap(url) : src = await loadImageBitmap(url) : src = await new Promise((resolve, reject) => {
+      const src2 = new Image();
+      src2.crossOrigin = this.config.crossOrigin, src2.src = url, src2.complete ? resolve(src2) : (src2.onload = () => resolve(src2), src2.onerror = (e) => reject(e));
+    });
+    const options = { ...asset.data };
+    options.resolution ?? (options.resolution = core.utils.getResolutionOfUrl(url)), useImageBitmap && options.resourceOptions?.ownsImageBitmap === void 0 && (options.resourceOptions = { ...options.resourceOptions }, options.resourceOptions.ownsImageBitmap = !0);
+    const base = new core.BaseTexture(src, options);
+    return base.resource.src = url, createTexture.createTexture(base, loader, url);
+  },
+  unload(texture) {
+    texture.destroy(!0);
+  }
+};
+core.extensions.add(loadTextures);
+exports.loadImageBitmap = loadImageBitmap;
+exports.loadTextures = loadTextures;
+//# sourceMappingURL=loadTextures.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadTextures.mjs

@@ -0,0 +1,55 @@
+import { settings, ExtensionType, utils, BaseTexture, extensions } from "@pixi/core";
+import { checkDataUrl } from "../../../utils/checkDataUrl.mjs";
+import { checkExtension } from "../../../utils/checkExtension.mjs";
+import { LoaderParserPriority } from "../LoaderParser.mjs";
+import { WorkerManager } from "../WorkerManager.mjs";
+import { createTexture } from "./utils/createTexture.mjs";
+const validImageExtensions = [".jpeg", ".jpg", ".png", ".webp", ".avif"], 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();
+  return await createImageBitmap(imageBlob);
+}
+const loadTextures = {
+  name: "loadTextures",
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.High
+  },
+  config: {
+    preferWorkers: !0,
+    preferCreateImageBitmap: !0,
+    crossOrigin: "anonymous"
+  },
+  test(url) {
+    return checkDataUrl(url, validImageMIMEs) || checkExtension(url, validImageExtensions);
+  },
+  async load(url, asset, loader) {
+    const useImageBitmap = globalThis.createImageBitmap && this.config.preferCreateImageBitmap;
+    let src;
+    useImageBitmap ? this.config.preferWorkers && await WorkerManager.isImageBitmapSupported() ? src = await WorkerManager.loadImageBitmap(url) : src = await loadImageBitmap(url) : src = await new Promise((resolve, reject) => {
+      const src2 = new Image();
+      src2.crossOrigin = this.config.crossOrigin, src2.src = url, src2.complete ? resolve(src2) : (src2.onload = () => resolve(src2), src2.onerror = (e) => reject(e));
+    });
+    const options = { ...asset.data };
+    options.resolution ?? (options.resolution = utils.getResolutionOfUrl(url)), useImageBitmap && options.resourceOptions?.ownsImageBitmap === void 0 && (options.resourceOptions = { ...options.resourceOptions }, options.resourceOptions.ownsImageBitmap = !0);
+    const base = new BaseTexture(src, options);
+    return base.resource.src = url, createTexture(base, loader, url);
+  },
+  unload(texture) {
+    texture.destroy(!0);
+  }
+};
+extensions.add(loadTextures);
+export {
+  loadImageBitmap,
+  loadTextures
+};
+//# sourceMappingURL=loadTextures.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadVideo.js

@@ -0,0 +1,56 @@
+"use strict";
+var core = require("@pixi/core"), checkDataUrl = require("../../../utils/checkDataUrl.js"), checkExtension = require("../../../utils/checkExtension.js"), LoaderParser = require("../LoaderParser.js"), createTexture = require("./utils/createTexture.js");
+const validVideoExtensions = [".mp4", ".m4v", ".webm", ".ogv"], validVideoMIMEs = [
+  "video/mp4",
+  "video/webm",
+  "video/ogg"
+], loadVideo = {
+  name: "loadVideo",
+  extension: {
+    type: core.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.High
+  },
+  config: {
+    defaultAutoPlay: !0,
+    defaultUpdateFPS: 0,
+    defaultLoop: !1,
+    defaultMuted: !1,
+    defaultPlaysinline: !0
+  },
+  test(url) {
+    return checkDataUrl.checkDataUrl(url, validVideoMIMEs) || checkExtension.checkExtension(url, validVideoExtensions);
+  },
+  async load(url, loadAsset, loader) {
+    let texture;
+    const blob = await (await core.settings.ADAPTER.fetch(url)).blob(), blobURL = URL.createObjectURL(blob);
+    try {
+      const options = {
+        autoPlay: this.config.defaultAutoPlay,
+        updateFPS: this.config.defaultUpdateFPS,
+        loop: this.config.defaultLoop,
+        muted: this.config.defaultMuted,
+        playsinline: this.config.defaultPlaysinline,
+        ...loadAsset?.data?.resourceOptions,
+        autoLoad: !0
+      }, src = new core.VideoResource(blobURL, options);
+      await src.load();
+      const base = new core.BaseTexture(src, {
+        alphaMode: await core.utils.detectVideoAlphaMode(),
+        resolution: core.utils.getResolutionOfUrl(url),
+        ...loadAsset?.data
+      });
+      base.resource.src = url, texture = createTexture.createTexture(base, loader, url), texture.baseTexture.once("destroyed", () => {
+        URL.revokeObjectURL(blobURL);
+      });
+    } catch (e) {
+      throw URL.revokeObjectURL(blobURL), e;
+    }
+    return texture;
+  },
+  unload(texture) {
+    texture.destroy(!0);
+  }
+};
+core.extensions.add(loadVideo);
+exports.loadVideo = loadVideo;
+//# sourceMappingURL=loadVideo.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/loadVideo.mjs

@@ -0,0 +1,61 @@
+import { ExtensionType, settings, VideoResource, BaseTexture, utils, extensions } from "@pixi/core";
+import { checkDataUrl } from "../../../utils/checkDataUrl.mjs";
+import { checkExtension } from "../../../utils/checkExtension.mjs";
+import { LoaderParserPriority } from "../LoaderParser.mjs";
+import { createTexture } from "./utils/createTexture.mjs";
+const validVideoExtensions = [".mp4", ".m4v", ".webm", ".ogv"], validVideoMIMEs = [
+  "video/mp4",
+  "video/webm",
+  "video/ogg"
+], loadVideo = {
+  name: "loadVideo",
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.High
+  },
+  config: {
+    defaultAutoPlay: !0,
+    defaultUpdateFPS: 0,
+    defaultLoop: !1,
+    defaultMuted: !1,
+    defaultPlaysinline: !0
+  },
+  test(url) {
+    return checkDataUrl(url, validVideoMIMEs) || checkExtension(url, validVideoExtensions);
+  },
+  async load(url, loadAsset, loader) {
+    let texture;
+    const blob = await (await settings.ADAPTER.fetch(url)).blob(), blobURL = URL.createObjectURL(blob);
+    try {
+      const options = {
+        autoPlay: this.config.defaultAutoPlay,
+        updateFPS: this.config.defaultUpdateFPS,
+        loop: this.config.defaultLoop,
+        muted: this.config.defaultMuted,
+        playsinline: this.config.defaultPlaysinline,
+        ...loadAsset?.data?.resourceOptions,
+        autoLoad: !0
+      }, src = new VideoResource(blobURL, options);
+      await src.load();
+      const base = new BaseTexture(src, {
+        alphaMode: await utils.detectVideoAlphaMode(),
+        resolution: utils.getResolutionOfUrl(url),
+        ...loadAsset?.data
+      });
+      base.resource.src = url, texture = createTexture(base, loader, url), texture.baseTexture.once("destroyed", () => {
+        URL.revokeObjectURL(blobURL);
+      });
+    } catch (e) {
+      throw URL.revokeObjectURL(blobURL), e;
+    }
+    return texture;
+  },
+  unload(texture) {
+    texture.destroy(!0);
+  }
+};
+extensions.add(loadVideo);
+export {
+  loadVideo
+};
+//# sourceMappingURL=loadVideo.mjs.map

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

@@ -0,0 +1,15 @@
+"use strict";
+var core = require("@pixi/core"), Cache = require("../../../../cache/Cache.js");
+function createTexture(base, loader, url) {
+  base.resource.internal = !0;
+  const texture = new core.Texture(base), unload = () => {
+    delete loader.promiseCache[url], Cache.Cache.has(url) && Cache.Cache.remove(url);
+  };
+  return texture.baseTexture.once("destroyed", () => {
+    url in loader.promiseCache && (console.warn("[Assets] A BaseTexture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the BaseTexture."), unload());
+  }), texture.once("destroyed", () => {
+    base.destroyed || (console.warn("[Assets] A Texture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the Texture."), unload());
+  }), texture;
+}
+exports.createTexture = createTexture;
+//# sourceMappingURL=createTexture.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTexture.js","sources":["../../../../../src/loader/parsers/textures/utils/createTexture.ts"],"sourcesContent":["import { Texture } from '@pixi/core';\nimport { Cache } from '../../../../cache/Cache';\n\nimport type { BaseTexture } from '@pixi/core';\nimport type { Loader } from '../../../Loader';\n\nexport function createTexture(base: BaseTexture, loader: Loader, url: string)\n{\n    // make sure the resource is destroyed when the base texture is destroyed\n    base.resource.internal = true;\n\n    const texture = new Texture(base);\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.baseTexture.once('destroyed', () =>\n    {\n        if (url in loader.promiseCache)\n        {\n            console.warn('[Assets] A BaseTexture managed by Assets was destroyed instead of unloaded! '\n                + 'Use Assets.unload() instead of destroying the BaseTexture.');\n            unload();\n        }\n    });\n    texture.once('destroyed', () =>\n    {\n        if (!base.destroyed)\n        {\n            console.warn('[Assets] A Texture managed by Assets was destroyed instead of unloaded! '\n                + 'Use Assets.unload() instead of destroying the Texture.');\n            unload();\n        }\n    });\n\n    return texture;\n}\n"],"names":["Texture","Cache"],"mappings":";;AAMgB,SAAA,cAAc,MAAmB,QAAgB,KACjE;AAEI,OAAK,SAAS,WAAW;AAEzB,QAAM,UAAU,IAAIA,KAAAA,QAAQ,IAAI,GAC1B,SAAS,MACf;AACW,WAAA,OAAO,aAAa,GAAG,GAE1BC,MAAA,MAAM,IAAI,GAAG,KAEbA,MAAAA,MAAM,OAAO,GAAG;AAAA,EAAA;AAKhB,SAAA,QAAA,YAAY,KAAK,aAAa,MACtC;AACQ,WAAO,OAAO,iBAEd,QAAQ,KAAK,wIACqD,GAClE,OAAO;AAAA,EAEd,CAAA,GACD,QAAQ,KAAK,aAAa,MAC1B;AACS,SAAK,cAEN,QAAQ,KAAK,gIACiD,GAC9D,OAAO;AAAA,EAEd,CAAA,GAEM;AACX;;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/utils/createTexture.mjs

@@ -0,0 +1,17 @@
+import { Texture } from "@pixi/core";
+import { Cache } from "../../../../cache/Cache.mjs";
+function createTexture(base, loader, url) {
+  base.resource.internal = !0;
+  const texture = new Texture(base), unload = () => {
+    delete loader.promiseCache[url], Cache.has(url) && Cache.remove(url);
+  };
+  return texture.baseTexture.once("destroyed", () => {
+    url in loader.promiseCache && (console.warn("[Assets] A BaseTexture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the BaseTexture."), unload());
+  }), texture.once("destroyed", () => {
+    base.destroyed || (console.warn("[Assets] A Texture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the Texture."), unload());
+  }), texture;
+}
+export {
+  createTexture
+};
+//# sourceMappingURL=createTexture.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/utils/createTexture.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTexture.mjs","sources":["../../../../../src/loader/parsers/textures/utils/createTexture.ts"],"sourcesContent":["import { Texture } from '@pixi/core';\nimport { Cache } from '../../../../cache/Cache';\n\nimport type { BaseTexture } from '@pixi/core';\nimport type { Loader } from '../../../Loader';\n\nexport function createTexture(base: BaseTexture, loader: Loader, url: string)\n{\n    // make sure the resource is destroyed when the base texture is destroyed\n    base.resource.internal = true;\n\n    const texture = new Texture(base);\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.baseTexture.once('destroyed', () =>\n    {\n        if (url in loader.promiseCache)\n        {\n            console.warn('[Assets] A BaseTexture managed by Assets was destroyed instead of unloaded! '\n                + 'Use Assets.unload() instead of destroying the BaseTexture.');\n            unload();\n        }\n    });\n    texture.once('destroyed', () =>\n    {\n        if (!base.destroyed)\n        {\n            console.warn('[Assets] A Texture managed by Assets was destroyed instead of unloaded! '\n                + 'Use Assets.unload() instead of destroying the Texture.');\n            unload();\n        }\n    });\n\n    return texture;\n}\n"],"names":[],"mappings":";;AAMgB,SAAA,cAAc,MAAmB,QAAgB,KACjE;AAEI,OAAK,SAAS,WAAW;AAEzB,QAAM,UAAU,IAAI,QAAQ,IAAI,GAC1B,SAAS,MACf;AACW,WAAA,OAAO,aAAa,GAAG,GAE1B,MAAM,IAAI,GAAG,KAEb,MAAM,OAAO,GAAG;AAAA,EAAA;AAKhB,SAAA,QAAA,YAAY,KAAK,aAAa,MACtC;AACQ,WAAO,OAAO,iBAEd,QAAQ,KAAK,wIACqD,GAClE,OAAO;AAAA,EAEd,CAAA,GACD,QAAQ,KAAK,aAAa,MAC1B;AACS,SAAK,cAEN,QAAQ,KAAK,gIACiD,GAC9D,OAAO;AAAA,EAEd,CAAA,GAEM;AACX;"}

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+var createTexture = require("./createTexture.js");
+exports.createTexture = createTexture.createTexture;
+//# sourceMappingURL=index.js.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/utils/index.js.map

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

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/utils/index.mjs

@@ -0,0 +1,5 @@
+import { createTexture } from "./createTexture.mjs";
+export {
+  createTexture
+};
+//# sourceMappingURL=index.mjs.map

resources/app/node_modules/@pixi/assets/lib/loader/parsers/textures/utils/index.mjs.map

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