shadow$provide.module$node_modules$pixi_DOT_js$lib$assets$loader$Loader = function(global, require, module, exports) {
  var warn = require("module$node_modules$pixi_DOT_js$lib$utils$logging$warn"), path = require("module$node_modules$pixi_DOT_js$lib$utils$path"), convertToList = require("module$node_modules$pixi_DOT_js$lib$assets$utils$convertToList"), isSingleItem = require("module$node_modules$pixi_DOT_js$lib$assets$utils$isSingleItem");
  "use strict";
  const node_modules$pixi_DOT_js$lib$assets$loader$Loader$classdecl$var37 = class {
    constructor() {
      this.loadOptions = {...node_modules$pixi_DOT_js$lib$assets$loader$Loader$classdecl$var37.defaultOptions};
      this._parsers = [];
      this._parsersValidated = !1;
      this.parsers = new Proxy(this._parsers, {set:(target, key, value) => {
        this._parsersValidated = !1;
        target[key] = value;
        return !0;
      }});
      this.promiseCache = {};
    }
    reset() {
      this._parsersValidated = !1;
      this.promiseCache = {};
    }
    _getLoadPromiseAndParser(url, data) {
      const result = {promise:null, parser:null};
      result.promise = (async() => {
        var asset, parser = null;
        if (data.parser || data.loadParser) {
          parser = this._parserHash[data.parser || data.loadParser], data.loadParser && warn.warn(`[Assets] "loadParser" is deprecated, use "parser" instead for ${url}`), parser || warn.warn(`[Assets] specified load parser "${data.parser || data.loadParser}" not found while loading ${url}`);
        }
        if (!parser) {
          for (asset = 0; asset < this.parsers.length; asset++) {
            var parserX = this.parsers[asset];
            if (parserX.load && parserX.test?.(url, data, this)) {
              parser = parserX;
              break;
            }
          }
          if (!parser) {
            return warn.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 (parser = 0; parser < this.parsers.length; parser++) {
          parserX = this.parsers[parser], parserX.parse && parserX.parse && await parserX.testParse?.(asset, data, this) && (asset = await parserX.parse(asset, data, this) || asset, result.parser = parserX);
        }
        return asset;
      })();
      return result;
    }
    async load(assetsToLoadIn, onProgressOrOptions) {
      this._parsersValidated || this._validateParsers();
      const {onProgress, onError, strategy, retryCount, retryDelay} = "function" === typeof onProgressOrOptions ? {...node_modules$pixi_DOT_js$lib$assets$loader$Loader$classdecl$var37.defaultOptions, ...this.loadOptions, onProgress:onProgressOrOptions} : {...node_modules$pixi_DOT_js$lib$assets$loader$Loader$classdecl$var37.defaultOptions, ...this.loadOptions, ...(onProgressOrOptions || {})};
      let count = 0;
      const assets = {};
      onProgressOrOptions = isSingleItem.isSingleItem(assetsToLoadIn);
      assetsToLoadIn = convertToList.convertToList(assetsToLoadIn, item => ({alias:[item], src:item, data:{}}));
      const total = assetsToLoadIn.reduce((sum, asset) => sum + (asset.progressSize || 1), 0), promises = assetsToLoadIn.map(async asset => {
        const url = path.path.toAbsolute(asset.src);
        assets[asset.src] || (await this._loadAssetWithRetry(url, asset, {onProgress, onError, strategy, retryCount, retryDelay}, assets), count += asset.progressSize || 1, onProgress && onProgress(count / total));
      });
      await Promise.all(promises);
      return onProgressOrOptions ? assets[assetsToLoadIn[0].src] : assets;
    }
    async unload(assetsToUnloadIn) {
      assetsToUnloadIn = convertToList.convertToList(assetsToUnloadIn, item => ({alias:[item], src:item})).map(async asset => {
        const url = path.path.toAbsolute(asset.src), 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(assetsToUnloadIn);
    }
    _validateParsers() {
      this._parsersValidated = !0;
      this._parserHash = this._parsers.filter(parser => parser.name || parser.id).reduce((hash, parser) => {
        parser.name || parser.id ? (hash[parser.name] || hash[parser.id]) && warn.warn(`[Assets] parser id conflict "${parser.id}"`) : warn.warn("[Assets] parser should have an id");
        hash[parser.name] = parser;
        parser.id && (hash[parser.id] = parser);
        return hash;
      }, {});
    }
    async _loadAssetWithRetry(url, asset, options, assets) {
      let attempt = 0;
      const {onError, strategy, retryCount, retryDelay} = options;
      for (options = ms => new Promise(r => setTimeout(r, ms));;) {
        try {
          this.promiseCache[url] || (this.promiseCache[url] = this._getLoadPromiseAndParser(url, asset));
          assets[asset.src] = await this.promiseCache[url].promise;
          break;
        } catch (e) {
          delete this.promiseCache[url];
          delete assets[asset.src];
          attempt++;
          const isLast = "retry" !== strategy || attempt > retryCount;
          if ("retry" !== strategy || isLast) {
            if ("skip" === strategy) {
              onError && onError(e, asset);
              break;
            }
            onError && onError(e, asset);
            url = Error(`[Loader.load] Failed to load ${url}.
${e}`);
            e instanceof Error && e.stack && (url.stack = e.stack);
            throw url;
          }
          onError && onError(e, asset);
          await options(retryDelay);
        }
      }
    }
  };
  global = node_modules$pixi_DOT_js$lib$assets$loader$Loader$classdecl$var37;
  global.defaultOptions = {onProgress:void 0, onError:void 0, strategy:"throw", retryCount:3, retryDelay:250};
  exports.Loader = global;
};

//# sourceMappingURL=module$node_modules$pixi_DOT_js$lib$assets$loader$Loader.js.map