@draco-rust/decoder 0.1.2 → 0.2.0

package/README.md

@@ -85,36 +85,36 @@ webpack do, emits the worker on its own.
 
 ### With three.js
 
-`createDracoLoader` stands in for three.js's `DRACOLoader`, on the pool. It
-takes three's classes rather than importing three, so it builds with your own
-copy:
+`@draco-rust/decoder/three` exports `DRACOLoader`: three.js's own
+`DRACOLoader`, decoding on this package's workers instead of the Draco decoder
+three fetches with `setDecoderPath`. Everything else is three's class, so it
+goes wherever one is expected, TypeScript included:
 
 ```js
-import * as THREE from "three";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
-import { createDracoLoader } from "@draco-rust/decoder/mesh/three";
+import { DRACOLoader } from "@draco-rust/decoder/mesh/three";
 
-const gltfLoader = new GLTFLoader();
-gltfLoader.setDRACOLoader(createDracoLoader(THREE));
+const gltfLoader = new GLTFLoader().setDRACOLoader(new DRACOLoader());
 const gltf = await gltfLoader.loadAsync("model.glb");
 ```
 
-For a `.drc` file, `await loader.parseAsync(arrayBuffer)` returns a
-`BufferGeometry`, and `parse(buffer, onLoad, onError)` works as DRACOLoader's
-does. Vertex colours from a `.drc` file are converted from sRGB, as
-DRACOLoader converts them, and an attribute whose items are not a multiple of
-four bytes is padded and interleaved, as DRACOLoader pads it since r181. The
-geometry is the one DRACOLoader builds, byte for byte, with one difference: an
-attribute that does not convert to the type asked for -- a negative value
-into a `Uint16Array`, say -- is an error here, where DRACOLoader fills the
-attribute with whatever its failed conversion left in memory. `setWorkerLimit`,
-`preload` and `dispose` are there too. In TypeScript, `setDRACOLoader` expects the `DRACOLoader` class, so cast
-the loader: `createDracoLoader(THREE) as unknown as DRACOLoader`.
+`load`, `parse`, `setWorkerLimit`, `preload` and `dispose` work as three's do,
+and so does the geometry: three builds it, so vertex colours, normalization and
+the padding r181 added follow the three you have. Byte for byte it is the
+geometry three's own loader builds, with one difference: an attribute that
+does not convert to the type asked for -- a negative value into a
+`Uint16Array`, say -- is an error here, where three's loader fills the
+attribute with whatever its failed conversion left in memory.
+
+The constructor takes three's `LoadingManager` and then the pool's options,
+`new DRACOLoader(manager, { workers: 2 })`, or `{ pool }` to share one pool
+between loaders. `three` is a peer dependency, from r150 (`0.150.0`); the
+package's other entries do not need it.
 
 ### From a CDN, without a bundler
 
 ```js
-import init, { parse_drc_bytes } from "https://cdn.jsdelivr.net/npm/@draco-rust/decoder@0.1/mesh/index.js";
+import init, { parse_drc_bytes } from "https://cdn.jsdelivr.net/npm/@draco-rust/decoder@0.2/mesh/index.js";
 await init(); // finds index_bg.wasm next to the script
 ```
 
@@ -141,4 +141,4 @@ For a subpath entry, resolve its own file, for example
 - Licensed under Apache-2.0, like Draco.
 ## This build
 
-`@draco-rust/decoder@0.1.2` was built from draco-rust commit `6bc95d5c`, with draco-core 2.3.2, draco-io 0.6.0, draco-gltf 0.7.0.
+`@draco-rust/decoder@0.2.0` was built from draco-rust commit `8650e1ca`, with draco-core 2.3.2, draco-io 0.6.0, draco-gltf 0.7.0.

package/legacy/three.d.ts

@@ -1,65 +1,19 @@
-import type { DracoArrayType } from './index.js';
+import type { LoadingManager } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import type { DecoderPool, DecoderPoolOptions } from './pool.js';
 
-/**
- * The three.js classes the loader builds with, passed in so the package uses
- * the application's own copy of three: `import * as THREE from "three"` will
- * do. With `InterleavedBuffer` and `InterleavedBufferAttribute`, an attribute
- * whose items are not a multiple of four bytes is padded to one, as DRACOLoader
- * pads it since r181; with `Color` and `ColorManagement`, a `.drc` file's sRGB
- * vertex colours are made linear as DRACOLoader makes them.
- */
-export interface ThreeClasses<Geometry> {
-  BufferGeometry: new () => Geometry;
-  BufferAttribute: new (array: any, itemSize: number, normalized?: boolean) => any;
-  InterleavedBuffer?: new (array: any, stride: number) => any;
-  InterleavedBufferAttribute?: new (buffer: any, itemSize: number, offset: number) => any;
-  Color?: new () => any;
-  /** `colorSpaceToWorking` since three r177, `toWorkingColorSpace` before. */
-  ColorManagement?:
-    | { colorSpaceToWorking(color: any, colorSpace: string): any }
-    | { toWorkingColorSpace(color: any, colorSpace: string): any };
-}
-
-export interface DracoLoaderOptions extends DecoderPoolOptions {
+export interface DRACOLoaderOptions extends DecoderPoolOptions {
   /** A pool to share with other loaders, instead of one of the loader's own. */
   pool?: DecoderPool;
 }
 
-export interface DecodeGeometryOptions {
-  /** three.js attribute name to Draco unique id, as glTF names them. Without
-   * it, `position`, `normal`, `color` and `uv` are read by type. */
-  attributeIDs?: Record<string, number>;
-  /** three.js attribute name to the typed array it comes back in. */
-  attributeTypes?: Record<string, DracoArrayType>;
-  /** `"srgb"` makes vertex colours linear; the default leaves them as stored. */
-  vertexColorSpace?: string;
-}
-
-/** The part of three.js's DRACOLoader that GLTFLoader and `.drc` users call. */
-export interface DracoLoader<Geometry> {
-  readonly pool: DecoderPool;
-  decodeGeometry(buffer: ArrayBuffer | ArrayBufferView, options?: DecodeGeometryOptions): Promise<Geometry>;
-  decodeDracoFile(
-    buffer: ArrayBuffer,
-    callback: (geometry: Geometry) => void,
-    attributeIDs?: Record<string, number> | null,
-    attributeTypes?: Record<string, DracoArrayType> | null,
-    vertexColorSpace?: string,
-    onError?: (error: unknown) => void,
-  ): Promise<void>;
-  parse(buffer: ArrayBuffer, onLoad: (geometry: Geometry) => void, onError?: (error: unknown) => void): void;
-  parseAsync(buffer: ArrayBuffer | ArrayBufferView): Promise<Geometry>;
-  preload(): this;
-  setWorkerLimit(workers: number): this;
-  dispose(): this;
-}
-
 /**
- * A stand-in for three.js's DRACOLoader on the decoder pool:
- * `gltfLoader.setDRACOLoader(createDracoLoader(THREE))`.
+ * three.js's `DRACOLoader`, decoding on this entry's worker pool instead of
+ * the Draco decoder three fetches from `setDecoderPath`. It is three's class,
+ * so it goes wherever one is expected:
+ * `gltfLoader.setDRACOLoader(new DRACOLoader())`.
  */
-export function createDracoLoader<Geometry>(
-  three: ThreeClasses<Geometry>,
-  options?: DracoLoaderOptions,
-): DracoLoader<Geometry>;
+export class DRACOLoader extends ThreeDRACOLoader {
+  constructor(manager?: LoadingManager, options?: DRACOLoaderOptions);
+  readonly pool: DecoderPool;
+}

package/legacy/three.js

@@ -1,123 +1,82 @@
-// What three.js's GLTFLoader and DRACOLoader users call, over the decoder pool.
-// three.js is not imported: the caller hands in the classes, so the package
-// works with whichever copy of three the application bundles.
+// three.js's DRACOLoader, decoding on this entry's worker pool. Everything a
+// caller sees -- load, parse, decodeDracoFile, GLTFLoader's use of it, the
+// geometry it builds -- is three's own class; only the decode is replaced, so
+// the result follows whichever three the application has.
+import { REVISION } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import { createDecoderPool } from './pool.js';
 
-const SRGB = 'srgb';
-const LINEAR_SRGB = 'srgb-linear';
+// From r181 DRACOLoader pads an attribute whose items are not a multiple of
+// four bytes and builds it interleaved, from the stride its worker reports.
+const PADS = Number.parseInt(REVISION, 10) >= 181;
 
-// DRACOLoader's defaults for a `.drc` file, read by attribute type.
-const defaultAttributes = {
-  position: 'POSITION',
-  normal: 'NORMAL',
-  color: 'COLOR',
-  uv: 'TEX_COORD',
-};
-
-export function createDracoLoader(three, options = {}) {
-  const { BufferGeometry, BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute, Color, ColorManagement } =
-    three;
-  if (typeof BufferGeometry !== 'function' || typeof BufferAttribute !== 'function') {
-    throw new TypeError("createDracoLoader needs three.js's BufferGeometry and BufferAttribute");
+function padded(array, itemSize) {
+  const bytes = array.BYTES_PER_ELEMENT;
+  const stride = (Math.ceil((itemSize * bytes) / 4) * 4) / bytes;
+  if (!PADS || stride === itemSize) return { array, stride: itemSize };
+  const count = array.length / itemSize;
+  const out = new array.constructor(count * stride);
+  for (let i = 0; i < count; i += 1) {
+    out.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
   }
-  const pool = options.pool ?? createDecoderPool(options);
-  // The buffer goes to the worker by transfer, which leaves nothing here to
-  // decode a second time; GLTFLoader asks again for a primitive it shares, and
-  // gets the first answer, as DRACOLoader gives it.
-  const tasks = new WeakMap();
+  return { array: out, stride };
+}
 
-  // Vertex colours a `.drc` file stores in sRGB become linear, as DRACOLoader
-  // makes them; without Color and ColorManagement they are left as stored.
-  function toWorkingColorSpace(attribute) {
-    const convert = ColorManagement?.colorSpaceToWorking ?? ColorManagement?.toWorkingColorSpace;
-    if (!Color || !convert) return;
-    const color = new Color();
-    for (let i = 0; i < attribute.count; i += 1) {
-      color.fromBufferAttribute(attribute, i);
-      convert.call(ColorManagement, color, SRGB);
-      attribute.setXYZ(i, color.r, color.g, color.b);
-    }
-  }
+export class DRACOLoader extends ThreeDRACOLoader {
+  #tasks = new WeakMap();
 
-  // An item that is not a multiple of four bytes is padded to one, and the
-  // attribute interleaved over the padding, as DRACOLoader does since r181
-  // for glTF's data alignment rule -- when the classes for it were handed in.
-  function attributeOf(array, itemSize) {
-    const bytes = array.BYTES_PER_ELEMENT;
-    const stride = Math.ceil((itemSize * bytes) / 4) * (4 / bytes);
-    if (stride === itemSize || !InterleavedBuffer || !InterleavedBufferAttribute) {
-      return new BufferAttribute(array, itemSize);
-    }
-    const count = array.length / itemSize;
-    const padded = new array.constructor(count * stride);
-    for (let i = 0; i < count; i += 1) {
-      padded.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
-    }
-    return new InterleavedBufferAttribute(new InterleavedBuffer(padded, stride), itemSize, 0);
+  constructor(manager, options = {}) {
+    super(manager);
+    this.pool = options.pool ?? createDecoderPool(options);
   }
 
-  async function decode(buffer, attributeIDs, attributeTypes, vertexColorSpace) {
-    const byId = !!attributeIDs;
-    const requests = Object.entries(attributeIDs ?? defaultAttributes).map(([name, id]) => ({
+  // The buffer goes to a worker by transfer, which leaves nothing here to
+  // decode again; a second request for it gets the first answer, as three's
+  // own task cache gives it.
+  decodeGeometry(buffer, taskConfig) {
+    const key = JSON.stringify(taskConfig);
+    const cached = this.#tasks.get(buffer);
+    if (cached?.key === key) return cached.promise;
+    if (cached && buffer.byteLength === 0) {
+      return Promise.reject(new Error('THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred.'));
+    }
+    const { attributeIDs, attributeTypes, useUniqueIDs, vertexColorSpace } = taskConfig;
+    const requests = Object.keys(attributeIDs).map((name) => ({
       name,
-      ...(byId ? { id } : { semantic: id }),
-      type: attributeTypes?.[name] ?? 'Float32Array',
+      ...(useUniqueIDs ? { id: attributeIDs[name] } : { semantic: attributeIDs[name] }),
+      type: attributeTypes[name],
     }));
-    const result = await pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer });
-    if (!result.success) throw new Error(result.error);
+    const promise = this.pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer }).then((result) => {
+      if (!result.success) throw new Error(`THREE.DRACOLoader: Decoding failed: ${result.error}`);
+      return this._createGeometry({
+        index: result.index ? { array: result.index, itemSize: 1 } : null,
+        attributes: result.attributes.map(({ name, array, itemSize }) => ({
+          name,
+          itemSize,
+          ...padded(array, itemSize),
+          ...(name === 'color' ? { vertexColorSpace } : {}),
+        })),
+      });
+    });
+    if (buffer instanceof ArrayBuffer) this.#tasks.set(buffer, { key, promise });
+    return promise;
+  }
 
-    const geometry = new BufferGeometry();
-    if (result.index) geometry.setIndex(new BufferAttribute(result.index, 1));
-    for (const { name, array, itemSize } of result.attributes) {
-      const attribute = attributeOf(array, itemSize);
-      if (name === 'color') {
-        if (vertexColorSpace === SRGB) toWorkingColorSpace(attribute);
-        attribute.normalized = !(array instanceof Float32Array);
-      }
-      geometry.setAttribute(name, attribute);
-    }
-    return geometry;
+  setWorkerLimit(workerLimit) {
+    super.setWorkerLimit(workerLimit);
+    this.pool.setWorkerLimit(workerLimit);
+    return this;
   }
 
-  function decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB } = {}) {
-    const key = JSON.stringify([attributeIDs ?? null, attributeTypes ?? null, vertexColorSpace]);
-    const cached = buffer instanceof ArrayBuffer ? tasks.get(buffer) : undefined;
-    if (cached?.key === key) return cached.promise;
-    if (cached && buffer.byteLength === 0) {
-      return Promise.reject(new Error('this buffer was already decoded with other settings and handed to a worker'));
-    }
-    const promise = decode(buffer, attributeIDs, attributeTypes, vertexColorSpace);
-    if (buffer instanceof ArrayBuffer) tasks.set(buffer, { key, promise });
-    return promise;
+  preload() {
+    // A failure shows again on the first decode, which is where it is handled.
+    this.pool.preload().catch(() => {});
+    return this;
   }
 
-  const loader = {
-    pool,
-    decodeGeometry,
-    /** DRACOLoader's entry for GLTFLoader's `KHR_draco_mesh_compression`. */
-    decodeDracoFile(buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB, onError = () => {}) {
-      return decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace }).then(callback).catch(onError);
-    },
-    /** A `.drc` file's contents, as DRACOLoader's `parse`. */
-    parse(buffer, onLoad, onError = () => {}) {
-      loader.decodeDracoFile(buffer, onLoad, null, null, SRGB, onError);
-    },
-    parseAsync(buffer) {
-      return decodeGeometry(buffer, { vertexColorSpace: SRGB });
-    },
-    preload() {
-      // A failure shows again on the first decode, which is where it is handled.
-      pool.preload().catch(() => {});
-      return loader;
-    },
-    setWorkerLimit(workers) {
-      pool.setWorkerLimit(workers);
-      return loader;
-    },
-    dispose() {
-      pool.dispose();
-      return loader;
-    },
-  };
-  return loader;
+  dispose() {
+    super.dispose();
+    this.pool.dispose();
+    return this;
+  }
 }

package/mesh/three.d.ts

@@ -1,65 +1,19 @@
-import type { DracoArrayType } from './index.js';
+import type { LoadingManager } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import type { DecoderPool, DecoderPoolOptions } from './pool.js';
 
-/**
- * The three.js classes the loader builds with, passed in so the package uses
- * the application's own copy of three: `import * as THREE from "three"` will
- * do. With `InterleavedBuffer` and `InterleavedBufferAttribute`, an attribute
- * whose items are not a multiple of four bytes is padded to one, as DRACOLoader
- * pads it since r181; with `Color` and `ColorManagement`, a `.drc` file's sRGB
- * vertex colours are made linear as DRACOLoader makes them.
- */
-export interface ThreeClasses<Geometry> {
-  BufferGeometry: new () => Geometry;
-  BufferAttribute: new (array: any, itemSize: number, normalized?: boolean) => any;
-  InterleavedBuffer?: new (array: any, stride: number) => any;
-  InterleavedBufferAttribute?: new (buffer: any, itemSize: number, offset: number) => any;
-  Color?: new () => any;
-  /** `colorSpaceToWorking` since three r177, `toWorkingColorSpace` before. */
-  ColorManagement?:
-    | { colorSpaceToWorking(color: any, colorSpace: string): any }
-    | { toWorkingColorSpace(color: any, colorSpace: string): any };
-}
-
-export interface DracoLoaderOptions extends DecoderPoolOptions {
+export interface DRACOLoaderOptions extends DecoderPoolOptions {
   /** A pool to share with other loaders, instead of one of the loader's own. */
   pool?: DecoderPool;
 }
 
-export interface DecodeGeometryOptions {
-  /** three.js attribute name to Draco unique id, as glTF names them. Without
-   * it, `position`, `normal`, `color` and `uv` are read by type. */
-  attributeIDs?: Record<string, number>;
-  /** three.js attribute name to the typed array it comes back in. */
-  attributeTypes?: Record<string, DracoArrayType>;
-  /** `"srgb"` makes vertex colours linear; the default leaves them as stored. */
-  vertexColorSpace?: string;
-}
-
-/** The part of three.js's DRACOLoader that GLTFLoader and `.drc` users call. */
-export interface DracoLoader<Geometry> {
-  readonly pool: DecoderPool;
-  decodeGeometry(buffer: ArrayBuffer | ArrayBufferView, options?: DecodeGeometryOptions): Promise<Geometry>;
-  decodeDracoFile(
-    buffer: ArrayBuffer,
-    callback: (geometry: Geometry) => void,
-    attributeIDs?: Record<string, number> | null,
-    attributeTypes?: Record<string, DracoArrayType> | null,
-    vertexColorSpace?: string,
-    onError?: (error: unknown) => void,
-  ): Promise<void>;
-  parse(buffer: ArrayBuffer, onLoad: (geometry: Geometry) => void, onError?: (error: unknown) => void): void;
-  parseAsync(buffer: ArrayBuffer | ArrayBufferView): Promise<Geometry>;
-  preload(): this;
-  setWorkerLimit(workers: number): this;
-  dispose(): this;
-}
-
 /**
- * A stand-in for three.js's DRACOLoader on the decoder pool:
- * `gltfLoader.setDRACOLoader(createDracoLoader(THREE))`.
+ * three.js's `DRACOLoader`, decoding on this entry's worker pool instead of
+ * the Draco decoder three fetches from `setDecoderPath`. It is three's class,
+ * so it goes wherever one is expected:
+ * `gltfLoader.setDRACOLoader(new DRACOLoader())`.
  */
-export function createDracoLoader<Geometry>(
-  three: ThreeClasses<Geometry>,
-  options?: DracoLoaderOptions,
-): DracoLoader<Geometry>;
+export class DRACOLoader extends ThreeDRACOLoader {
+  constructor(manager?: LoadingManager, options?: DRACOLoaderOptions);
+  readonly pool: DecoderPool;
+}

package/mesh/three.js

@@ -1,123 +1,82 @@
-// What three.js's GLTFLoader and DRACOLoader users call, over the decoder pool.
-// three.js is not imported: the caller hands in the classes, so the package
-// works with whichever copy of three the application bundles.
+// three.js's DRACOLoader, decoding on this entry's worker pool. Everything a
+// caller sees -- load, parse, decodeDracoFile, GLTFLoader's use of it, the
+// geometry it builds -- is three's own class; only the decode is replaced, so
+// the result follows whichever three the application has.
+import { REVISION } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import { createDecoderPool } from './pool.js';
 
-const SRGB = 'srgb';
-const LINEAR_SRGB = 'srgb-linear';
+// From r181 DRACOLoader pads an attribute whose items are not a multiple of
+// four bytes and builds it interleaved, from the stride its worker reports.
+const PADS = Number.parseInt(REVISION, 10) >= 181;
 
-// DRACOLoader's defaults for a `.drc` file, read by attribute type.
-const defaultAttributes = {
-  position: 'POSITION',
-  normal: 'NORMAL',
-  color: 'COLOR',
-  uv: 'TEX_COORD',
-};
-
-export function createDracoLoader(three, options = {}) {
-  const { BufferGeometry, BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute, Color, ColorManagement } =
-    three;
-  if (typeof BufferGeometry !== 'function' || typeof BufferAttribute !== 'function') {
-    throw new TypeError("createDracoLoader needs three.js's BufferGeometry and BufferAttribute");
+function padded(array, itemSize) {
+  const bytes = array.BYTES_PER_ELEMENT;
+  const stride = (Math.ceil((itemSize * bytes) / 4) * 4) / bytes;
+  if (!PADS || stride === itemSize) return { array, stride: itemSize };
+  const count = array.length / itemSize;
+  const out = new array.constructor(count * stride);
+  for (let i = 0; i < count; i += 1) {
+    out.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
   }
-  const pool = options.pool ?? createDecoderPool(options);
-  // The buffer goes to the worker by transfer, which leaves nothing here to
-  // decode a second time; GLTFLoader asks again for a primitive it shares, and
-  // gets the first answer, as DRACOLoader gives it.
-  const tasks = new WeakMap();
+  return { array: out, stride };
+}
 
-  // Vertex colours a `.drc` file stores in sRGB become linear, as DRACOLoader
-  // makes them; without Color and ColorManagement they are left as stored.
-  function toWorkingColorSpace(attribute) {
-    const convert = ColorManagement?.colorSpaceToWorking ?? ColorManagement?.toWorkingColorSpace;
-    if (!Color || !convert) return;
-    const color = new Color();
-    for (let i = 0; i < attribute.count; i += 1) {
-      color.fromBufferAttribute(attribute, i);
-      convert.call(ColorManagement, color, SRGB);
-      attribute.setXYZ(i, color.r, color.g, color.b);
-    }
-  }
+export class DRACOLoader extends ThreeDRACOLoader {
+  #tasks = new WeakMap();
 
-  // An item that is not a multiple of four bytes is padded to one, and the
-  // attribute interleaved over the padding, as DRACOLoader does since r181
-  // for glTF's data alignment rule -- when the classes for it were handed in.
-  function attributeOf(array, itemSize) {
-    const bytes = array.BYTES_PER_ELEMENT;
-    const stride = Math.ceil((itemSize * bytes) / 4) * (4 / bytes);
-    if (stride === itemSize || !InterleavedBuffer || !InterleavedBufferAttribute) {
-      return new BufferAttribute(array, itemSize);
-    }
-    const count = array.length / itemSize;
-    const padded = new array.constructor(count * stride);
-    for (let i = 0; i < count; i += 1) {
-      padded.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
-    }
-    return new InterleavedBufferAttribute(new InterleavedBuffer(padded, stride), itemSize, 0);
+  constructor(manager, options = {}) {
+    super(manager);
+    this.pool = options.pool ?? createDecoderPool(options);
   }
 
-  async function decode(buffer, attributeIDs, attributeTypes, vertexColorSpace) {
-    const byId = !!attributeIDs;
-    const requests = Object.entries(attributeIDs ?? defaultAttributes).map(([name, id]) => ({
+  // The buffer goes to a worker by transfer, which leaves nothing here to
+  // decode again; a second request for it gets the first answer, as three's
+  // own task cache gives it.
+  decodeGeometry(buffer, taskConfig) {
+    const key = JSON.stringify(taskConfig);
+    const cached = this.#tasks.get(buffer);
+    if (cached?.key === key) return cached.promise;
+    if (cached && buffer.byteLength === 0) {
+      return Promise.reject(new Error('THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred.'));
+    }
+    const { attributeIDs, attributeTypes, useUniqueIDs, vertexColorSpace } = taskConfig;
+    const requests = Object.keys(attributeIDs).map((name) => ({
       name,
-      ...(byId ? { id } : { semantic: id }),
-      type: attributeTypes?.[name] ?? 'Float32Array',
+      ...(useUniqueIDs ? { id: attributeIDs[name] } : { semantic: attributeIDs[name] }),
+      type: attributeTypes[name],
     }));
-    const result = await pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer });
-    if (!result.success) throw new Error(result.error);
+    const promise = this.pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer }).then((result) => {
+      if (!result.success) throw new Error(`THREE.DRACOLoader: Decoding failed: ${result.error}`);
+      return this._createGeometry({
+        index: result.index ? { array: result.index, itemSize: 1 } : null,
+        attributes: result.attributes.map(({ name, array, itemSize }) => ({
+          name,
+          itemSize,
+          ...padded(array, itemSize),
+          ...(name === 'color' ? { vertexColorSpace } : {}),
+        })),
+      });
+    });
+    if (buffer instanceof ArrayBuffer) this.#tasks.set(buffer, { key, promise });
+    return promise;
+  }
 
-    const geometry = new BufferGeometry();
-    if (result.index) geometry.setIndex(new BufferAttribute(result.index, 1));
-    for (const { name, array, itemSize } of result.attributes) {
-      const attribute = attributeOf(array, itemSize);
-      if (name === 'color') {
-        if (vertexColorSpace === SRGB) toWorkingColorSpace(attribute);
-        attribute.normalized = !(array instanceof Float32Array);
-      }
-      geometry.setAttribute(name, attribute);
-    }
-    return geometry;
+  setWorkerLimit(workerLimit) {
+    super.setWorkerLimit(workerLimit);
+    this.pool.setWorkerLimit(workerLimit);
+    return this;
   }
 
-  function decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB } = {}) {
-    const key = JSON.stringify([attributeIDs ?? null, attributeTypes ?? null, vertexColorSpace]);
-    const cached = buffer instanceof ArrayBuffer ? tasks.get(buffer) : undefined;
-    if (cached?.key === key) return cached.promise;
-    if (cached && buffer.byteLength === 0) {
-      return Promise.reject(new Error('this buffer was already decoded with other settings and handed to a worker'));
-    }
-    const promise = decode(buffer, attributeIDs, attributeTypes, vertexColorSpace);
-    if (buffer instanceof ArrayBuffer) tasks.set(buffer, { key, promise });
-    return promise;
+  preload() {
+    // A failure shows again on the first decode, which is where it is handled.
+    this.pool.preload().catch(() => {});
+    return this;
   }
 
-  const loader = {
-    pool,
-    decodeGeometry,
-    /** DRACOLoader's entry for GLTFLoader's `KHR_draco_mesh_compression`. */
-    decodeDracoFile(buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB, onError = () => {}) {
-      return decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace }).then(callback).catch(onError);
-    },
-    /** A `.drc` file's contents, as DRACOLoader's `parse`. */
-    parse(buffer, onLoad, onError = () => {}) {
-      loader.decodeDracoFile(buffer, onLoad, null, null, SRGB, onError);
-    },
-    parseAsync(buffer) {
-      return decodeGeometry(buffer, { vertexColorSpace: SRGB });
-    },
-    preload() {
-      // A failure shows again on the first decode, which is where it is handled.
-      pool.preload().catch(() => {});
-      return loader;
-    },
-    setWorkerLimit(workers) {
-      pool.setWorkerLimit(workers);
-      return loader;
-    },
-    dispose() {
-      pool.dispose();
-      return loader;
-    },
-  };
-  return loader;
+  dispose() {
+    super.dispose();
+    this.pool.dispose();
+    return this;
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@draco-rust/decoder",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Draco geometry decoder in WebAssembly, a safe Rust port of Google Draco: meshes, point clouds and older bitstreams, each as its own small entry.",
   "keywords": [
     "draco",
@@ -24,7 +24,7 @@
     "directory": "web/npm/decoder"
   },
   "draco-rust": {
-    "commit": "6bc95d5c",
+    "commit": "8650e1ca",
     "draco-core": "2.3.2",
     "draco-io": "0.6.0",
     "draco-gltf": "0.7.0"
@@ -72,6 +72,14 @@
     "**/*.d.ts",
     "**/*.wasm"
   ],
+  "peerDependencies": {
+    "three": ">=0.150.0"
+  },
+  "peerDependenciesMeta": {
+    "three": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   }

package/point-cloud/three.d.ts

@@ -1,65 +1,19 @@
-import type { DracoArrayType } from './index.js';
+import type { LoadingManager } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import type { DecoderPool, DecoderPoolOptions } from './pool.js';
 
-/**
- * The three.js classes the loader builds with, passed in so the package uses
- * the application's own copy of three: `import * as THREE from "three"` will
- * do. With `InterleavedBuffer` and `InterleavedBufferAttribute`, an attribute
- * whose items are not a multiple of four bytes is padded to one, as DRACOLoader
- * pads it since r181; with `Color` and `ColorManagement`, a `.drc` file's sRGB
- * vertex colours are made linear as DRACOLoader makes them.
- */
-export interface ThreeClasses<Geometry> {
-  BufferGeometry: new () => Geometry;
-  BufferAttribute: new (array: any, itemSize: number, normalized?: boolean) => any;
-  InterleavedBuffer?: new (array: any, stride: number) => any;
-  InterleavedBufferAttribute?: new (buffer: any, itemSize: number, offset: number) => any;
-  Color?: new () => any;
-  /** `colorSpaceToWorking` since three r177, `toWorkingColorSpace` before. */
-  ColorManagement?:
-    | { colorSpaceToWorking(color: any, colorSpace: string): any }
-    | { toWorkingColorSpace(color: any, colorSpace: string): any };
-}
-
-export interface DracoLoaderOptions extends DecoderPoolOptions {
+export interface DRACOLoaderOptions extends DecoderPoolOptions {
   /** A pool to share with other loaders, instead of one of the loader's own. */
   pool?: DecoderPool;
 }
 
-export interface DecodeGeometryOptions {
-  /** three.js attribute name to Draco unique id, as glTF names them. Without
-   * it, `position`, `normal`, `color` and `uv` are read by type. */
-  attributeIDs?: Record<string, number>;
-  /** three.js attribute name to the typed array it comes back in. */
-  attributeTypes?: Record<string, DracoArrayType>;
-  /** `"srgb"` makes vertex colours linear; the default leaves them as stored. */
-  vertexColorSpace?: string;
-}
-
-/** The part of three.js's DRACOLoader that GLTFLoader and `.drc` users call. */
-export interface DracoLoader<Geometry> {
-  readonly pool: DecoderPool;
-  decodeGeometry(buffer: ArrayBuffer | ArrayBufferView, options?: DecodeGeometryOptions): Promise<Geometry>;
-  decodeDracoFile(
-    buffer: ArrayBuffer,
-    callback: (geometry: Geometry) => void,
-    attributeIDs?: Record<string, number> | null,
-    attributeTypes?: Record<string, DracoArrayType> | null,
-    vertexColorSpace?: string,
-    onError?: (error: unknown) => void,
-  ): Promise<void>;
-  parse(buffer: ArrayBuffer, onLoad: (geometry: Geometry) => void, onError?: (error: unknown) => void): void;
-  parseAsync(buffer: ArrayBuffer | ArrayBufferView): Promise<Geometry>;
-  preload(): this;
-  setWorkerLimit(workers: number): this;
-  dispose(): this;
-}
-
 /**
- * A stand-in for three.js's DRACOLoader on the decoder pool:
- * `gltfLoader.setDRACOLoader(createDracoLoader(THREE))`.
+ * three.js's `DRACOLoader`, decoding on this entry's worker pool instead of
+ * the Draco decoder three fetches from `setDecoderPath`. It is three's class,
+ * so it goes wherever one is expected:
+ * `gltfLoader.setDRACOLoader(new DRACOLoader())`.
  */
-export function createDracoLoader<Geometry>(
-  three: ThreeClasses<Geometry>,
-  options?: DracoLoaderOptions,
-): DracoLoader<Geometry>;
+export class DRACOLoader extends ThreeDRACOLoader {
+  constructor(manager?: LoadingManager, options?: DRACOLoaderOptions);
+  readonly pool: DecoderPool;
+}

package/point-cloud/three.js

@@ -1,123 +1,82 @@
-// What three.js's GLTFLoader and DRACOLoader users call, over the decoder pool.
-// three.js is not imported: the caller hands in the classes, so the package
-// works with whichever copy of three the application bundles.
+// three.js's DRACOLoader, decoding on this entry's worker pool. Everything a
+// caller sees -- load, parse, decodeDracoFile, GLTFLoader's use of it, the
+// geometry it builds -- is three's own class; only the decode is replaced, so
+// the result follows whichever three the application has.
+import { REVISION } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import { createDecoderPool } from './pool.js';
 
-const SRGB = 'srgb';
-const LINEAR_SRGB = 'srgb-linear';
+// From r181 DRACOLoader pads an attribute whose items are not a multiple of
+// four bytes and builds it interleaved, from the stride its worker reports.
+const PADS = Number.parseInt(REVISION, 10) >= 181;
 
-// DRACOLoader's defaults for a `.drc` file, read by attribute type.
-const defaultAttributes = {
-  position: 'POSITION',
-  normal: 'NORMAL',
-  color: 'COLOR',
-  uv: 'TEX_COORD',
-};
-
-export function createDracoLoader(three, options = {}) {
-  const { BufferGeometry, BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute, Color, ColorManagement } =
-    three;
-  if (typeof BufferGeometry !== 'function' || typeof BufferAttribute !== 'function') {
-    throw new TypeError("createDracoLoader needs three.js's BufferGeometry and BufferAttribute");
+function padded(array, itemSize) {
+  const bytes = array.BYTES_PER_ELEMENT;
+  const stride = (Math.ceil((itemSize * bytes) / 4) * 4) / bytes;
+  if (!PADS || stride === itemSize) return { array, stride: itemSize };
+  const count = array.length / itemSize;
+  const out = new array.constructor(count * stride);
+  for (let i = 0; i < count; i += 1) {
+    out.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
   }
-  const pool = options.pool ?? createDecoderPool(options);
-  // The buffer goes to the worker by transfer, which leaves nothing here to
-  // decode a second time; GLTFLoader asks again for a primitive it shares, and
-  // gets the first answer, as DRACOLoader gives it.
-  const tasks = new WeakMap();
+  return { array: out, stride };
+}
 
-  // Vertex colours a `.drc` file stores in sRGB become linear, as DRACOLoader
-  // makes them; without Color and ColorManagement they are left as stored.
-  function toWorkingColorSpace(attribute) {
-    const convert = ColorManagement?.colorSpaceToWorking ?? ColorManagement?.toWorkingColorSpace;
-    if (!Color || !convert) return;
-    const color = new Color();
-    for (let i = 0; i < attribute.count; i += 1) {
-      color.fromBufferAttribute(attribute, i);
-      convert.call(ColorManagement, color, SRGB);
-      attribute.setXYZ(i, color.r, color.g, color.b);
-    }
-  }
+export class DRACOLoader extends ThreeDRACOLoader {
+  #tasks = new WeakMap();
 
-  // An item that is not a multiple of four bytes is padded to one, and the
-  // attribute interleaved over the padding, as DRACOLoader does since r181
-  // for glTF's data alignment rule -- when the classes for it were handed in.
-  function attributeOf(array, itemSize) {
-    const bytes = array.BYTES_PER_ELEMENT;
-    const stride = Math.ceil((itemSize * bytes) / 4) * (4 / bytes);
-    if (stride === itemSize || !InterleavedBuffer || !InterleavedBufferAttribute) {
-      return new BufferAttribute(array, itemSize);
-    }
-    const count = array.length / itemSize;
-    const padded = new array.constructor(count * stride);
-    for (let i = 0; i < count; i += 1) {
-      padded.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
-    }
-    return new InterleavedBufferAttribute(new InterleavedBuffer(padded, stride), itemSize, 0);
+  constructor(manager, options = {}) {
+    super(manager);
+    this.pool = options.pool ?? createDecoderPool(options);
   }
 
-  async function decode(buffer, attributeIDs, attributeTypes, vertexColorSpace) {
-    const byId = !!attributeIDs;
-    const requests = Object.entries(attributeIDs ?? defaultAttributes).map(([name, id]) => ({
+  // The buffer goes to a worker by transfer, which leaves nothing here to
+  // decode again; a second request for it gets the first answer, as three's
+  // own task cache gives it.
+  decodeGeometry(buffer, taskConfig) {
+    const key = JSON.stringify(taskConfig);
+    const cached = this.#tasks.get(buffer);
+    if (cached?.key === key) return cached.promise;
+    if (cached && buffer.byteLength === 0) {
+      return Promise.reject(new Error('THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred.'));
+    }
+    const { attributeIDs, attributeTypes, useUniqueIDs, vertexColorSpace } = taskConfig;
+    const requests = Object.keys(attributeIDs).map((name) => ({
       name,
-      ...(byId ? { id } : { semantic: id }),
-      type: attributeTypes?.[name] ?? 'Float32Array',
+      ...(useUniqueIDs ? { id: attributeIDs[name] } : { semantic: attributeIDs[name] }),
+      type: attributeTypes[name],
     }));
-    const result = await pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer });
-    if (!result.success) throw new Error(result.error);
+    const promise = this.pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer }).then((result) => {
+      if (!result.success) throw new Error(`THREE.DRACOLoader: Decoding failed: ${result.error}`);
+      return this._createGeometry({
+        index: result.index ? { array: result.index, itemSize: 1 } : null,
+        attributes: result.attributes.map(({ name, array, itemSize }) => ({
+          name,
+          itemSize,
+          ...padded(array, itemSize),
+          ...(name === 'color' ? { vertexColorSpace } : {}),
+        })),
+      });
+    });
+    if (buffer instanceof ArrayBuffer) this.#tasks.set(buffer, { key, promise });
+    return promise;
+  }
 
-    const geometry = new BufferGeometry();
-    if (result.index) geometry.setIndex(new BufferAttribute(result.index, 1));
-    for (const { name, array, itemSize } of result.attributes) {
-      const attribute = attributeOf(array, itemSize);
-      if (name === 'color') {
-        if (vertexColorSpace === SRGB) toWorkingColorSpace(attribute);
-        attribute.normalized = !(array instanceof Float32Array);
-      }
-      geometry.setAttribute(name, attribute);
-    }
-    return geometry;
+  setWorkerLimit(workerLimit) {
+    super.setWorkerLimit(workerLimit);
+    this.pool.setWorkerLimit(workerLimit);
+    return this;
   }
 
-  function decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB } = {}) {
-    const key = JSON.stringify([attributeIDs ?? null, attributeTypes ?? null, vertexColorSpace]);
-    const cached = buffer instanceof ArrayBuffer ? tasks.get(buffer) : undefined;
-    if (cached?.key === key) return cached.promise;
-    if (cached && buffer.byteLength === 0) {
-      return Promise.reject(new Error('this buffer was already decoded with other settings and handed to a worker'));
-    }
-    const promise = decode(buffer, attributeIDs, attributeTypes, vertexColorSpace);
-    if (buffer instanceof ArrayBuffer) tasks.set(buffer, { key, promise });
-    return promise;
+  preload() {
+    // A failure shows again on the first decode, which is where it is handled.
+    this.pool.preload().catch(() => {});
+    return this;
   }
 
-  const loader = {
-    pool,
-    decodeGeometry,
-    /** DRACOLoader's entry for GLTFLoader's `KHR_draco_mesh_compression`. */
-    decodeDracoFile(buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB, onError = () => {}) {
-      return decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace }).then(callback).catch(onError);
-    },
-    /** A `.drc` file's contents, as DRACOLoader's `parse`. */
-    parse(buffer, onLoad, onError = () => {}) {
-      loader.decodeDracoFile(buffer, onLoad, null, null, SRGB, onError);
-    },
-    parseAsync(buffer) {
-      return decodeGeometry(buffer, { vertexColorSpace: SRGB });
-    },
-    preload() {
-      // A failure shows again on the first decode, which is where it is handled.
-      pool.preload().catch(() => {});
-      return loader;
-    },
-    setWorkerLimit(workers) {
-      pool.setWorkerLimit(workers);
-      return loader;
-    },
-    dispose() {
-      pool.dispose();
-      return loader;
-    },
-  };
-  return loader;
+  dispose() {
+    super.dispose();
+    this.pool.dispose();
+    return this;
+  }
 }

package/three.d.ts

@@ -1,65 +1,19 @@
-import type { DracoArrayType } from './index.js';
+import type { LoadingManager } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import type { DecoderPool, DecoderPoolOptions } from './pool.js';
 
-/**
- * The three.js classes the loader builds with, passed in so the package uses
- * the application's own copy of three: `import * as THREE from "three"` will
- * do. With `InterleavedBuffer` and `InterleavedBufferAttribute`, an attribute
- * whose items are not a multiple of four bytes is padded to one, as DRACOLoader
- * pads it since r181; with `Color` and `ColorManagement`, a `.drc` file's sRGB
- * vertex colours are made linear as DRACOLoader makes them.
- */
-export interface ThreeClasses<Geometry> {
-  BufferGeometry: new () => Geometry;
-  BufferAttribute: new (array: any, itemSize: number, normalized?: boolean) => any;
-  InterleavedBuffer?: new (array: any, stride: number) => any;
-  InterleavedBufferAttribute?: new (buffer: any, itemSize: number, offset: number) => any;
-  Color?: new () => any;
-  /** `colorSpaceToWorking` since three r177, `toWorkingColorSpace` before. */
-  ColorManagement?:
-    | { colorSpaceToWorking(color: any, colorSpace: string): any }
-    | { toWorkingColorSpace(color: any, colorSpace: string): any };
-}
-
-export interface DracoLoaderOptions extends DecoderPoolOptions {
+export interface DRACOLoaderOptions extends DecoderPoolOptions {
   /** A pool to share with other loaders, instead of one of the loader's own. */
   pool?: DecoderPool;
 }
 
-export interface DecodeGeometryOptions {
-  /** three.js attribute name to Draco unique id, as glTF names them. Without
-   * it, `position`, `normal`, `color` and `uv` are read by type. */
-  attributeIDs?: Record<string, number>;
-  /** three.js attribute name to the typed array it comes back in. */
-  attributeTypes?: Record<string, DracoArrayType>;
-  /** `"srgb"` makes vertex colours linear; the default leaves them as stored. */
-  vertexColorSpace?: string;
-}
-
-/** The part of three.js's DRACOLoader that GLTFLoader and `.drc` users call. */
-export interface DracoLoader<Geometry> {
-  readonly pool: DecoderPool;
-  decodeGeometry(buffer: ArrayBuffer | ArrayBufferView, options?: DecodeGeometryOptions): Promise<Geometry>;
-  decodeDracoFile(
-    buffer: ArrayBuffer,
-    callback: (geometry: Geometry) => void,
-    attributeIDs?: Record<string, number> | null,
-    attributeTypes?: Record<string, DracoArrayType> | null,
-    vertexColorSpace?: string,
-    onError?: (error: unknown) => void,
-  ): Promise<void>;
-  parse(buffer: ArrayBuffer, onLoad: (geometry: Geometry) => void, onError?: (error: unknown) => void): void;
-  parseAsync(buffer: ArrayBuffer | ArrayBufferView): Promise<Geometry>;
-  preload(): this;
-  setWorkerLimit(workers: number): this;
-  dispose(): this;
-}
-
 /**
- * A stand-in for three.js's DRACOLoader on the decoder pool:
- * `gltfLoader.setDRACOLoader(createDracoLoader(THREE))`.
+ * three.js's `DRACOLoader`, decoding on this entry's worker pool instead of
+ * the Draco decoder three fetches from `setDecoderPath`. It is three's class,
+ * so it goes wherever one is expected:
+ * `gltfLoader.setDRACOLoader(new DRACOLoader())`.
  */
-export function createDracoLoader<Geometry>(
-  three: ThreeClasses<Geometry>,
-  options?: DracoLoaderOptions,
-): DracoLoader<Geometry>;
+export class DRACOLoader extends ThreeDRACOLoader {
+  constructor(manager?: LoadingManager, options?: DRACOLoaderOptions);
+  readonly pool: DecoderPool;
+}

package/three.js

@@ -1,123 +1,82 @@
-// What three.js's GLTFLoader and DRACOLoader users call, over the decoder pool.
-// three.js is not imported: the caller hands in the classes, so the package
-// works with whichever copy of three the application bundles.
+// three.js's DRACOLoader, decoding on this entry's worker pool. Everything a
+// caller sees -- load, parse, decodeDracoFile, GLTFLoader's use of it, the
+// geometry it builds -- is three's own class; only the decode is replaced, so
+// the result follows whichever three the application has.
+import { REVISION } from 'three';
+import { DRACOLoader as ThreeDRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
 import { createDecoderPool } from './pool.js';
 
-const SRGB = 'srgb';
-const LINEAR_SRGB = 'srgb-linear';
+// From r181 DRACOLoader pads an attribute whose items are not a multiple of
+// four bytes and builds it interleaved, from the stride its worker reports.
+const PADS = Number.parseInt(REVISION, 10) >= 181;
 
-// DRACOLoader's defaults for a `.drc` file, read by attribute type.
-const defaultAttributes = {
-  position: 'POSITION',
-  normal: 'NORMAL',
-  color: 'COLOR',
-  uv: 'TEX_COORD',
-};
-
-export function createDracoLoader(three, options = {}) {
-  const { BufferGeometry, BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute, Color, ColorManagement } =
-    three;
-  if (typeof BufferGeometry !== 'function' || typeof BufferAttribute !== 'function') {
-    throw new TypeError("createDracoLoader needs three.js's BufferGeometry and BufferAttribute");
+function padded(array, itemSize) {
+  const bytes = array.BYTES_PER_ELEMENT;
+  const stride = (Math.ceil((itemSize * bytes) / 4) * 4) / bytes;
+  if (!PADS || stride === itemSize) return { array, stride: itemSize };
+  const count = array.length / itemSize;
+  const out = new array.constructor(count * stride);
+  for (let i = 0; i < count; i += 1) {
+    out.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
   }
-  const pool = options.pool ?? createDecoderPool(options);
-  // The buffer goes to the worker by transfer, which leaves nothing here to
-  // decode a second time; GLTFLoader asks again for a primitive it shares, and
-  // gets the first answer, as DRACOLoader gives it.
-  const tasks = new WeakMap();
+  return { array: out, stride };
+}
 
-  // Vertex colours a `.drc` file stores in sRGB become linear, as DRACOLoader
-  // makes them; without Color and ColorManagement they are left as stored.
-  function toWorkingColorSpace(attribute) {
-    const convert = ColorManagement?.colorSpaceToWorking ?? ColorManagement?.toWorkingColorSpace;
-    if (!Color || !convert) return;
-    const color = new Color();
-    for (let i = 0; i < attribute.count; i += 1) {
-      color.fromBufferAttribute(attribute, i);
-      convert.call(ColorManagement, color, SRGB);
-      attribute.setXYZ(i, color.r, color.g, color.b);
-    }
-  }
+export class DRACOLoader extends ThreeDRACOLoader {
+  #tasks = new WeakMap();
 
-  // An item that is not a multiple of four bytes is padded to one, and the
-  // attribute interleaved over the padding, as DRACOLoader does since r181
-  // for glTF's data alignment rule -- when the classes for it were handed in.
-  function attributeOf(array, itemSize) {
-    const bytes = array.BYTES_PER_ELEMENT;
-    const stride = Math.ceil((itemSize * bytes) / 4) * (4 / bytes);
-    if (stride === itemSize || !InterleavedBuffer || !InterleavedBufferAttribute) {
-      return new BufferAttribute(array, itemSize);
-    }
-    const count = array.length / itemSize;
-    const padded = new array.constructor(count * stride);
-    for (let i = 0; i < count; i += 1) {
-      padded.set(array.subarray(i * itemSize, (i + 1) * itemSize), i * stride);
-    }
-    return new InterleavedBufferAttribute(new InterleavedBuffer(padded, stride), itemSize, 0);
+  constructor(manager, options = {}) {
+    super(manager);
+    this.pool = options.pool ?? createDecoderPool(options);
   }
 
-  async function decode(buffer, attributeIDs, attributeTypes, vertexColorSpace) {
-    const byId = !!attributeIDs;
-    const requests = Object.entries(attributeIDs ?? defaultAttributes).map(([name, id]) => ({
+  // The buffer goes to a worker by transfer, which leaves nothing here to
+  // decode again; a second request for it gets the first answer, as three's
+  // own task cache gives it.
+  decodeGeometry(buffer, taskConfig) {
+    const key = JSON.stringify(taskConfig);
+    const cached = this.#tasks.get(buffer);
+    if (cached?.key === key) return cached.promise;
+    if (cached && buffer.byteLength === 0) {
+      return Promise.reject(new Error('THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred.'));
+    }
+    const { attributeIDs, attributeTypes, useUniqueIDs, vertexColorSpace } = taskConfig;
+    const requests = Object.keys(attributeIDs).map((name) => ({
       name,
-      ...(byId ? { id } : { semantic: id }),
-      type: attributeTypes?.[name] ?? 'Float32Array',
+      ...(useUniqueIDs ? { id: attributeIDs[name] } : { semantic: attributeIDs[name] }),
+      type: attributeTypes[name],
     }));
-    const result = await pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer });
-    if (!result.success) throw new Error(result.error);
+    const promise = this.pool.decode(buffer, requests, { transfer: buffer instanceof ArrayBuffer }).then((result) => {
+      if (!result.success) throw new Error(`THREE.DRACOLoader: Decoding failed: ${result.error}`);
+      return this._createGeometry({
+        index: result.index ? { array: result.index, itemSize: 1 } : null,
+        attributes: result.attributes.map(({ name, array, itemSize }) => ({
+          name,
+          itemSize,
+          ...padded(array, itemSize),
+          ...(name === 'color' ? { vertexColorSpace } : {}),
+        })),
+      });
+    });
+    if (buffer instanceof ArrayBuffer) this.#tasks.set(buffer, { key, promise });
+    return promise;
+  }
 
-    const geometry = new BufferGeometry();
-    if (result.index) geometry.setIndex(new BufferAttribute(result.index, 1));
-    for (const { name, array, itemSize } of result.attributes) {
-      const attribute = attributeOf(array, itemSize);
-      if (name === 'color') {
-        if (vertexColorSpace === SRGB) toWorkingColorSpace(attribute);
-        attribute.normalized = !(array instanceof Float32Array);
-      }
-      geometry.setAttribute(name, attribute);
-    }
-    return geometry;
+  setWorkerLimit(workerLimit) {
+    super.setWorkerLimit(workerLimit);
+    this.pool.setWorkerLimit(workerLimit);
+    return this;
   }
 
-  function decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB } = {}) {
-    const key = JSON.stringify([attributeIDs ?? null, attributeTypes ?? null, vertexColorSpace]);
-    const cached = buffer instanceof ArrayBuffer ? tasks.get(buffer) : undefined;
-    if (cached?.key === key) return cached.promise;
-    if (cached && buffer.byteLength === 0) {
-      return Promise.reject(new Error('this buffer was already decoded with other settings and handed to a worker'));
-    }
-    const promise = decode(buffer, attributeIDs, attributeTypes, vertexColorSpace);
-    if (buffer instanceof ArrayBuffer) tasks.set(buffer, { key, promise });
-    return promise;
+  preload() {
+    // A failure shows again on the first decode, which is where it is handled.
+    this.pool.preload().catch(() => {});
+    return this;
   }
 
-  const loader = {
-    pool,
-    decodeGeometry,
-    /** DRACOLoader's entry for GLTFLoader's `KHR_draco_mesh_compression`. */
-    decodeDracoFile(buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = LINEAR_SRGB, onError = () => {}) {
-      return decodeGeometry(buffer, { attributeIDs, attributeTypes, vertexColorSpace }).then(callback).catch(onError);
-    },
-    /** A `.drc` file's contents, as DRACOLoader's `parse`. */
-    parse(buffer, onLoad, onError = () => {}) {
-      loader.decodeDracoFile(buffer, onLoad, null, null, SRGB, onError);
-    },
-    parseAsync(buffer) {
-      return decodeGeometry(buffer, { vertexColorSpace: SRGB });
-    },
-    preload() {
-      // A failure shows again on the first decode, which is where it is handled.
-      pool.preload().catch(() => {});
-      return loader;
-    },
-    setWorkerLimit(workers) {
-      pool.setWorkerLimit(workers);
-      return loader;
-    },
-    dispose() {
-      pool.dispose();
-      return loader;
-    },
-  };
-  return loader;
+  dispose() {
+    super.dispose();
+    this.pool.dispose();
+    return this;
+  }
 }