System.register(["cc"], function (_export, _context) {
  "use strict";

  var _cclegacy, __checkObsolete__, __checkObsoleteInNamespace__, assetManager, AssetManager, director, ImageAsset, resources, Texture2D, _crd, headImgExt, ResUtil;

  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

  function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

  _export("ResUtil", void 0);

  return {
    setters: [function (_cc) {
      _cclegacy = _cc.cclegacy;
      __checkObsolete__ = _cc.__checkObsolete__;
      __checkObsoleteInNamespace__ = _cc.__checkObsoleteInNamespace__;
      assetManager = _cc.assetManager;
      AssetManager = _cc.AssetManager;
      director = _cc.director;
      ImageAsset = _cc.ImageAsset;
      resources = _cc.resources;
      Texture2D = _cc.Texture2D;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "fdca4buPvxCtqd20MSvpC7T", "ResUtil", undefined);
      /**
       *
       * @file ResUtil.ts
       * @author
       * @description Cocos方法整合，如果Cocos版本升级，造成API修改，仅需修改此处
       */


      //export type Constructor<T extends Asset> = new () => T;
      __checkObsolete__(['Asset', 'assetManager', 'AssetManager', 'director', 'ImageAsset', 'resources', 'SceneAsset', 'Texture2D']);

      _export("headImgExt", headImgExt = ".head");

      (function (_ResUtil) {
        function loadRemote(url, option) {
          return new Promise((resolve, reject) => {
            assetManager.loadRemote(url, option, (err, asset) => {
              resolve && resolve(err ? null : asset);
            });
          });
        }

        _ResUtil.loadRemote = loadRemote;

        function loadBundle(bundleName) {
          return new Promise((resolve, reject) => {
            assetManager.loadBundle(bundleName, (err, bundle) => {
              resolve && resolve(err ? null : bundle);
            });
          });
        }

        _ResUtil.loadBundle = loadBundle;

        function getBundle(bundleName) {
          if (null == bundleName || '' === bundleName) {
            return resources;
          } else {
            return assetManager.getBundle(bundleName);
          }
        }

        _ResUtil.getBundle = getBundle;

        function loadAsset(_x, _x2) {
          return _loadAsset.apply(this, arguments);
        }

        function _loadAsset() {
          _loadAsset = _asyncToGenerator(function* (path, bundle) {
            var bd;
            if (!bundle) bundle = '';

            if (typeof bundle === 'string') {
              bd = getBundle(bundle);
              if (!bd) bd = yield loadBundle(bundle);
            } else if (bundle instanceof AssetManager.Bundle) {
              bd = bundle;
            }

            var asset = bd.get(path);

            if (null != asset) {
              return Promise.resolve(asset);
            }

            return new Promise((resolve, reject) => {
              bd.load(path, (err, asset) => {
                resolve(err ? null : asset);
              });
            });
          });
          return _loadAsset.apply(this, arguments);
        }

        _ResUtil.loadAsset = loadAsset;

        function loadDir(_x3, _x4, _x5) {
          return _loadDir.apply(this, arguments);
        }

        function _loadDir() {
          _loadDir = _asyncToGenerator(function* (path, bundle, progressCallback) {
            var bd;
            if (!bundle) bundle = '';

            if (typeof bundle === 'string') {
              bd = getBundle(bundle);
              if (!bd) bd = yield loadBundle(bundle);
            } else if (bundle instanceof AssetManager.Bundle) {
              bd = bundle;
            }

            return new Promise((resolve, reject) => {
              bd.loadDir(path, (finished, total, item) => {
                progressCallback == null || progressCallback(finished, total);
              }, (err, assets) => {
                resolve(err ? null : assets);
              });
            });
          });
          return _loadDir.apply(this, arguments);
        }

        _ResUtil.loadDir = loadDir;

        function loadAssets(_x6, _x7, _x8) {
          return _loadAssets.apply(this, arguments);
        }

        function _loadAssets() {
          _loadAssets = _asyncToGenerator(function* (list, bundle, progressCallback) {
            var bd;
            if (!bundle) bundle = '';

            if (typeof bundle === 'string') {
              bd = getBundle(bundle);
              if (!bd) bd = yield loadBundle(bundle);
            } else if (bundle instanceof AssetManager.Bundle) {
              bd = bundle;
            }

            return new Promise((resolve, reject) => {
              bd.load(list, (finished, total, item) => {
                progressCallback == null || progressCallback(finished, total);
              }, (err, data) => {
                resolve(err ? null : data);
              });
            });
          });
          return _loadAssets.apply(this, arguments);
        }

        _ResUtil.loadAssets = loadAssets;

        function loadScene(_x9, _x10, _x11) {
          return _loadScene.apply(this, arguments);
        }

        function _loadScene() {
          _loadScene = _asyncToGenerator(function* (scene_name, bundle, show) {
            if (show === void 0) {
              show = false;
            }

            var bd;
            if (!bundle) bundle = '';

            if (typeof bundle === 'string') {
              bd = getBundle(bundle);
              if (!bd) bd = yield loadBundle(bundle);
            } else if (bundle instanceof AssetManager.Bundle) {
              bd = bundle;
            }

            return new Promise((resolve, reject) => {
              bd.loadScene(scene_name, (err, asset) => {
                resolve(err ? null : asset);
                if (show) director.loadScene(scene_name);
              });
            });
          });
          return _loadScene.apply(this, arguments);
        }

        _ResUtil.loadScene = loadScene;

        function releaseAll() {
          assetManager.releaseAll();
        }

        _ResUtil.releaseAll = releaseAll;

        function releaseAsset(asset) {
          assetManager.releaseAsset(asset);
        }

        _ResUtil.releaseAsset = releaseAsset;

        function release(path, bundle) {
          var bd;
          if (!bundle) bundle = '';

          if (typeof bundle === 'string') {
            bd = getBundle(bundle);
          } else if (bundle instanceof AssetManager.Bundle) {
            bd = bundle;
          }

          if (path && path != '') {
            var _bd;

            (_bd = bd) == null || _bd.release(path);
          } else {
            var _bd2;

            (_bd2 = bd) == null || _bd2.releaseAll();
          }
        }

        _ResUtil.release = release;

        function registerHeadImgLoader() {
          assetManager.downloader.register(headImgExt, (content, options, onComplete) => {
            onComplete(null, content);
          });
          assetManager.parser.register(headImgExt, downloadDomImage);
          assetManager.factory.register(headImgExt, createTexture);
        }

        _ResUtil.registerHeadImgLoader = registerHeadImgLoader;

        function createTexture(id, data, options, onComplete) {
          var out = null;
          var err = null;

          try {
            out = new Texture2D();
            var imageAsset = new ImageAsset(data);
            out.image = imageAsset;
          } catch (e) {
            err = e;
          }

          onComplete && onComplete(err, out);
        }

        function downloadDomImage(url, options, onComplete) {
          var img = new Image();

          if (window.location.protocol !== 'file:') {
            img.crossOrigin = 'anonymous';
          }

          function loadCallback() {
            img.removeEventListener('load', loadCallback);
            img.removeEventListener('error', errorCallback);

            if (onComplete) {
              onComplete(null, img);
            }
          }

          function errorCallback() {
            img.removeEventListener('load', loadCallback);
            img.removeEventListener('error', errorCallback);

            if (onComplete) {
              onComplete(new Error(url));
            }
          }

          img.addEventListener('load', loadCallback);
          img.addEventListener('error', errorCallback);
          img.src = url;
          return img;
        }
      })(ResUtil || _export("ResUtil", ResUtil = {}));

      _cclegacy._RF.pop();

      _crd = false;
    }
  };
});
//# sourceMappingURL=ceeb3152ac4e7ec1cbbfe167a34c441034286a77.js.map