opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/KMZLoader.js

@@ -0,0 +1,142 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../loaders/ColladaLoader.js", "../libs/fflate.module.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../loaders/ColladaLoader.js"), require("../libs/fflate.module.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.ColladaLoader, global.fflateModule);
+    global.KMZLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _ColladaLoader, fflate) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.KMZLoader = void 0;
+  fflate = _interopRequireWildcard(fflate);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var KMZLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(KMZLoader, _Loader);
+
+    var _super = _createSuper(KMZLoader);
+
+    function KMZLoader(manager) {
+      _classCallCheck(this, KMZLoader);
+
+      return _super.call(this, manager);
+    }
+
+    _createClass(KMZLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.FileLoader(scope.manager);
+        loader.setPath(scope.path);
+        loader.setResponseType('arraybuffer');
+        loader.setRequestHeader(scope.requestHeader);
+        loader.setWithCredentials(scope.withCredentials);
+        loader.load(url, function (text) {
+          try {
+            onLoad(scope.parse(text));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      }
+    }, {
+      key: "parse",
+      value: function parse(data) {
+        function findFile(url) {
+          for (var path in zip) {
+            if (path.substr(-url.length) === url) {
+              return zip[path];
+            }
+          }
+        }
+
+        var manager = new _three.LoadingManager();
+        manager.setURLModifier(function (url) {
+          var image = findFile(url);
+
+          if (image) {
+            console.log('Loading', url);
+            var blob = new Blob([image.buffer], {
+              type: 'application/octet-stream'
+            });
+            return URL.createObjectURL(blob);
+          }
+
+          return url;
+        }); //
+
+        var zip = fflate.unzipSync(new Uint8Array(data)); // eslint-disable-line no-undef
+
+        if (zip['doc.kml']) {
+          var xml = new DOMParser().parseFromString(fflate.strFromU8(zip['doc.kml']), 'application/xml'); // eslint-disable-line no-undef
+
+          var model = xml.querySelector('Placemark Model Link href');
+
+          if (model) {
+            var loader = new _ColladaLoader.ColladaLoader(manager);
+            return loader.parse(fflate.strFromU8(zip[model.textContent])); // eslint-disable-line no-undef
+          }
+        } else {
+          console.warn('KMZLoader: Missing doc.kml file.');
+
+          for (var path in zip) {
+            var extension = path.split('.').pop().toLowerCase();
+
+            if (extension === 'dae') {
+              var _loader = new _ColladaLoader.ColladaLoader(manager);
+
+              return _loader.parse(fflate.strFromU8(zip[path])); // eslint-disable-line no-undef
+            }
+          }
+        }
+
+        console.error('KMZLoader: Couldn\'t find .dae file.');
+        return {
+          scene: new _three.Group()
+        };
+      }
+    }]);
+
+    return KMZLoader;
+  }(_three.Loader);
+
+  _exports.KMZLoader = KMZLoader;
+});

data/lib-opal/js_wrap/three/loaders/KTX2Loader.js

@@ -0,0 +1,535 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../utils/WorkerPool.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../utils/WorkerPool.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.WorkerPool);
+    global.KTX2Loader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _WorkerPool) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.KTX2Loader = void 0;
+
+  function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+  function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+  function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var KTX2TransferSRGB = 2;
+  var KTX2_ALPHA_PREMULTIPLIED = 1;
+
+  var _taskCache = new WeakMap();
+
+  var _activeLoaders = 0;
+
+  var KTX2Loader = /*#__PURE__*/function (_Loader) {
+    _inherits(KTX2Loader, _Loader);
+
+    var _super = _createSuper(KTX2Loader);
+
+    function KTX2Loader(manager) {
+      var _this;
+
+      _classCallCheck(this, KTX2Loader);
+
+      _this = _super.call(this, manager);
+      _this.transcoderPath = '';
+      _this.transcoderBinary = null;
+      _this.transcoderPending = null;
+      _this.workerPool = new _WorkerPool.WorkerPool();
+      _this.workerSourceURL = '';
+      _this.workerConfig = null;
+
+      if (typeof MSC_TRANSCODER !== 'undefined') {
+        console.warn('THREE.KTX2Loader: Please update to latest "basis_transcoder".' + ' "msc_basis_transcoder" is no longer supported in three.js r125+.');
+      }
+
+      return _this;
+    }
+
+    _createClass(KTX2Loader, [{
+      key: "setTranscoderPath",
+      value: function setTranscoderPath(path) {
+        this.transcoderPath = path;
+        return this;
+      }
+    }, {
+      key: "setWorkerLimit",
+      value: function setWorkerLimit(num) {
+        this.workerPool.setWorkerLimit(num);
+        return this;
+      }
+    }, {
+      key: "detectSupport",
+      value: function detectSupport(renderer) {
+        this.workerConfig = {
+          astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+          etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
+          etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
+          dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
+          bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
+          pvrtcSupported: renderer.extensions.has('WEBGL_compressed_texture_pvrtc') || renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc')
+        };
+        return this;
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        URL.revokeObjectURL(this.workerSourceURL);
+        this.workerPool.dispose();
+        _activeLoaders--;
+        return this;
+      }
+    }, {
+      key: "init",
+      value: function init() {
+        var _this2 = this;
+
+        if (!this.transcoderPending) {
+          // Load transcoder wrapper.
+          var jsLoader = new _three.FileLoader(this.manager);
+          jsLoader.setPath(this.transcoderPath);
+          jsLoader.setWithCredentials(this.withCredentials);
+          var jsContent = jsLoader.loadAsync('basis_transcoder.js'); // Load transcoder WASM binary.
+
+          var binaryLoader = new _three.FileLoader(this.manager);
+          binaryLoader.setPath(this.transcoderPath);
+          binaryLoader.setResponseType('arraybuffer');
+          binaryLoader.setWithCredentials(this.withCredentials);
+          var binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm');
+          this.transcoderPending = Promise.all([jsContent, binaryContent]).then(function (_ref) {
+            var _ref2 = _slicedToArray(_ref, 2),
+                jsContent = _ref2[0],
+                binaryContent = _ref2[1];
+
+            var fn = KTX2Loader.BasisWorker.toString();
+            var body = ['/* constants */', 'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat), 'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat), 'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat), '/* basis_transcoder.js */', jsContent, '/* worker */', fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))].join('\n');
+            _this2.workerSourceURL = URL.createObjectURL(new Blob([body]));
+            _this2.transcoderBinary = binaryContent;
+
+            _this2.workerPool.setWorkerCreator(function () {
+              var worker = new Worker(_this2.workerSourceURL);
+
+              var transcoderBinary = _this2.transcoderBinary.slice(0);
+
+              worker.postMessage({
+                type: 'init',
+                config: _this2.workerConfig,
+                transcoderBinary: transcoderBinary
+              }, [transcoderBinary]);
+              return worker;
+            });
+          });
+
+          if (_activeLoaders > 0) {
+            // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
+            console.warn('THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' + ' Use a single KTX2Loader instance, or call .dispose() on old instances.');
+          }
+
+          _activeLoaders++;
+        }
+
+        return this.transcoderPending;
+      }
+    }, {
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var _this3 = this;
+
+        if (this.workerConfig === null) {
+          throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.');
+        }
+
+        var loader = new _three.FileLoader(this.manager);
+        loader.setResponseType('arraybuffer');
+        loader.setWithCredentials(this.withCredentials);
+        var texture = new _three.CompressedTexture();
+        loader.load(url, function (buffer) {
+          // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+          // again from this thread.
+          if (_taskCache.has(buffer)) {
+            var cachedTask = _taskCache.get(buffer);
+
+            return cachedTask.promise.then(onLoad).catch(onError);
+          }
+
+          _this3._createTexture([buffer]).then(function (_texture) {
+            texture.copy(_texture);
+            texture.needsUpdate = true;
+            if (onLoad) onLoad(texture);
+          }).catch(onError);
+        }, onProgress, onError);
+        return texture;
+      }
+    }, {
+      key: "_createTextureFrom",
+      value: function _createTextureFrom(transcodeResult) {
+        var mipmaps = transcodeResult.mipmaps,
+            width = transcodeResult.width,
+            height = transcodeResult.height,
+            format = transcodeResult.format,
+            type = transcodeResult.type,
+            error = transcodeResult.error,
+            dfdTransferFn = transcodeResult.dfdTransferFn,
+            dfdFlags = transcodeResult.dfdFlags;
+        if (type === 'error') return Promise.reject(error);
+        var texture = new _three.CompressedTexture(mipmaps, width, height, format, _three.UnsignedByteType);
+        texture.minFilter = mipmaps.length === 1 ? _three.LinearFilter : _three.LinearMipmapLinearFilter;
+        texture.magFilter = _three.LinearFilter;
+        texture.generateMipmaps = false;
+        texture.needsUpdate = true;
+        texture.encoding = dfdTransferFn === KTX2TransferSRGB ? _three.sRGBEncoding : _three.LinearEncoding;
+        texture.premultiplyAlpha = !!(dfdFlags & KTX2_ALPHA_PREMULTIPLIED);
+        return texture;
+      }
+      /**
+       * @param {ArrayBuffer[]} buffers
+       * @param {object?} config
+       * @return {Promise<CompressedTexture>}
+       */
+
+    }, {
+      key: "_createTexture",
+      value: function _createTexture(buffers) {
+        var _this4 = this;
+
+        var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var taskConfig = config;
+        var texturePending = this.init().then(function () {
+          return _this4.workerPool.postMessage({
+            type: 'transcode',
+            buffers: buffers,
+            taskConfig: taskConfig
+          }, buffers);
+        }).then(function (e) {
+          return _this4._createTextureFrom(e.data);
+        }); // Cache the task result.
+
+        _taskCache.set(buffers[0], {
+          promise: texturePending
+        });
+
+        return texturePending;
+      }
+    }]);
+
+    return KTX2Loader;
+  }(_three.Loader);
+  /* CONSTANTS */
+
+
+  _exports.KTX2Loader = KTX2Loader;
+  KTX2Loader.BasisFormat = {
+    ETC1S: 0,
+    UASTC_4x4: 1
+  };
+  KTX2Loader.TranscoderFormat = {
+    ETC1: 0,
+    ETC2: 1,
+    BC1: 2,
+    BC3: 3,
+    BC4: 4,
+    BC5: 5,
+    BC7_M6_OPAQUE_ONLY: 6,
+    BC7_M5: 7,
+    PVRTC1_4_RGB: 8,
+    PVRTC1_4_RGBA: 9,
+    ASTC_4x4: 10,
+    ATC_RGB: 11,
+    ATC_RGBA_INTERPOLATED_ALPHA: 12,
+    RGBA32: 13,
+    RGB565: 14,
+    BGR565: 15,
+    RGBA4444: 16
+  };
+  KTX2Loader.EngineFormat = {
+    RGBAFormat: _three.RGBAFormat,
+    RGBA_ASTC_4x4_Format: _three.RGBA_ASTC_4x4_Format,
+    RGBA_BPTC_Format: _three.RGBA_BPTC_Format,
+    RGBA_ETC2_EAC_Format: _three.RGBA_ETC2_EAC_Format,
+    RGBA_PVRTC_4BPPV1_Format: _three.RGBA_PVRTC_4BPPV1_Format,
+    RGBA_S3TC_DXT5_Format: _three.RGBA_S3TC_DXT5_Format,
+    RGB_ETC1_Format: _three.RGB_ETC1_Format,
+    RGB_ETC2_Format: _three.RGB_ETC2_Format,
+    RGB_PVRTC_4BPPV1_Format: _three.RGB_PVRTC_4BPPV1_Format,
+    RGB_S3TC_DXT1_Format: _three.RGB_S3TC_DXT1_Format
+  };
+  /* WEB WORKER */
+
+  KTX2Loader.BasisWorker = function () {
+    var config;
+    var transcoderPending;
+    var BasisModule;
+    var EngineFormat = _EngineFormat; // eslint-disable-line no-undef
+
+    var TranscoderFormat = _TranscoderFormat; // eslint-disable-line no-undef
+
+    var BasisFormat = _BasisFormat; // eslint-disable-line no-undef
+
+    self.addEventListener('message', function (e) {
+      var message = e.data;
+
+      switch (message.type) {
+        case 'init':
+          config = message.config;
+          init(message.transcoderBinary);
+          break;
+
+        case 'transcode':
+          transcoderPending.then(function () {
+            try {
+              var _transcode = transcode(message.buffers[0]),
+                  width = _transcode.width,
+                  height = _transcode.height,
+                  hasAlpha = _transcode.hasAlpha,
+                  mipmaps = _transcode.mipmaps,
+                  format = _transcode.format,
+                  dfdTransferFn = _transcode.dfdTransferFn,
+                  dfdFlags = _transcode.dfdFlags;
+
+              var buffers = [];
+
+              for (var i = 0; i < mipmaps.length; ++i) {
+                buffers.push(mipmaps[i].data.buffer);
+              }
+
+              self.postMessage({
+                type: 'transcode',
+                id: message.id,
+                width: width,
+                height: height,
+                hasAlpha: hasAlpha,
+                mipmaps: mipmaps,
+                format: format,
+                dfdTransferFn: dfdTransferFn,
+                dfdFlags: dfdFlags
+              }, buffers);
+            } catch (error) {
+              console.error(error);
+              self.postMessage({
+                type: 'error',
+                id: message.id,
+                error: error.message
+              });
+            }
+          });
+          break;
+      }
+    });
+
+    function init(wasmBinary) {
+      transcoderPending = new Promise(function (resolve) {
+        BasisModule = {
+          wasmBinary: wasmBinary,
+          onRuntimeInitialized: resolve
+        };
+        BASIS(BasisModule); // eslint-disable-line no-undef
+      }).then(function () {
+        BasisModule.initializeBasis();
+
+        if (BasisModule.KTX2File === undefined) {
+          console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.');
+        }
+      });
+    }
+
+    function transcode(buffer) {
+      var ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer));
+
+      function cleanup() {
+        ktx2File.close();
+        ktx2File.delete();
+      }
+
+      if (!ktx2File.isValid()) {
+        cleanup();
+        throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file');
+      }
+
+      var basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S;
+      var width = ktx2File.getWidth();
+      var height = ktx2File.getHeight();
+      var levels = ktx2File.getLevels();
+      var hasAlpha = ktx2File.getHasAlpha();
+      var dfdTransferFn = ktx2File.getDFDTransferFunc();
+      var dfdFlags = ktx2File.getDFDFlags();
+
+      var _getTranscoderFormat = getTranscoderFormat(basisFormat, width, height, hasAlpha),
+          transcoderFormat = _getTranscoderFormat.transcoderFormat,
+          engineFormat = _getTranscoderFormat.engineFormat;
+
+      if (!width || !height || !levels) {
+        cleanup();
+        throw new Error('THREE.KTX2Loader:	Invalid texture');
+      }
+
+      if (!ktx2File.startTranscoding()) {
+        cleanup();
+        throw new Error('THREE.KTX2Loader: .startTranscoding failed');
+      }
+
+      var mipmaps = [];
+
+      for (var mip = 0; mip < levels; mip++) {
+        var levelInfo = ktx2File.getImageLevelInfo(mip, 0, 0);
+        var mipWidth = levelInfo.origWidth;
+        var mipHeight = levelInfo.origHeight;
+        var dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, 0, 0, transcoderFormat));
+        var status = ktx2File.transcodeImage(dst, mip, 0, 0, transcoderFormat, 0, -1, -1);
+
+        if (!status) {
+          cleanup();
+          throw new Error('THREE.KTX2Loader: .transcodeImage failed.');
+        }
+
+        mipmaps.push({
+          data: dst,
+          width: mipWidth,
+          height: mipHeight
+        });
+      }
+
+      cleanup();
+      return {
+        width: width,
+        height: height,
+        hasAlpha: hasAlpha,
+        mipmaps: mipmaps,
+        format: engineFormat,
+        dfdTransferFn: dfdTransferFn,
+        dfdFlags: dfdFlags
+      };
+    } //
+    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+    // device capabilities, and texture dimensions. The list below ranks the formats separately
+    // for ETC1S and UASTC.
+    //
+    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+
+
+    var FORMAT_OPTIONS = [{
+      if: 'astcSupported',
+      basisFormat: [BasisFormat.UASTC_4x4],
+      transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+      engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+      priorityETC1S: Infinity,
+      priorityUASTC: 1,
+      needsPowerOfTwo: false
+    }, {
+      if: 'bptcSupported',
+      basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+      transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+      engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+      priorityETC1S: 3,
+      priorityUASTC: 2,
+      needsPowerOfTwo: false
+    }, {
+      if: 'dxtSupported',
+      basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+      transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+      engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+      priorityETC1S: 4,
+      priorityUASTC: 5,
+      needsPowerOfTwo: false
+    }, {
+      if: 'etc2Supported',
+      basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+      transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+      engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+      priorityETC1S: 1,
+      priorityUASTC: 3,
+      needsPowerOfTwo: false
+    }, {
+      if: 'etc1Supported',
+      basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+      transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
+      engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
+      priorityETC1S: 2,
+      priorityUASTC: 4,
+      needsPowerOfTwo: false
+    }, {
+      if: 'pvrtcSupported',
+      basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
+      transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+      engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+      priorityETC1S: 5,
+      priorityUASTC: 6,
+      needsPowerOfTwo: true
+    }];
+    var ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+      return a.priorityETC1S - b.priorityETC1S;
+    });
+    var UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
+      return a.priorityUASTC - b.priorityUASTC;
+    });
+
+    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+      var transcoderFormat;
+      var engineFormat;
+      var options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS;
+
+      for (var i = 0; i < options.length; i++) {
+        var opt = options[i];
+        if (!config[opt.if]) continue;
+        if (!opt.basisFormat.includes(basisFormat)) continue;
+        if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue;
+        transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0];
+        engineFormat = opt.engineFormat[hasAlpha ? 1 : 0];
+        return {
+          transcoderFormat: transcoderFormat,
+          engineFormat: engineFormat
+        };
+      }
+
+      console.warn('THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.');
+      transcoderFormat = TranscoderFormat.RGBA32;
+      engineFormat = EngineFormat.RGBAFormat;
+      return {
+        transcoderFormat: transcoderFormat,
+        engineFormat: engineFormat
+      };
+    }
+
+    function isPowerOfTwo(value) {
+      if (value <= 2) return true;
+      return (value & value - 1) === 0 && value !== 0;
+    }
+  };
+});