@realsee/five 6.0.0-alpha.7 → 6.0.0-alpha.71

package/gltf-loader/index.mjs

@@ -0,0 +1,2696 @@
+/**
+ * @license
+ * @realsee/five
+ * Generated: 12/20/2023
+ * Version: 6.0.0-alpha.71
+ * Terms:
+ * Realsee SDK License Agreement
+ * Update: July 28, 2021
+ * THIS LICENSE AGREEMENT BETWEEN YOU AND 【BEIKE REALSEE TECHNOLOGY (HK) 
+ * LIMITED】(“Realsee”) FORMS A LEGALLY BINDING CONTRACT BETWEEN YOU AND REALSEE IN 
+ * RELATION TO YOUR USE OF THE SDK. This License Agreement accompanies the Realsee 
+ * Software Development Kit(s) for the software and related explanatory materials 
+ * (the "SDK") and includes any upgrades, modified versions, updates, additions, 
+ * and copies of the SDK licensed to You by Realsee.
+ * BY DOWNLOADING, INSTALLING, OR OTHERWISE ACCESSING OR USING THE SDK, YOU AGREE 
+ * THAT YOU HAVE READ, UNDERSTOOD, AND AGREE TO BE BOUND BY THIS AGREEMENT. YOU ARE 
+ * AGREEING ON YOUR OWN BEHALF AND/OR ON BEHALF OF YOUR COMPANY OR ORGANIZATION TO 
+ * THE TERMS AND CONDITIONS STATED BELOW.
+ * This Agreement applies to Your use of the SDK in the country in which You 
+ * legally install it (“Territory”) and is subject to the laws of such Territory 
+ * and further subject to Section 12 below. Different terms, conditions, and 
+ * limitations may apply to the use of the SDK in any additional countries.
+ * 1. DEFINITIONS.
+ * “Agreement” means this Realsee SDK License Agreement.
+ * “Developer”, “You” and “Your” means the person(s) or entity acquiring or using 
+ * the SDK or otherwise exercising rights under the terms of this Agreement.
+ * “Documentation” means the technical or other specifications or documentation 
+ * that Realsee may provide to You for use in connection with the SDK.
+ * “Integrated Product” means any software, website, or on-line service developed 
+ * by You based on or using the SDK (collectively, the “Integrated Product”).
+ * “Intellectual Property” means any patents, patent rights, trademarks, service 
+ * marks, registered and unregistered designs, applications for any of the 
+ * foregoing, copyright, and any other similar protected rights in any country and 
+ * to the extent recognised by any relevant jurisdiction as intellectual property, 
+ * trade secrets, know-how and confidential information. Realsee reserves all 
+ * rights not expressly granted to You.
+ * “Realsee” means [Beike Realsee Technology (HK) Limited, a company incorporated 
+ * and validly existing under the laws of Hong Kong].
+ * “SDK” means the Realsee-proprietary Software Development Kits (SDK) provided 
+ * hereunder, includes all development tools (including any compiler and debugger), 
+ * application programming interfaces (“APIs”), libraries, binary utilities, header 
+ * files, Documentation, content, data, code samples, and other materials provided 
+ * to You in connection with this Agreement, whether delivered through a download, 
+ * or any other media or form, and is licensed, not sold, to You by Realsee for use 
+ * only under the terms of this Agreement. The terms of this Agreement will govern 
+ * any updates provided by Realsee that replace and/or supplement the original SDK 
+ * delivered to You, unless such update is accompanied by a separate license, in 
+ * which case the terms of such license will govern.
+ * 2. LICENSED USES AND RESTRICTIONS.
+ * 2.1 Subject to the restrictions contained in this Section 2, Realsee grants to 
+ * You during the term, a limited, non-exclusive, revocable, non-sublicensable, 
+ * non-transferable license to install and use the SDK within the Territory only 
+ * for the purpose of internal development.
+ * 2.2 Restrictions. You acknowledge and agree that, You shall not, and shall 
+ * ensure that Your affiliates, employees, agents, representatives, officers, 
+ * representatives, and subcontractors do not (directly or indirectly):
+ * 2.2.1 decompile, reverse engineer, disassemble or attempt to derive the source 
+ * code of, those components of the SDK provided in object code form, or any part 
+ * thereof;
+ * 2.2.2 remove, alter, or obscure any copyright notice or other proprietary rights 
+ * notice on any part of the SDK;
+ * 2.2.3 sell, assign, pledge, rent, lease, lend, upload to or host on any website 
+ * or server for use by any third party except You, redistribute, or sublicense the 
+ * SDK (or any part thereof), or operate the SDK (or any part thereof) in the 
+ * capacity of a service bureau or other hosted services provider, in whole or in 
+ * part, nor may You enable others to do so;
+ * 2.2.4 or alter, modify, customize or improve the SDK, or any part thereof;
+ * 2.2.5 use the SDK (or any part thereof) for any illegal purpose, in any manner 
+ * that is inconsistent with the terms of this Agreement, or to engage in any 
+ * illegal activity;
+ * 2.2.6 use the SDK (or any part thereof) in any manner that may damage the 
+ * operation of Realsee’s products or services; or
+ * 2.2.7 use the SDK or any information contained therein or otherwise provided by 
+ * Realsee for the purpose of developing, or having developed, any product 
+ * competitive with any Realsee product or service, as determined by Realsee in its 
+ * sole discretion;
+ * 2.2.8 include any portion of the SDK in Your Developer products.
+ * 2.3 Realsee has the right to impose reasonable conditions such as a reasonable 
+ * fee for use of the SDK in Integrated Product in the future.
+ * 2.4 You may make a limited number of copies of the SDK to be used by Your 
+ * employees or consultants as provided herein, and not for general business 
+ * purposes, and such employees or consultants shall be subject to the obligations 
+ * and restrictions in this Agreement.
+ * 2.5 All licenses not expressly granted in this Agreement are reserved and no 
+ * other licenses, immunity, or rights, express or implied, are granted by Realsee, 
+ * by implication, estoppel, or otherwise.
+ * 3. CONFIDENTIALITY.
+ * The SDK and all source code, Documentation, specifications, engineering details, 
+ * and related information pertaining to the SDK, whether in oral, written, 
+ * graphic, or electronic form, are and shall remain the confidential and 
+ * proprietary information of Realsee or its licensors (collectively, the 
+ * “Confidential Information”). You shall (i) disclose Confidential Information to 
+ * only those directors and employees (collectively, “Affiliates”) whose duties 
+ * justify their need to know such information and who have been clearly informed 
+ * of their obligation to maintain the confidential, proprietary, and/or trade 
+ * secret status of such Confidential Information; and (ii) use Confidential 
+ * Information solely in accordance with the license granted hereunder. In any 
+ * event, You and Your Affiliates shall treat Confidential Information as strictly 
+ * confidential and shall use the same care to prevent disclosure of such 
+ * information as You use with respect to Your own similar confidential and/or 
+ * proprietary information, which shall not be less than the care a reasonable 
+ * person would use under similar circumstances. All Confidential Information, and 
+ * any copies thereof, shall be returned promptly to Realsee upon request. You 
+ * shall ensure that Your Affiliates comply with the provisions of this Section 3, 
+ * and You shall be liable for any breach of this Section 3 resulting from the act 
+ * or omission of any of Your Affiliates. You shall not disclose Confidential 
+ * Information to any third party, including, without limitation, any of Your 
+ * subcontractors.
+ * 4. PROPRIETARY RIGHTS.
+ * 4.1 As between You and Realsee, Realsee and/or its licensors retain ownership of 
+ * all right, title, and interest in, to, and under the SDK, including, without 
+ * limitation, all patents, copyrights, trade secrets, trademarks and other 
+ * intellectual property and other proprietary rights therein, and reserve all 
+ * rights not expressly granted to You.
+ * 4.2 The items contained in the SDK are the intellectual property of Realsee and 
+ * its licensors and are protected by PRC copyright and patent law, international 
+ * treaty provisions and applicable laws of the country in which it is being used. 
+ * You agree to protect all copyright and other ownership interests of Realsee 
+ * and/or its licensors in all items in the SDK supplied under this License 
+ * Agreement. You agree that all copies of the items in the SDK, reproduced for any 
+ * reason by You, contain the same copyright notices, and other proprietary notices 
+ * as appropriate, as appear on or in the original items delivered by Realsee in 
+ * the SDK. Realsee and/or its licensors retain title and ownership of the items in 
+ * the SDK, the media on which it is loaded, and all subsequent copies, regardless 
+ * of the form or media in or on which the original and other copies may exist. 
+ * Except as stated above, this Agreement does not grant You any rights to patents, 
+ * copyrights, trade secrets, trademarks or any other rights in respect to the 
+ * items in the SDK.
+ * 5. TERM AND TERMINATION.
+ * 5.1 This Agreement is effective until terminated. Realsee has the right to 
+ * terminate this Agreement immediately, without judicial intervention, if You fail 
+ * to comply with any term herein. Upon any such termination You must remove all 
+ * full and partial copies of the items in the SDK from Your computer and 
+ * discontinue the use of the items in the SDK.
+ * 5.2 Realsee may at any time, terminate the Agreement with You if: (A) You have 
+ * breached any provision of the Agreement; or (B) Realsee is required to do so by 
+ * law; or (C) Realsee decides to no longer provide the SDK or certain parts of the 
+ * SDK to users in the country in which You are resident or from which You use the 
+ * service, or the provision of the SDK or certain SDK services to You by Realsee 
+ * is, in Realsee's sole discretion, no longer legally or commercially viable.
+ * 5.3 When the Agreement comes to an end, all of the legal rights, obligations and 
+ * liabilities that You and Realsee have benefited from, been subject to (or which 
+ * have accrued over time whilst the Agreement has been in force) or which are 
+ * expressed to continue indefinitely, shall be unaffected by this cessation, and 
+ * the provisions of Section 3, 4, 6, 7 and 8 shall continue to apply to such 
+ * rights, obligations and liabilities indefinitely.
+ * 6. DISCLAIMER OF WARRANTY.
+ * YOU EXPRESSLY ACKNOWLEDGE AND AGREE THAT, TO THE EXTENT PERMITTED BY APPLICABLE 
+ * LAW, USE OF THE SDK (OR ANY PART THEREOF) IS AT YOUR SOLE RISK AND THAT THE 
+ * ENTIRE RISK AS TO SATISFACTORY QUALITY, PERFORMANCE, ACCURACY, AND EFFORT IS 
+ * WITH YOU. REALSEE LICENSES THE SDK TO YOU ONLY ON AN "AS-IS" BASIS. REALSEE 
+ * MAKES NO REPRESENTATION WITH RESPECT TO THE ADEQUACY OF ANY ITEMS IN THE SDK, 
+ * WHETHER OR NOT USED BY YOU IN THE DEVELOPMENT OF INTEGRATED PRODUCT, FOR ANY 
+ * PARTICULAR PURPOSE OR WITH RESPECT TO THEIR ADEQUACY TO PRODUCE ANY PARTICULAR 
+ * RESULT. REALSEE AND ITS LICENSORS SHALL NOT BE LIABLE FOR LOSS OR DAMAGE ARISING 
+ * OUT OF THIS AGREEMENT OR FROM THE DISTRIBUTION OR USE OF INTEGRATED PRODUCT 
+ * CONTAINING PORTIONS OF THE SDK. REALSEE AND ITS LICENSORS DISCLAIM ALL 
+ * WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO IMPLIED 
+ * CONDITIONS OR WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * OR NONINFRINGEMENT OF ANY THIRD PARTY RIGHT IN RESPECT OF THE ITEMS IN THE SDK 
+ * OR ANY SERVICES RELATED TO THE SDK.
+ * REALSEE IS UNDER NO OBLIGATION TO PROVIDE ANY SUPPORT UNDER THIS LICENSE 
+ * AGREEMENT, INCLUDING UPGRADES OR FUTURE VERSIONS OF THE SDK OR ANY PORTIONS 
+ * THEREOF, TO YOU, END USER OR TO ANY OTHER PARTY.
+ * 7. LIMITATION OF LIABILITY.
+ * TO THE EXTENT NOT PROHIBITED BY APPLICABLE LAW, IN NO EVENT WILL REALSEE OR ITS 
+ * LICENSORS BE LIABLE FOR ANY DIRECT, INCIDENTAL, SPECIAL, INDIRECT, OR 
+ * CONSEQUENTIAL DAMAGES, INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF USE, 
+ * LOSS OF BUSINESS, REVENUE, OR PROFITS, LOSS OF OPPORTUNITY (WHETHER DIRECT OR 
+ * INDIRECT), CORRUPTION OR LOSS OF DATA, LOSS OF REPUTATION OR SAVINGS, DOWNTIME, 
+ * OR DAMAGE TO, LOSS OF OR REPLACEMENT OF DATA OR TRANSACTIONS, COST OF 
+ * PROCUREMENT OF SUBSTITUTE SERVICES, BUSINESS INTERRUPTION, OR ANY OTHER 
+ * COMMERCIAL DAMAGES OR LOSSES, ARISING OUT OF OR RELATED TO YOUR USE OR INABILITY 
+ * TO USE THE SDK (OR ANY PART THEREOF), ANY INTEGRATED PRODUCT, OR ANY THIRD PARTY 
+ * SOFTWARE, APPLICATIONS, OR SERVICES IN CONJUNCTION WITH THE SDK (OR ANY PART 
+ * THEREOF), HOWEVER CAUSED, REGARDLESS OF THE THEORY OF LIABILITY (CONTRACT, TORT, 
+ * OR OTHERWISE) AND EVEN IF REALSEE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 
+ * DAMAGES. IN NO EVENT WILL REALSEE’S TOTAL LIABILITY TO YOU FOR ALL DAMAGES 
+ * EXCEED ONE HUNDRED DOLLARS ($100.00). THE FOREGOING LIMITATIONS WILL APPLY EVEN 
+ * IF THE ABOVE STATED REMEDY FAILS OF ITS ESSENTIAL PURPOSE. THE LIMITATIONS 
+ * CONTAINED IN SECTIONS 6 AND THIS SECTION 7 ARE A FUNDAMENTAL PART OF THE BASIS 
+ * OF REALSEE’S BARGAIN HEREUNDER, AND REALSEE WOULD NOT ENTER INTO THIS AGREEMENT 
+ * OR PROVIDE YOU WITH ACCESS TO THE SDK ABSENT SUCH LIMITATIONS.
+ * 8. INDEMNIFICATION.
+ * To the extent permitted by applicable law, You agree to indemnify, defend and 
+ * hold harmless Realsee, its affiliates and each of their directors, officers, 
+ * employees, independent contractors, and agents (each a “Realsee Indemnified 
+ * Party”) from any and all claims, losses, liabilities, damages, expenses, and 
+ * costs (including without limitation attorneys’ fees and court costs) incurred by 
+ * a Realsee Indemnified Party as a result of: (i) Your non-compliance with any 
+ * terms of this Agreement; (ii) Your use of the SDK (or any part thereof); or 
+ * (iii) Your use of any Integrated Product, including any claim that Integrated 
+ * Product infringes the copyright, trademark, trade secret or other intellectual 
+ * property right of a third party.
+ * 9. ACKNOWLEDGEMENTS.
+ * Portions of the SDK may utilize or include third party software and other 
+ * copyrighted material. Acknowledgments, licensing terms, and disclaimers for such 
+ * material are contained in Documentation for the SDK or may otherwise accompany 
+ * such material, and Your use of such materials governed by their respective 
+ * terms. In the event of conflict between the terms of this Agreement and an 
+ * applicable open source or third party agreement, the open source or third party 
+ * agreement will control solely with respect to the open source software or third 
+ * party software. Moreover, You shall not subject any items (including not limited 
+ * to source code, object code, and any software)  included in the SDK to any open 
+ * source license.
+ * 10. NON-BLOCKING OF REALSEE DEVELOPMENT.
+ * You acknowledge that Realsee is currently developing or may develop technologies 
+ * and products in the future that have or may have design and/or functionality 
+ * similar to Integrated Product that You may develop based on Your license herein. 
+ * Nothing in this Agreement shall impair, limit or curtail Realsee's right to 
+ * continue with its development, maintenance and/or distribution of Realsee's 
+ * technology or products.
+ * 11. GENERAL.
+ * 11.1 Export Control. You may not use or otherwise export or re-export the SDK 
+ * (or any part thereof) except as authorized by United States law and the laws of 
+ * the jurisdiction(s) in which the SDK (or any part thereof) was obtained. In 
+ * particular, but without limitation, the SDK may not be exported or re-exported 
+ * (i) into any U.S. embargoed countries or (ii) to anyone on the U.S. Treasury 
+ * Department's list of Specially Designated Nationals or the U.S. Department of 
+ * Commerce Denied Person's List or Entity List. By using the SDK (or any part 
+ * thereof), You represent and warrant that You are not located in any such country 
+ * or on any such list.
+ * 11.2 Governing Law. This Agreement and the rights of the parties hereunder shall 
+ * be governed by and construed in accordance with the laws of People’s Republic of 
+ * China (for purpose of this Agreement, excluding Hong Kong, Taiwan, and Macau), 
+ * without reference to its conflict of laws principles. Any dispute, controversy 
+ * or claim arising from or in connection with this Agreement, or the breach, 
+ * termination or invalidity thereof, shall be submitted to China International 
+ * Economic and Trade Arbitration Commission (“CIETAC”) for arbitration in Beijing 
+ * which shall be conducted in accordance with the CIETAC's arbitration rules in 
+ * effect at the time of applying for arbitration. The arbitral award is final and 
+ * binding upon both parties.
+ * 11.3 Severability. If any provision of this Agreement is held by a court of 
+ * competent jurisdiction to be unenforceable for any reason, the remaining 
+ * provisions hereof will be unaffected and remain in full force and effect.
+ * 11.4. Modifications. Realsee reserves the right, from time to time, with or 
+ * without notice to You, to make revisions to this Agreement in our sole and 
+ * absolute discretion.  The most current version of this Agreement will supersede 
+ * all previous versions and shall be made available on the website where the SDK 
+ * is made available, or by such other means as Realsee may determine in its 
+ * discretion. Any modified versions of this Agreement hereto shall take effect 
+ * from the time that it is made available. You shall be responsible for regularly 
+ * checking for notice of any such modifications. You agree that Your continued use 
+ * of the SDK constitutes Your agreement to the modified Agreement.
+ * 11.5 Relationship of the Parties. This Agreement will not be construed as 
+ * creating an agency, partnership, joint venture, fiduciary duty, or any other 
+ * form of legal association between You and Realsee, and You will not represent to 
+ * the contrary, whether expressly, by implication, appearance, or otherwise.
+ * 11.6 Entire Agreement; Governing Language. This Agreement constitutes the entire 
+ * agreement between You and Realsee with respect to the use of the SDK licensed 
+ * hereunder and supersedes all prior understandings regarding such subject matter. 
+ * No amendment to or modification of this Agreement will be binding unless in 
+ * writing and signed by Realsee. You and Realsee hereto confirm that this 
+ * Agreement and all related documents shall be drafted in English.
+*/import * as THREE from "three";
+import { Loader, LoaderUtils, FileLoader, Color, SpotLight, PointLight, DirectionalLight, MeshBasicMaterial, MeshPhysicalMaterial, Vector2, MeshStandardMaterial, TangentSpaceNormalMap, Interpolant, TextureLoader, InterleavedBuffer, InterleavedBufferAttribute, BufferAttribute, LinearFilter, LinearMipmapLinearFilter, RepeatWrapping, RGBFormat, PointsMaterial, Material, LineBasicMaterial, DoubleSide, sRGBEncoding, BufferGeometry, SkinnedMesh, Mesh, LineSegments, Line, LineLoop, Points, Group, PerspectiveCamera, MathUtils, OrthographicCamera, InterpolateLinear, AnimationClip, Bone, Object3D, PropertyBinding, Matrix4, NearestFilter, NearestMipmapNearestFilter, LinearMipmapNearestFilter, NearestMipmapLinearFilter, ClampToEdgeWrapping, MirroredRepeatWrapping, InterpolateDiscrete, RGBAFormat, FrontSide, TriangleFanDrawMode, TriangleStripDrawMode, VectorKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, Skeleton, Box3, Vector3, Sphere, CompressedTextureLoader, RGB_ETC1_Format, RGBA_S3TC_DXT5_Format, RGBA_S3TC_DXT3_Format, RGB_S3TC_DXT1_Format } from "three";
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2)
+      if (Object.prototype.hasOwnProperty.call(b2, p))
+        d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+var GLTFLoader$1 = function() {
+  function GLTFLoader2(manager) {
+    Loader.call(this, manager);
+    this.dracoLoader = null;
+    this.ddsLoader = null;
+  }
+  GLTFLoader2.prototype = Object.assign(Object.create(Loader.prototype), {
+    constructor: GLTFLoader2,
+    load: function(url, onLoad, onProgress, onError) {
+      var scope = this;
+      var resourcePath;
+      if (this.resourcePath !== "") {
+        resourcePath = this.resourcePath;
+      } else if (this.path !== "") {
+        resourcePath = this.path;
+      } else {
+        resourcePath = LoaderUtils.extractUrlBase(url);
+      }
+      scope.manager.itemStart(url);
+      var _onError = function(e) {
+        if (onError) {
+          onError(e);
+        } else {
+          console.error(e);
+        }
+        scope.manager.itemError(url);
+        scope.manager.itemEnd(url);
+      };
+      var loader = new FileLoader(scope.manager);
+      loader.setPath(this.path);
+      loader.setResponseType("arraybuffer");
+      loader.setRequestHeader(this.requestHeader);
+      if (scope.crossOrigin === "use-credentials") {
+        loader.setWithCredentials(true);
+      }
+      loader.load(url, function(data) {
+        try {
+          scope.parse(data, resourcePath, function(gltf) {
+            onLoad(gltf);
+            scope.manager.itemEnd(url);
+          }, _onError);
+        } catch (e) {
+          _onError(e);
+        }
+      }, onProgress, _onError);
+    },
+    setDRACOLoader: function(dracoLoader) {
+      this.dracoLoader = dracoLoader;
+      return this;
+    },
+    setDDSLoader: function(ddsLoader) {
+      this.ddsLoader = ddsLoader;
+      return this;
+    },
+    parse: function(data, path, onLoad, onError) {
+      var content;
+      var extensions = {};
+      if (typeof data === "string") {
+        content = data;
+      } else {
+        var magic = LoaderUtils.decodeText(new Uint8Array(data, 0, 4));
+        if (magic === BINARY_EXTENSION_HEADER_MAGIC) {
+          try {
+            extensions[EXTENSIONS.KHR_BINARY_GLTF] = new GLTFBinaryExtension(data);
+          } catch (error) {
+            if (onError)
+              onError(error);
+            return;
+          }
+          content = extensions[EXTENSIONS.KHR_BINARY_GLTF].content;
+        } else {
+          content = LoaderUtils.decodeText(new Uint8Array(data));
+        }
+      }
+      var json = JSON.parse(content);
+      if (json.asset === void 0 || json.asset.version[0] < 2) {
+        if (onError)
+          onError(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+        return;
+      }
+      if (json.extensionsUsed) {
+        for (var i = 0; i < json.extensionsUsed.length; ++i) {
+          var extensionName = json.extensionsUsed[i];
+          var extensionsRequired = json.extensionsRequired || [];
+          switch (extensionName) {
+            case EXTENSIONS.KHR_LIGHTS_PUNCTUAL:
+              extensions[extensionName] = new GLTFLightsExtension(json);
+              break;
+            case EXTENSIONS.KHR_MATERIALS_CLEARCOAT:
+              extensions[extensionName] = new GLTFMaterialsClearcoatExtension();
+              break;
+            case EXTENSIONS.KHR_MATERIALS_TRANSMISSION:
+              extensions[extensionName] = new GLTFMaterialsTransmissionExtension();
+              break;
+            case EXTENSIONS.KHR_MATERIALS_UNLIT:
+              extensions[extensionName] = new GLTFMaterialsUnlitExtension();
+              break;
+            case EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
+              extensions[extensionName] = new GLTFMaterialsPbrSpecularGlossinessExtension();
+              break;
+            case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
+              extensions[extensionName] = new GLTFDracoMeshCompressionExtension(json, this.dracoLoader);
+              break;
+            case EXTENSIONS.MSFT_TEXTURE_DDS:
+              extensions[extensionName] = new GLTFTextureDDSExtension(this.ddsLoader);
+              break;
+            case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
+              extensions[extensionName] = new GLTFTextureTransformExtension();
+              break;
+            case EXTENSIONS.KHR_MESH_QUANTIZATION:
+              extensions[extensionName] = new GLTFMeshQuantizationExtension();
+              break;
+            default:
+              if (extensionsRequired.indexOf(extensionName) >= 0) {
+                console.warn('THREE.GLTFLoader: Unknown extension "' + extensionName + '".');
+              }
+          }
+        }
+      }
+      var parser = new GLTFParser(json, extensions, {
+        path: path || this.resourcePath || "",
+        crossOrigin: this.crossOrigin,
+        manager: this.manager
+      });
+      parser.fileLoader.setRequestHeader(this.requestHeader);
+      parser.parse(onLoad, onError);
+    }
+  });
+  function GLTFRegistry() {
+    var objects = {};
+    return {
+      get: function(key) {
+        return objects[key];
+      },
+      add: function(key, object) {
+        objects[key] = object;
+      },
+      remove: function(key) {
+        delete objects[key];
+      },
+      removeAll: function() {
+        objects = {};
+      }
+    };
+  }
+  var EXTENSIONS = {
+    KHR_BINARY_GLTF: "KHR_binary_glTF",
+    KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
+    KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
+    KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
+    KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: "KHR_materials_pbrSpecularGlossiness",
+    KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
+    KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
+    KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
+    KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
+    MSFT_TEXTURE_DDS: "MSFT_texture_dds"
+  };
+  function GLTFTextureDDSExtension(ddsLoader) {
+    if (!ddsLoader) {
+      throw new Error("THREE.GLTFLoader: Attempting to load .dds texture without importing DDSLoader");
+    }
+    this.name = EXTENSIONS.MSFT_TEXTURE_DDS;
+    this.ddsLoader = ddsLoader;
+  }
+  function GLTFLightsExtension(json) {
+    this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
+    var extension = json.extensions && json.extensions[EXTENSIONS.KHR_LIGHTS_PUNCTUAL] || {};
+    this.lightDefs = extension.lights || [];
+  }
+  GLTFLightsExtension.prototype.loadLight = function(lightIndex) {
+    var lightDef = this.lightDefs[lightIndex];
+    var lightNode;
+    var color = new Color(16777215);
+    if (lightDef.color !== void 0)
+      color.fromArray(lightDef.color);
+    var range = lightDef.range !== void 0 ? lightDef.range : 0;
+    switch (lightDef.type) {
+      case "directional":
+        lightNode = new DirectionalLight(color);
+        lightNode.target.position.set(0, 0, -1);
+        lightNode.add(lightNode.target);
+        break;
+      case "point":
+        lightNode = new PointLight(color);
+        lightNode.distance = range;
+        break;
+      case "spot":
+        lightNode = new SpotLight(color);
+        lightNode.distance = range;
+        lightDef.spot = lightDef.spot || {};
+        lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== void 0 ? lightDef.spot.innerConeAngle : 0;
+        lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== void 0 ? lightDef.spot.outerConeAngle : Math.PI / 4;
+        lightNode.angle = lightDef.spot.outerConeAngle;
+        lightNode.penumbra = 1 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
+        lightNode.target.position.set(0, 0, -1);
+        lightNode.add(lightNode.target);
+        break;
+      default:
+        throw new Error('THREE.GLTFLoader: Unexpected light type, "' + lightDef.type + '".');
+    }
+    lightNode.position.set(0, 0, 0);
+    lightNode.decay = 2;
+    if (lightDef.intensity !== void 0)
+      lightNode.intensity = lightDef.intensity;
+    lightNode.name = lightDef.name || "light_" + lightIndex;
+    return Promise.resolve(lightNode);
+  };
+  function GLTFMaterialsUnlitExtension() {
+    this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
+  }
+  GLTFMaterialsUnlitExtension.prototype.getMaterialType = function() {
+    return MeshBasicMaterial;
+  };
+  GLTFMaterialsUnlitExtension.prototype.extendParams = function(materialParams, materialDef, parser) {
+    var pending = [];
+    materialParams.color = new Color(1, 1, 1);
+    materialParams.opacity = 1;
+    var metallicRoughness = materialDef.pbrMetallicRoughness;
+    if (metallicRoughness) {
+      if (Array.isArray(metallicRoughness.baseColorFactor)) {
+        var array = metallicRoughness.baseColorFactor;
+        materialParams.color.fromArray(array);
+        materialParams.opacity = array[3];
+      }
+      if (metallicRoughness.baseColorTexture !== void 0) {
+        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture));
+      }
+    }
+    return Promise.all(pending);
+  };
+  function GLTFMaterialsClearcoatExtension() {
+    this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
+  }
+  GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function() {
+    return MeshPhysicalMaterial;
+  };
+  GLTFMaterialsClearcoatExtension.prototype.extendParams = function(materialParams, materialDef, parser) {
+    var pending = [];
+    var extension = materialDef.extensions[this.name];
+    if (extension.clearcoatFactor !== void 0) {
+      materialParams.clearcoat = extension.clearcoatFactor;
+    }
+    if (extension.clearcoatTexture !== void 0) {
+      pending.push(parser.assignTexture(materialParams, "clearcoatMap", extension.clearcoatTexture));
+    }
+    if (extension.clearcoatRoughnessFactor !== void 0) {
+      materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
+    }
+    if (extension.clearcoatRoughnessTexture !== void 0) {
+      pending.push(parser.assignTexture(materialParams, "clearcoatRoughnessMap", extension.clearcoatRoughnessTexture));
+    }
+    if (extension.clearcoatNormalTexture !== void 0) {
+      pending.push(parser.assignTexture(materialParams, "clearcoatNormalMap", extension.clearcoatNormalTexture));
+      if (extension.clearcoatNormalTexture.scale !== void 0) {
+        var scale = extension.clearcoatNormalTexture.scale;
+        materialParams.clearcoatNormalScale = new Vector2(scale, scale);
+      }
+    }
+    return Promise.all(pending);
+  };
+  function GLTFMaterialsTransmissionExtension() {
+    this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;
+  }
+  GLTFMaterialsTransmissionExtension.prototype.getMaterialType = function() {
+    return MeshPhysicalMaterial;
+  };
+  GLTFMaterialsTransmissionExtension.prototype.extendParams = function(materialParams, materialDef, parser) {
+    var pending = [];
+    var extension = materialDef.extensions[this.name];
+    if (extension.transmissionFactor !== void 0) {
+      materialParams.premultipliedAlpha = true;
+      materialParams.transparent = true;
+      materialParams.opacity = 1;
+      materialParams.transparency = extension.transmissionFactor;
+      if (materialParams.map || materialParams.color.r * materialParams.color.g * materialParams.color.b < 0.99) {
+        materialParams.transparency *= 0.75;
+      }
+    }
+    return Promise.all(pending);
+  };
+  var BINARY_EXTENSION_HEADER_MAGIC = "glTF";
+  var BINARY_EXTENSION_HEADER_LENGTH = 12;
+  var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 1313821514, BIN: 5130562 };
+  function GLTFBinaryExtension(data) {
+    this.name = EXTENSIONS.KHR_BINARY_GLTF;
+    this.content = null;
+    this.body = null;
+    var headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH);
+    this.header = {
+      magic: LoaderUtils.decodeText(new Uint8Array(data.slice(0, 4))),
+      version: headerView.getUint32(4, true),
+      length: headerView.getUint32(8, true)
+    };
+    if (this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    } else if (this.header.version < 2) {
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    }
+    var chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH);
+    var chunkIndex = 0;
+    while (chunkIndex < chunkView.byteLength) {
+      var chunkLength = chunkView.getUint32(chunkIndex, true);
+      chunkIndex += 4;
+      var chunkType = chunkView.getUint32(chunkIndex, true);
+      chunkIndex += 4;
+      if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
+        var contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength);
+        this.content = LoaderUtils.decodeText(contentArray);
+      } else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
+        var byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
+        this.body = data.slice(byteOffset, byteOffset + chunkLength);
+      }
+      chunkIndex += chunkLength;
+    }
+    if (this.content === null) {
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+    }
+  }
+  function GLTFDracoMeshCompressionExtension(json, dracoLoader) {
+    if (!dracoLoader) {
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    }
+    this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
+    this.json = json;
+    this.dracoLoader = dracoLoader;
+    this.dracoLoader.preload();
+  }
+  GLTFDracoMeshCompressionExtension.prototype.decodePrimitive = function(primitive, parser) {
+    var json = this.json;
+    var dracoLoader = this.dracoLoader;
+    var bufferViewIndex = primitive.extensions[this.name].bufferView;
+    var gltfAttributeMap = primitive.extensions[this.name].attributes;
+    var threeAttributeMap = {};
+    var attributeNormalizedMap = {};
+    var attributeTypeMap = {};
+    for (var attributeName in gltfAttributeMap) {
+      var threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
+      threeAttributeMap[threeAttributeName] = gltfAttributeMap[attributeName];
+    }
+    for (attributeName in primitive.attributes) {
+      var threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
+      if (gltfAttributeMap[attributeName] !== void 0) {
+        var accessorDef = json.accessors[primitive.attributes[attributeName]];
+        var componentType = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
+        attributeTypeMap[threeAttributeName] = componentType;
+        attributeNormalizedMap[threeAttributeName] = accessorDef.normalized === true;
+      }
+    }
+    return parser.getDependency("bufferView", bufferViewIndex).then(function(bufferView) {
+      return new Promise(function(resolve) {
+        dracoLoader.decodeDracoFile(bufferView, function(geometry) {
+          for (var attributeName2 in geometry.attributes) {
+            var attribute = geometry.attributes[attributeName2];
+            var normalized = attributeNormalizedMap[attributeName2];
+            if (normalized !== void 0)
+              attribute.normalized = normalized;
+          }
+          resolve(geometry);
+        }, threeAttributeMap, attributeTypeMap);
+      });
+    });
+  };
+  function GLTFTextureTransformExtension() {
+    this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
+  }
+  GLTFTextureTransformExtension.prototype.extendTexture = function(texture, transform) {
+    texture = texture.clone();
+    if (transform.offset !== void 0) {
+      texture.offset.fromArray(transform.offset);
+    }
+    if (transform.rotation !== void 0) {
+      texture.rotation = transform.rotation;
+    }
+    if (transform.scale !== void 0) {
+      texture.repeat.fromArray(transform.scale);
+    }
+    if (transform.texCoord !== void 0) {
+      console.warn('THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.');
+    }
+    texture.needsUpdate = true;
+    return texture;
+  };
+  function GLTFMeshStandardSGMaterial(params) {
+    MeshStandardMaterial.call(this);
+    this.isGLTFSpecularGlossinessMaterial = true;
+    var specularMapParsFragmentChunk = [
+      "#ifdef USE_SPECULARMAP",
+      "	uniform sampler2D specularMap;",
+      "#endif"
+    ].join("\n");
+    var glossinessMapParsFragmentChunk = [
+      "#ifdef USE_GLOSSINESSMAP",
+      "	uniform sampler2D glossinessMap;",
+      "#endif"
+    ].join("\n");
+    var specularMapFragmentChunk = [
+      "vec3 specularFactor = specular;",
+      "#ifdef USE_SPECULARMAP",
+      "	vec4 texelSpecular = texture2D( specularMap, vUv );",
+      "	texelSpecular = sRGBToLinear( texelSpecular );",
+      "	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture",
+      "	specularFactor *= texelSpecular.rgb;",
+      "#endif"
+    ].join("\n");
+    var glossinessMapFragmentChunk = [
+      "float glossinessFactor = glossiness;",
+      "#ifdef USE_GLOSSINESSMAP",
+      "	vec4 texelGlossiness = texture2D( glossinessMap, vUv );",
+      "	// reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture",
+      "	glossinessFactor *= texelGlossiness.a;",
+      "#endif"
+    ].join("\n");
+    var lightPhysicalFragmentChunk = [
+      "PhysicalMaterial material;",
+      "material.diffuseColor = diffuseColor.rgb;",
+      "vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );",
+      "float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );",
+      "material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 );// 0.0525 corresponds to the base mip of a 256 cubemap.",
+      "material.specularRoughness += geometryRoughness;",
+      "material.specularRoughness = min( material.specularRoughness, 1.0 );",
+      "material.specularColor = specularFactor.rgb;"
+    ].join("\n");
+    var uniforms = {
+      specular: { value: new Color().setHex(16777215) },
+      glossiness: { value: 1 },
+      specularMap: { value: null },
+      glossinessMap: { value: null }
+    };
+    this._extraUniforms = uniforms;
+    this.onBeforeCompile = function(shader) {
+      for (var uniformName in uniforms) {
+        shader.uniforms[uniformName] = uniforms[uniformName];
+      }
+      shader.fragmentShader = shader.fragmentShader.replace("uniform float roughness;", "uniform vec3 specular;");
+      shader.fragmentShader = shader.fragmentShader.replace("uniform float metalness;", "uniform float glossiness;");
+      shader.fragmentShader = shader.fragmentShader.replace("#include <roughnessmap_pars_fragment>", specularMapParsFragmentChunk);
+      shader.fragmentShader = shader.fragmentShader.replace("#include <metalnessmap_pars_fragment>", glossinessMapParsFragmentChunk);
+      shader.fragmentShader = shader.fragmentShader.replace("#include <roughnessmap_fragment>", specularMapFragmentChunk);
+      shader.fragmentShader = shader.fragmentShader.replace("#include <metalnessmap_fragment>", glossinessMapFragmentChunk);
+      shader.fragmentShader = shader.fragmentShader.replace("#include <lights_physical_fragment>", lightPhysicalFragmentChunk);
+    };
+    Object.defineProperties(
+      this,
+      {
+        specular: {
+          get: function() {
+            return uniforms.specular.value;
+          },
+          set: function(v) {
+            uniforms.specular.value = v;
+          }
+        },
+        specularMap: {
+          get: function() {
+            return uniforms.specularMap.value;
+          },
+          set: function(v) {
+            uniforms.specularMap.value = v;
+          }
+        },
+        glossiness: {
+          get: function() {
+            return uniforms.glossiness.value;
+          },
+          set: function(v) {
+            uniforms.glossiness.value = v;
+          }
+        },
+        glossinessMap: {
+          get: function() {
+            return uniforms.glossinessMap.value;
+          },
+          set: function(v) {
+            uniforms.glossinessMap.value = v;
+            if (v) {
+              this.defines.USE_GLOSSINESSMAP = "";
+              this.defines.USE_ROUGHNESSMAP = "";
+            } else {
+              delete this.defines.USE_ROUGHNESSMAP;
+              delete this.defines.USE_GLOSSINESSMAP;
+            }
+          }
+        }
+      }
+    );
+    delete this.metalness;
+    delete this.roughness;
+    delete this.metalnessMap;
+    delete this.roughnessMap;
+    this.setValues(params);
+  }
+  GLTFMeshStandardSGMaterial.prototype = Object.create(MeshStandardMaterial.prototype);
+  GLTFMeshStandardSGMaterial.prototype.constructor = GLTFMeshStandardSGMaterial;
+  GLTFMeshStandardSGMaterial.prototype.copy = function(source) {
+    MeshStandardMaterial.prototype.copy.call(this, source);
+    this.specularMap = source.specularMap;
+    this.specular.copy(source.specular);
+    this.glossinessMap = source.glossinessMap;
+    this.glossiness = source.glossiness;
+    delete this.metalness;
+    delete this.roughness;
+    delete this.metalnessMap;
+    delete this.roughnessMap;
+    return this;
+  };
+  function GLTFMaterialsPbrSpecularGlossinessExtension() {
+    return {
+      name: EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS,
+      specularGlossinessParams: [
+        "color",
+        "map",
+        "lightMap",
+        "lightMapIntensity",
+        "aoMap",
+        "aoMapIntensity",
+        "emissive",
+        "emissiveIntensity",
+        "emissiveMap",
+        "bumpMap",
+        "bumpScale",
+        "normalMap",
+        "normalMapType",
+        "displacementMap",
+        "displacementScale",
+        "displacementBias",
+        "specularMap",
+        "specular",
+        "glossinessMap",
+        "glossiness",
+        "alphaMap",
+        "envMap",
+        "envMapIntensity",
+        "refractionRatio"
+      ],
+      getMaterialType: function() {
+        return GLTFMeshStandardSGMaterial;
+      },
+      extendParams: function(materialParams, materialDef, parser) {
+        var pbrSpecularGlossiness = materialDef.extensions[this.name];
+        materialParams.color = new Color(1, 1, 1);
+        materialParams.opacity = 1;
+        var pending = [];
+        if (Array.isArray(pbrSpecularGlossiness.diffuseFactor)) {
+          var array = pbrSpecularGlossiness.diffuseFactor;
+          materialParams.color.fromArray(array);
+          materialParams.opacity = array[3];
+        }
+        if (pbrSpecularGlossiness.diffuseTexture !== void 0) {
+          pending.push(parser.assignTexture(materialParams, "map", pbrSpecularGlossiness.diffuseTexture));
+        }
+        materialParams.emissive = new Color(0, 0, 0);
+        materialParams.glossiness = pbrSpecularGlossiness.glossinessFactor !== void 0 ? pbrSpecularGlossiness.glossinessFactor : 1;
+        materialParams.specular = new Color(1, 1, 1);
+        if (Array.isArray(pbrSpecularGlossiness.specularFactor)) {
+          materialParams.specular.fromArray(pbrSpecularGlossiness.specularFactor);
+        }
+        if (pbrSpecularGlossiness.specularGlossinessTexture !== void 0) {
+          var specGlossMapDef = pbrSpecularGlossiness.specularGlossinessTexture;
+          pending.push(parser.assignTexture(materialParams, "glossinessMap", specGlossMapDef));
+          pending.push(parser.assignTexture(materialParams, "specularMap", specGlossMapDef));
+        }
+        return Promise.all(pending);
+      },
+      createMaterial: function(materialParams) {
+        var material = new GLTFMeshStandardSGMaterial(materialParams);
+        material.fog = true;
+        material.color = materialParams.color;
+        material.map = materialParams.map === void 0 ? null : materialParams.map;
+        material.lightMap = null;
+        material.lightMapIntensity = 1;
+        material.aoMap = materialParams.aoMap === void 0 ? null : materialParams.aoMap;
+        material.aoMapIntensity = 1;
+        material.emissive = materialParams.emissive;
+        material.emissiveIntensity = 1;
+        material.emissiveMap = materialParams.emissiveMap === void 0 ? null : materialParams.emissiveMap;
+        material.bumpMap = materialParams.bumpMap === void 0 ? null : materialParams.bumpMap;
+        material.bumpScale = 1;
+        material.normalMap = materialParams.normalMap === void 0 ? null : materialParams.normalMap;
+        material.normalMapType = TangentSpaceNormalMap;
+        if (materialParams.normalScale)
+          material.normalScale = materialParams.normalScale;
+        material.displacementMap = null;
+        material.displacementScale = 1;
+        material.displacementBias = 0;
+        material.specularMap = materialParams.specularMap === void 0 ? null : materialParams.specularMap;
+        material.specular = materialParams.specular;
+        material.glossinessMap = materialParams.glossinessMap === void 0 ? null : materialParams.glossinessMap;
+        material.glossiness = materialParams.glossiness;
+        material.alphaMap = null;
+        material.envMap = materialParams.envMap === void 0 ? null : materialParams.envMap;
+        material.envMapIntensity = 1;
+        material.refractionRatio = 0.98;
+        return material;
+      }
+    };
+  }
+  function GLTFMeshQuantizationExtension() {
+    this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
+  }
+  function GLTFCubicSplineInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer);
+  }
+  GLTFCubicSplineInterpolant.prototype = Object.create(Interpolant.prototype);
+  GLTFCubicSplineInterpolant.prototype.constructor = GLTFCubicSplineInterpolant;
+  GLTFCubicSplineInterpolant.prototype.copySampleValue_ = function(index) {
+    var result = this.resultBuffer, values = this.sampleValues, valueSize = this.valueSize, offset = index * valueSize * 3 + valueSize;
+    for (var i = 0; i !== valueSize; i++) {
+      result[i] = values[offset + i];
+    }
+    return result;
+  };
+  GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
+  GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
+  GLTFCubicSplineInterpolant.prototype.interpolate_ = function(i1, t0, t, t1) {
+    var result = this.resultBuffer;
+    var values = this.sampleValues;
+    var stride = this.valueSize;
+    var stride2 = stride * 2;
+    var stride3 = stride * 3;
+    var td = t1 - t0;
+    var p = (t - t0) / td;
+    var pp = p * p;
+    var ppp = pp * p;
+    var offset1 = i1 * stride3;
+    var offset0 = offset1 - stride3;
+    var s2 = -2 * ppp + 3 * pp;
+    var s3 = ppp - pp;
+    var s0 = 1 - s2;
+    var s1 = s3 - pp + p;
+    for (var i = 0; i !== stride; i++) {
+      var p0 = values[offset0 + i + stride];
+      var m0 = values[offset0 + i + stride2] * td;
+      var p1 = values[offset1 + i + stride];
+      var m1 = values[offset1 + i] * td;
+      result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
+    }
+    return result;
+  };
+  var WEBGL_CONSTANTS = {
+    FLOAT: 5126,
+    //FLOAT_MAT2: 35674,
+    FLOAT_MAT3: 35675,
+    FLOAT_MAT4: 35676,
+    FLOAT_VEC2: 35664,
+    FLOAT_VEC3: 35665,
+    FLOAT_VEC4: 35666,
+    LINEAR: 9729,
+    REPEAT: 10497,
+    SAMPLER_2D: 35678,
+    POINTS: 0,
+    LINES: 1,
+    LINE_LOOP: 2,
+    LINE_STRIP: 3,
+    TRIANGLES: 4,
+    TRIANGLE_STRIP: 5,
+    TRIANGLE_FAN: 6,
+    UNSIGNED_BYTE: 5121,
+    UNSIGNED_SHORT: 5123
+  };
+  var WEBGL_COMPONENT_TYPES = {
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5125: Uint32Array,
+    5126: Float32Array
+  };
+  var WEBGL_FILTERS = {
+    9728: NearestFilter,
+    9729: LinearFilter,
+    9984: NearestMipmapNearestFilter,
+    9985: LinearMipmapNearestFilter,
+    9986: NearestMipmapLinearFilter,
+    9987: LinearMipmapLinearFilter
+  };
+  var WEBGL_WRAPPINGS = {
+    33071: ClampToEdgeWrapping,
+    33648: MirroredRepeatWrapping,
+    10497: RepeatWrapping
+  };
+  var WEBGL_TYPE_SIZES = {
+    "SCALAR": 1,
+    "VEC2": 2,
+    "VEC3": 3,
+    "VEC4": 4,
+    "MAT2": 4,
+    "MAT3": 9,
+    "MAT4": 16
+  };
+  var ATTRIBUTES = {
+    POSITION: "position",
+    NORMAL: "normal",
+    TANGENT: "tangent",
+    TEXCOORD_0: "uv",
+    TEXCOORD_1: "uv2",
+    COLOR_0: "color",
+    WEIGHTS_0: "skinWeight",
+    JOINTS_0: "skinIndex"
+  };
+  var PATH_PROPERTIES = {
+    scale: "scale",
+    translation: "position",
+    rotation: "quaternion",
+    weights: "morphTargetInfluences"
+  };
+  var INTERPOLATION = {
+    CUBICSPLINE: void 0,
+    // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
+    // keyframe track will be initialized with a default interpolation type, then modified.
+    LINEAR: InterpolateLinear,
+    STEP: InterpolateDiscrete
+  };
+  var ALPHA_MODES = {
+    OPAQUE: "OPAQUE",
+    MASK: "MASK",
+    BLEND: "BLEND"
+  };
+  var MIME_TYPE_FORMATS = {
+    "image/png": RGBAFormat,
+    "image/jpeg": RGBFormat
+  };
+  function resolveURL(url, path) {
+    if (typeof url !== "string" || url === "")
+      return "";
+    if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
+      path = path.replace(/(^https?:\/\/[^\/]+).*/i, "$1");
+    }
+    if (/^(https?:)?\/\//i.test(url))
+      return url;
+    if (/^data:.*,.*$/i.test(url))
+      return url;
+    if (/^blob:.*$/i.test(url))
+      return url;
+    return path + url;
+  }
+  function createDefaultMaterial(cache) {
+    if (cache["DefaultMaterial"] === void 0) {
+      cache["DefaultMaterial"] = new MeshStandardMaterial({
+        color: 16777215,
+        emissive: 0,
+        metalness: 1,
+        roughness: 1,
+        transparent: false,
+        depthTest: true,
+        side: FrontSide
+      });
+    }
+    return cache["DefaultMaterial"];
+  }
+  function addUnknownExtensionsToUserData(knownExtensions, object, objectDef) {
+    for (var name in objectDef.extensions) {
+      if (knownExtensions[name] === void 0) {
+        object.userData.gltfExtensions = object.userData.gltfExtensions || {};
+        object.userData.gltfExtensions[name] = objectDef.extensions[name];
+      }
+    }
+  }
+  function assignExtrasToUserData(object, gltfDef) {
+    if (gltfDef.extras !== void 0) {
+      if (typeof gltfDef.extras === "object") {
+        Object.assign(object.userData, gltfDef.extras);
+      } else {
+        console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + gltfDef.extras);
+      }
+    }
+  }
+  function addMorphTargets(geometry, targets, parser) {
+    var hasMorphPosition = false;
+    var hasMorphNormal = false;
+    for (var i = 0, il = targets.length; i < il; i++) {
+      var target = targets[i];
+      if (target.POSITION !== void 0)
+        hasMorphPosition = true;
+      if (target.NORMAL !== void 0)
+        hasMorphNormal = true;
+      if (hasMorphPosition && hasMorphNormal)
+        break;
+    }
+    if (!hasMorphPosition && !hasMorphNormal)
+      return Promise.resolve(geometry);
+    var pendingPositionAccessors = [];
+    var pendingNormalAccessors = [];
+    for (var i = 0, il = targets.length; i < il; i++) {
+      var target = targets[i];
+      if (hasMorphPosition) {
+        var pendingAccessor = target.POSITION !== void 0 ? parser.getDependency("accessor", target.POSITION) : geometry.attributes.position;
+        pendingPositionAccessors.push(pendingAccessor);
+      }
+      if (hasMorphNormal) {
+        var pendingAccessor = target.NORMAL !== void 0 ? parser.getDependency("accessor", target.NORMAL) : geometry.attributes.normal;
+        pendingNormalAccessors.push(pendingAccessor);
+      }
+    }
+    return Promise.all([
+      Promise.all(pendingPositionAccessors),
+      Promise.all(pendingNormalAccessors)
+    ]).then(function(accessors) {
+      var morphPositions = accessors[0];
+      var morphNormals = accessors[1];
+      if (hasMorphPosition)
+        geometry.morphAttributes.position = morphPositions;
+      if (hasMorphNormal)
+        geometry.morphAttributes.normal = morphNormals;
+      geometry.morphTargetsRelative = true;
+      return geometry;
+    });
+  }
+  function updateMorphTargets(mesh, meshDef) {
+    mesh.updateMorphTargets();
+    if (meshDef.weights !== void 0) {
+      for (var i = 0, il = meshDef.weights.length; i < il; i++) {
+        mesh.morphTargetInfluences[i] = meshDef.weights[i];
+      }
+    }
+    if (meshDef.extras && Array.isArray(meshDef.extras.targetNames)) {
+      var targetNames = meshDef.extras.targetNames;
+      if (mesh.morphTargetInfluences.length === targetNames.length) {
+        mesh.morphTargetDictionary = {};
+        for (var i = 0, il = targetNames.length; i < il; i++) {
+          mesh.morphTargetDictionary[targetNames[i]] = i;
+        }
+      } else {
+        console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+      }
+    }
+  }
+  function createPrimitiveKey(primitiveDef) {
+    var dracoExtension = primitiveDef.extensions && primitiveDef.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION];
+    var geometryKey;
+    if (dracoExtension) {
+      geometryKey = "draco:" + dracoExtension.bufferView + ":" + dracoExtension.indices + ":" + createAttributesKey(dracoExtension.attributes);
+    } else {
+      geometryKey = primitiveDef.indices + ":" + createAttributesKey(primitiveDef.attributes) + ":" + primitiveDef.mode;
+    }
+    return geometryKey;
+  }
+  function createAttributesKey(attributes) {
+    var attributesKey = "";
+    var keys = Object.keys(attributes).sort();
+    for (var i = 0, il = keys.length; i < il; i++) {
+      attributesKey += keys[i] + ":" + attributes[keys[i]] + ";";
+    }
+    return attributesKey;
+  }
+  function GLTFParser(json, extensions, options) {
+    this.json = json || {};
+    this.extensions = extensions || {};
+    this.options = options || {};
+    this.cache = new GLTFRegistry();
+    this.associations = /* @__PURE__ */ new Map();
+    this.primitiveCache = {};
+    this.textureLoader = new TextureLoader(this.options.manager);
+    this.textureLoader.setCrossOrigin(this.options.crossOrigin);
+    this.fileLoader = new FileLoader(this.options.manager);
+    this.fileLoader.setResponseType("arraybuffer");
+    if (this.options.crossOrigin === "use-credentials") {
+      this.fileLoader.setWithCredentials(true);
+    }
+  }
+  GLTFParser.prototype.parse = function(onLoad, onError) {
+    var parser = this;
+    var json = this.json;
+    var extensions = this.extensions;
+    this.cache.removeAll();
+    this.markDefs();
+    Promise.all([
+      this.getDependencies("scene"),
+      this.getDependencies("animation"),
+      this.getDependencies("camera")
+    ]).then(function(dependencies) {
+      var result = {
+        scene: dependencies[0][json.scene || 0],
+        scenes: dependencies[0],
+        animations: dependencies[1],
+        cameras: dependencies[2],
+        asset: json.asset,
+        parser,
+        userData: {}
+      };
+      addUnknownExtensionsToUserData(extensions, result, json);
+      assignExtrasToUserData(result, json);
+      onLoad(result);
+    }).catch(onError);
+  };
+  GLTFParser.prototype.markDefs = function() {
+    var nodeDefs = this.json.nodes || [];
+    var skinDefs = this.json.skins || [];
+    var meshDefs = this.json.meshes || [];
+    var meshReferences = {};
+    var meshUses = {};
+    for (var skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex++) {
+      var joints = skinDefs[skinIndex].joints;
+      for (var i = 0, il = joints.length; i < il; i++) {
+        nodeDefs[joints[i]].isBone = true;
+      }
+    }
+    for (var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) {
+      var nodeDef = nodeDefs[nodeIndex];
+      if (nodeDef.mesh !== void 0) {
+        if (meshReferences[nodeDef.mesh] === void 0) {
+          meshReferences[nodeDef.mesh] = meshUses[nodeDef.mesh] = 0;
+        }
+        meshReferences[nodeDef.mesh]++;
+        if (nodeDef.skin !== void 0) {
+          meshDefs[nodeDef.mesh].isSkinnedMesh = true;
+        }
+      }
+    }
+    this.json.meshReferences = meshReferences;
+    this.json.meshUses = meshUses;
+  };
+  GLTFParser.prototype.getDependency = function(type, index) {
+    var cacheKey = type + ":" + index;
+    var dependency = this.cache.get(cacheKey);
+    if (!dependency) {
+      switch (type) {
+        case "scene":
+          dependency = this.loadScene(index);
+          break;
+        case "node":
+          dependency = this.loadNode(index);
+          break;
+        case "mesh":
+          dependency = this.loadMesh(index);
+          break;
+        case "accessor":
+          dependency = this.loadAccessor(index);
+          break;
+        case "bufferView":
+          dependency = this.loadBufferView(index);
+          break;
+        case "buffer":
+          dependency = this.loadBuffer(index);
+          break;
+        case "material":
+          dependency = this.loadMaterial(index);
+          break;
+        case "texture":
+          dependency = this.loadTexture(index);
+          break;
+        case "skin":
+          dependency = this.loadSkin(index);
+          break;
+        case "animation":
+          dependency = this.loadAnimation(index);
+          break;
+        case "camera":
+          dependency = this.loadCamera(index);
+          break;
+        case "light":
+          dependency = this.extensions[EXTENSIONS.KHR_LIGHTS_PUNCTUAL].loadLight(index);
+          break;
+        default:
+          throw new Error("Unknown type: " + type);
+      }
+      this.cache.add(cacheKey, dependency);
+    }
+    return dependency;
+  };
+  GLTFParser.prototype.getDependencies = function(type) {
+    var dependencies = this.cache.get(type);
+    if (!dependencies) {
+      var parser = this;
+      var defs = this.json[type + (type === "mesh" ? "es" : "s")] || [];
+      dependencies = Promise.all(defs.map(function(def, index) {
+        return parser.getDependency(type, index);
+      }));
+      this.cache.add(type, dependencies);
+    }
+    return dependencies;
+  };
+  GLTFParser.prototype.loadBuffer = function(bufferIndex) {
+    var bufferDef = this.json.buffers[bufferIndex];
+    var loader = this.fileLoader;
+    if (bufferDef.type && bufferDef.type !== "arraybuffer") {
+      throw new Error("THREE.GLTFLoader: " + bufferDef.type + " buffer type is not supported.");
+    }
+    if (bufferDef.uri === void 0 && bufferIndex === 0) {
+      return Promise.resolve(this.extensions[EXTENSIONS.KHR_BINARY_GLTF].body);
+    }
+    var options = this.options;
+    return new Promise(function(resolve, reject) {
+      loader.load(resolveURL(bufferDef.uri, options.path), resolve, void 0, function() {
+        reject(new Error('THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".'));
+      });
+    });
+  };
+  GLTFParser.prototype.loadBufferView = function(bufferViewIndex) {
+    var bufferViewDef = this.json.bufferViews[bufferViewIndex];
+    return this.getDependency("buffer", bufferViewDef.buffer).then(function(buffer) {
+      var byteLength = bufferViewDef.byteLength || 0;
+      var byteOffset = bufferViewDef.byteOffset || 0;
+      return buffer.slice(byteOffset, byteOffset + byteLength);
+    });
+  };
+  GLTFParser.prototype.loadAccessor = function(accessorIndex) {
+    var parser = this;
+    var json = this.json;
+    var accessorDef = this.json.accessors[accessorIndex];
+    if (accessorDef.bufferView === void 0 && accessorDef.sparse === void 0) {
+      return Promise.resolve(null);
+    }
+    var pendingBufferViews = [];
+    if (accessorDef.bufferView !== void 0) {
+      pendingBufferViews.push(this.getDependency("bufferView", accessorDef.bufferView));
+    } else {
+      pendingBufferViews.push(null);
+    }
+    if (accessorDef.sparse !== void 0) {
+      pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.indices.bufferView));
+      pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.values.bufferView));
+    }
+    return Promise.all(pendingBufferViews).then(function(bufferViews) {
+      var bufferView = bufferViews[0];
+      var itemSize = WEBGL_TYPE_SIZES[accessorDef.type];
+      var TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
+      var elementBytes = TypedArray.BYTES_PER_ELEMENT;
+      var itemBytes = elementBytes * itemSize;
+      var byteOffset = accessorDef.byteOffset || 0;
+      var byteStride = accessorDef.bufferView !== void 0 ? json.bufferViews[accessorDef.bufferView].byteStride : void 0;
+      var normalized = accessorDef.normalized === true;
+      var array, bufferAttribute;
+      if (byteStride && byteStride !== itemBytes) {
+        var ibSlice = Math.floor(byteOffset / byteStride);
+        var ibCacheKey = "InterleavedBuffer:" + accessorDef.bufferView + ":" + accessorDef.componentType + ":" + ibSlice + ":" + accessorDef.count;
+        var ib = parser.cache.get(ibCacheKey);
+        if (!ib) {
+          array = new TypedArray(bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes);
+          ib = new InterleavedBuffer(array, byteStride / elementBytes);
+          parser.cache.add(ibCacheKey, ib);
+        }
+        bufferAttribute = new InterleavedBufferAttribute(ib, itemSize, byteOffset % byteStride / elementBytes, normalized);
+      } else {
+        if (bufferView === null) {
+          array = new TypedArray(accessorDef.count * itemSize);
+        } else {
+          array = new TypedArray(bufferView, byteOffset, accessorDef.count * itemSize);
+        }
+        bufferAttribute = new BufferAttribute(array, itemSize, normalized);
+      }
+      if (accessorDef.sparse !== void 0) {
+        var itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
+        var TypedArrayIndices = WEBGL_COMPONENT_TYPES[accessorDef.sparse.indices.componentType];
+        var byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
+        var byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
+        var sparseIndices = new TypedArrayIndices(bufferViews[1], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices);
+        var sparseValues = new TypedArray(bufferViews[2], byteOffsetValues, accessorDef.sparse.count * itemSize);
+        if (bufferView !== null) {
+          bufferAttribute = new BufferAttribute(bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized);
+        }
+        for (var i = 0, il = sparseIndices.length; i < il; i++) {
+          var index = sparseIndices[i];
+          bufferAttribute.setX(index, sparseValues[i * itemSize]);
+          if (itemSize >= 2)
+            bufferAttribute.setY(index, sparseValues[i * itemSize + 1]);
+          if (itemSize >= 3)
+            bufferAttribute.setZ(index, sparseValues[i * itemSize + 2]);
+          if (itemSize >= 4)
+            bufferAttribute.setW(index, sparseValues[i * itemSize + 3]);
+          if (itemSize >= 5)
+            throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+      }
+      return bufferAttribute;
+    });
+  };
+  GLTFParser.prototype.loadTexture = function(textureIndex) {
+    var parser = this;
+    var json = this.json;
+    var options = this.options;
+    var textureLoader = this.textureLoader;
+    var URL2 = self.URL || self.webkitURL;
+    var textureDef = json.textures[textureIndex];
+    var textureExtensions = textureDef.extensions || {};
+    var source;
+    if (textureExtensions[EXTENSIONS.MSFT_TEXTURE_DDS]) {
+      source = json.images[textureExtensions[EXTENSIONS.MSFT_TEXTURE_DDS].source];
+    } else {
+      source = json.images[textureDef.source];
+    }
+    var sourceURI = source.uri;
+    var isObjectURL = false;
+    if (source.bufferView !== void 0) {
+      sourceURI = parser.getDependency("bufferView", source.bufferView).then(function(bufferView) {
+        isObjectURL = true;
+        var blob = new Blob([bufferView], { type: source.mimeType });
+        sourceURI = URL2.createObjectURL(blob);
+        return sourceURI;
+      });
+    }
+    return Promise.resolve(sourceURI).then(function(sourceURI2) {
+      var loader = options.manager.getHandler(sourceURI2);
+      if (!loader) {
+        loader = textureExtensions[EXTENSIONS.MSFT_TEXTURE_DDS] ? parser.extensions[EXTENSIONS.MSFT_TEXTURE_DDS].ddsLoader : textureLoader;
+      }
+      return new Promise(function(resolve, reject) {
+        loader.load(resolveURL(sourceURI2, options.path), resolve, void 0, reject);
+      });
+    }).then(function(texture) {
+      if (isObjectURL === true) {
+        URL2.revokeObjectURL(sourceURI);
+      }
+      texture.flipY = false;
+      if (textureDef.name)
+        texture.name = textureDef.name;
+      if (source.mimeType in MIME_TYPE_FORMATS) {
+        texture.format = MIME_TYPE_FORMATS[source.mimeType];
+      }
+      var samplers = json.samplers || {};
+      var sampler = samplers[textureDef.sampler] || {};
+      texture.magFilter = WEBGL_FILTERS[sampler.magFilter] || LinearFilter;
+      texture.minFilter = WEBGL_FILTERS[sampler.minFilter] || LinearMipmapLinearFilter;
+      texture.wrapS = WEBGL_WRAPPINGS[sampler.wrapS] || RepeatWrapping;
+      texture.wrapT = WEBGL_WRAPPINGS[sampler.wrapT] || RepeatWrapping;
+      parser.associations.set(texture, {
+        type: "textures",
+        index: textureIndex
+      });
+      return texture;
+    });
+  };
+  GLTFParser.prototype.assignTexture = function(materialParams, mapName, mapDef) {
+    var parser = this;
+    return this.getDependency("texture", mapDef.index).then(function(texture) {
+      if (!texture.isCompressedTexture) {
+        switch (mapName) {
+          case "aoMap":
+          case "emissiveMap":
+          case "metalnessMap":
+          case "normalMap":
+          case "roughnessMap":
+            texture.format = RGBFormat;
+            break;
+        }
+      }
+      if (mapDef.texCoord !== void 0 && mapDef.texCoord != 0 && !(mapName === "aoMap" && mapDef.texCoord == 1)) {
+        console.warn("THREE.GLTFLoader: Custom UV set " + mapDef.texCoord + " for texture " + mapName + " not yet supported.");
+      }
+      if (parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM]) {
+        var transform = mapDef.extensions !== void 0 ? mapDef.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (transform) {
+          var gltfReference = this.associations.get(texture);
+          texture = parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM].extendTexture(texture, transform);
+          this.associations.set(texture, gltfReference);
+        }
+      }
+      materialParams[mapName] = texture;
+    });
+  };
+  GLTFParser.prototype.assignFinalMaterial = function(mesh) {
+    var geometry = mesh.geometry;
+    var material = mesh.material;
+    var useVertexTangents = geometry.attributes.tangent !== void 0;
+    var useVertexColors = geometry.attributes.color !== void 0;
+    var useFlatShading = geometry.attributes.normal === void 0;
+    var useSkinning = mesh.isSkinnedMesh === true;
+    var useMorphTargets = Object.keys(geometry.morphAttributes).length > 0;
+    var useMorphNormals = useMorphTargets && geometry.morphAttributes.normal !== void 0;
+    if (mesh.isPoints) {
+      var cacheKey = "PointsMaterial:" + material.uuid;
+      var pointsMaterial = this.cache.get(cacheKey);
+      if (!pointsMaterial) {
+        pointsMaterial = new PointsMaterial();
+        Material.prototype.copy.call(pointsMaterial, material);
+        pointsMaterial.color.copy(material.color);
+        pointsMaterial.map = material.map;
+        pointsMaterial.sizeAttenuation = false;
+        this.cache.add(cacheKey, pointsMaterial);
+      }
+      material = pointsMaterial;
+    } else if (mesh.isLine) {
+      var cacheKey = "LineBasicMaterial:" + material.uuid;
+      var lineMaterial = this.cache.get(cacheKey);
+      if (!lineMaterial) {
+        lineMaterial = new LineBasicMaterial();
+        Material.prototype.copy.call(lineMaterial, material);
+        lineMaterial.color.copy(material.color);
+        this.cache.add(cacheKey, lineMaterial);
+      }
+      material = lineMaterial;
+    }
+    if (useVertexTangents || useVertexColors || useFlatShading || useSkinning || useMorphTargets) {
+      var cacheKey = "ClonedMaterial:" + material.uuid + ":";
+      if (material.isGLTFSpecularGlossinessMaterial)
+        cacheKey += "specular-glossiness:";
+      if (useSkinning)
+        cacheKey += "skinning:";
+      if (useVertexTangents)
+        cacheKey += "vertex-tangents:";
+      if (useVertexColors)
+        cacheKey += "vertex-colors:";
+      if (useFlatShading)
+        cacheKey += "flat-shading:";
+      if (useMorphTargets)
+        cacheKey += "morph-targets:";
+      if (useMorphNormals)
+        cacheKey += "morph-normals:";
+      var cachedMaterial = this.cache.get(cacheKey);
+      if (!cachedMaterial) {
+        cachedMaterial = material.clone();
+        if (useSkinning)
+          cachedMaterial.skinning = true;
+        if (useVertexTangents)
+          cachedMaterial.vertexTangents = true;
+        if (useVertexColors)
+          cachedMaterial.vertexColors = true;
+        if (useFlatShading)
+          cachedMaterial.flatShading = true;
+        if (useMorphTargets)
+          cachedMaterial.morphTargets = true;
+        if (useMorphNormals)
+          cachedMaterial.morphNormals = true;
+        this.cache.add(cacheKey, cachedMaterial);
+        this.associations.set(cachedMaterial, this.associations.get(material));
+      }
+      material = cachedMaterial;
+    }
+    if (material.aoMap && geometry.attributes.uv2 === void 0 && geometry.attributes.uv !== void 0) {
+      geometry.setAttribute("uv2", geometry.attributes.uv);
+    }
+    if (material.normalScale && !useVertexTangents) {
+      material.normalScale.y = -material.normalScale.y;
+    }
+    if (material.clearcoatNormalScale && !useVertexTangents) {
+      material.clearcoatNormalScale.y = -material.clearcoatNormalScale.y;
+    }
+    mesh.material = material;
+  };
+  GLTFParser.prototype.loadMaterial = function(materialIndex) {
+    var parser = this;
+    var json = this.json;
+    var extensions = this.extensions;
+    var materialDef = json.materials[materialIndex];
+    var materialType;
+    var materialParams = {};
+    var materialExtensions = materialDef.extensions || {};
+    var pending = [];
+    if (materialExtensions[EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS]) {
+      var sgExtension = extensions[EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS];
+      materialType = sgExtension.getMaterialType();
+      pending.push(sgExtension.extendParams(materialParams, materialDef, parser));
+    } else if (materialExtensions[EXTENSIONS.KHR_MATERIALS_UNLIT]) {
+      var kmuExtension = extensions[EXTENSIONS.KHR_MATERIALS_UNLIT];
+      materialType = kmuExtension.getMaterialType();
+      pending.push(kmuExtension.extendParams(materialParams, materialDef, parser));
+    } else {
+      materialType = MeshStandardMaterial;
+      var metallicRoughness = materialDef.pbrMetallicRoughness || {};
+      materialParams.color = new Color(1, 1, 1);
+      materialParams.opacity = 1;
+      if (Array.isArray(metallicRoughness.baseColorFactor)) {
+        var array = metallicRoughness.baseColorFactor;
+        materialParams.color.fromArray(array);
+        materialParams.opacity = array[3];
+      }
+      if (metallicRoughness.baseColorTexture !== void 0) {
+        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture));
+      }
+      materialParams.metalness = metallicRoughness.metallicFactor !== void 0 ? metallicRoughness.metallicFactor : 1;
+      materialParams.roughness = metallicRoughness.roughnessFactor !== void 0 ? metallicRoughness.roughnessFactor : 1;
+      if (metallicRoughness.metallicRoughnessTexture !== void 0) {
+        pending.push(parser.assignTexture(materialParams, "metalnessMap", metallicRoughness.metallicRoughnessTexture));
+        pending.push(parser.assignTexture(materialParams, "roughnessMap", metallicRoughness.metallicRoughnessTexture));
+      }
+    }
+    if (materialDef.doubleSided === true) {
+      materialParams.side = DoubleSide;
+    }
+    var alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
+    if (alphaMode === ALPHA_MODES.BLEND) {
+      materialParams.transparent = true;
+      materialParams.depthWrite = false;
+    } else {
+      materialParams.transparent = false;
+      if (alphaMode === ALPHA_MODES.MASK) {
+        materialParams.alphaTest = materialDef.alphaCutoff !== void 0 ? materialDef.alphaCutoff : 0.5;
+      }
+    }
+    if (materialDef.normalTexture !== void 0 && materialType !== MeshBasicMaterial) {
+      pending.push(parser.assignTexture(materialParams, "normalMap", materialDef.normalTexture));
+      materialParams.normalScale = new Vector2(1, 1);
+      if (materialDef.normalTexture.scale !== void 0) {
+        materialParams.normalScale.set(materialDef.normalTexture.scale, materialDef.normalTexture.scale);
+      }
+    }
+    if (materialDef.occlusionTexture !== void 0 && materialType !== MeshBasicMaterial) {
+      pending.push(parser.assignTexture(materialParams, "aoMap", materialDef.occlusionTexture));
+      if (materialDef.occlusionTexture.strength !== void 0) {
+        materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
+      }
+    }
+    if (materialDef.emissiveFactor !== void 0 && materialType !== MeshBasicMaterial) {
+      materialParams.emissive = new Color().fromArray(materialDef.emissiveFactor);
+    }
+    if (materialDef.emissiveTexture !== void 0 && materialType !== MeshBasicMaterial) {
+      pending.push(parser.assignTexture(materialParams, "emissiveMap", materialDef.emissiveTexture));
+    }
+    if (materialExtensions[EXTENSIONS.KHR_MATERIALS_CLEARCOAT]) {
+      var clearcoatExtension = extensions[EXTENSIONS.KHR_MATERIALS_CLEARCOAT];
+      materialType = clearcoatExtension.getMaterialType();
+      pending.push(clearcoatExtension.extendParams(materialParams, { extensions: materialExtensions }, parser));
+    }
+    if (materialExtensions[EXTENSIONS.KHR_MATERIALS_TRANSMISSION]) {
+      var clearcoatExtension = extensions[EXTENSIONS.KHR_MATERIALS_TRANSMISSION];
+      materialType = clearcoatExtension.getMaterialType();
+      pending.push(clearcoatExtension.extendParams(materialParams, { extensions: materialExtensions }, parser));
+    }
+    return Promise.all(pending).then(function() {
+      var material;
+      if (materialType === GLTFMeshStandardSGMaterial) {
+        material = extensions[EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS].createMaterial(materialParams);
+      } else {
+        material = new materialType(materialParams);
+      }
+      if (materialDef.name)
+        material.name = materialDef.name;
+      if (material.map)
+        material.map.encoding = sRGBEncoding;
+      if (material.emissiveMap)
+        material.emissiveMap.encoding = sRGBEncoding;
+      assignExtrasToUserData(material, materialDef);
+      parser.associations.set(material, { type: "materials", index: materialIndex });
+      if (materialDef.extensions)
+        addUnknownExtensionsToUserData(extensions, material, materialDef);
+      return material;
+    });
+  };
+  function computeBounds(geometry, primitiveDef, parser) {
+    var attributes = primitiveDef.attributes;
+    var box = new Box3();
+    if (attributes.POSITION !== void 0) {
+      var accessor = parser.json.accessors[attributes.POSITION];
+      var min = accessor.min;
+      var max = accessor.max;
+      if (min !== void 0 && max !== void 0) {
+        box.set(
+          new Vector3(min[0], min[1], min[2]),
+          new Vector3(max[0], max[1], max[2])
+        );
+      } else {
+        console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+        return;
+      }
+    } else {
+      return;
+    }
+    var targets = primitiveDef.targets;
+    if (targets !== void 0) {
+      var maxDisplacement = new Vector3();
+      var vector = new Vector3();
+      for (var i = 0, il = targets.length; i < il; i++) {
+        var target = targets[i];
+        if (target.POSITION !== void 0) {
+          var accessor = parser.json.accessors[target.POSITION];
+          var min = accessor.min;
+          var max = accessor.max;
+          if (min !== void 0 && max !== void 0) {
+            vector.setX(Math.max(Math.abs(min[0]), Math.abs(max[0])));
+            vector.setY(Math.max(Math.abs(min[1]), Math.abs(max[1])));
+            vector.setZ(Math.max(Math.abs(min[2]), Math.abs(max[2])));
+            maxDisplacement.max(vector);
+          } else {
+            console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+          }
+        }
+      }
+      box.expandByVector(maxDisplacement);
+    }
+    geometry.boundingBox = box;
+    var sphere = new Sphere();
+    box.getCenter(sphere.center);
+    sphere.radius = box.min.distanceTo(box.max) / 2;
+    geometry.boundingSphere = sphere;
+  }
+  function addPrimitiveAttributes(geometry, primitiveDef, parser) {
+    var attributes = primitiveDef.attributes;
+    var pending = [];
+    function assignAttributeAccessor(accessorIndex, attributeName) {
+      return parser.getDependency("accessor", accessorIndex).then(function(accessor2) {
+        geometry.setAttribute(attributeName, accessor2);
+      });
+    }
+    for (var gltfAttributeName in attributes) {
+      var threeAttributeName = ATTRIBUTES[gltfAttributeName] || gltfAttributeName.toLowerCase();
+      if (threeAttributeName in geometry.attributes)
+        continue;
+      pending.push(assignAttributeAccessor(attributes[gltfAttributeName], threeAttributeName));
+    }
+    if (primitiveDef.indices !== void 0 && !geometry.index) {
+      var accessor = parser.getDependency("accessor", primitiveDef.indices).then(function(accessor2) {
+        geometry.setIndex(accessor2);
+      });
+      pending.push(accessor);
+    }
+    assignExtrasToUserData(geometry, primitiveDef);
+    computeBounds(geometry, primitiveDef, parser);
+    return Promise.all(pending).then(function() {
+      return primitiveDef.targets !== void 0 ? addMorphTargets(geometry, primitiveDef.targets, parser) : geometry;
+    });
+  }
+  function toTrianglesDrawMode(geometry, drawMode) {
+    var index = geometry.getIndex();
+    if (index === null) {
+      var indices = [];
+      var position = geometry.getAttribute("position");
+      if (position !== void 0) {
+        for (var i = 0; i < position.count; i++) {
+          indices.push(i);
+        }
+        geometry.setIndex(indices);
+        index = geometry.getIndex();
+      } else {
+        console.error("THREE.GLTFLoader.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.");
+        return geometry;
+      }
+    }
+    var numberOfTriangles = index.count - 2;
+    var newIndices = [];
+    if (drawMode === TriangleFanDrawMode) {
+      for (var i = 1; i <= numberOfTriangles; i++) {
+        newIndices.push(index.getX(0));
+        newIndices.push(index.getX(i));
+        newIndices.push(index.getX(i + 1));
+      }
+    } else {
+      for (var i = 0; i < numberOfTriangles; i++) {
+        if (i % 2 === 0) {
+          newIndices.push(index.getX(i));
+          newIndices.push(index.getX(i + 1));
+          newIndices.push(index.getX(i + 2));
+        } else {
+          newIndices.push(index.getX(i + 2));
+          newIndices.push(index.getX(i + 1));
+          newIndices.push(index.getX(i));
+        }
+      }
+    }
+    if (newIndices.length / 3 !== numberOfTriangles) {
+      console.error("THREE.GLTFLoader.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    }
+    var newGeometry = geometry.clone();
+    newGeometry.setIndex(newIndices);
+    return newGeometry;
+  }
+  GLTFParser.prototype.loadGeometries = function(primitives) {
+    var parser = this;
+    var extensions = this.extensions;
+    var cache = this.primitiveCache;
+    function createDracoPrimitive(primitive2) {
+      return extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(primitive2, parser).then(function(geometry) {
+        return addPrimitiveAttributes(geometry, primitive2, parser);
+      });
+    }
+    var pending = [];
+    for (var i = 0, il = primitives.length; i < il; i++) {
+      var primitive = primitives[i];
+      var cacheKey = createPrimitiveKey(primitive);
+      var cached = cache[cacheKey];
+      if (cached) {
+        pending.push(cached.promise);
+      } else {
+        var geometryPromise;
+        if (primitive.extensions && primitive.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]) {
+          geometryPromise = createDracoPrimitive(primitive);
+        } else {
+          geometryPromise = addPrimitiveAttributes(new BufferGeometry(), primitive, parser);
+        }
+        cache[cacheKey] = { primitive, promise: geometryPromise };
+        pending.push(geometryPromise);
+      }
+    }
+    return Promise.all(pending);
+  };
+  GLTFParser.prototype.loadMesh = function(meshIndex) {
+    var parser = this;
+    var json = this.json;
+    var meshDef = json.meshes[meshIndex];
+    var primitives = meshDef.primitives;
+    var pending = [];
+    for (var i = 0, il = primitives.length; i < il; i++) {
+      var material = primitives[i].material === void 0 ? createDefaultMaterial(this.cache) : this.getDependency("material", primitives[i].material);
+      pending.push(material);
+    }
+    pending.push(parser.loadGeometries(primitives));
+    return Promise.all(pending).then(function(results) {
+      var materials = results.slice(0, results.length - 1);
+      var geometries = results[results.length - 1];
+      var meshes = [];
+      for (var i2 = 0, il2 = geometries.length; i2 < il2; i2++) {
+        var geometry = geometries[i2];
+        var primitive = primitives[i2];
+        var mesh;
+        var material2 = materials[i2];
+        if (primitive.mode === WEBGL_CONSTANTS.TRIANGLES || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN || primitive.mode === void 0) {
+          mesh = meshDef.isSkinnedMesh === true ? new SkinnedMesh(geometry, material2) : new Mesh(geometry, material2);
+          if (mesh.isSkinnedMesh === true && !mesh.geometry.attributes.skinWeight.normalized) {
+            mesh.normalizeSkinWeights();
+          }
+          if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP) {
+            mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleStripDrawMode);
+          } else if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN) {
+            mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleFanDrawMode);
+          }
+        } else if (primitive.mode === WEBGL_CONSTANTS.LINES) {
+          mesh = new LineSegments(geometry, material2);
+        } else if (primitive.mode === WEBGL_CONSTANTS.LINE_STRIP) {
+          mesh = new Line(geometry, material2);
+        } else if (primitive.mode === WEBGL_CONSTANTS.LINE_LOOP) {
+          mesh = new LineLoop(geometry, material2);
+        } else if (primitive.mode === WEBGL_CONSTANTS.POINTS) {
+          mesh = new Points(geometry, material2);
+        } else {
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + primitive.mode);
+        }
+        if (Object.keys(mesh.geometry.morphAttributes).length > 0) {
+          updateMorphTargets(mesh, meshDef);
+        }
+        mesh.name = meshDef.name || "mesh_" + meshIndex;
+        if (geometries.length > 1)
+          mesh.name += "_" + i2;
+        assignExtrasToUserData(mesh, meshDef);
+        parser.assignFinalMaterial(mesh);
+        meshes.push(mesh);
+      }
+      if (meshes.length === 1) {
+        return meshes[0];
+      }
+      var group = new Group();
+      for (var i2 = 0, il2 = meshes.length; i2 < il2; i2++) {
+        group.add(meshes[i2]);
+      }
+      return group;
+    });
+  };
+  GLTFParser.prototype.loadCamera = function(cameraIndex) {
+    var camera;
+    var cameraDef = this.json.cameras[cameraIndex];
+    var params = cameraDef[cameraDef.type];
+    if (!params) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    if (cameraDef.type === "perspective") {
+      camera = new PerspectiveCamera(MathUtils.radToDeg(params.yfov), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6);
+    } else if (cameraDef.type === "orthographic") {
+      camera = new OrthographicCamera(-params.xmag, params.xmag, params.ymag, -params.ymag, params.znear, params.zfar);
+    }
+    if (cameraDef.name)
+      camera.name = cameraDef.name;
+    assignExtrasToUserData(camera, cameraDef);
+    return Promise.resolve(camera);
+  };
+  GLTFParser.prototype.loadSkin = function(skinIndex) {
+    var skinDef = this.json.skins[skinIndex];
+    var skinEntry = { joints: skinDef.joints };
+    if (skinDef.inverseBindMatrices === void 0) {
+      return Promise.resolve(skinEntry);
+    }
+    return this.getDependency("accessor", skinDef.inverseBindMatrices).then(function(accessor) {
+      skinEntry.inverseBindMatrices = accessor;
+      return skinEntry;
+    });
+  };
+  GLTFParser.prototype.loadAnimation = function(animationIndex) {
+    var json = this.json;
+    var animationDef = json.animations[animationIndex];
+    var pendingNodes = [];
+    var pendingInputAccessors = [];
+    var pendingOutputAccessors = [];
+    var pendingSamplers = [];
+    var pendingTargets = [];
+    for (var i = 0, il = animationDef.channels.length; i < il; i++) {
+      var channel = animationDef.channels[i];
+      var sampler = animationDef.samplers[channel.sampler];
+      var target = channel.target;
+      var name = target.node !== void 0 ? target.node : target.id;
+      var input = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.input] : sampler.input;
+      var output = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.output] : sampler.output;
+      pendingNodes.push(this.getDependency("node", name));
+      pendingInputAccessors.push(this.getDependency("accessor", input));
+      pendingOutputAccessors.push(this.getDependency("accessor", output));
+      pendingSamplers.push(sampler);
+      pendingTargets.push(target);
+    }
+    return Promise.all([
+      Promise.all(pendingNodes),
+      Promise.all(pendingInputAccessors),
+      Promise.all(pendingOutputAccessors),
+      Promise.all(pendingSamplers),
+      Promise.all(pendingTargets)
+    ]).then(function(dependencies) {
+      var nodes = dependencies[0];
+      var inputAccessors = dependencies[1];
+      var outputAccessors = dependencies[2];
+      var samplers = dependencies[3];
+      var targets = dependencies[4];
+      var tracks = [];
+      for (var i2 = 0, il2 = nodes.length; i2 < il2; i2++) {
+        var node = nodes[i2];
+        var inputAccessor = inputAccessors[i2];
+        var outputAccessor = outputAccessors[i2];
+        var sampler2 = samplers[i2];
+        var target2 = targets[i2];
+        if (node === void 0)
+          continue;
+        node.updateMatrix();
+        node.matrixAutoUpdate = true;
+        var TypedKeyframeTrack;
+        switch (PATH_PROPERTIES[target2.path]) {
+          case PATH_PROPERTIES.weights:
+            TypedKeyframeTrack = NumberKeyframeTrack;
+            break;
+          case PATH_PROPERTIES.rotation:
+            TypedKeyframeTrack = QuaternionKeyframeTrack;
+            break;
+          case PATH_PROPERTIES.position:
+          case PATH_PROPERTIES.scale:
+          default:
+            TypedKeyframeTrack = VectorKeyframeTrack;
+            break;
+        }
+        var targetName = node.name ? node.name : node.uuid;
+        var interpolation = sampler2.interpolation !== void 0 ? INTERPOLATION[sampler2.interpolation] : InterpolateLinear;
+        var targetNames = [];
+        if (PATH_PROPERTIES[target2.path] === PATH_PROPERTIES.weights) {
+          node.traverse(function(object) {
+            if (object.isMesh === true && object.morphTargetInfluences) {
+              targetNames.push(object.name ? object.name : object.uuid);
+            }
+          });
+        } else {
+          targetNames.push(targetName);
+        }
+        var outputArray = outputAccessor.array;
+        if (outputAccessor.normalized) {
+          var scale;
+          if (outputArray.constructor === Int8Array) {
+            scale = 1 / 127;
+          } else if (outputArray.constructor === Uint8Array) {
+            scale = 1 / 255;
+          } else if (outputArray.constructor == Int16Array) {
+            scale = 1 / 32767;
+          } else if (outputArray.constructor === Uint16Array) {
+            scale = 1 / 65535;
+          } else {
+            throw new Error("THREE.GLTFLoader: Unsupported output accessor component type.");
+          }
+          var scaled = new Float32Array(outputArray.length);
+          for (var j = 0, jl = outputArray.length; j < jl; j++) {
+            scaled[j] = outputArray[j] * scale;
+          }
+          outputArray = scaled;
+        }
+        for (var j = 0, jl = targetNames.length; j < jl; j++) {
+          var track = new TypedKeyframeTrack(
+            targetNames[j] + "." + PATH_PROPERTIES[target2.path],
+            inputAccessor.array,
+            outputArray,
+            interpolation
+          );
+          if (sampler2.interpolation === "CUBICSPLINE") {
+            track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
+              return new GLTFCubicSplineInterpolant(this.times, this.values, this.getValueSize() / 3, result);
+            };
+            track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
+          }
+          tracks.push(track);
+        }
+      }
+      var name2 = animationDef.name ? animationDef.name : "animation_" + animationIndex;
+      return new AnimationClip(name2, void 0, tracks);
+    });
+  };
+  GLTFParser.prototype.loadNode = function(nodeIndex) {
+    var json = this.json;
+    var extensions = this.extensions;
+    var parser = this;
+    var meshReferences = json.meshReferences;
+    var meshUses = json.meshUses;
+    var nodeDef = json.nodes[nodeIndex];
+    return function() {
+      var pending = [];
+      if (nodeDef.mesh !== void 0) {
+        pending.push(parser.getDependency("mesh", nodeDef.mesh).then(function(mesh) {
+          var node;
+          if (meshReferences[nodeDef.mesh] > 1) {
+            var instanceNum = meshUses[nodeDef.mesh]++;
+            node = mesh.clone();
+            node.name += "_instance_" + instanceNum;
+          } else {
+            node = mesh;
+          }
+          if (nodeDef.weights !== void 0) {
+            node.traverse(function(o) {
+              if (!o.isMesh)
+                return;
+              for (var i = 0, il = nodeDef.weights.length; i < il; i++) {
+                o.morphTargetInfluences[i] = nodeDef.weights[i];
+              }
+            });
+          }
+          return node;
+        }));
+      }
+      if (nodeDef.camera !== void 0) {
+        pending.push(parser.getDependency("camera", nodeDef.camera));
+      }
+      if (nodeDef.extensions && nodeDef.extensions[EXTENSIONS.KHR_LIGHTS_PUNCTUAL] && nodeDef.extensions[EXTENSIONS.KHR_LIGHTS_PUNCTUAL].light !== void 0) {
+        pending.push(parser.getDependency("light", nodeDef.extensions[EXTENSIONS.KHR_LIGHTS_PUNCTUAL].light));
+      }
+      return Promise.all(pending);
+    }().then(function(objects) {
+      var node;
+      if (nodeDef.isBone === true) {
+        node = new Bone();
+      } else if (objects.length > 1) {
+        node = new Group();
+      } else if (objects.length === 1) {
+        node = objects[0];
+      } else {
+        node = new Object3D();
+      }
+      if (node !== objects[0]) {
+        for (var i = 0, il = objects.length; i < il; i++) {
+          node.add(objects[i]);
+        }
+      }
+      if (nodeDef.name) {
+        node.userData.name = nodeDef.name;
+        node.name = PropertyBinding.sanitizeNodeName(nodeDef.name);
+      }
+      assignExtrasToUserData(node, nodeDef);
+      if (nodeDef.extensions)
+        addUnknownExtensionsToUserData(extensions, node, nodeDef);
+      if (nodeDef.matrix !== void 0) {
+        var matrix = new Matrix4();
+        matrix.fromArray(nodeDef.matrix);
+        node.applyMatrix4(matrix);
+      } else {
+        if (nodeDef.translation !== void 0) {
+          node.position.fromArray(nodeDef.translation);
+        }
+        if (nodeDef.rotation !== void 0) {
+          node.quaternion.fromArray(nodeDef.rotation);
+        }
+        if (nodeDef.scale !== void 0) {
+          node.scale.fromArray(nodeDef.scale);
+        }
+      }
+      parser.associations.set(node, { type: "nodes", index: nodeIndex });
+      return node;
+    });
+  };
+  GLTFParser.prototype.loadScene = /* @__PURE__ */ function() {
+    function buildNodeHierachy(nodeId, parentObject, json, parser) {
+      var nodeDef = json.nodes[nodeId];
+      return parser.getDependency("node", nodeId).then(function(node) {
+        if (nodeDef.skin === void 0)
+          return node;
+        var skinEntry;
+        return parser.getDependency("skin", nodeDef.skin).then(function(skin) {
+          skinEntry = skin;
+          var pendingJoints = [];
+          for (var i = 0, il = skinEntry.joints.length; i < il; i++) {
+            pendingJoints.push(parser.getDependency("node", skinEntry.joints[i]));
+          }
+          return Promise.all(pendingJoints);
+        }).then(function(jointNodes) {
+          node.traverse(function(mesh) {
+            if (!mesh.isMesh)
+              return;
+            var bones = [];
+            var boneInverses = [];
+            for (var j = 0, jl = jointNodes.length; j < jl; j++) {
+              var jointNode = jointNodes[j];
+              if (jointNode) {
+                bones.push(jointNode);
+                var mat = new Matrix4();
+                if (skinEntry.inverseBindMatrices !== void 0) {
+                  mat.fromArray(skinEntry.inverseBindMatrices.array, j * 16);
+                }
+                boneInverses.push(mat);
+              } else {
+                console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', skinEntry.joints[j]);
+              }
+            }
+            mesh.bind(new Skeleton(bones, boneInverses), mesh.matrixWorld);
+          });
+          return node;
+        });
+      }).then(function(node) {
+        parentObject.add(node);
+        var pending = [];
+        if (nodeDef.children) {
+          var children = nodeDef.children;
+          for (var i = 0, il = children.length; i < il; i++) {
+            var child = children[i];
+            pending.push(buildNodeHierachy(child, node, json, parser));
+          }
+        }
+        return Promise.all(pending);
+      });
+    }
+    return function loadScene(sceneIndex) {
+      var json = this.json;
+      var extensions = this.extensions;
+      var sceneDef = this.json.scenes[sceneIndex];
+      var parser = this;
+      var scene = new Group();
+      if (sceneDef.name)
+        scene.name = sceneDef.name;
+      assignExtrasToUserData(scene, sceneDef);
+      if (sceneDef.extensions)
+        addUnknownExtensionsToUserData(extensions, scene, sceneDef);
+      var nodeIds = sceneDef.nodes || [];
+      var pending = [];
+      for (var i = 0, il = nodeIds.length; i < il; i++) {
+        pending.push(buildNodeHierachy(nodeIds[i], scene, json, parser));
+      }
+      return Promise.all(pending).then(function() {
+        return scene;
+      });
+    };
+  }();
+  return GLTFLoader2;
+}();
+var DRACOLoader = function(manager) {
+  Loader.call(this, manager);
+  this.decoderPath = "";
+  this.decoderConfig = {};
+  this.decoderBinary = null;
+  this.decoderPending = null;
+  this.workerLimit = 4;
+  this.workerPool = [];
+  this.workerNextTaskID = 1;
+  this.workerSourceURL = "";
+  this.defaultAttributeIDs = {
+    position: "POSITION",
+    normal: "NORMAL",
+    color: "COLOR",
+    uv: "TEX_COORD"
+  };
+  this.defaultAttributeTypes = {
+    position: "Float32Array",
+    normal: "Float32Array",
+    color: "Float32Array",
+    uv: "Float32Array"
+  };
+};
+DRACOLoader.prototype = Object.assign(Object.create(Loader.prototype), {
+  constructor: DRACOLoader,
+  setDecoderPath: function(path) {
+    this.decoderPath = path;
+    return this;
+  },
+  setDecoderConfig: function(config) {
+    this.decoderConfig = config;
+    return this;
+  },
+  setWorkerLimit: function(workerLimit) {
+    this.workerLimit = workerLimit;
+    return this;
+  },
+  /** @deprecated */
+  setVerbosity: function() {
+    console.warn("THREE.DRACOLoader: The .setVerbosity() method has been removed.");
+  },
+  /** @deprecated */
+  setDrawMode: function() {
+    console.warn("THREE.DRACOLoader: The .setDrawMode() method has been removed.");
+  },
+  /** @deprecated */
+  setSkipDequantization: function() {
+    console.warn("THREE.DRACOLoader: The .setSkipDequantization() method has been removed.");
+  },
+  load: function(url, onLoad, onProgress, onError) {
+    var loader = new FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("arraybuffer");
+    if (this.crossOrigin === "use-credentials") {
+      loader.setWithCredentials(true);
+    }
+    loader.load(url, (buffer) => {
+      var taskConfig = {
+        attributeIDs: this.defaultAttributeIDs,
+        attributeTypes: this.defaultAttributeTypes,
+        useUniqueIDs: false
+      };
+      this.decodeGeometry(buffer, taskConfig).then(onLoad).catch(onError);
+    }, onProgress, onError);
+  },
+  /** @deprecated Kept for backward-compatibility with previous DRACOLoader versions. */
+  decodeDracoFile: function(buffer, callback, attributeIDs, attributeTypes) {
+    var taskConfig = {
+      attributeIDs: attributeIDs || this.defaultAttributeIDs,
+      attributeTypes: attributeTypes || this.defaultAttributeTypes,
+      useUniqueIDs: !!attributeIDs
+    };
+    this.decodeGeometry(buffer, taskConfig).then(callback);
+  },
+  decodeGeometry: function(buffer, taskConfig) {
+    for (var attribute in taskConfig.attributeTypes) {
+      var type = taskConfig.attributeTypes[attribute];
+      if (type.BYTES_PER_ELEMENT !== void 0) {
+        taskConfig.attributeTypes[attribute] = type.name;
+      }
+    }
+    var taskKey = JSON.stringify(taskConfig);
+    if (DRACOLoader.taskCache.has(buffer)) {
+      var cachedTask = DRACOLoader.taskCache.get(buffer);
+      if (cachedTask.key === taskKey) {
+        return cachedTask.promise;
+      } else if (buffer.byteLength === 0) {
+        throw new Error(
+          "THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred."
+        );
+      }
+    }
+    var worker;
+    var taskID = this.workerNextTaskID++;
+    var taskCost = buffer.byteLength;
+    var geometryPending = this._getWorker(taskID, taskCost).then((_worker) => {
+      worker = _worker;
+      return new Promise((resolve, reject) => {
+        worker._callbacks[taskID] = { resolve, reject };
+        worker.postMessage({ type: "decode", id: taskID, taskConfig, buffer }, [buffer]);
+      });
+    }).then((message) => this._createGeometry(message.geometry));
+    geometryPending.catch(() => true).then(() => {
+      if (worker && taskID) {
+        this._releaseTask(worker, taskID);
+      }
+    });
+    DRACOLoader.taskCache.set(buffer, {
+      key: taskKey,
+      promise: geometryPending
+    });
+    return geometryPending;
+  },
+  _createGeometry: function(geometryData) {
+    var geometry = new BufferGeometry();
+    if (geometryData.index) {
+      geometry.setIndex(new BufferAttribute(geometryData.index.array, 1));
+    }
+    for (var i = 0; i < geometryData.attributes.length; i++) {
+      var attribute = geometryData.attributes[i];
+      var name = attribute.name;
+      var array = attribute.array;
+      var itemSize = attribute.itemSize;
+      geometry.setAttribute(name, new BufferAttribute(array, itemSize));
+    }
+    return geometry;
+  },
+  _loadLibrary: function(url, responseType) {
+    var loader = new FileLoader(this.manager);
+    loader.setPath(this.decoderPath);
+    loader.setResponseType(responseType);
+    return new Promise((resolve, reject) => {
+      loader.load(url, resolve, void 0, reject);
+    });
+  },
+  preload: function() {
+    this._initDecoder();
+    return this;
+  },
+  _initDecoder: function() {
+    if (this.decoderPending)
+      return this.decoderPending;
+    var useJS = typeof WebAssembly !== "object" || this.decoderConfig.type === "js";
+    var librariesPending = [];
+    if (useJS) {
+      librariesPending.push(this._loadLibrary("draco_decoder.js", "text"));
+    } else {
+      librariesPending.push(this._loadLibrary("draco_wasm_wrapper.js", "text"));
+      librariesPending.push(this._loadLibrary("draco_decoder.wasm", "arraybuffer"));
+    }
+    this.decoderPending = Promise.all(librariesPending).then((libraries) => {
+      var jsContent = libraries[0];
+      if (!useJS) {
+        this.decoderConfig.wasmBinary = libraries[1];
+      }
+      var fn = DRACOLoader.DRACOWorker.toString();
+      var body = [
+        "/* draco decoder */",
+        jsContent,
+        "",
+        "/* worker */",
+        fn.substring(fn.indexOf("{") + 1, fn.lastIndexOf("}"))
+      ].join("\n");
+      this.workerSourceURL = URL.createObjectURL(new Blob([body]));
+    });
+    return this.decoderPending;
+  },
+  _getWorker: function(taskID, taskCost) {
+    return this._initDecoder().then(() => {
+      if (this.workerPool.length < this.workerLimit) {
+        var worker = new Worker(this.workerSourceURL);
+        worker._callbacks = {};
+        worker._taskCosts = {};
+        worker._taskLoad = 0;
+        worker.postMessage({ type: "init", decoderConfig: this.decoderConfig });
+        worker.onmessage = function(e) {
+          var message = e.data;
+          switch (message.type) {
+            case "decode":
+              worker._callbacks[message.id].resolve(message);
+              break;
+            case "error":
+              worker._callbacks[message.id].reject(message);
+              break;
+            default:
+              console.error('THREE.DRACOLoader: Unexpected message, "' + message.type + '"');
+          }
+        };
+        this.workerPool.push(worker);
+      } else {
+        this.workerPool.sort(function(a, b) {
+          return a._taskLoad > b._taskLoad ? -1 : 1;
+        });
+      }
+      var worker = this.workerPool[this.workerPool.length - 1];
+      worker._taskCosts[taskID] = taskCost;
+      worker._taskLoad += taskCost;
+      return worker;
+    });
+  },
+  _releaseTask: function(worker, taskID) {
+    worker._taskLoad -= worker._taskCosts[taskID];
+    delete worker._callbacks[taskID];
+    delete worker._taskCosts[taskID];
+  },
+  debug: function() {
+    console.log("Task load: ", this.workerPool.map((worker) => worker._taskLoad));
+  },
+  dispose: function() {
+    for (var i = 0; i < this.workerPool.length; ++i) {
+      this.workerPool[i].terminate();
+    }
+    this.workerPool.length = 0;
+    return this;
+  }
+});
+DRACOLoader.DRACOWorker = function() {
+  var decoderConfig;
+  var decoderPending;
+  onmessage = function(e) {
+    var message = e.data;
+    switch (message.type) {
+      case "init":
+        decoderConfig = message.decoderConfig;
+        decoderPending = new Promise(function(resolve) {
+          decoderConfig.onModuleLoaded = function(draco) {
+            resolve({ draco });
+          };
+          DracoDecoderModule(decoderConfig);
+        });
+        break;
+      case "decode":
+        var buffer = message.buffer;
+        var taskConfig = message.taskConfig;
+        decoderPending.then((module) => {
+          var draco = module.draco;
+          var decoder = new draco.Decoder();
+          var decoderBuffer = new draco.DecoderBuffer();
+          decoderBuffer.Init(new Int8Array(buffer), buffer.byteLength);
+          try {
+            var geometry = decodeGeometry(draco, decoder, decoderBuffer, taskConfig);
+            var buffers = geometry.attributes.map((attr) => attr.array.buffer);
+            if (geometry.index)
+              buffers.push(geometry.index.array.buffer);
+            self.postMessage({ type: "decode", id: message.id, geometry }, buffers);
+          } catch (error) {
+            console.error(error);
+            self.postMessage({ type: "error", id: message.id, error: error.message });
+          } finally {
+            draco.destroy(decoderBuffer);
+            draco.destroy(decoder);
+          }
+        });
+        break;
+    }
+  };
+  function decodeGeometry(draco, decoder, decoderBuffer, taskConfig) {
+    var attributeIDs = taskConfig.attributeIDs;
+    var attributeTypes = taskConfig.attributeTypes;
+    var dracoGeometry;
+    var decodingStatus;
+    var geometryType = decoder.GetEncodedGeometryType(decoderBuffer);
+    if (geometryType === draco.TRIANGULAR_MESH) {
+      dracoGeometry = new draco.Mesh();
+      decodingStatus = decoder.DecodeBufferToMesh(decoderBuffer, dracoGeometry);
+    } else if (geometryType === draco.POINT_CLOUD) {
+      dracoGeometry = new draco.PointCloud();
+      decodingStatus = decoder.DecodeBufferToPointCloud(decoderBuffer, dracoGeometry);
+    } else {
+      throw new Error("THREE.DRACOLoader: Unexpected geometry type.");
+    }
+    if (!decodingStatus.ok() || dracoGeometry.ptr === 0) {
+      throw new Error("THREE.DRACOLoader: Decoding failed: " + decodingStatus.error_msg());
+    }
+    var geometry = { index: null, attributes: [] };
+    for (var attributeName in attributeIDs) {
+      var attributeType = self[attributeTypes[attributeName]];
+      var attribute;
+      var attributeID;
+      if (taskConfig.useUniqueIDs) {
+        attributeID = attributeIDs[attributeName];
+        attribute = decoder.GetAttributeByUniqueId(dracoGeometry, attributeID);
+      } else {
+        attributeID = decoder.GetAttributeId(dracoGeometry, draco[attributeIDs[attributeName]]);
+        if (attributeID === -1)
+          continue;
+        attribute = decoder.GetAttribute(dracoGeometry, attributeID);
+      }
+      geometry.attributes.push(decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute));
+    }
+    if (geometryType === draco.TRIANGULAR_MESH) {
+      var numFaces = dracoGeometry.num_faces();
+      var numIndices = numFaces * 3;
+      var index = new Uint32Array(numIndices);
+      var indexArray = new draco.DracoInt32Array();
+      for (var i = 0; i < numFaces; ++i) {
+        decoder.GetFaceFromMesh(dracoGeometry, i, indexArray);
+        for (var j = 0; j < 3; ++j) {
+          index[i * 3 + j] = indexArray.GetValue(j);
+        }
+      }
+      geometry.index = { array: index, itemSize: 1 };
+      draco.destroy(indexArray);
+    }
+    draco.destroy(dracoGeometry);
+    return geometry;
+  }
+  function decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute) {
+    var numComponents = attribute.num_components();
+    var numPoints = dracoGeometry.num_points();
+    var numValues = numPoints * numComponents;
+    var dracoArray;
+    var array;
+    switch (attributeType) {
+      case Float32Array:
+        dracoArray = new draco.DracoFloat32Array();
+        decoder.GetAttributeFloatForAllPoints(dracoGeometry, attribute, dracoArray);
+        array = new Float32Array(numValues);
+        break;
+      case Int8Array:
+        dracoArray = new draco.DracoInt8Array();
+        decoder.GetAttributeInt8ForAllPoints(dracoGeometry, attribute, dracoArray);
+        array = new Int8Array(numValues);
+        break;
+      case Int16Array:
+        dracoArray = new draco.DracoInt16Array();
+        decoder.GetAttributeInt16ForAllPoints(dracoGeometry, attribute, dracoArray);
+        array = new Int16Array(numValues);
+        break;
+      case Int32Array:
+        dracoArray = new draco.DracoInt32Array();
+        decoder.GetAttributeInt32ForAllPoints(dracoGeometry, attribute, dracoArray);
+        array = new Int32Array(numValues);
+        break;
+      case Uint8Array:
+        dracoArray = new draco.DracoUInt8Array();
+        decoder.GetAttributeUInt8ForAllPoints(dracoGeometry, attribute, dracoArray);
+        array = new Uint8Array(numValues);
+        break;
+      case Uint16Array:
+        dracoArray = new draco.DracoUInt16Array();
+        decoder.GetAttributeUInt16ForAllPoints(dracoGeometry, attribute, dracoArray);
+        array = new Uint16Array(numValues);
+        break;
+      case Uint32Array:
+        dracoArray = new draco.DracoUInt32Array();
+        decoder.GetAttributeUInt32ForAllPoints(dracoGeometry, attribute, dracoArray);
+        array = new Uint32Array(numValues);
+        break;
+      default:
+        throw new Error("THREE.DRACOLoader: Unexpected attribute type.");
+    }
+    for (var i = 0; i < numValues; i++) {
+      array[i] = dracoArray.GetValue(i);
+    }
+    draco.destroy(dracoArray);
+    return {
+      name: attributeName,
+      array,
+      itemSize: numComponents
+    };
+  }
+};
+DRACOLoader.taskCache = /* @__PURE__ */ new WeakMap();
+DRACOLoader.setDecoderPath = function() {
+  console.warn("THREE.DRACOLoader: The .setDecoderPath() method has been removed. Use instance methods.");
+};
+DRACOLoader.setDecoderConfig = function() {
+  console.warn("THREE.DRACOLoader: The .setDecoderConfig() method has been removed. Use instance methods.");
+};
+DRACOLoader.releaseDecoderModule = function() {
+  console.warn("THREE.DRACOLoader: The .releaseDecoderModule() method has been removed. Use instance methods.");
+};
+DRACOLoader.getDecoderModule = function() {
+  console.warn("THREE.DRACOLoader: The .getDecoderModule() method has been removed. Use instance methods.");
+};
+var DDSLoader = function(manager) {
+  CompressedTextureLoader.call(this, manager);
+};
+DDSLoader.prototype = Object.assign(Object.create(CompressedTextureLoader.prototype), {
+  constructor: DDSLoader,
+  parse: function(buffer, loadMipmaps) {
+    var dds = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
+    var DDS_MAGIC = 542327876;
+    var DDSD_MIPMAPCOUNT = 131072;
+    var DDSCAPS2_CUBEMAP = 512;
+    var DDSCAPS2_CUBEMAP_POSITIVEX = 1024;
+    var DDSCAPS2_CUBEMAP_NEGATIVEX = 2048;
+    var DDSCAPS2_CUBEMAP_POSITIVEY = 4096;
+    var DDSCAPS2_CUBEMAP_NEGATIVEY = 8192;
+    var DDSCAPS2_CUBEMAP_POSITIVEZ = 16384;
+    var DDSCAPS2_CUBEMAP_NEGATIVEZ = 32768;
+    var DDPF_FOURCC = 4;
+    function fourCCToInt32(value) {
+      return value.charCodeAt(0) + (value.charCodeAt(1) << 8) + (value.charCodeAt(2) << 16) + (value.charCodeAt(3) << 24);
+    }
+    function int32ToFourCC(value) {
+      return String.fromCharCode(
+        value & 255,
+        value >> 8 & 255,
+        value >> 16 & 255,
+        value >> 24 & 255
+      );
+    }
+    function loadARGBMip(buffer2, dataOffset2, width2, height2) {
+      var dataLength2 = width2 * height2 * 4;
+      var srcBuffer = new Uint8Array(buffer2, dataOffset2, dataLength2);
+      var byteArray2 = new Uint8Array(dataLength2);
+      var dst = 0;
+      var src = 0;
+      for (var y = 0; y < height2; y++) {
+        for (var x = 0; x < width2; x++) {
+          var b = srcBuffer[src];
+          src++;
+          var g = srcBuffer[src];
+          src++;
+          var r = srcBuffer[src];
+          src++;
+          var a = srcBuffer[src];
+          src++;
+          byteArray2[dst] = r;
+          dst++;
+          byteArray2[dst] = g;
+          dst++;
+          byteArray2[dst] = b;
+          dst++;
+          byteArray2[dst] = a;
+          dst++;
+        }
+      }
+      return byteArray2;
+    }
+    var FOURCC_DXT1 = fourCCToInt32("DXT1");
+    var FOURCC_DXT3 = fourCCToInt32("DXT3");
+    var FOURCC_DXT5 = fourCCToInt32("DXT5");
+    var FOURCC_ETC1 = fourCCToInt32("ETC1");
+    var headerLengthInt = 31;
+    var off_magic = 0;
+    var off_size = 1;
+    var off_flags = 2;
+    var off_height = 3;
+    var off_width = 4;
+    var off_mipmapCount = 7;
+    var off_pfFlags = 20;
+    var off_pfFourCC = 21;
+    var off_RGBBitCount = 22;
+    var off_RBitMask = 23;
+    var off_GBitMask = 24;
+    var off_BBitMask = 25;
+    var off_ABitMask = 26;
+    var off_caps2 = 28;
+    var header = new Int32Array(buffer, 0, headerLengthInt);
+    if (header[off_magic] !== DDS_MAGIC) {
+      console.error("THREE.DDSLoader.parse: Invalid magic number in DDS header.");
+      return dds;
+    }
+    if (!header[off_pfFlags] & DDPF_FOURCC) {
+      console.error("THREE.DDSLoader.parse: Unsupported format, must contain a FourCC code.");
+      return dds;
+    }
+    var blockBytes;
+    var fourCC = header[off_pfFourCC];
+    var isRGBAUncompressed = false;
+    switch (fourCC) {
+      case FOURCC_DXT1:
+        blockBytes = 8;
+        dds.format = RGB_S3TC_DXT1_Format;
+        break;
+      case FOURCC_DXT3:
+        blockBytes = 16;
+        dds.format = RGBA_S3TC_DXT3_Format;
+        break;
+      case FOURCC_DXT5:
+        blockBytes = 16;
+        dds.format = RGBA_S3TC_DXT5_Format;
+        break;
+      case FOURCC_ETC1:
+        blockBytes = 8;
+        dds.format = RGB_ETC1_Format;
+        break;
+      default:
+        if (header[off_RGBBitCount] === 32 && header[off_RBitMask] & 16711680 && header[off_GBitMask] & 65280 && header[off_BBitMask] & 255 && header[off_ABitMask] & 4278190080) {
+          isRGBAUncompressed = true;
+          blockBytes = 64;
+          dds.format = RGBAFormat;
+        } else {
+          console.error("THREE.DDSLoader.parse: Unsupported FourCC code ", int32ToFourCC(fourCC));
+          return dds;
+        }
+    }
+    dds.mipmapCount = 1;
+    if (header[off_flags] & DDSD_MIPMAPCOUNT && loadMipmaps !== false) {
+      dds.mipmapCount = Math.max(1, header[off_mipmapCount]);
+    }
+    var caps2 = header[off_caps2];
+    dds.isCubemap = caps2 & DDSCAPS2_CUBEMAP ? true : false;
+    if (dds.isCubemap && (!(caps2 & DDSCAPS2_CUBEMAP_POSITIVEX) || !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) || !(caps2 & DDSCAPS2_CUBEMAP_POSITIVEY) || !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) || !(caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) || !(caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ))) {
+      console.error("THREE.DDSLoader.parse: Incomplete cubemap faces");
+      return dds;
+    }
+    dds.width = header[off_width];
+    dds.height = header[off_height];
+    var dataOffset = header[off_size] + 4;
+    var faces = dds.isCubemap ? 6 : 1;
+    for (var face = 0; face < faces; face++) {
+      var width = dds.width;
+      var height = dds.height;
+      for (var i = 0; i < dds.mipmapCount; i++) {
+        if (isRGBAUncompressed) {
+          var byteArray = loadARGBMip(buffer, dataOffset, width, height);
+          var dataLength = byteArray.length;
+        } else {
+          var dataLength = Math.max(4, width) / 4 * Math.max(4, height) / 4 * blockBytes;
+          var byteArray = new Uint8Array(buffer, dataOffset, dataLength);
+        }
+        var mipmap = { "data": byteArray, "width": width, "height": height };
+        dds.mipmaps.push(mipmap);
+        dataOffset += dataLength;
+        width = Math.max(width >> 1, 1);
+        height = Math.max(height >> 1, 1);
+      }
+    }
+    return dds;
+  }
+});
+var GLTFObject = (
+  /** @class */
+  function(_super) {
+    __extends(GLTFObject2, _super);
+    function GLTFObject2(rootObject) {
+      var _this = _super.call(this) || this;
+      _this.needsRender = true;
+      if (rootObject && rootObject.children.length) {
+        _this.add.apply(_this, rootObject.children);
+      }
+      _this.mixer = new THREE.AnimationMixer(_this);
+      return _this;
+    }
+    GLTFObject2.prototype.clone = function() {
+      var cloned = _super.prototype.clone.call(this, true);
+      var mixer = new THREE.AnimationMixer(cloned);
+      cloned.mixer = mixer;
+      cloned.needsRender = true;
+      return cloned;
+    };
+    return GLTFObject2;
+  }(THREE.Group)
+);
+var DRACO_PATH = "https://vr-public.realsee-cdn.cn/release/static/image/release/five/resource/draco/1.5.6/";
+var GLTFLoader = (
+  /** @class */
+  function(_super) {
+    __extends(GLTFLoader2, _super);
+    function GLTFLoader2(manager) {
+      var _this = _super.call(this, manager) || this;
+      _this.ddsLoader = new DDSLoader(manager);
+      _this.dracoLoader = new DRACOLoader(manager);
+      _this.dracoLoader.setDecoderPath(DRACO_PATH);
+      return _this;
+    }
+    Object.defineProperty(GLTFLoader2, "version", {
+      get: function() {
+        return "6.0.0-alpha.71";
+      },
+      enumerable: false,
+      configurable: true
+    });
+    GLTFLoader2.prototype.load = function(url, onLoad, onProgress, onError) {
+      return _super.prototype.load.call(this, url, onLoad, onProgress, onError);
+    };
+    GLTFLoader2.prototype.parse = function(data, path, onLoad, onError) {
+      return _super.prototype.parse.call(this, data, path, function(gltf) {
+        var scene = new GLTFObject(gltf.scene);
+        var scenes = gltf.scenes.map(function(scene_) {
+          if (scene_ === gltf.scene)
+            return scene;
+          return new GLTFObject(scene_);
+        });
+        onLoad(Object.assign(gltf, { scene, scenes }));
+      }, onError);
+    };
+    return GLTFLoader2;
+  }(GLTFLoader$1)
+);
+export {
+  DDSLoader,
+  DRACOLoader,
+  GLTFLoader,
+  GLTFObject,
+  GLTFLoader$1 as THREEGLTFLoader
+};