three-stdlib 2.22.7 → 2.22.8

package/dist/loaders/DDSLoader.d.ts

@@ -0,0 +1,16 @@
+import { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
+
+export interface DDS {
+  mipmaps: object[]
+  width: number
+  height: number
+  format: PixelFormat | CompressedPixelFormat
+  mipmapCount: number
+  isCubemap: boolean
+}
+
+export class DDSLoader extends CompressedTextureLoader {
+  constructor(manager?: LoadingManager)
+
+  parse(buffer: ArrayBuffer, loadMipmaps: boolean): DDS
+}

package/dist/loaders/DDSLoader.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class DDSLoader extends THREE.CompressedTextureLoader {
+  constructor(manager) {
+    super(manager);
+  }
+  parse(buffer, loadMipmaps) {
+    const dds = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
+    const DDS_MAGIC = 542327876;
+    const DDSD_MIPMAPCOUNT = 131072;
+    const DDSCAPS2_CUBEMAP = 512;
+    const DDSCAPS2_CUBEMAP_POSITIVEX = 1024;
+    const DDSCAPS2_CUBEMAP_NEGATIVEX = 2048;
+    const DDSCAPS2_CUBEMAP_POSITIVEY = 4096;
+    const DDSCAPS2_CUBEMAP_NEGATIVEY = 8192;
+    const DDSCAPS2_CUBEMAP_POSITIVEZ = 16384;
+    const DDSCAPS2_CUBEMAP_NEGATIVEZ = 32768;
+    const 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, width, height) {
+      const dataLength = width * height * 4;
+      const srcBuffer = new Uint8Array(buffer2, dataOffset2, dataLength);
+      const byteArray = new Uint8Array(dataLength);
+      let dst = 0;
+      let src = 0;
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const b = srcBuffer[src];
+          src++;
+          const g = srcBuffer[src];
+          src++;
+          const r = srcBuffer[src];
+          src++;
+          const a = srcBuffer[src];
+          src++;
+          byteArray[dst] = r;
+          dst++;
+          byteArray[dst] = g;
+          dst++;
+          byteArray[dst] = b;
+          dst++;
+          byteArray[dst] = a;
+          dst++;
+        }
+      }
+      return byteArray;
+    }
+    const FOURCC_DXT1 = fourCCToInt32("DXT1");
+    const FOURCC_DXT3 = fourCCToInt32("DXT3");
+    const FOURCC_DXT5 = fourCCToInt32("DXT5");
+    const FOURCC_ETC1 = fourCCToInt32("ETC1");
+    const headerLengthInt = 31;
+    const off_magic = 0;
+    const off_size = 1;
+    const off_flags = 2;
+    const off_height = 3;
+    const off_width = 4;
+    const off_mipmapCount = 7;
+    const off_pfFlags = 20;
+    const off_pfFourCC = 21;
+    const off_RGBBitCount = 22;
+    const off_RBitMask = 23;
+    const off_GBitMask = 24;
+    const off_BBitMask = 25;
+    const off_ABitMask = 26;
+    const off_caps2 = 28;
+    const 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;
+    }
+    let blockBytes;
+    const fourCC = header[off_pfFourCC];
+    let isRGBAUncompressed = false;
+    switch (fourCC) {
+      case FOURCC_DXT1:
+        blockBytes = 8;
+        dds.format = THREE.RGB_S3TC_DXT1_Format;
+        break;
+      case FOURCC_DXT3:
+        blockBytes = 16;
+        dds.format = THREE.RGBA_S3TC_DXT3_Format;
+        break;
+      case FOURCC_DXT5:
+        blockBytes = 16;
+        dds.format = THREE.RGBA_S3TC_DXT5_Format;
+        break;
+      case FOURCC_ETC1:
+        blockBytes = 8;
+        dds.format = THREE.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 = THREE.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]);
+    }
+    const 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];
+    let dataOffset = header[off_size] + 4;
+    const faces = dds.isCubemap ? 6 : 1;
+    for (let face = 0; face < faces; face++) {
+      let width = dds.width;
+      let height = dds.height;
+      for (let i = 0; i < dds.mipmapCount; i++) {
+        let byteArray, dataLength;
+        if (isRGBAUncompressed) {
+          byteArray = loadARGBMip(buffer, dataOffset, width, height);
+          dataLength = byteArray.length;
+        } else {
+          dataLength = Math.max(4, width) / 4 * Math.max(4, height) / 4 * blockBytes;
+          byteArray = new Uint8Array(buffer, dataOffset, dataLength);
+        }
+        const mipmap = { data: byteArray, width, height };
+        dds.mipmaps.push(mipmap);
+        dataOffset += dataLength;
+        width = Math.max(width >> 1, 1);
+        height = Math.max(height >> 1, 1);
+      }
+    }
+    return dds;
+  }
+}
+exports.DDSLoader = DDSLoader;

package/dist/loaders/DDSLoader.mjs

@@ -0,0 +1,148 @@
+import { CompressedTextureLoader, RGBAFormat, RGB_ETC1_Format, RGBA_S3TC_DXT5_Format, RGBA_S3TC_DXT3_Format, RGB_S3TC_DXT1_Format } from "three";
+class DDSLoader extends CompressedTextureLoader {
+  constructor(manager) {
+    super(manager);
+  }
+  parse(buffer, loadMipmaps) {
+    const dds = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
+    const DDS_MAGIC = 542327876;
+    const DDSD_MIPMAPCOUNT = 131072;
+    const DDSCAPS2_CUBEMAP = 512;
+    const DDSCAPS2_CUBEMAP_POSITIVEX = 1024;
+    const DDSCAPS2_CUBEMAP_NEGATIVEX = 2048;
+    const DDSCAPS2_CUBEMAP_POSITIVEY = 4096;
+    const DDSCAPS2_CUBEMAP_NEGATIVEY = 8192;
+    const DDSCAPS2_CUBEMAP_POSITIVEZ = 16384;
+    const DDSCAPS2_CUBEMAP_NEGATIVEZ = 32768;
+    const 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, width, height) {
+      const dataLength = width * height * 4;
+      const srcBuffer = new Uint8Array(buffer2, dataOffset2, dataLength);
+      const byteArray = new Uint8Array(dataLength);
+      let dst = 0;
+      let src = 0;
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const b = srcBuffer[src];
+          src++;
+          const g = srcBuffer[src];
+          src++;
+          const r = srcBuffer[src];
+          src++;
+          const a = srcBuffer[src];
+          src++;
+          byteArray[dst] = r;
+          dst++;
+          byteArray[dst] = g;
+          dst++;
+          byteArray[dst] = b;
+          dst++;
+          byteArray[dst] = a;
+          dst++;
+        }
+      }
+      return byteArray;
+    }
+    const FOURCC_DXT1 = fourCCToInt32("DXT1");
+    const FOURCC_DXT3 = fourCCToInt32("DXT3");
+    const FOURCC_DXT5 = fourCCToInt32("DXT5");
+    const FOURCC_ETC1 = fourCCToInt32("ETC1");
+    const headerLengthInt = 31;
+    const off_magic = 0;
+    const off_size = 1;
+    const off_flags = 2;
+    const off_height = 3;
+    const off_width = 4;
+    const off_mipmapCount = 7;
+    const off_pfFlags = 20;
+    const off_pfFourCC = 21;
+    const off_RGBBitCount = 22;
+    const off_RBitMask = 23;
+    const off_GBitMask = 24;
+    const off_BBitMask = 25;
+    const off_ABitMask = 26;
+    const off_caps2 = 28;
+    const 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;
+    }
+    let blockBytes;
+    const fourCC = header[off_pfFourCC];
+    let 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]);
+    }
+    const 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];
+    let dataOffset = header[off_size] + 4;
+    const faces = dds.isCubemap ? 6 : 1;
+    for (let face = 0; face < faces; face++) {
+      let width = dds.width;
+      let height = dds.height;
+      for (let i = 0; i < dds.mipmapCount; i++) {
+        let byteArray, dataLength;
+        if (isRGBAUncompressed) {
+          byteArray = loadARGBMip(buffer, dataOffset, width, height);
+          dataLength = byteArray.length;
+        } else {
+          dataLength = Math.max(4, width) / 4 * Math.max(4, height) / 4 * blockBytes;
+          byteArray = new Uint8Array(buffer, dataOffset, dataLength);
+        }
+        const mipmap = { data: byteArray, width, height };
+        dds.mipmaps.push(mipmap);
+        dataOffset += dataLength;
+        width = Math.max(width >> 1, 1);
+        height = Math.max(height >> 1, 1);
+      }
+    }
+    return dds;
+  }
+}
+export {
+  DDSLoader
+};

package/dist/loaders/DRACOLoader.d.ts

@@ -0,0 +1,18 @@
+import { Loader, LoadingManager, BufferGeometry } from 'three'
+
+export class DRACOLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (geometry: BufferGeometry) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>
+  setDecoderPath(path: string): DRACOLoader
+  setDecoderConfig(config: object): DRACOLoader
+  setWorkerLimit(workerLimit: number): DRACOLoader
+  preload(): DRACOLoader
+  dispose(): DRACOLoader
+}

package/dist/loaders/DRACOLoader.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const _taskCache = /* @__PURE__ */ new WeakMap();
+class DRACOLoader extends THREE.Loader {
+  constructor(manager) {
+    super(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"
+    };
+  }
+  setDecoderPath(path) {
+    this.decoderPath = path;
+    return this;
+  }
+  setDecoderConfig(config) {
+    this.decoderConfig = config;
+    return this;
+  }
+  setWorkerLimit(workerLimit) {
+    this.workerLimit = workerLimit;
+    return this;
+  }
+  load(url, onLoad, onProgress, onError) {
+    const loader = new THREE.FileLoader(this.manager);
+    loader.setPath(this.path);
+    loader.setResponseType("arraybuffer");
+    loader.setRequestHeader(this.requestHeader);
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(
+      url,
+      (buffer) => {
+        const 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(buffer, callback, attributeIDs, attributeTypes) {
+    const taskConfig = {
+      attributeIDs: attributeIDs || this.defaultAttributeIDs,
+      attributeTypes: attributeTypes || this.defaultAttributeTypes,
+      useUniqueIDs: !!attributeIDs
+    };
+    this.decodeGeometry(buffer, taskConfig).then(callback);
+  }
+  decodeGeometry(buffer, taskConfig) {
+    for (const attribute in taskConfig.attributeTypes) {
+      const type = taskConfig.attributeTypes[attribute];
+      if (type.BYTES_PER_ELEMENT !== void 0) {
+        taskConfig.attributeTypes[attribute] = type.name;
+      }
+    }
+    const taskKey = JSON.stringify(taskConfig);
+    if (_taskCache.has(buffer)) {
+      const cachedTask = _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."
+        );
+      }
+    }
+    let worker;
+    const taskID = this.workerNextTaskID++;
+    const taskCost = buffer.byteLength;
+    const 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);
+      }
+    });
+    _taskCache.set(buffer, {
+      key: taskKey,
+      promise: geometryPending
+    });
+    return geometryPending;
+  }
+  _createGeometry(geometryData) {
+    const geometry = new THREE.BufferGeometry();
+    if (geometryData.index) {
+      geometry.setIndex(new THREE.BufferAttribute(geometryData.index.array, 1));
+    }
+    for (let i = 0; i < geometryData.attributes.length; i++) {
+      const attribute = geometryData.attributes[i];
+      const name = attribute.name;
+      const array = attribute.array;
+      const itemSize = attribute.itemSize;
+      geometry.setAttribute(name, new THREE.BufferAttribute(array, itemSize));
+    }
+    return geometry;
+  }
+  _loadLibrary(url, responseType) {
+    const loader = new THREE.FileLoader(this.manager);
+    loader.setPath(this.decoderPath);
+    loader.setResponseType(responseType);
+    loader.setWithCredentials(this.withCredentials);
+    return new Promise((resolve, reject) => {
+      loader.load(url, resolve, void 0, reject);
+    });
+  }
+  preload() {
+    this._initDecoder();
+    return this;
+  }
+  _initDecoder() {
+    if (this.decoderPending)
+      return this.decoderPending;
+    const useJS = typeof WebAssembly !== "object" || this.decoderConfig.type === "js";
+    const 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) => {
+      const jsContent = libraries[0];
+      if (!useJS) {
+        this.decoderConfig.wasmBinary = libraries[1];
+      }
+      const fn = DRACOWorker.toString();
+      const 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(taskID, taskCost) {
+    return this._initDecoder().then(() => {
+      if (this.workerPool.length < this.workerLimit) {
+        const worker2 = new Worker(this.workerSourceURL);
+        worker2._callbacks = {};
+        worker2._taskCosts = {};
+        worker2._taskLoad = 0;
+        worker2.postMessage({ type: "init", decoderConfig: this.decoderConfig });
+        worker2.onmessage = function(e) {
+          const message = e.data;
+          switch (message.type) {
+            case "decode":
+              worker2._callbacks[message.id].resolve(message);
+              break;
+            case "error":
+              worker2._callbacks[message.id].reject(message);
+              break;
+            default:
+              console.error('THREE.DRACOLoader: Unexpected message, "' + message.type + '"');
+          }
+        };
+        this.workerPool.push(worker2);
+      } else {
+        this.workerPool.sort(function(a, b) {
+          return a._taskLoad > b._taskLoad ? -1 : 1;
+        });
+      }
+      const worker = this.workerPool[this.workerPool.length - 1];
+      worker._taskCosts[taskID] = taskCost;
+      worker._taskLoad += taskCost;
+      return worker;
+    });
+  }
+  _releaseTask(worker, taskID) {
+    worker._taskLoad -= worker._taskCosts[taskID];
+    delete worker._callbacks[taskID];
+    delete worker._taskCosts[taskID];
+  }
+  debug() {
+    console.log(
+      "Task load: ",
+      this.workerPool.map((worker) => worker._taskLoad)
+    );
+  }
+  dispose() {
+    for (let i = 0; i < this.workerPool.length; ++i) {
+      this.workerPool[i].terminate();
+    }
+    this.workerPool.length = 0;
+    return this;
+  }
+}
+function DRACOWorker() {
+  let decoderConfig;
+  let decoderPending;
+  onmessage = function(e) {
+    const 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":
+        const buffer = message.buffer;
+        const taskConfig = message.taskConfig;
+        decoderPending.then((module2) => {
+          const draco = module2.draco;
+          const decoder = new draco.Decoder();
+          const decoderBuffer = new draco.DecoderBuffer();
+          decoderBuffer.Init(new Int8Array(buffer), buffer.byteLength);
+          try {
+            const geometry = decodeGeometry(draco, decoder, decoderBuffer, taskConfig);
+            const 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) {
+    const attributeIDs = taskConfig.attributeIDs;
+    const attributeTypes = taskConfig.attributeTypes;
+    let dracoGeometry;
+    let decodingStatus;
+    const 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());
+    }
+    const geometry = { index: null, attributes: [] };
+    for (const attributeName in attributeIDs) {
+      const attributeType = self[attributeTypes[attributeName]];
+      let attribute;
+      let 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) {
+      geometry.index = decodeIndex(draco, decoder, dracoGeometry);
+    }
+    draco.destroy(dracoGeometry);
+    return geometry;
+  }
+  function decodeIndex(draco, decoder, dracoGeometry) {
+    const numFaces = dracoGeometry.num_faces();
+    const numIndices = numFaces * 3;
+    const byteLength = numIndices * 4;
+    const ptr = draco._malloc(byteLength);
+    decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
+    const index = new Uint32Array(draco.HEAPF32.buffer, ptr, numIndices).slice();
+    draco._free(ptr);
+    return { array: index, itemSize: 1 };
+  }
+  function decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute) {
+    const numComponents = attribute.num_components();
+    const numPoints = dracoGeometry.num_points();
+    const numValues = numPoints * numComponents;
+    const byteLength = numValues * attributeType.BYTES_PER_ELEMENT;
+    const dataType = getDracoDataType(draco, attributeType);
+    const ptr = draco._malloc(byteLength);
+    decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, dataType, byteLength, ptr);
+    const array = new attributeType(draco.HEAPF32.buffer, ptr, numValues).slice();
+    draco._free(ptr);
+    return {
+      name: attributeName,
+      array,
+      itemSize: numComponents
+    };
+  }
+  function getDracoDataType(draco, attributeType) {
+    switch (attributeType) {
+      case Float32Array:
+        return draco.DT_FLOAT32;
+      case Int8Array:
+        return draco.DT_INT8;
+      case Int16Array:
+        return draco.DT_INT16;
+      case Int32Array:
+        return draco.DT_INT32;
+      case Uint8Array:
+        return draco.DT_UINT8;
+      case Uint16Array:
+        return draco.DT_UINT16;
+      case Uint32Array:
+        return draco.DT_UINT32;
+    }
+  }
+}
+exports.DRACOLoader = DRACOLoader;