three-stdlib 2.22.9 → 2.22.10

package/dist/exporters/GLTFExporter.js

@@ -1,15 +1,89 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
+let _renderer;
+let fullscreenQuadGeometry;
+let fullscreenQuadMaterial;
+let fullscreenQuad;
+function decompress(texture, maxTextureSize = Infinity, renderer = null) {
+  if (!fullscreenQuadGeometry)
+    fullscreenQuadGeometry = new THREE.PlaneGeometry(2, 2, 1, 1);
+  if (!fullscreenQuadMaterial)
+    fullscreenQuadMaterial = new THREE.ShaderMaterial({
+      uniforms: { blitTexture: new THREE.Uniform(texture) },
+      vertexShader: (
+        /* glsl */
+        `
+        varying vec2 vUv;
+        void main(){
+            vUv = uv;
+            gl_Position = vec4(position.xy * 1.0,0.,.999999);
+        }
+      `
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+          uniform sampler2D blitTexture; 
+          varying vec2 vUv;
+
+          void main(){ 
+              gl_FragColor = vec4(vUv.xy, 0, 1);
+              
+              #ifdef IS_SRGB
+              gl_FragColor = LinearTosRGB( texture2D( blitTexture, vUv) );
+              #else
+              gl_FragColor = texture2D( blitTexture, vUv);
+              #endif
+          }
+      `
+      )
+    });
+  fullscreenQuadMaterial.uniforms.blitTexture.value = texture;
+  fullscreenQuadMaterial.defines.IS_SRGB = "colorSpace" in texture ? texture.colorSpace === "srgb" : texture.encoding === 3001;
+  fullscreenQuadMaterial.needsUpdate = true;
+  if (!fullscreenQuad) {
+    fullscreenQuad = new THREE.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
+    fullscreenQuad.frustrumCulled = false;
+  }
+  const _camera = new THREE.PerspectiveCamera();
+  const _scene = new THREE.Scene();
+  _scene.add(fullscreenQuad);
+  if (!renderer) {
+    renderer = _renderer = new THREE.WebGLRenderer({ antialias: false });
+  }
+  renderer.setSize(Math.min(texture.image.width, maxTextureSize), Math.min(texture.image.height, maxTextureSize));
+  renderer.clear();
+  renderer.render(_scene, _camera);
+  const readableTexture = new THREE.Texture(renderer.domElement);
+  readableTexture.minFilter = texture.minFilter;
+  readableTexture.magFilter = texture.magFilter;
+  readableTexture.wrapS = texture.wrapS;
+  readableTexture.wrapT = texture.wrapT;
+  readableTexture.name = texture.name;
+  if (_renderer) {
+    _renderer.dispose();
+    _renderer = null;
+  }
+  return readableTexture;
+}
+const KHR_mesh_quantization_ExtraAttrTypes = {
+  POSITION: [
+    "byte",
+    "byte normalized",
+    "unsigned byte",
+    "unsigned byte normalized",
+    "short",
+    "short normalized",
+    "unsigned short",
+    "unsigned short normalized"
+  ],
+  NORMAL: ["byte normalized", "short normalized"],
+  TANGENT: ["byte normalized", "short normalized"],
+  TEXCOORD: ["byte", "byte normalized", "unsigned byte", "short", "short normalized", "unsigned short"]
+};
 class GLTFExporter {
   constructor() {
-    __publicField(this, "pluginCallbacks");
     this.pluginCallbacks = [];
     this.register(function(writer) {
       return new GLTFLightExtension(writer);
@@ -17,15 +91,33 @@ class GLTFExporter {
     this.register(function(writer) {
       return new GLTFMaterialsUnlitExtension(writer);
     });
-    this.register(function(writer) {
-      return new GLTFMaterialsPBRSpecularGlossiness(writer);
-    });
     this.register(function(writer) {
       return new GLTFMaterialsTransmissionExtension(writer);
     });
     this.register(function(writer) {
       return new GLTFMaterialsVolumeExtension(writer);
     });
+    this.register(function(writer) {
+      return new GLTFMaterialsIorExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsSpecularExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsClearcoatExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsIridescenceExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsSheenExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsAnisotropyExtension(writer);
+    });
+    this.register(function(writer) {
+      return new GLTFMaterialsEmissiveStrengthExtension(writer);
+    });
   }
   register(callback) {
     if (this.pluginCallbacks.indexOf(callback) === -1) {
@@ -39,126 +131,29 @@ class GLTFExporter {
     }
     return this;
   }
-  parse(input, onDone, options) {
+  /**
+   * Parse scenes and generate GLTF output
+   * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+   * @param  {Function} onDone  Callback on completed
+   * @param  {Function} onError  Callback on errors
+   * @param  {Object} options options
+   */
+  parse(input, onDone, onError, options) {
     const writer = new GLTFWriter();
     const plugins = [];
     for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
       plugins.push(this.pluginCallbacks[i](writer));
     }
     writer.setPlugins(plugins);
-    writer.write(input, onDone, options);
+    writer.write(input, onDone, options).catch(onError);
   }
-}
-/**
- * Static utility functions
- */
-__publicField(GLTFExporter, "Utils", {
-  insertKeyframe: function(track, time) {
-    const tolerance = 1e-3;
-    const valueSize = track.getValueSize();
-    const times = new track.TimeBufferType(track.times.length + 1);
-    const values = new track.ValueBufferType(track.values.length + valueSize);
-    const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize));
-    let index;
-    if (track.times.length === 0) {
-      times[0] = time;
-      for (let i = 0; i < valueSize; i++) {
-        values[i] = 0;
-      }
-      index = 0;
-    } else if (time < track.times[0]) {
-      if (Math.abs(track.times[0] - time) < tolerance)
-        return 0;
-      times[0] = time;
-      times.set(track.times, 1);
-      values.set(interpolant.evaluate(time), 0);
-      values.set(track.values, valueSize);
-      index = 0;
-    } else if (time > track.times[track.times.length - 1]) {
-      if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
-        return track.times.length - 1;
-      }
-      times[times.length - 1] = time;
-      times.set(track.times, 0);
-      values.set(track.values, 0);
-      values.set(interpolant.evaluate(time), track.values.length);
-      index = times.length - 1;
-    } else {
-      for (let i = 0; i < track.times.length; i++) {
-        if (Math.abs(track.times[i] - time) < tolerance)
-          return i;
-        if (track.times[i] < time && track.times[i + 1] > time) {
-          times.set(track.times.slice(0, i + 1), 0);
-          times[i + 1] = time;
-          times.set(track.times.slice(i + 1), i + 2);
-          values.set(track.values.slice(0, (i + 1) * valueSize), 0);
-          values.set(interpolant.evaluate(time), (i + 1) * valueSize);
-          values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize);
-          index = i + 1;
-          break;
-        }
-      }
-    }
-    track.times = times;
-    track.values = values;
-    return index;
-  },
-  mergeMorphTargetTracks: function(clip, root) {
-    const tracks = [];
-    const mergedTracks = {};
-    const sourceTracks = clip.tracks;
-    for (let i = 0; i < sourceTracks.length; ++i) {
-      let sourceTrack = sourceTracks[i];
-      const sourceTrackBinding = THREE.PropertyBinding.parseTrackName(sourceTrack.name);
-      const sourceTrackNode = THREE.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
-      if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
-        tracks.push(sourceTrack);
-        continue;
-      }
-      if (
-        // @ts-expect-error
-        sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete && // @ts-expect-error
-        sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear
-      ) {
-        if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
-          throw new Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
-        }
-        console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
-        sourceTrack = sourceTrack.clone();
-        sourceTrack.setInterpolation(THREE.InterpolateLinear);
-      }
-      const targetCount = sourceTrackNode.morphTargetInfluences.length;
-      const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
-      if (targetIndex === void 0) {
-        throw new Error("THREE.GLTFExporter: Morph target name not found: " + sourceTrackBinding.propertyIndex);
-      }
-      let mergedTrack;
-      if (mergedTracks[sourceTrackNode.uuid] === void 0) {
-        mergedTrack = sourceTrack.clone();
-        const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length);
-        for (let j = 0; j < mergedTrack.times.length; j++) {
-          values[j * targetCount + targetIndex] = mergedTrack.values[j];
-        }
-        mergedTrack.name = (sourceTrackBinding.nodeName || "") + ".morphTargetInfluences";
-        mergedTrack.values = values;
-        mergedTracks[sourceTrackNode.uuid] = mergedTrack;
-        tracks.push(mergedTrack);
-        continue;
-      }
-      const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
-      mergedTrack = mergedTracks[sourceTrackNode.uuid];
-      for (let j = 0; j < mergedTrack.times.length; j++) {
-        mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j]);
-      }
-      for (let j = 0; j < sourceTrack.times.length; j++) {
-        const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j]);
-        mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j];
-      }
-    }
-    clip.tracks = tracks;
-    return clip;
+  parseAsync(input, options) {
+    const scope = this;
+    return new Promise(function(resolve, reject) {
+      scope.parse(input, resolve, reject, options);
+    });
   }
-});
+}
 const WEBGL_CONSTANTS = {
   POINTS: 0,
   LINES: 1,
@@ -167,10 +162,13 @@ const WEBGL_CONSTANTS = {
   TRIANGLES: 4,
   TRIANGLE_STRIP: 5,
   TRIANGLE_FAN: 6,
+  BYTE: 5120,
   UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
   UNSIGNED_SHORT: 5123,
-  FLOAT: 5126,
+  INT: 5124,
   UNSIGNED_INT: 5125,
+  FLOAT: 5126,
   ARRAY_BUFFER: 34962,
   ELEMENT_ARRAY_BUFFER: 34963,
   NEAREST: 9728,
@@ -183,6 +181,7 @@ const WEBGL_CONSTANTS = {
   MIRRORED_REPEAT: 33648,
   REPEAT: 10497
 };
+const KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
 const THREE_TO_WEBGL = {};
 THREE_TO_WEBGL[THREE.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
 THREE_TO_WEBGL[THREE.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
@@ -199,35 +198,103 @@ const PATH_PROPERTIES = {
   quaternion: "rotation",
   morphTargetInfluences: "weights"
 };
+const DEFAULT_SPECULAR_COLOR = new THREE.Color();
 const GLB_HEADER_BYTES = 12;
 const GLB_HEADER_MAGIC = 1179937895;
 const GLB_VERSION = 2;
 const GLB_CHUNK_PREFIX_BYTES = 8;
 const GLB_CHUNK_TYPE_JSON = 1313821514;
 const GLB_CHUNK_TYPE_BIN = 5130562;
+function equalArray(array1, array2) {
+  return array1.length === array2.length && array1.every(function(element, index) {
+    return element === array2[index];
+  });
+}
+function stringToArrayBuffer(text) {
+  return new TextEncoder().encode(text).buffer;
+}
+function isIdentityMatrix(matrix) {
+  return equalArray(matrix.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+}
+function getMinMax(attribute, start, count) {
+  const output = {
+    min: new Array(attribute.itemSize).fill(Number.POSITIVE_INFINITY),
+    max: new Array(attribute.itemSize).fill(Number.NEGATIVE_INFINITY)
+  };
+  for (let i = start; i < start + count; i++) {
+    for (let a = 0; a < attribute.itemSize; a++) {
+      let value;
+      if (attribute.itemSize > 4) {
+        value = attribute.array[i * attribute.itemSize + a];
+      } else {
+        if (a === 0)
+          value = attribute.getX(i);
+        else if (a === 1)
+          value = attribute.getY(i);
+        else if (a === 2)
+          value = attribute.getZ(i);
+        else if (a === 3)
+          value = attribute.getW(i);
+        if (attribute.normalized === true) {
+          value = THREE.MathUtils.normalize(value, attribute.array);
+        }
+      }
+      output.min[a] = Math.min(output.min[a], value);
+      output.max[a] = Math.max(output.max[a], value);
+    }
+  }
+  return output;
+}
+function getPaddedBufferSize(bufferSize) {
+  return Math.ceil(bufferSize / 4) * 4;
+}
+function getPaddedArrayBuffer(arrayBuffer, paddingByte = 0) {
+  const paddedLength = getPaddedBufferSize(arrayBuffer.byteLength);
+  if (paddedLength !== arrayBuffer.byteLength) {
+    const array = new Uint8Array(paddedLength);
+    array.set(new Uint8Array(arrayBuffer));
+    if (paddingByte !== 0) {
+      for (let i = arrayBuffer.byteLength; i < paddedLength; i++) {
+        array[i] = paddingByte;
+      }
+    }
+    return array.buffer;
+  }
+  return arrayBuffer;
+}
+function getCanvas() {
+  if (typeof document === "undefined" && typeof OffscreenCanvas !== "undefined") {
+    return new OffscreenCanvas(1, 1);
+  }
+  return document.createElement("canvas");
+}
+function getToBlobPromise(canvas, mimeType) {
+  if (canvas.toBlob !== void 0) {
+    return new Promise((resolve) => canvas.toBlob(resolve, mimeType));
+  }
+  let quality;
+  if (mimeType === "image/jpeg") {
+    quality = 0.92;
+  } else if (mimeType === "image/webp") {
+    quality = 0.8;
+  }
+  return canvas.convertToBlob({
+    type: mimeType,
+    quality
+  });
+}
 class GLTFWriter {
   constructor() {
-    __publicField(this, "plugins");
-    __publicField(this, "options");
-    __publicField(this, "pending");
-    __publicField(this, "buffers");
-    __publicField(this, "byteOffset");
-    __publicField(this, "nodeMap");
-    __publicField(this, "skins");
-    __publicField(this, "extensionsUsed");
-    __publicField(this, "uids");
-    __publicField(this, "uid");
-    __publicField(this, "json");
-    __publicField(this, "cache");
-    __publicField(this, "cachedCanvas");
     this.plugins = [];
     this.options = {};
     this.pending = [];
     this.buffers = [];
     this.byteOffset = 0;
+    this.buffers = [];
     this.nodeMap = /* @__PURE__ */ new Map();
     this.skins = [];
     this.extensionsUsed = {};
+    this.extensionsRequired = {};
     this.uids = /* @__PURE__ */ new Map();
     this.uid = 0;
     this.json = {
@@ -244,7 +311,6 @@ class GLTFWriter {
       textures: /* @__PURE__ */ new Map(),
       images: /* @__PURE__ */ new Map()
     };
-    this.cachedCanvas = null;
   }
   setPlugins(plugins) {
     this.plugins = plugins;
@@ -255,85 +321,79 @@ class GLTFWriter {
    * @param  {Function} onDone  Callback on completed
    * @param  {Object} options options
    */
-  write(input, onDone, options) {
+  async write(input, onDone, options = {}) {
     this.options = Object.assign(
-      {},
       {
         // default options
         binary: false,
         trs: false,
         onlyVisible: true,
-        truncateDrawRange: true,
-        embedImages: true,
         maxTextureSize: Infinity,
         animations: [],
         includeCustomExtensions: false
       },
       options
     );
-    if (this.options.animations !== void 0 && this.options.animations.length > 0) {
+    if (this.options.animations.length > 0) {
       this.options.trs = true;
     }
     this.processInput(input);
+    await Promise.all(this.pending);
     const writer = this;
-    Promise.all(this.pending).then(() => {
-      const buffers = writer.buffers;
-      const json = writer.json;
-      const options2 = writer.options;
-      const extensionsUsed = writer.extensionsUsed;
-      const blob = new Blob(buffers, { type: "application/octet-stream" });
-      const extensionsUsedList = Object.keys(extensionsUsed);
-      if (extensionsUsedList.length > 0)
-        json.extensionsUsed = extensionsUsedList;
-      if (json.buffers && json.buffers.length > 0)
-        json.buffers[0].byteLength = blob.size;
-      if (options2.binary) {
-        const reader = new window.FileReader();
-        reader.readAsArrayBuffer(blob);
-        reader.onloadend = () => {
-          if (reader.result !== null && typeof reader.result !== "string") {
-            const binaryChunk = this.getPaddedArrayBuffer(reader.result);
-            const binaryChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
-            binaryChunkPrefix.setUint32(0, binaryChunk.byteLength, true);
-            binaryChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_BIN, true);
-            const jsonChunk = this.getPaddedArrayBuffer(this.stringToArrayBuffer(JSON.stringify(json)), 32);
-            const jsonChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
-            jsonChunkPrefix.setUint32(0, jsonChunk.byteLength, true);
-            jsonChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_JSON, true);
-            const header = new ArrayBuffer(GLB_HEADER_BYTES);
-            const headerView = new DataView(header);
-            headerView.setUint32(0, GLB_HEADER_MAGIC, true);
-            headerView.setUint32(4, GLB_VERSION, true);
-            const totalByteLength = GLB_HEADER_BYTES + jsonChunkPrefix.byteLength + jsonChunk.byteLength + binaryChunkPrefix.byteLength + binaryChunk.byteLength;
-            headerView.setUint32(8, totalByteLength, true);
-            const glbBlob = new Blob([header, jsonChunkPrefix, jsonChunk, binaryChunkPrefix, binaryChunk], {
-              type: "application/octet-stream"
-            });
-            const glbReader = new window.FileReader();
-            glbReader.readAsArrayBuffer(glbBlob);
-            glbReader.onloadend = function() {
-              if (glbReader.result !== null && typeof glbReader.result !== "string") {
-                onDone(glbReader.result);
-              }
-            };
-          }
+    const buffers = writer.buffers;
+    const json = writer.json;
+    options = writer.options;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionsRequired = writer.extensionsRequired;
+    const blob = new Blob(buffers, { type: "application/octet-stream" });
+    const extensionsUsedList = Object.keys(extensionsUsed);
+    const extensionsRequiredList = Object.keys(extensionsRequired);
+    if (extensionsUsedList.length > 0)
+      json.extensionsUsed = extensionsUsedList;
+    if (extensionsRequiredList.length > 0)
+      json.extensionsRequired = extensionsRequiredList;
+    if (json.buffers && json.buffers.length > 0)
+      json.buffers[0].byteLength = blob.size;
+    if (options.binary === true) {
+      const reader = new FileReader();
+      reader.readAsArrayBuffer(blob);
+      reader.onloadend = function() {
+        const binaryChunk = getPaddedArrayBuffer(reader.result);
+        const binaryChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+        binaryChunkPrefix.setUint32(0, binaryChunk.byteLength, true);
+        binaryChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_BIN, true);
+        const jsonChunk = getPaddedArrayBuffer(stringToArrayBuffer(JSON.stringify(json)), 32);
+        const jsonChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+        jsonChunkPrefix.setUint32(0, jsonChunk.byteLength, true);
+        jsonChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_JSON, true);
+        const header = new ArrayBuffer(GLB_HEADER_BYTES);
+        const headerView = new DataView(header);
+        headerView.setUint32(0, GLB_HEADER_MAGIC, true);
+        headerView.setUint32(4, GLB_VERSION, true);
+        const totalByteLength = GLB_HEADER_BYTES + jsonChunkPrefix.byteLength + jsonChunk.byteLength + binaryChunkPrefix.byteLength + binaryChunk.byteLength;
+        headerView.setUint32(8, totalByteLength, true);
+        const glbBlob = new Blob([header, jsonChunkPrefix, jsonChunk, binaryChunkPrefix, binaryChunk], {
+          type: "application/octet-stream"
+        });
+        const glbReader = new FileReader();
+        glbReader.readAsArrayBuffer(glbBlob);
+        glbReader.onloadend = function() {
+          onDone(glbReader.result);
         };
-      } else {
-        if (json.buffers && json.buffers.length > 0) {
-          const reader = new window.FileReader();
-          reader.readAsDataURL(blob);
-          reader.onloadend = function() {
-            const base64data = reader.result;
-            if (json.buffers !== void 0 && base64data !== null) {
-              json.buffers[0].uri = base64data;
-              onDone(json);
-            }
-          };
-        } else {
+      };
+    } else {
+      if (json.buffers && json.buffers.length > 0) {
+        const reader = new FileReader();
+        reader.readAsDataURL(blob);
+        reader.onloadend = function() {
+          const base64data = reader.result;
+          json.buffers[0].uri = base64data;
           onDone(json);
-        }
+        };
+      } else {
+        onDone(json);
       }
-    });
+    }
   }
   /**
    * Serializes a userData.
@@ -360,23 +420,25 @@ class GLTFWriter {
       if (Object.keys(json).length > 0)
         objectDef.extras = json;
     } catch (error) {
-      if (error instanceof Error) {
-        console.warn(
-          "THREE.GLTFExporter: userData of '" + object.name + "' won't be serialized because of JSON.stringify error - " + error.message
-        );
-      }
+      console.warn(
+        "THREE.GLTFExporter: userData of '" + object.name + "' won't be serialized because of JSON.stringify error - " + error.message
+      );
     }
   }
   /**
-   * Assign and return a temporal unique id for an object
-   * especially which doesn't have .uuid
+   * Returns ids for buffer attributes.
    * @param  {Object} object
    * @return {Integer}
    */
-  getUID(object) {
-    if (!this.uids.has(object))
-      this.uids.set(object, this.uid++);
-    return this.uids.get(object);
+  getUID(attribute, isRelativeCopy = false) {
+    if (this.uids.has(attribute) === false) {
+      const uids2 = /* @__PURE__ */ new Map();
+      uids2.set(true, this.uid++);
+      uids2.set(false, this.uid++);
+      this.uids.set(attribute, uids2);
+    }
+    const uids = this.uids.get(attribute);
+    return uids.get(isRelativeCopy);
   }
   /**
    * Checks if normal attribute values are normalized.
@@ -448,6 +510,64 @@ class GLTFWriter {
       this.extensionsUsed["KHR_texture_transform"] = true;
     }
   }
+  buildMetalRoughTexture(metalnessMap, roughnessMap) {
+    if (metalnessMap === roughnessMap)
+      return metalnessMap;
+    function getEncodingConversion(map) {
+      if (map.colorSpace === THREE.SRGBColorSpace) {
+        return function SRGBToLinear(c) {
+          return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+        };
+      }
+      return function LinearToLinear(c) {
+        return c;
+      };
+    }
+    console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
+    if (metalnessMap instanceof THREE.CompressedTexture) {
+      metalnessMap = decompress(metalnessMap);
+    }
+    if (roughnessMap instanceof THREE.CompressedTexture) {
+      roughnessMap = decompress(roughnessMap);
+    }
+    const metalness = metalnessMap ? metalnessMap.image : null;
+    const roughness = roughnessMap ? roughnessMap.image : null;
+    const width = Math.max(metalness ? metalness.width : 0, roughness ? roughness.width : 0);
+    const height = Math.max(metalness ? metalness.height : 0, roughness ? roughness.height : 0);
+    const canvas = getCanvas();
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext("2d");
+    context.fillStyle = "#00ffff";
+    context.fillRect(0, 0, width, height);
+    const composite = context.getImageData(0, 0, width, height);
+    if (metalness) {
+      context.drawImage(metalness, 0, 0, width, height);
+      const convert = getEncodingConversion(metalnessMap);
+      const data = context.getImageData(0, 0, width, height).data;
+      for (let i = 2; i < data.length; i += 4) {
+        composite.data[i] = convert(data[i] / 256) * 256;
+      }
+    }
+    if (roughness) {
+      context.drawImage(roughness, 0, 0, width, height);
+      const convert = getEncodingConversion(roughnessMap);
+      const data = context.getImageData(0, 0, width, height).data;
+      for (let i = 1; i < data.length; i += 4) {
+        composite.data[i] = convert(data[i] / 256) * 256;
+      }
+    }
+    context.putImageData(composite, 0, 0);
+    const reference = metalnessMap || roughnessMap;
+    const texture = reference.clone();
+    texture.source = new THREE.Source(canvas);
+    texture.colorSpace = THREE.NoColorSpace;
+    texture.channel = (metalnessMap || roughnessMap).channel;
+    if (metalnessMap && roughnessMap && metalnessMap.channel !== roughnessMap.channel) {
+      console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match.");
+    }
+    return texture;
+  }
   /**
    * Process a buffer to append to the default one.
    * @param  {ArrayBuffer} buffer
@@ -475,14 +595,19 @@ class GLTFWriter {
     if (!json.bufferViews)
       json.bufferViews = [];
     let componentSize;
-    if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
-      componentSize = 1;
-    } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
-      componentSize = 2;
-    } else {
-      componentSize = 4;
-    }
-    const byteLength = this.getPaddedBufferSize(count * attribute.itemSize * componentSize);
+    switch (componentType) {
+      case WEBGL_CONSTANTS.BYTE:
+      case WEBGL_CONSTANTS.UNSIGNED_BYTE:
+        componentSize = 1;
+        break;
+      case WEBGL_CONSTANTS.SHORT:
+      case WEBGL_CONSTANTS.UNSIGNED_SHORT:
+        componentSize = 2;
+        break;
+      default:
+        componentSize = 4;
+    }
+    const byteLength = getPaddedBufferSize(count * attribute.itemSize * componentSize);
     const dataView = new DataView(new ArrayBuffer(byteLength));
     let offset = 0;
     for (let i = start; i < start + count; i++) {
@@ -499,18 +624,25 @@ class GLTFWriter {
             value = attribute.getZ(i);
           else if (a === 3)
             value = attribute.getW(i);
-        }
-        if (value !== void 0) {
-          if (componentType === WEBGL_CONSTANTS.FLOAT) {
-            dataView.setFloat32(offset, value, true);
-          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_INT) {
-            dataView.setUint32(offset, value, true);
-          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
-            dataView.setUint16(offset, value, true);
-          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
-            dataView.setUint8(offset, value);
+          if (attribute.normalized === true) {
+            value = THREE.MathUtils.normalize(value, attribute.array);
           }
         }
+        if (componentType === WEBGL_CONSTANTS.FLOAT) {
+          dataView.setFloat32(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.INT) {
+          dataView.setInt32(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_INT) {
+          dataView.setUint32(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.SHORT) {
+          dataView.setInt16(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
+          dataView.setUint16(offset, value, true);
+        } else if (componentType === WEBGL_CONSTANTS.BYTE) {
+          dataView.setInt8(offset, value);
+        } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
+          dataView.setUint8(offset, value);
+        }
         offset += componentSize;
       }
     }
@@ -542,20 +674,18 @@ class GLTFWriter {
     const json = writer.json;
     if (!json.bufferViews)
       json.bufferViews = [];
-    return new Promise((resolve) => {
-      const reader = new window.FileReader();
+    return new Promise(function(resolve) {
+      const reader = new FileReader();
       reader.readAsArrayBuffer(blob);
-      reader.onloadend = () => {
-        if (reader.result !== null && typeof reader.result !== "string" && json.bufferViews !== void 0) {
-          const buffer = this.getPaddedArrayBuffer(reader.result);
-          const bufferViewDef = {
-            buffer: writer.processBuffer(buffer),
-            byteOffset: writer.byteOffset,
-            byteLength: buffer.byteLength
-          };
-          writer.byteOffset += buffer.byteLength;
-          resolve(json.bufferViews.push(bufferViewDef) - 1);
-        }
+      reader.onloadend = function() {
+        const buffer = getPaddedArrayBuffer(reader.result);
+        const bufferViewDef = {
+          buffer: writer.processBuffer(buffer),
+          byteOffset: writer.byteOffset,
+          byteLength: buffer.byteLength
+        };
+        writer.byteOffset += buffer.byteLength;
+        resolve(json.bufferViews.push(bufferViewDef) - 1);
       };
     });
   }
@@ -568,139 +698,135 @@ class GLTFWriter {
    * @return {Integer|null} Index of the processed accessor on the "accessors" array
    */
   processAccessor(attribute, geometry, start, count) {
-    const options = this.options;
     const json = this.json;
     const types = {
       1: "SCALAR",
       2: "VEC2",
       3: "VEC3",
       4: "VEC4",
+      9: "MAT3",
       16: "MAT4"
     };
     let componentType;
     if (attribute.array.constructor === Float32Array) {
       componentType = WEBGL_CONSTANTS.FLOAT;
+    } else if (attribute.array.constructor === Int32Array) {
+      componentType = WEBGL_CONSTANTS.INT;
     } else if (attribute.array.constructor === Uint32Array) {
       componentType = WEBGL_CONSTANTS.UNSIGNED_INT;
+    } else if (attribute.array.constructor === Int16Array) {
+      componentType = WEBGL_CONSTANTS.SHORT;
     } else if (attribute.array.constructor === Uint16Array) {
       componentType = WEBGL_CONSTANTS.UNSIGNED_SHORT;
+    } else if (attribute.array.constructor === Int8Array) {
+      componentType = WEBGL_CONSTANTS.BYTE;
     } else if (attribute.array.constructor === Uint8Array) {
       componentType = WEBGL_CONSTANTS.UNSIGNED_BYTE;
     } else {
-      throw new Error("THREE.GLTFExporter: Unsupported bufferAttribute component type.");
+      throw new Error(
+        "THREE.GLTFExporter: Unsupported bufferAttribute component type: " + attribute.array.constructor.name
+      );
     }
     if (start === void 0)
       start = 0;
     if (count === void 0)
       count = attribute.count;
-    if (options.truncateDrawRange && geometry !== void 0 && geometry.index === null) {
-      const end = start + count;
-      const end2 = geometry.drawRange.count === Infinity ? attribute.count : geometry.drawRange.start + geometry.drawRange.count;
-      start = Math.max(start, geometry.drawRange.start);
-      count = Math.min(end, end2) - start;
-      if (count < 0)
-        count = 0;
-    }
     if (count === 0)
       return null;
-    const minMax = this.getMinMax(attribute, start, count);
+    const minMax = getMinMax(attribute, start, count);
     let bufferViewTarget;
     if (geometry !== void 0) {
       bufferViewTarget = attribute === geometry.index ? WEBGL_CONSTANTS.ELEMENT_ARRAY_BUFFER : WEBGL_CONSTANTS.ARRAY_BUFFER;
     }
-    if (bufferViewTarget !== void 0) {
-      const bufferView = this.processBufferView(attribute, componentType, start, count, bufferViewTarget);
-      const accessorDef = {
-        bufferView: bufferView.id,
-        byteOffset: bufferView.byteOffset,
-        componentType,
-        count,
-        max: minMax.max,
-        min: minMax.min,
-        type: types[attribute.itemSize]
-      };
-      if (attribute.normalized)
-        accessorDef.normalized = true;
-      if (!json.accessors)
-        json.accessors = [];
-      return json.accessors.push(accessorDef) - 1;
-    }
+    const bufferView = this.processBufferView(attribute, componentType, start, count, bufferViewTarget);
+    const accessorDef = {
+      bufferView: bufferView.id,
+      byteOffset: bufferView.byteOffset,
+      componentType,
+      count,
+      max: minMax.max,
+      min: minMax.min,
+      type: types[attribute.itemSize]
+    };
+    if (attribute.normalized === true)
+      accessorDef.normalized = true;
+    if (!json.accessors)
+      json.accessors = [];
+    return json.accessors.push(accessorDef) - 1;
   }
   /**
    * Process image
    * @param  {Image} image to process
    * @param  {Integer} format of the image (RGBAFormat)
    * @param  {Boolean} flipY before writing out the image
+   * @param  {String} mimeType export format
    * @return {Integer}     Index of the processed texture in the "images" array
    */
-  processImage(image, format, flipY) {
-    const writer = this;
-    const cache = writer.cache;
-    const json = writer.json;
-    const options = writer.options;
-    const pending = writer.pending;
-    if (!cache.images.has(image))
-      cache.images.set(image, {});
-    const cachedImages = cache.images.get(image);
-    const mimeType = format === THREE.RGBAFormat ? "image/png" : "image/jpeg";
-    const key = mimeType + ":flipY/" + flipY.toString();
-    if (cachedImages !== void 0 && cachedImages[key] !== void 0)
-      return cachedImages[key];
-    if (!json.images)
-      json.images = [];
-    const imageDef = { mimeType };
-    if (options.embedImages && options.maxTextureSize !== void 0) {
-      const canvas = this.cachedCanvas = this.cachedCanvas || document.createElement("canvas");
+  processImage(image, format, flipY, mimeType = "image/png") {
+    if (image !== null) {
+      const writer = this;
+      const cache = writer.cache;
+      const json = writer.json;
+      const options = writer.options;
+      const pending = writer.pending;
+      if (!cache.images.has(image))
+        cache.images.set(image, {});
+      const cachedImages = cache.images.get(image);
+      const key = mimeType + ":flipY/" + flipY.toString();
+      if (cachedImages[key] !== void 0)
+        return cachedImages[key];
+      if (!json.images)
+        json.images = [];
+      const imageDef = { mimeType };
+      const canvas = getCanvas();
       canvas.width = Math.min(image.width, options.maxTextureSize);
       canvas.height = Math.min(image.height, options.maxTextureSize);
       const ctx = canvas.getContext("2d");
-      if (flipY) {
-        ctx == null ? void 0 : ctx.translate(0, canvas.height);
-        ctx == null ? void 0 : ctx.scale(1, -1);
+      if (flipY === true) {
+        ctx.translate(0, canvas.height);
+        ctx.scale(1, -1);
       }
-      if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && image instanceof OffscreenCanvas || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
-        ctx == null ? void 0 : ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
-      } else {
+      if (image.data !== void 0) {
         if (format !== THREE.RGBAFormat) {
-          console.error("GLTFExporter: Only RGBA format is supported.");
+          console.error("GLTFExporter: Only RGBAFormat is supported.", format);
         }
         if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
           console.warn("GLTFExporter: Image size is bigger than maxTextureSize", image);
         }
         const data = new Uint8ClampedArray(image.height * image.width * 4);
-        if (image instanceof ImageData) {
-          for (let i = 0; i < data.length; i += 4) {
-            data[i + 0] = image.data[i + 0];
-            data[i + 1] = image.data[i + 1];
-            data[i + 2] = image.data[i + 2];
-            data[i + 3] = image.data[i + 3];
-          }
+        for (let i = 0; i < data.length; i += 4) {
+          data[i + 0] = image.data[i + 0];
+          data[i + 1] = image.data[i + 1];
+          data[i + 2] = image.data[i + 2];
+          data[i + 3] = image.data[i + 3];
         }
-        ctx == null ? void 0 : ctx.putImageData(new ImageData(data, image.width, image.height), 0, 0);
+        ctx.putImageData(new ImageData(data, image.width, image.height), 0, 0);
+      } else {
+        ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
       }
-      if (options.binary) {
+      if (options.binary === true) {
         pending.push(
-          new Promise(function(resolve) {
-            canvas.toBlob(function(blob) {
-              if (blob !== null) {
-                writer.processBufferViewImage(blob).then(function(bufferViewIndex) {
-                  imageDef.bufferView = bufferViewIndex;
-                  resolve();
-                });
-              }
-            }, mimeType);
+          getToBlobPromise(canvas, mimeType).then((blob) => writer.processBufferViewImage(blob)).then((bufferViewIndex) => {
+            imageDef.bufferView = bufferViewIndex;
           })
         );
       } else {
-        imageDef.uri = canvas.toDataURL(mimeType);
+        if (canvas.toDataURL !== void 0) {
+          imageDef.uri = canvas.toDataURL(mimeType);
+        } else {
+          pending.push(
+            getToBlobPromise(canvas, mimeType).then((blob) => new FileReader().readAsDataURL(blob)).then((dataURL) => {
+              imageDef.uri = dataURL;
+            })
+          );
+        }
       }
-    } else if (image instanceof Image) {
-      imageDef.uri = image.src;
-    }
-    const index = json.images.push(imageDef) - 1;
-    if (cachedImages !== void 0)
+      const index = json.images.push(imageDef) - 1;
       cachedImages[key] = index;
-    return index;
+      return index;
+    } else {
+      throw new Error("THREE.GLTFExporter: No valid image data found. Unable to process texture.");
+    }
   }
   /**
    * Process sampler
@@ -725,15 +851,23 @@ class GLTFWriter {
    * @return {Integer} Index of the processed texture in the "textures" array
    */
   processTexture(map) {
+    const writer = this;
+    const options = writer.options;
     const cache = this.cache;
     const json = this.json;
     if (cache.textures.has(map))
       return cache.textures.get(map);
     if (!json.textures)
       json.textures = [];
+    if (map instanceof THREE.CompressedTexture) {
+      map = decompress(map, options.maxTextureSize);
+    }
+    let mimeType = map.userData.mimeType;
+    if (mimeType === "image/webp")
+      mimeType = "image/png";
     const textureDef = {
       sampler: this.processSampler(map),
-      source: this.processImage(map.image, map.format, map.flipY)
+      source: this.processImage(map.image, map.format, map.flipY, mimeType)
     };
     if (map.name)
       textureDef.name = map.name;
@@ -754,74 +888,74 @@ class GLTFWriter {
     const json = this.json;
     if (cache.materials.has(material))
       return cache.materials.get(material);
-    if (material instanceof THREE.ShaderMaterial && material.isShaderMaterial) {
+    if (material.isShaderMaterial) {
       console.warn("GLTFExporter: THREE.ShaderMaterial not supported.");
       return null;
     }
     if (!json.materials)
       json.materials = [];
     const materialDef = { pbrMetallicRoughness: {} };
-    if (!(material instanceof THREE.MeshStandardMaterial && material.isMeshStandardMaterial && material instanceof THREE.MeshBasicMaterial && // @ts-expect-error
-    material.isMeshBasicMaterial)) {
+    if (material.isMeshStandardMaterial !== true && material.isMeshBasicMaterial !== true) {
       console.warn("GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.");
     }
-    if (material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshPhysicalMaterial) {
-      const color = material.color.toArray().concat([material.opacity]);
-      if (!this.equalArray(color, [1, 1, 1, 1])) {
-        materialDef.pbrMetallicRoughness.baseColorFactor = color;
-      }
+    const color = material.color.toArray().concat([material.opacity]);
+    if (!equalArray(color, [1, 1, 1, 1])) {
+      materialDef.pbrMetallicRoughness.baseColorFactor = color;
     }
-    if (material instanceof THREE.MeshStandardMaterial && material.isMeshStandardMaterial) {
+    if (material.isMeshStandardMaterial) {
       materialDef.pbrMetallicRoughness.metallicFactor = material.metalness;
       materialDef.pbrMetallicRoughness.roughnessFactor = material.roughness;
     } else {
       materialDef.pbrMetallicRoughness.metallicFactor = 0.5;
       materialDef.pbrMetallicRoughness.roughnessFactor = 0.5;
     }
-    if (material instanceof THREE.MeshStandardMaterial && material.metalnessMap || material instanceof THREE.MeshStandardMaterial && material.roughnessMap) {
-      if (material.metalnessMap === material.roughnessMap && material.metalnessMap !== null) {
-        const metalRoughMapDef = { index: this.processTexture(material.metalnessMap) };
-        this.applyTextureTransform(metalRoughMapDef, material.metalnessMap);
-        materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
-      } else {
-        console.warn(
-          "THREE.GLTFExporter: Ignoring metalnessMap and roughnessMap because they are not the same Texture."
-        );
-      }
+    if (material.metalnessMap || material.roughnessMap) {
+      const metalRoughTexture = this.buildMetalRoughTexture(material.metalnessMap, material.roughnessMap);
+      const metalRoughMapDef = {
+        index: this.processTexture(metalRoughTexture),
+        channel: metalRoughTexture.channel
+      };
+      this.applyTextureTransform(metalRoughMapDef, metalRoughTexture);
+      materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
     }
-    if ((material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshPhysicalMaterial) && material.map) {
-      const baseColorMapDef = { index: this.processTexture(material.map) };
+    if (material.map) {
+      const baseColorMapDef = {
+        index: this.processTexture(material.map),
+        texCoord: material.map.channel
+      };
       this.applyTextureTransform(baseColorMapDef, material.map);
       materialDef.pbrMetallicRoughness.baseColorTexture = baseColorMapDef;
     }
-    if ((material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshPhysicalMaterial) && material.emissive) {
-      const emissive = material.emissive.clone().multiplyScalar(material.emissiveIntensity);
+    if (material.emissive) {
+      const emissive = material.emissive;
       const maxEmissiveComponent = Math.max(emissive.r, emissive.g, emissive.b);
-      if (maxEmissiveComponent > 1) {
-        emissive.multiplyScalar(1 / maxEmissiveComponent);
-        console.warn("THREE.GLTFExporter: Some emissive components exceed 1; emissive has been limited");
-      }
       if (maxEmissiveComponent > 0) {
-        materialDef.emissiveFactor = emissive.toArray();
+        materialDef.emissiveFactor = material.emissive.toArray();
       }
       if (material.emissiveMap) {
-        const emissiveMapDef = { index: this.processTexture(material.emissiveMap) };
+        const emissiveMapDef = {
+          index: this.processTexture(material.emissiveMap),
+          texCoord: material.emissiveMap.channel
+        };
         this.applyTextureTransform(emissiveMapDef, material.emissiveMap);
         materialDef.emissiveTexture = emissiveMapDef;
       }
     }
-    if ((material instanceof THREE.MeshMatcapMaterial || material instanceof THREE.MeshNormalMaterial || material instanceof THREE.MeshPhongMaterial || material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshToonMaterial) && material.normalMap) {
-      const normalMapDef = { index: this.processTexture(material.normalMap) };
+    if (material.normalMap) {
+      const normalMapDef = {
+        index: this.processTexture(material.normalMap),
+        texCoord: material.normalMap.channel
+      };
       if (material.normalScale && material.normalScale.x !== 1) {
         normalMapDef.scale = material.normalScale.x;
       }
       this.applyTextureTransform(normalMapDef, material.normalMap);
       materialDef.normalTexture = normalMapDef;
     }
-    if ((material instanceof THREE.MeshBasicMaterial || material instanceof THREE.MeshLambertMaterial || material instanceof THREE.MeshPhongMaterial || material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshToonMaterial) && material.aoMap) {
+    if (material.aoMap) {
       const occlusionMapDef = {
         index: this.processTexture(material.aoMap),
-        texCoord: 1
+        texCoord: material.aoMap.channel
       };
       if (material.aoMapIntensity !== 1) {
         occlusionMapDef.strength = material.aoMapIntensity;
@@ -870,19 +1004,16 @@ class GLTFWriter {
       return cache.meshes.get(meshCacheKey);
     const geometry = mesh.geometry;
     let mode;
-    if (mesh instanceof THREE.LineSegments && mesh.isLineSegments) {
+    if (mesh.isLineSegments) {
       mode = WEBGL_CONSTANTS.LINES;
-    } else if (mesh instanceof THREE.LineLoop && mesh.isLineLoop) {
+    } else if (mesh.isLineLoop) {
       mode = WEBGL_CONSTANTS.LINE_LOOP;
-    } else if (mesh instanceof THREE.Line && mesh.isLine) {
+    } else if (mesh.isLine) {
       mode = WEBGL_CONSTANTS.LINE_STRIP;
-    } else if (mesh instanceof THREE.Points && mesh.isPoints) {
+    } else if (mesh.isPoints) {
       mode = WEBGL_CONSTANTS.POINTS;
     } else {
-      mode = (mesh.material instanceof THREE.MeshBasicMaterial || mesh.material instanceof THREE.MeshDepthMaterial || mesh.material instanceof THREE.MeshLambertMaterial || mesh.material instanceof THREE.MeshNormalMaterial || mesh.material instanceof THREE.MeshPhongMaterial || mesh.material instanceof THREE.MeshStandardMaterial || mesh.material instanceof THREE.MeshToonMaterial || mesh.material instanceof THREE.ShaderMaterial) && mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
-    }
-    if (!geometry.isBufferGeometry) {
-      throw new Error("THREE.GLTFExporter: Geometry is not of type THREE.BufferGeometry.");
+      mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
     }
     const meshDef = {};
     const attributes = {};
@@ -890,19 +1021,19 @@ class GLTFWriter {
     const targets = [];
     const nameConversion = {
       uv: "TEXCOORD_0",
-      uv2: "TEXCOORD_1",
+      [THREE.REVISION.replace(/\D+/g, "") >= 152 ? "uv1" : "uv2"]: "TEXCOORD_1",
       color: "COLOR_0",
       skinWeight: "WEIGHTS_0",
       skinIndex: "JOINTS_0"
     };
     const originalNormal = geometry.getAttribute("normal");
-    if (originalNormal !== void 0 && !(originalNormal instanceof THREE.InterleavedBufferAttribute) && !this.isNormalizedNormalAttribute(originalNormal)) {
+    if (originalNormal !== void 0 && !this.isNormalizedNormalAttribute(originalNormal)) {
       console.warn("THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one.");
       geometry.setAttribute("normal", this.createNormalizedNormalAttribute(originalNormal));
     }
     let modifiedAttribute = null;
     for (let attributeName in geometry.attributes) {
-      if (attributeName.substr(0, 5) === "morph")
+      if (attributeName.slice(0, 5) === "morph")
         continue;
       const attribute = geometry.attributes[attributeName];
       attributeName = nameConversion[attributeName] || attributeName.toUpperCase();
@@ -919,8 +1050,11 @@ class GLTFWriter {
         console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.');
         modifiedAttribute = new THREE.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
       }
-      const accessor = modifiedAttribute !== null && this.processAccessor(modifiedAttribute || attribute, geometry);
-      if (accessor) {
+      const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
+      if (accessor !== null) {
+        if (!attributeName.startsWith("_")) {
+          this.detectMeshQuantization(attributeName, attribute);
+        }
         attributes[attributeName] = accessor;
         cache.attributes.set(this.getUID(attribute), accessor);
       }
@@ -952,26 +1086,27 @@ class GLTFWriter {
           const attribute = geometry.morphAttributes[attributeName][i];
           const gltfAttributeName = attributeName.toUpperCase();
           const baseAttribute = geometry.attributes[attributeName];
-          if (cache.attributes.has(this.getUID(attribute))) {
-            target[gltfAttributeName] = cache.attributes.get(this.getUID(attribute));
+          if (cache.attributes.has(this.getUID(attribute, true))) {
+            target[gltfAttributeName] = cache.attributes.get(this.getUID(attribute, true));
             continue;
           }
           const relativeAttribute = attribute.clone();
           if (!geometry.morphTargetsRelative) {
             for (let j = 0, jl = attribute.count; j < jl; j++) {
-              relativeAttribute.setXYZ(
-                j,
-                attribute.getX(j) - baseAttribute.getX(j),
-                attribute.getY(j) - baseAttribute.getY(j),
-                attribute.getZ(j) - baseAttribute.getZ(j)
-              );
+              for (let a = 0; a < attribute.itemSize; a++) {
+                if (a === 0)
+                  relativeAttribute.setX(j, attribute.getX(j) - baseAttribute.getX(j));
+                if (a === 1)
+                  relativeAttribute.setY(j, attribute.getY(j) - baseAttribute.getY(j));
+                if (a === 2)
+                  relativeAttribute.setZ(j, attribute.getZ(j) - baseAttribute.getZ(j));
+                if (a === 3)
+                  relativeAttribute.setW(j, attribute.getW(j) - baseAttribute.getW(j));
+              }
             }
           }
-          const accessor = this.processAccessor(relativeAttribute, geometry);
-          if (accessor != void 0) {
-            target[gltfAttributeName] = accessor;
-          }
-          cache.attributes.set(this.getUID(baseAttribute), target[gltfAttributeName]);
+          target[gltfAttributeName] = this.processAccessor(relativeAttribute, geometry);
+          cache.attributes.set(this.getUID(baseAttribute, true), target[gltfAttributeName]);
         }
         targets.push(target);
         weights.push(mesh.morphTargetInfluences[i]);
@@ -994,15 +1129,13 @@ class GLTFWriter {
         mode,
         attributes
       };
-      if (geometry instanceof THREE.Object3D || geometry instanceof THREE.Material) {
-        this.serializeUserData(geometry, primitive);
-      }
+      this.serializeUserData(geometry, primitive);
       if (targets.length > 0)
         primitive.targets = targets;
       if (geometry.index !== null) {
         let cacheKey = this.getUID(geometry.index);
         if (groups[i].start !== void 0 || groups[i].count !== void 0) {
-          cacheKey += `:${groups[i].start}:${groups[i].count}`;
+          cacheKey += ":" + groups[i].start + ":" + groups[i].count;
         }
         if (cache.attributes.has(cacheKey)) {
           primitive.indices = cache.attributes.get(cacheKey);
@@ -1013,16 +1146,10 @@ class GLTFWriter {
         if (primitive.indices === null)
           delete primitive.indices;
       }
-      const materialIndex = groups[i].materialIndex;
-      if (materialIndex !== void 0 && Array.isArray(materials)) {
-        const targetMaterials = materials[materialIndex];
-        if (!Array.isArray(targetMaterials)) {
-          const material = this.processMaterial(targetMaterials);
-          if (material !== null)
-            primitive.material = material;
-          primitives.push(primitive);
-        }
-      }
+      const material = this.processMaterial(materials[groups[i].materialIndex]);
+      if (material !== null)
+        primitive.material = material;
+      primitives.push(primitive);
     }
     meshDef.primitives = primitives;
     if (!json.meshes)
@@ -1034,6 +1161,45 @@ class GLTFWriter {
     cache.meshes.set(meshCacheKey, index);
     return index;
   }
+  /**
+   * If a vertex attribute with a
+   * [non-standard data type](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#meshes-overview)
+   * is used, it is checked whether it is a valid data type according to the
+   * [KHR_mesh_quantization](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md)
+   * extension.
+   * In this case the extension is automatically added to the list of used extensions.
+   *
+   * @param {string} attributeName
+   * @param {THREE.BufferAttribute} attribute
+   */
+  detectMeshQuantization(attributeName, attribute) {
+    if (this.extensionsUsed[KHR_MESH_QUANTIZATION])
+      return;
+    let attrType = void 0;
+    switch (attribute.array.constructor) {
+      case Int8Array:
+        attrType = "byte";
+        break;
+      case Uint8Array:
+        attrType = "unsigned byte";
+        break;
+      case Int16Array:
+        attrType = "short";
+        break;
+      case Uint16Array:
+        attrType = "unsigned short";
+        break;
+      default:
+        return;
+    }
+    if (attribute.normalized)
+      attrType += " normalized";
+    const attrNamePrefix = attributeName.split("_", 1)[0];
+    if (KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix] && KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix].includes(attrType)) {
+      this.extensionsUsed[KHR_MESH_QUANTIZATION] = true;
+      this.extensionsRequired[KHR_MESH_QUANTIZATION] = true;
+    }
+  }
   /**
    * Process camera
    * @param  {THREE.Camera} camera Camera to process
@@ -1043,18 +1209,18 @@ class GLTFWriter {
     const json = this.json;
     if (!json.cameras)
       json.cameras = [];
-    const isOrtho = camera instanceof THREE.OrthographicCamera && camera.isOrthographicCamera;
+    const isOrtho = camera.isOrthographicCamera;
     const cameraDef = {
       type: isOrtho ? "orthographic" : "perspective"
     };
-    if (camera instanceof THREE.OrthographicCamera && isOrtho) {
+    if (isOrtho) {
       cameraDef.orthographic = {
         xmag: camera.right * 2,
         ymag: camera.top * 2,
         zfar: camera.far <= 0 ? 1e-3 : camera.far,
         znear: camera.near < 0 ? 0 : camera.near
       };
-    } else if (camera instanceof THREE.PerspectiveCamera) {
+    } else {
       cameraDef.perspective = {
         aspectRatio: camera.aspect,
         yfov: THREE.MathUtils.degToRad(camera.fov),
@@ -1091,7 +1257,7 @@ class GLTFWriter {
       let trackNode = THREE.PropertyBinding.findNode(root, trackBinding.nodeName);
       const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
       if (trackBinding.objectName === "bones") {
-        if (trackNode.isSkinnedMesh) {
+        if (trackNode.isSkinnedMesh === true) {
           trackNode = trackNode.skeleton.getBoneByName(trackBinding.objectIndex);
         } else {
           trackNode = void 0;
@@ -1107,7 +1273,7 @@ class GLTFWriter {
         outputItemSize /= trackNode.morphTargetInfluences.length;
       }
       let interpolation;
-      if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+      if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
         interpolation = "CUBICSPLINE";
         outputItemSize /= 3;
       } else if (track.getInterpolation() === THREE.InterpolateDiscrete) {
@@ -1142,34 +1308,30 @@ class GLTFWriter {
   processSkin(object) {
     const json = this.json;
     const nodeMap = this.nodeMap;
-    if (json.nodes !== void 0 && object instanceof THREE.SkinnedMesh) {
-      const node = json.nodes[nodeMap.get(object)];
-      const skeleton = object.skeleton;
-      if (skeleton === void 0)
-        return null;
-      const rootJoint = object.skeleton.bones[0];
-      if (rootJoint === void 0)
-        return null;
-      const joints = [];
-      const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
-      const temporaryBoneInverse = new THREE.Matrix4();
-      for (let i = 0; i < skeleton.bones.length; ++i) {
-        joints.push(nodeMap.get(skeleton.bones[i]));
-        temporaryBoneInverse.copy(skeleton.boneInverses[i]);
-        temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i * 16);
-      }
-      if (json.skins === void 0)
-        json.skins = [];
-      json.skins.push({
-        inverseBindMatrices: this.processAccessor(new THREE.BufferAttribute(inverseBindMatrices, 16)),
-        joints,
-        skeleton: nodeMap.get(rootJoint)
-      });
-      const skinIndex = node.skin = json.skins.length - 1;
-      return skinIndex;
-    } else {
+    const node = json.nodes[nodeMap.get(object)];
+    const skeleton = object.skeleton;
+    if (skeleton === void 0)
       return null;
-    }
+    const rootJoint = object.skeleton.bones[0];
+    if (rootJoint === void 0)
+      return null;
+    const joints = [];
+    const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
+    const temporaryBoneInverse = new THREE.Matrix4();
+    for (let i = 0; i < skeleton.bones.length; ++i) {
+      joints.push(nodeMap.get(skeleton.bones[i]));
+      temporaryBoneInverse.copy(skeleton.boneInverses[i]);
+      temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i * 16);
+    }
+    if (json.skins === void 0)
+      json.skins = [];
+    json.skins.push({
+      inverseBindMatrices: this.processAccessor(new THREE.BufferAttribute(inverseBindMatrices, 16)),
+      joints,
+      skeleton: nodeMap.get(rootJoint)
+    });
+    const skinIndex = node.skin = json.skins.length - 1;
+    return skinIndex;
   }
   /**
    * Process Object3D node
@@ -1187,40 +1349,40 @@ class GLTFWriter {
       const rotation = object.quaternion.toArray();
       const position = object.position.toArray();
       const scale = object.scale.toArray();
-      if (!this.equalArray(rotation, [0, 0, 0, 1])) {
+      if (!equalArray(rotation, [0, 0, 0, 1])) {
         nodeDef.rotation = rotation;
       }
-      if (!this.equalArray(position, [0, 0, 0])) {
+      if (!equalArray(position, [0, 0, 0])) {
         nodeDef.translation = position;
       }
-      if (!this.equalArray(scale, [1, 1, 1])) {
+      if (!equalArray(scale, [1, 1, 1])) {
         nodeDef.scale = scale;
       }
     } else {
       if (object.matrixAutoUpdate) {
         object.updateMatrix();
       }
-      if (!this.isIdentityMatrix(object.matrix)) {
+      if (isIdentityMatrix(object.matrix) === false) {
         nodeDef.matrix = object.matrix.elements;
       }
     }
     if (object.name !== "")
       nodeDef.name = String(object.name);
     this.serializeUserData(object, nodeDef);
-    if ((object instanceof THREE.Mesh && object.isMesh || object instanceof THREE.Line && object.isLine || object instanceof THREE.Points && object.isPoints) && object instanceof THREE.Mesh) {
+    if (object.isMesh || object.isLine || object.isPoints) {
       const meshIndex = this.processMesh(object);
       if (meshIndex !== null)
         nodeDef.mesh = meshIndex;
-    } else if (object instanceof THREE.Camera && object.isCamera) {
+    } else if (object.isCamera) {
       nodeDef.camera = this.processCamera(object);
     }
-    if (object instanceof THREE.SkinnedMesh && object.isSkinnedMesh)
+    if (object.isSkinnedMesh)
       this.skins.push(object);
     if (object.children.length > 0) {
       const children = [];
       for (let i = 0, l = object.children.length; i < l; i++) {
         const child = object.children[i];
-        if (child.visible || !options.onlyVisible) {
+        if (child.visible || options.onlyVisible === false) {
           const nodeIndex2 = this.processNode(child);
           if (nodeIndex2 !== null)
             children.push(nodeIndex2);
@@ -1254,7 +1416,7 @@ class GLTFWriter {
     const nodes = [];
     for (let i = 0, l = scene.children.length; i < l; i++) {
       const child = scene.children[i];
-      if (child.visible || !options.onlyVisible) {
+      if (child.visible || options.onlyVisible === false) {
         const nodeIndex = this.processNode(child);
         if (nodeIndex !== null)
           nodes.push(nodeIndex);
@@ -1264,6 +1426,10 @@ class GLTFWriter {
       sceneDef.nodes = nodes;
     this.serializeUserData(scene, sceneDef);
   }
+  /**
+   * Creates a Scene to hold a list of objects and parse it
+   * @param  {Array} objects List of objects to process
+   */
   processObjects(objects) {
     const scene = new THREE.Scene();
     scene.name = "AuxScene";
@@ -1283,9 +1449,8 @@ class GLTFWriter {
     });
     const objectsWithoutScene = [];
     for (let i = 0; i < input.length; i++) {
-      const inputScene = input[i];
-      if (inputScene instanceof THREE.Scene) {
-        this.processScene(inputScene);
+      if (input[i] instanceof THREE.Scene) {
+        this.processScene(input[i]);
       } else {
         objectsWithoutScene.push(input[i]);
       }
@@ -1295,7 +1460,7 @@ class GLTFWriter {
     for (let i = 0; i < this.skins.length; ++i) {
       this.processSkin(this.skins[i]);
     }
-    for (let i = 0; options.animations !== void 0 && i < options.animations.length; ++i) {
+    for (let i = 0; i < options.animations.length; ++i) {
       this.processAnimation(options.animations[i], input[0]);
     }
     this._invokeAll(function(ext) {
@@ -1307,108 +1472,16 @@ class GLTFWriter {
       func(this.plugins[i]);
     }
   }
-  //------------------------------------------------------------------------------
-  // Utility functions
-  //------------------------------------------------------------------------------
-  /**
-   * Compare two arrays
-   * @param  {Array} array1 Array 1 to compare
-   * @param  {Array} array2 Array 2 to compare
-   * @return {Boolean}        Returns true if both arrays are equal
-   */
-  equalArray(array1, array2) {
-    return array1.length === array2.length && array1.every(function(element, index) {
-      return element === array2[index];
-    });
-  }
-  /**
-   * Converts a string to an ArrayBuffer.
-   * @param  {string} text
-   * @return {ArrayBuffer}
-   */
-  stringToArrayBuffer(text) {
-    if (window.TextEncoder !== void 0) {
-      return new TextEncoder().encode(text).buffer;
-    }
-    const array = new Uint8Array(new ArrayBuffer(text.length));
-    for (let i = 0, il = text.length; i < il; i++) {
-      const value = text.charCodeAt(i);
-      array[i] = value > 255 ? 32 : value;
-    }
-    return array.buffer;
-  }
-  isIdentityMatrix(matrix) {
-    return this.equalArray(matrix.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-  }
-  getMinMax(attribute, start, count) {
-    const output = {
-      min: new Array(attribute.itemSize).fill(Number.POSITIVE_INFINITY),
-      max: new Array(attribute.itemSize).fill(Number.NEGATIVE_INFINITY)
-    };
-    for (let i = start; i < start + count; i++) {
-      for (let a = 0; a < attribute.itemSize; a++) {
-        let value;
-        if (attribute.itemSize > 4) {
-          value = attribute.array[i * attribute.itemSize + a];
-        } else {
-          if (a === 0)
-            value = attribute.getX(i);
-          else if (a === 1)
-            value = attribute.getY(i);
-          else if (a === 2)
-            value = attribute.getZ(i);
-          else if (a === 3)
-            value = attribute.getW(i);
-        }
-        if (value !== void 0) {
-          output.min[a] = Math.min(output.min[a], value);
-          output.max[a] = Math.max(output.max[a], value);
-        }
-      }
-    }
-    return output;
-  }
-  /**
-   * Get the required size + padding for a buffer, rounded to the next 4-byte boundary.
-   * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment
-   */
-  getPaddedBufferSize(bufferSize) {
-    return Math.ceil(bufferSize / 4) * 4;
-  }
-  /**
-   * Returns a buffer aligned to 4-byte boundary.
-   *
-   * @param {ArrayBuffer} arrayBuffer Buffer to pad
-   * @param {Integer} paddingByte (Optional)
-   * @returns {ArrayBuffer} The same buffer if it's already aligned to 4-byte boundary or a new buffer
-   */
-  getPaddedArrayBuffer(arrayBuffer, paddingByte = 0) {
-    const paddedLength = this.getPaddedBufferSize(arrayBuffer.byteLength);
-    if (paddedLength !== arrayBuffer.byteLength) {
-      const array = new Uint8Array(paddedLength);
-      array.set(new Uint8Array(arrayBuffer));
-      if (paddingByte !== 0) {
-        for (let i = arrayBuffer.byteLength; i < paddedLength; i++) {
-          array[i] = paddingByte;
-        }
-      }
-      return array.buffer;
-    }
-    return arrayBuffer;
-  }
 }
 class GLTFLightExtension {
   constructor(writer) {
-    __publicField(this, "writer");
-    __publicField(this, "name");
     this.writer = writer;
     this.name = "KHR_lights_punctual";
   }
   writeNode(light, nodeDef) {
     if (!light.isLight)
       return;
-    if (!(light instanceof THREE.DirectionalLight && light.isDirectionalLight) && // @ts-expect-error
-    !(light instanceof THREE.PointLight && light.isPointLight) && !(light instanceof THREE.SpotLight && light.isSpotLight)) {
+    if (!light.isDirectionalLight && !light.isPointLight && !light.isSpotLight) {
       console.warn("THREE.GLTFExporter: Only directional, point, and spot lights are supported.", light);
       return;
     }
@@ -1420,14 +1493,13 @@ class GLTFLightExtension {
       lightDef.name = light.name;
     lightDef.color = light.color.toArray();
     lightDef.intensity = light.intensity;
-    if (light instanceof THREE.DirectionalLight && light.isDirectionalLight) {
+    if (light.isDirectionalLight) {
       lightDef.type = "directional";
-    } else if (light instanceof THREE.PointLight && // @ts-expect-error
-    light.isPointLight) {
+    } else if (light.isPointLight) {
       lightDef.type = "point";
       if (light.distance > 0)
         lightDef.range = light.distance;
-    } else if (light instanceof THREE.SpotLight && light.isSpotLight) {
+    } else if (light.isSpotLight) {
       lightDef.type = "spot";
       if (light.distance > 0)
         lightDef.range = light.distance;
@@ -1435,12 +1507,12 @@ class GLTFLightExtension {
       lightDef.spot.innerConeAngle = (light.penumbra - 1) * light.angle * -1;
       lightDef.spot.outerConeAngle = light.angle;
     }
-    if (!(light instanceof THREE.DirectionalLight) && light.decay !== void 0 && light.decay !== 2) {
+    if (light.decay !== void 0 && light.decay !== 2) {
       console.warn(
         "THREE.GLTFExporter: Light decay may be lost. glTF is physically-based, and expects light.decay=2."
       );
     }
-    if (!(light instanceof THREE.PointLight) && light.target && (light.target.parent !== light || light.target.position.x !== 0 || light.target.position.y !== 0 || light.target.position.z !== -1)) {
+    if (light.target && (light.target.parent !== light || light.target.position.x !== 0 || light.target.position.y !== 0 || light.target.position.z !== -1)) {
       console.warn(
         "THREE.GLTFExporter: Light direction may be lost. For best results, make light.target a child of the light with position 0,0,-1."
       );
@@ -1450,26 +1522,20 @@ class GLTFLightExtension {
       json.extensions[this.name] = { lights: [] };
       extensionsUsed[this.name] = true;
     }
-    if (json.extensions !== void 0) {
-      const lights = json.extensions[this.name].lights;
-      lights.push(lightDef);
-      nodeDef.extensions = nodeDef.extensions || {};
-      nodeDef.extensions[this.name] = { light: lights.length - 1 };
-    }
+    const lights = json.extensions[this.name].lights;
+    lights.push(lightDef);
+    nodeDef.extensions = nodeDef.extensions || {};
+    nodeDef.extensions[this.name] = { light: lights.length - 1 };
   }
 }
 class GLTFMaterialsUnlitExtension {
   constructor(writer) {
-    __publicField(this, "writer");
-    __publicField(this, "name");
     this.writer = writer;
     this.name = "KHR_materials_unlit";
   }
   writeMaterial(material, materialDef) {
-    if (!(material instanceof THREE.MeshBasicMaterial && // @ts-expect-error
-    material.isMeshBasicMaterial)) {
+    if (!material.isMeshBasicMaterial)
       return;
-    }
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     materialDef.extensions = materialDef.extensions || {};
@@ -1479,36 +1545,78 @@ class GLTFMaterialsUnlitExtension {
     materialDef.pbrMetallicRoughness.roughnessFactor = 0.9;
   }
 }
-class GLTFMaterialsPBRSpecularGlossiness {
+class GLTFMaterialsClearcoatExtension {
   constructor(writer) {
-    __publicField(this, "writer");
-    __publicField(this, "name");
     this.writer = writer;
-    this.name = "KHR_materials_pbrSpecularGlossiness";
+    this.name = "KHR_materials_clearcoat";
   }
   writeMaterial(material, materialDef) {
-    if (!material.isGLTFSpecularGlossinessMaterial)
+    if (!material.isMeshPhysicalMaterial || material.clearcoat === 0)
       return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     const extensionDef = {};
-    if (materialDef.pbrMetallicRoughness.baseColorFactor) {
-      extensionDef.diffuseFactor = materialDef.pbrMetallicRoughness.baseColorFactor;
-    }
-    if (material instanceof THREE.MeshPhongMaterial) {
-      const specularFactor = [1, 1, 1];
-      material.specular.toArray(specularFactor, 0);
-      extensionDef.specularFactor = specularFactor;
-      extensionDef.glossinessFactor = // @ts-expect-error
-      material.glossiness;
+    extensionDef.clearcoatFactor = material.clearcoat;
+    if (material.clearcoatMap) {
+      const clearcoatMapDef = {
+        index: writer.processTexture(material.clearcoatMap),
+        texCoord: material.clearcoatMap.channel
+      };
+      writer.applyTextureTransform(clearcoatMapDef, material.clearcoatMap);
+      extensionDef.clearcoatTexture = clearcoatMapDef;
+    }
+    extensionDef.clearcoatRoughnessFactor = material.clearcoatRoughness;
+    if (material.clearcoatRoughnessMap) {
+      const clearcoatRoughnessMapDef = {
+        index: writer.processTexture(material.clearcoatRoughnessMap),
+        texCoord: material.clearcoatRoughnessMap.channel
+      };
+      writer.applyTextureTransform(clearcoatRoughnessMapDef, material.clearcoatRoughnessMap);
+      extensionDef.clearcoatRoughnessTexture = clearcoatRoughnessMapDef;
     }
-    if (materialDef.pbrMetallicRoughness.baseColorTexture) {
-      extensionDef.diffuseTexture = materialDef.pbrMetallicRoughness.baseColorTexture;
+    if (material.clearcoatNormalMap) {
+      const clearcoatNormalMapDef = {
+        index: writer.processTexture(material.clearcoatNormalMap),
+        texCoord: material.clearcoatNormalMap.channel
+      };
+      writer.applyTextureTransform(clearcoatNormalMapDef, material.clearcoatNormalMap);
+      extensionDef.clearcoatNormalTexture = clearcoatNormalMapDef;
     }
-    if ((material instanceof THREE.MeshBasicMaterial || material instanceof THREE.MeshLambertMaterial || material instanceof THREE.MeshPhongMaterial) && material.specularMap) {
-      const specularMapDef = { index: writer.processTexture(material.specularMap) };
-      writer.applyTextureTransform(specularMapDef, material.specularMap);
-      extensionDef.specularGlossinessTexture = specularMapDef;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+}
+class GLTFMaterialsIridescenceExtension {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_iridescence";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.iridescence === 0)
+      return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.iridescenceFactor = material.iridescence;
+    if (material.iridescenceMap) {
+      const iridescenceMapDef = {
+        index: writer.processTexture(material.iridescenceMap),
+        texCoord: material.iridescenceMap.channel
+      };
+      writer.applyTextureTransform(iridescenceMapDef, material.iridescenceMap);
+      extensionDef.iridescenceTexture = iridescenceMapDef;
+    }
+    extensionDef.iridescenceIor = material.iridescenceIOR;
+    extensionDef.iridescenceThicknessMinimum = material.iridescenceThicknessRange[0];
+    extensionDef.iridescenceThicknessMaximum = material.iridescenceThicknessRange[1];
+    if (material.iridescenceThicknessMap) {
+      const iridescenceThicknessMapDef = {
+        index: writer.processTexture(material.iridescenceThicknessMap),
+        texCoord: material.iridescenceThicknessMap.channel
+      };
+      writer.applyTextureTransform(iridescenceThicknessMapDef, material.iridescenceThicknessMap);
+      extensionDef.iridescenceThicknessTexture = iridescenceThicknessMapDef;
     }
     materialDef.extensions = materialDef.extensions || {};
     materialDef.extensions[this.name] = extensionDef;
@@ -1517,22 +1625,21 @@ class GLTFMaterialsPBRSpecularGlossiness {
 }
 class GLTFMaterialsTransmissionExtension {
   constructor(writer) {
-    __publicField(this, "writer");
-    __publicField(this, "name");
     this.writer = writer;
     this.name = "KHR_materials_transmission";
   }
   writeMaterial(material, materialDef) {
-    if (!(material instanceof THREE.MeshPhysicalMaterial && // @ts-expect-error
-    material.isMeshPhysicalMaterial) || material.transmission === 0) {
+    if (!material.isMeshPhysicalMaterial || material.transmission === 0)
       return;
-    }
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     const extensionDef = {};
     extensionDef.transmissionFactor = material.transmission;
     if (material.transmissionMap) {
-      const transmissionMapDef = { index: writer.processTexture(material.transmissionMap) };
+      const transmissionMapDef = {
+        index: writer.processTexture(material.transmissionMap),
+        texCoord: material.transmissionMap.channel
+      };
       writer.applyTextureTransform(transmissionMapDef, material.transmissionMap);
       extensionDef.transmissionTexture = transmissionMapDef;
     }
@@ -1543,33 +1650,257 @@ class GLTFMaterialsTransmissionExtension {
 }
 class GLTFMaterialsVolumeExtension {
   constructor(writer) {
-    __publicField(this, "writer");
-    __publicField(this, "name");
     this.writer = writer;
     this.name = "KHR_materials_volume";
   }
   writeMaterial(material, materialDef) {
-    if (!(material instanceof THREE.MeshPhysicalMaterial && // @ts-expect-error
-    material.isMeshPhysicalMaterial) || material.thickness === 0) {
+    if (!material.isMeshPhysicalMaterial || material.transmission === 0)
       return;
-    }
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     const extensionDef = {};
-    extensionDef.thickness = material.thickness;
+    extensionDef.thicknessFactor = material.thickness;
     if (material.thicknessMap) {
       const thicknessMapDef = {
-        index: writer.processTexture(material.thicknessMap)
+        index: writer.processTexture(material.thicknessMap),
+        texCoord: material.thicknessMap.channel
       };
       writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
       extensionDef.thicknessTexture = thicknessMapDef;
     }
     extensionDef.attenuationDistance = material.attenuationDistance;
-    extensionDef.attenuationColor = //@ts-expect-error
-    material.attenuationTint.toArray();
+    extensionDef.attenuationColor = material.attenuationColor.toArray();
     materialDef.extensions = materialDef.extensions || {};
     materialDef.extensions[this.name] = extensionDef;
     extensionsUsed[this.name] = true;
   }
 }
+class GLTFMaterialsIorExtension {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_ior";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.ior === 1.5)
+      return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.ior = material.ior;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+}
+class GLTFMaterialsSpecularExtension {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_specular";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.specularIntensity === 1 && material.specularColor.equals(DEFAULT_SPECULAR_COLOR) && !material.specularIntensityMap && !material.specularColorTexture)
+      return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.specularIntensityMap) {
+      const specularIntensityMapDef = {
+        index: writer.processTexture(material.specularIntensityMap),
+        texCoord: material.specularIntensityMap.channel
+      };
+      writer.applyTextureTransform(specularIntensityMapDef, material.specularIntensityMap);
+      extensionDef.specularTexture = specularIntensityMapDef;
+    }
+    if (material.specularColorMap) {
+      const specularColorMapDef = {
+        index: writer.processTexture(material.specularColorMap),
+        texCoord: material.specularColorMap.channel
+      };
+      writer.applyTextureTransform(specularColorMapDef, material.specularColorMap);
+      extensionDef.specularColorTexture = specularColorMapDef;
+    }
+    extensionDef.specularFactor = material.specularIntensity;
+    extensionDef.specularColorFactor = material.specularColor.toArray();
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+}
+class GLTFMaterialsSheenExtension {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_sheen";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.sheen == 0)
+      return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.sheenRoughnessMap) {
+      const sheenRoughnessMapDef = {
+        index: writer.processTexture(material.sheenRoughnessMap),
+        texCoord: material.sheenRoughnessMap.channel
+      };
+      writer.applyTextureTransform(sheenRoughnessMapDef, material.sheenRoughnessMap);
+      extensionDef.sheenRoughnessTexture = sheenRoughnessMapDef;
+    }
+    if (material.sheenColorMap) {
+      const sheenColorMapDef = {
+        index: writer.processTexture(material.sheenColorMap),
+        texCoord: material.sheenColorMap.channel
+      };
+      writer.applyTextureTransform(sheenColorMapDef, material.sheenColorMap);
+      extensionDef.sheenColorTexture = sheenColorMapDef;
+    }
+    extensionDef.sheenRoughnessFactor = material.sheenRoughness;
+    extensionDef.sheenColorFactor = material.sheenColor.toArray();
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+}
+class GLTFMaterialsAnisotropyExtension {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_anisotropy";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.anisotropy == 0)
+      return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.anisotropyMap) {
+      const anisotropyMapDef = { index: writer.processTexture(material.anisotropyMap) };
+      writer.applyTextureTransform(anisotropyMapDef, material.anisotropyMap);
+      extensionDef.anisotropyTexture = anisotropyMapDef;
+    }
+    extensionDef.anisotropyStrength = material.anisotropy;
+    extensionDef.anisotropyRotation = material.anisotropyRotation;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+}
+class GLTFMaterialsEmissiveStrengthExtension {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_emissive_strength";
+  }
+  writeMaterial(material, materialDef) {
+    if (!material.isMeshStandardMaterial || material.emissiveIntensity === 1)
+      return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.emissiveStrength = material.emissiveIntensity;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+}
+GLTFExporter.Utils = {
+  insertKeyframe: function(track, time) {
+    const tolerance = 1e-3;
+    const valueSize = track.getValueSize();
+    const times = new track.TimeBufferType(track.times.length + 1);
+    const values = new track.ValueBufferType(track.values.length + valueSize);
+    const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize));
+    let index;
+    if (track.times.length === 0) {
+      times[0] = time;
+      for (let i = 0; i < valueSize; i++) {
+        values[i] = 0;
+      }
+      index = 0;
+    } else if (time < track.times[0]) {
+      if (Math.abs(track.times[0] - time) < tolerance)
+        return 0;
+      times[0] = time;
+      times.set(track.times, 1);
+      values.set(interpolant.evaluate(time), 0);
+      values.set(track.values, valueSize);
+      index = 0;
+    } else if (time > track.times[track.times.length - 1]) {
+      if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
+        return track.times.length - 1;
+      }
+      times[times.length - 1] = time;
+      times.set(track.times, 0);
+      values.set(track.values, 0);
+      values.set(interpolant.evaluate(time), track.values.length);
+      index = times.length - 1;
+    } else {
+      for (let i = 0; i < track.times.length; i++) {
+        if (Math.abs(track.times[i] - time) < tolerance)
+          return i;
+        if (track.times[i] < time && track.times[i + 1] > time) {
+          times.set(track.times.slice(0, i + 1), 0);
+          times[i + 1] = time;
+          times.set(track.times.slice(i + 1), i + 2);
+          values.set(track.values.slice(0, (i + 1) * valueSize), 0);
+          values.set(interpolant.evaluate(time), (i + 1) * valueSize);
+          values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize);
+          index = i + 1;
+          break;
+        }
+      }
+    }
+    track.times = times;
+    track.values = values;
+    return index;
+  },
+  mergeMorphTargetTracks: function(clip, root) {
+    const tracks = [];
+    const mergedTracks = {};
+    const sourceTracks = clip.tracks;
+    for (let i = 0; i < sourceTracks.length; ++i) {
+      let sourceTrack = sourceTracks[i];
+      const sourceTrackBinding = THREE.PropertyBinding.parseTrackName(sourceTrack.name);
+      const sourceTrackNode = THREE.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+      if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
+        tracks.push(sourceTrack);
+        continue;
+      }
+      if (sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete && sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear) {
+        if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+          throw new Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
+        }
+        console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
+        sourceTrack = sourceTrack.clone();
+        sourceTrack.setInterpolation(THREE.InterpolateLinear);
+      }
+      const targetCount = sourceTrackNode.morphTargetInfluences.length;
+      const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
+      if (targetIndex === void 0) {
+        throw new Error("THREE.GLTFExporter: Morph target name not found: " + sourceTrackBinding.propertyIndex);
+      }
+      let mergedTrack;
+      if (mergedTracks[sourceTrackNode.uuid] === void 0) {
+        mergedTrack = sourceTrack.clone();
+        const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length);
+        for (let j = 0; j < mergedTrack.times.length; j++) {
+          values[j * targetCount + targetIndex] = mergedTrack.values[j];
+        }
+        mergedTrack.name = (sourceTrackBinding.nodeName || "") + ".morphTargetInfluences";
+        mergedTrack.values = values;
+        mergedTracks[sourceTrackNode.uuid] = mergedTrack;
+        tracks.push(mergedTrack);
+        continue;
+      }
+      const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
+      mergedTrack = mergedTracks[sourceTrackNode.uuid];
+      for (let j = 0; j < mergedTrack.times.length; j++) {
+        mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j]);
+      }
+      for (let j = 0; j < sourceTrack.times.length; j++) {
+        const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j]);
+        mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j];
+      }
+    }
+    clip.tracks = tracks;
+    return clip;
+  }
+};
 exports.GLTFExporter = GLTFExporter;