@loaders.gl/scene 5.0.0-alpha.9 → 5.0.0-beta.2

package/dist/draco/draco-writer.cjs

@@ -0,0 +1,183 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/draco/draco-writer.ts
+var draco_writer_exports = {};
+__export(draco_writer_exports, {
+  DracoWriter: () => DracoWriter,
+  DracoWriterWorker: () => DracoWriterWorker,
+  encodeDraco: () => encodeDraco,
+  encodeDracoBatch: () => encodeDracoBatch,
+  encodeDracoInBatches: () => encodeDracoInBatches,
+  encodeDracoInBatchesLocally: () => encodeDracoInBatchesLocally
+});
+module.exports = __toCommonJS(draco_writer_exports);
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_worker_utils = require("@loaders.gl/core/worker-utils");
+var import_draco_builder = __toESM(require("./lib/draco-builder.cjs"), 1);
+var import_draco_module_loader = require("./lib/draco-module-loader.cjs");
+var import_version = require("./lib/utils/version.cjs");
+var import_draco_format = require("./draco-format.cjs");
+var DEFAULT_DRACO_WRITER_OPTIONS = {
+  pointcloud: false,
+  // Set to true if pointcloud (mode: 0, no indices)
+  attributeNameEntry: "name"
+  // Draco Compression Parameters
+  // method: 'MESH_EDGEBREAKER_ENCODING', // Use draco defaults
+  // speed: [5, 5], // Use draco defaults
+  // quantization: { // Use draco defaults
+  //   POSITION: 10
+  // }
+};
+var DracoWriterWorker = {
+  ...import_draco_format.DracoFormat,
+  id: "draco-writer",
+  name: "Draco compressed geometry writer",
+  module: "scene",
+  version: import_version.VERSION,
+  worker: true,
+  workerNode: "draco-writer-worker-node.cjs",
+  /** Node test workers live with the Draco implementation. */
+  workerSourceNode: "draco/workers/draco-writer-worker-node.ts",
+  options: {
+    draco: {}
+  }
+};
+var DracoWriter = {
+  ...import_draco_format.DracoFormat,
+  name: "DRACO",
+  version: import_version.VERSION,
+  options: {
+    draco: DEFAULT_DRACO_WRITER_OPTIONS
+  },
+  encode,
+  encodeInBatches
+};
+async function encode(data, options = {}) {
+  return (await encodeDraco(data, options)).data;
+}
+async function encodeDraco(data, options = {}) {
+  const { draco } = await (0, import_draco_module_loader.loadDracoEncoderModule)((0, import_worker_utils.extractLoadLibraryOptions)(options));
+  const dracoBuilder = new import_draco_builder.default(draco);
+  try {
+    return dracoBuilder.encodeSyncWithReport(normalizeDracoMesh(data), options.draco);
+  } finally {
+    dracoBuilder.destroy();
+  }
+}
+async function encodeDracoBatch(data, options = {}) {
+  throwIfAborted(options.signal);
+  const results = [];
+  let completed = 0;
+  for await (const result of encodeDracoInBatches([data], options)) {
+    results.push(result);
+    completed++;
+    options.onProgress?.({ completed, total: data.length });
+  }
+  return results;
+}
+function encodeDracoInBatches(data, options = {}) {
+  const normalizedData = normalizeDracoInputBatches(data);
+  if ((0, import_loader_utils.canEncodeWithWorker)(DracoWriterWorker, options)) {
+    const { onProgress: _onProgress, ...workerOptions } = options;
+    return (0, import_worker_utils.processOnWorkerInBatches)(
+      DracoWriterWorker,
+      normalizedData,
+      workerOptions
+    );
+  }
+  return encodeDracoInBatchesLocally(normalizedData, options);
+}
+async function* encodeInBatches(data, options = {}) {
+  const geometryBatches = (async function* () {
+    for await (const geometry of data) {
+      yield [geometry];
+    }
+  })();
+  for await (const result of encodeDracoInBatches(geometryBatches, options)) {
+    yield result.data;
+  }
+}
+async function* encodeDracoInBatchesLocally(data, options = {}) {
+  const { draco } = await (0, import_draco_module_loader.loadDracoEncoderModule)((0, import_worker_utils.extractLoadLibraryOptions)(options));
+  const dracoBuilder = new import_draco_builder.default(draco);
+  try {
+    for await (const batch of data) {
+      for (const geometry of batch) {
+        throwIfAborted(options.signal);
+        yield dracoBuilder.encodeSyncWithReport(geometry, options.draco);
+      }
+    }
+  } finally {
+    dracoBuilder.destroy();
+  }
+}
+async function* normalizeDracoInputBatches(data) {
+  for await (const batch of data) {
+    yield batch.map(normalizeDracoMesh);
+  }
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) {
+    return;
+  }
+  if (signal.reason !== void 0) {
+    throw signal.reason;
+  }
+  const error = new Error("Draco batch encoding aborted");
+  error.name = "AbortError";
+  throw error;
+}
+function normalizeDracoMesh(data) {
+  if (isMeshArrowTable(data)) {
+    return (0, import_schema_utils.convertTableToMesh)(data);
+  }
+  if (isDracoBuilderMesh(data)) {
+    return data;
+  }
+  const { indices, ...attributes } = data;
+  return { attributes, ...indices ? { indices } : {} };
+}
+function isMeshArrowTable(data) {
+  return typeof data === "object" && data !== null && "shape" in data && data.shape === "arrow-table";
+}
+function isDracoBuilderMesh(data) {
+  return typeof data === "object" && data !== null && "attributes" in data && typeof data.attributes === "object" && data.attributes !== null && !ArrayBuffer.isView(data.attributes);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DracoWriter,
+  DracoWriterWorker,
+  encodeDraco,
+  encodeDracoBatch,
+  encodeDracoInBatches,
+  encodeDracoInBatchesLocally
+});
+//# sourceMappingURL=draco-writer.cjs.map

package/dist/draco/draco-writer.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/draco/draco-writer.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {\n  canEncodeWithWorker,\n  type WriterWithEncoder,\n  type WriterOptions\n} from '@loaders.gl/core/loader-utils';\nimport type {Mesh, MeshArrowTable, TypedArray} from '@loaders.gl/core/schema';\nimport {convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport {extractLoadLibraryOptions, processOnWorkerInBatches} from '@loaders.gl/core/worker-utils';\nimport type {DracoMesh} from './lib/draco-types';\nimport type {DracoBuilderMesh, DracoBuildOptions, DracoEncodingResult} from './lib/draco-builder';\nimport DRACOBuilder from './lib/draco-builder';\nimport {loadDracoEncoderModule} from './lib/draco-module-loader';\nimport {VERSION} from './lib/utils/version';\nimport {DracoFormat} from './draco-format';\n\n/** Legacy flat attribute map accepted by `DracoWriter`. */\nexport type DracoWriterAttributes = Record<string, TypedArray>;\n\n/** Inputs accepted by `DracoWriter`. */\nexport type DracoWriterInput =\n  | DracoMesh\n  | Mesh\n  | MeshArrowTable\n  | DracoBuilderMesh\n  | DracoWriterAttributes;\n\n/** Options for `DracoWriter`. */\nexport type DracoWriterOptions = WriterOptions & {\n  /** Draco-specific writer options. */\n  draco?: DracoBuildOptions;\n};\n\n/** Progress notification emitted after each geometry in a batch. */\nexport type DracoBatchProgress = {\n  /** Number of geometries completed. */\n  completed: number;\n  /** Total number of geometries in the batch. */\n  total: number;\n};\n\n/** Options for cancellable, progress-reporting batch encoding. */\nexport type DracoBatchOptions = DracoWriterOptions & {\n  /** Abort signal checked between native encoding operations. */\n  signal?: AbortSignal;\n  /** Called after each geometry is encoded. */\n  onProgress?: (progress: DracoBatchProgress) => void;\n};\n\n/** A batch of Draco-writable geometries. */\nexport type DracoWriterInputBatch = DracoWriterInput[];\n\nconst DEFAULT_DRACO_WRITER_OPTIONS = {\n  pointcloud: false, // Set to true if pointcloud (mode: 0, no indices)\n  attributeNameEntry: 'name'\n  // Draco Compression Parameters\n  // method: 'MESH_EDGEBREAKER_ENCODING', // Use draco defaults\n  // speed: [5, 5], // Use draco defaults\n  // quantization: { // Use draco defaults\n  //   POSITION: 10\n  // }\n};\n\n/** Worker-enabled exporter for Draco3D compressed geometries. */\nexport const DracoWriterWorker = {\n  ...DracoFormat,\n  id: 'draco-writer',\n  name: 'Draco compressed geometry writer',\n  module: 'scene',\n  version: VERSION,\n  worker: true,\n  workerNode: 'draco-writer-worker-node.cjs',\n  /** Node test workers live with the Draco implementation. */\n  workerSourceNode: 'draco/workers/draco-writer-worker-node.ts',\n  options: {\n    draco: {}\n  }\n};\n\n/**\n * Exporter for Draco3D compressed geometries\n */\nexport const DracoWriter = {\n  ...DracoFormat,\n  name: 'DRACO',\n  version: VERSION,\n  options: {\n    draco: DEFAULT_DRACO_WRITER_OPTIONS\n  },\n  encode,\n  encodeInBatches\n} as const satisfies WriterWithEncoder<DracoWriterInput, unknown, DracoWriterOptions>;\n\n/** Encode Draco mesh category data. */\nasync function encode(\n  data: DracoWriterInput,\n  options: DracoWriterOptions = {}\n): Promise<ArrayBuffer> {\n  return (await encodeDraco(data, options)).data;\n}\n\n/** Encodes Draco geometry and returns bytes together with native encoding diagnostics. */\nexport async function encodeDraco(\n  data: DracoWriterInput,\n  options: DracoWriterOptions = {}\n): Promise<DracoEncodingResult> {\n  // Dynamically load draco\n  const {draco} = await loadDracoEncoderModule(extractLoadLibraryOptions(options));\n  const dracoBuilder = new DRACOBuilder(draco);\n\n  try {\n    return dracoBuilder.encodeSyncWithReport(normalizeDracoMesh(data), options.draco);\n  } finally {\n    dracoBuilder.destroy();\n  }\n}\n\n/**\n * Encodes multiple geometries while loading and initializing the Draco runtime once.\n *\n * The input geometries are processed sequentially to keep peak native memory bounded.\n * Each result is independent and uses the same writer options.\n */\nexport async function encodeDracoBatch(\n  data: DracoWriterInput[],\n  options: DracoBatchOptions = {}\n): Promise<DracoEncodingResult[]> {\n  throwIfAborted(options.signal);\n  const results: DracoEncodingResult[] = [];\n  let completed = 0;\n  for await (const result of encodeDracoInBatches([data], options)) {\n    results.push(result);\n    completed++;\n    options.onProgress?.({completed, total: data.length});\n  }\n  return results;\n}\n\n/**\n * Encodes geometry batches while retaining one encoder runtime and one worker\n * lease for the complete input iterator.\n *\n * Worker mode is selected with `worker: true` and the normal Draco writer\n * worker options. Set `worker: false` to keep the operation local.\n */\nexport function encodeDracoInBatches(\n  data: AsyncIterable<DracoWriterInputBatch> | Iterable<DracoWriterInputBatch>,\n  options: DracoBatchOptions = {}\n): AsyncIterable<DracoEncodingResult> {\n  const normalizedData = normalizeDracoInputBatches(data);\n  if (canEncodeWithWorker(DracoWriterWorker, options)) {\n    const {onProgress: _onProgress, ...workerOptions} = options;\n    return processOnWorkerInBatches<DracoBuilderMesh[], DracoEncodingResult>(\n      DracoWriterWorker,\n      normalizedData,\n      workerOptions\n    );\n  }\n  return encodeDracoInBatchesLocally(normalizedData, options);\n}\n\n/** Encodes batches through the public writer's ArrayBuffer-only batch API. */\nasync function* encodeInBatches(\n  data: AsyncIterable<DracoWriterInput> | Iterable<DracoWriterInput>,\n  options: DracoBatchOptions = {}\n): AsyncIterable<ArrayBuffer> {\n  const geometryBatches = (async function* () {\n    for await (const geometry of data) {\n      yield [geometry];\n    }\n  })();\n  for await (const result of encodeDracoInBatches(geometryBatches, options)) {\n    yield result.data;\n  }\n}\n\n/** Worker-safe local implementation that initializes Draco exactly once. */\nexport async function* encodeDracoInBatchesLocally(\n  data: AsyncIterable<DracoBuilderMesh[]> | Iterable<DracoBuilderMesh[]>,\n  options: DracoBatchOptions = {}\n): AsyncIterable<DracoEncodingResult> {\n  const {draco} = await loadDracoEncoderModule(extractLoadLibraryOptions(options));\n  const dracoBuilder = new DRACOBuilder(draco);\n  try {\n    for await (const batch of data) {\n      for (const geometry of batch) {\n        throwIfAborted(options.signal);\n        yield dracoBuilder.encodeSyncWithReport(geometry, options.draco);\n      }\n    }\n  } finally {\n    dracoBuilder.destroy();\n  }\n}\n\n/** Converts any accepted input batch into structured-clone-safe builder meshes. */\nasync function* normalizeDracoInputBatches(\n  data: AsyncIterable<DracoWriterInputBatch> | Iterable<DracoWriterInputBatch>\n): AsyncIterable<DracoBuilderMesh[]> {\n  for await (const batch of data) {\n    yield batch.map(normalizeDracoMesh);\n  }\n}\n\n/** Throws the signal's reason before starting or between native encodes. */\nfunction throwIfAborted(signal: AbortSignal | undefined): void {\n  if (!signal?.aborted) {\n    return;\n  }\n  if (signal.reason !== undefined) {\n    throw signal.reason;\n  }\n  const error = new Error('Draco batch encoding aborted');\n  error.name = 'AbortError';\n  throw error;\n}\n\n/** Returns Draco-writable mesh data without copying ordinary Mesh attributes. */\nfunction normalizeDracoMesh(data: DracoWriterInput): DracoBuilderMesh {\n  if (isMeshArrowTable(data)) {\n    return convertTableToMesh(data);\n  }\n\n  if (isDracoBuilderMesh(data)) {\n    return data;\n  }\n\n  const {indices, ...attributes} = data;\n  return {attributes, ...(indices ? {indices} : {})};\n}\n\n/** Return true when the input is MeshArrowTable category data. */\nfunction isMeshArrowTable(data: unknown): data is MeshArrowTable {\n  return (\n    typeof data === 'object' && data !== null && 'shape' in data && data.shape === 'arrow-table'\n  );\n}\n\n/** Returns true when input uses the nested Mesh attribute representation. */\nfunction isDracoBuilderMesh(data: DracoWriterInput): data is DracoBuilderMesh | Mesh | DracoMesh {\n  return (\n    typeof data === 'object' &&\n    data !== null &&\n    'attributes' in data &&\n    typeof data.attributes === 'object' &&\n    data.attributes !== null &&\n    !ArrayBuffer.isView(data.attributes)\n  );\n}\n"],
+  "mappings": "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",
+  "names": ["DRACOBuilder"]
+}

package/dist/draco/draco-writer.d.ts

@@ -0,0 +1,97 @@
+import { type WriterOptions } from '@loaders.gl/core/loader-utils';
+import type { Mesh, MeshArrowTable, TypedArray } from '@loaders.gl/core/schema';
+import type { DracoMesh } from "./lib/draco-types.js";
+import type { DracoBuilderMesh, DracoBuildOptions, DracoEncodingResult } from "./lib/draco-builder.js";
+/** Legacy flat attribute map accepted by `DracoWriter`. */
+export type DracoWriterAttributes = Record<string, TypedArray>;
+/** Inputs accepted by `DracoWriter`. */
+export type DracoWriterInput = DracoMesh | Mesh | MeshArrowTable | DracoBuilderMesh | DracoWriterAttributes;
+/** Options for `DracoWriter`. */
+export type DracoWriterOptions = WriterOptions & {
+    /** Draco-specific writer options. */
+    draco?: DracoBuildOptions;
+};
+/** Progress notification emitted after each geometry in a batch. */
+export type DracoBatchProgress = {
+    /** Number of geometries completed. */
+    completed: number;
+    /** Total number of geometries in the batch. */
+    total: number;
+};
+/** Options for cancellable, progress-reporting batch encoding. */
+export type DracoBatchOptions = DracoWriterOptions & {
+    /** Abort signal checked between native encoding operations. */
+    signal?: AbortSignal;
+    /** Called after each geometry is encoded. */
+    onProgress?: (progress: DracoBatchProgress) => void;
+};
+/** A batch of Draco-writable geometries. */
+export type DracoWriterInputBatch = DracoWriterInput[];
+/** Worker-enabled exporter for Draco3D compressed geometries. */
+export declare const DracoWriterWorker: {
+    id: string;
+    name: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    workerNode: string;
+    /** Node test workers live with the Draco implementation. */
+    workerSourceNode: string;
+    options: {
+        draco: {};
+    };
+    encoding: "binary";
+    format: "draco";
+    extensions: ["drc"];
+    mimeTypes: ["application/octet-stream"];
+    binary: true;
+    tests: ["DRACO"];
+};
+/**
+ * Exporter for Draco3D compressed geometries
+ */
+export declare const DracoWriter: {
+    readonly name: "DRACO";
+    readonly version: any;
+    readonly options: {
+        readonly draco: {
+            pointcloud: boolean;
+            attributeNameEntry: string;
+        };
+    };
+    readonly encode: typeof encode;
+    readonly encodeInBatches: typeof encodeInBatches;
+    readonly id: "draco";
+    readonly module: "scene";
+    readonly encoding: "binary";
+    readonly format: "draco";
+    readonly extensions: ["drc"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly binary: true;
+    readonly tests: ["DRACO"];
+};
+/** Encode Draco mesh category data. */
+declare function encode(data: DracoWriterInput, options?: DracoWriterOptions): Promise<ArrayBuffer>;
+/** Encodes Draco geometry and returns bytes together with native encoding diagnostics. */
+export declare function encodeDraco(data: DracoWriterInput, options?: DracoWriterOptions): Promise<DracoEncodingResult>;
+/**
+ * Encodes multiple geometries while loading and initializing the Draco runtime once.
+ *
+ * The input geometries are processed sequentially to keep peak native memory bounded.
+ * Each result is independent and uses the same writer options.
+ */
+export declare function encodeDracoBatch(data: DracoWriterInput[], options?: DracoBatchOptions): Promise<DracoEncodingResult[]>;
+/**
+ * Encodes geometry batches while retaining one encoder runtime and one worker
+ * lease for the complete input iterator.
+ *
+ * Worker mode is selected with `worker: true` and the normal Draco writer
+ * worker options. Set `worker: false` to keep the operation local.
+ */
+export declare function encodeDracoInBatches(data: AsyncIterable<DracoWriterInputBatch> | Iterable<DracoWriterInputBatch>, options?: DracoBatchOptions): AsyncIterable<DracoEncodingResult>;
+/** Encodes batches through the public writer's ArrayBuffer-only batch API. */
+declare function encodeInBatches(data: AsyncIterable<DracoWriterInput> | Iterable<DracoWriterInput>, options?: DracoBatchOptions): AsyncIterable<ArrayBuffer>;
+/** Worker-safe local implementation that initializes Draco exactly once. */
+export declare function encodeDracoInBatchesLocally(data: AsyncIterable<DracoBuilderMesh[]> | Iterable<DracoBuilderMesh[]>, options?: DracoBatchOptions): AsyncIterable<DracoEncodingResult>;
+export {};
+//# sourceMappingURL=draco-writer.d.ts.map

package/dist/draco/draco-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draco-writer.d.ts","sourceRoot":"","sources":["../../src/draco/draco-writer.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAC,IAAI,EAAE,cAAc,EAAE,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAG9E,OAAO,KAAK,EAAC,SAAS,EAAC,6BAA0B;AACjD,OAAO,KAAK,EAAC,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB,EAAC,+BAA4B;AAMlG,2DAA2D;AAC3D,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAE/D,wCAAwC;AACxC,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,IAAI,GACJ,cAAc,GACd,gBAAgB,GAChB,qBAAqB,CAAC;AAE1B,iCAAiC;AACjC,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,qCAAqC;IACrC,KAAK,CAAC,EAAE,iBAAiB,CAAC;CAC3B,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,GAAG;IACnD,+DAA+D;IAC/D,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACrD,CAAC;AAEF,4CAA4C;AAC5C,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,EAAE,CAAC;AAavD,iEAAiE;AACjE,eAAO,MAAM,iBAAiB;;;;;;;IAQ5B,4DAA4D;;;;;;;;;;;CAK7D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;CAS6D,CAAC;AAEtF,uCAAuC;AACvC,iBAAe,MAAM,CACnB,IAAI,EAAE,gBAAgB,EACtB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,WAAW,CAAC,CAEtB;AAED,0FAA0F;AAC1F,wBAAsB,WAAW,CAC/B,IAAI,EAAE,gBAAgB,EACtB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CAU9B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,gBAAgB,EAAE,EACxB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAUhC;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,CAAC,qBAAqB,CAAC,GAAG,QAAQ,CAAC,qBAAqB,CAAC,EAC5E,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CAAC,mBAAmB,CAAC,CAWpC;AAED,8EAA8E;AAC9E,iBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,QAAQ,CAAC,gBAAgB,CAAC,EAClE,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CAAC,WAAW,CAAC,CAS5B;AAED,4EAA4E;AAC5E,wBAAuB,2BAA2B,CAChD,IAAI,EAAE,aAAa,CAAC,gBAAgB,EAAE,CAAC,GAAG,QAAQ,CAAC,gBAAgB,EAAE,CAAC,EACtE,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CAAC,mBAAmB,CAAC,CAapC"}

package/dist/draco/draco-writer.js

@@ -0,0 +1,166 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { canEncodeWithWorker } from '@loaders.gl/core/loader-utils';
+import { convertTableToMesh } from '@loaders.gl/core/schema-utils';
+import { extractLoadLibraryOptions, processOnWorkerInBatches } from '@loaders.gl/core/worker-utils';
+import DRACOBuilder from "./lib/draco-builder.js";
+import { loadDracoEncoderModule } from "./lib/draco-module-loader.js";
+import { VERSION } from "./lib/utils/version.js";
+import { DracoFormat } from "./draco-format.js";
+const DEFAULT_DRACO_WRITER_OPTIONS = {
+    pointcloud: false, // Set to true if pointcloud (mode: 0, no indices)
+    attributeNameEntry: 'name'
+    // Draco Compression Parameters
+    // method: 'MESH_EDGEBREAKER_ENCODING', // Use draco defaults
+    // speed: [5, 5], // Use draco defaults
+    // quantization: { // Use draco defaults
+    //   POSITION: 10
+    // }
+};
+/** Worker-enabled exporter for Draco3D compressed geometries. */
+export const DracoWriterWorker = {
+    ...DracoFormat,
+    id: 'draco-writer',
+    name: 'Draco compressed geometry writer',
+    module: 'scene',
+    version: VERSION,
+    worker: true,
+    workerNode: 'draco-writer-worker-node.cjs',
+    /** Node test workers live with the Draco implementation. */
+    workerSourceNode: 'draco/workers/draco-writer-worker-node.ts',
+    options: {
+        draco: {}
+    }
+};
+/**
+ * Exporter for Draco3D compressed geometries
+ */
+export const DracoWriter = {
+    ...DracoFormat,
+    name: 'DRACO',
+    version: VERSION,
+    options: {
+        draco: DEFAULT_DRACO_WRITER_OPTIONS
+    },
+    encode,
+    encodeInBatches
+};
+/** Encode Draco mesh category data. */
+async function encode(data, options = {}) {
+    return (await encodeDraco(data, options)).data;
+}
+/** Encodes Draco geometry and returns bytes together with native encoding diagnostics. */
+export async function encodeDraco(data, options = {}) {
+    // Dynamically load draco
+    const { draco } = await loadDracoEncoderModule(extractLoadLibraryOptions(options));
+    const dracoBuilder = new DRACOBuilder(draco);
+    try {
+        return dracoBuilder.encodeSyncWithReport(normalizeDracoMesh(data), options.draco);
+    }
+    finally {
+        dracoBuilder.destroy();
+    }
+}
+/**
+ * Encodes multiple geometries while loading and initializing the Draco runtime once.
+ *
+ * The input geometries are processed sequentially to keep peak native memory bounded.
+ * Each result is independent and uses the same writer options.
+ */
+export async function encodeDracoBatch(data, options = {}) {
+    throwIfAborted(options.signal);
+    const results = [];
+    let completed = 0;
+    for await (const result of encodeDracoInBatches([data], options)) {
+        results.push(result);
+        completed++;
+        options.onProgress?.({ completed, total: data.length });
+    }
+    return results;
+}
+/**
+ * Encodes geometry batches while retaining one encoder runtime and one worker
+ * lease for the complete input iterator.
+ *
+ * Worker mode is selected with `worker: true` and the normal Draco writer
+ * worker options. Set `worker: false` to keep the operation local.
+ */
+export function encodeDracoInBatches(data, options = {}) {
+    const normalizedData = normalizeDracoInputBatches(data);
+    if (canEncodeWithWorker(DracoWriterWorker, options)) {
+        const { onProgress: _onProgress, ...workerOptions } = options;
+        return processOnWorkerInBatches(DracoWriterWorker, normalizedData, workerOptions);
+    }
+    return encodeDracoInBatchesLocally(normalizedData, options);
+}
+/** Encodes batches through the public writer's ArrayBuffer-only batch API. */
+async function* encodeInBatches(data, options = {}) {
+    const geometryBatches = (async function* () {
+        for await (const geometry of data) {
+            yield [geometry];
+        }
+    })();
+    for await (const result of encodeDracoInBatches(geometryBatches, options)) {
+        yield result.data;
+    }
+}
+/** Worker-safe local implementation that initializes Draco exactly once. */
+export async function* encodeDracoInBatchesLocally(data, options = {}) {
+    const { draco } = await loadDracoEncoderModule(extractLoadLibraryOptions(options));
+    const dracoBuilder = new DRACOBuilder(draco);
+    try {
+        for await (const batch of data) {
+            for (const geometry of batch) {
+                throwIfAborted(options.signal);
+                yield dracoBuilder.encodeSyncWithReport(geometry, options.draco);
+            }
+        }
+    }
+    finally {
+        dracoBuilder.destroy();
+    }
+}
+/** Converts any accepted input batch into structured-clone-safe builder meshes. */
+async function* normalizeDracoInputBatches(data) {
+    for await (const batch of data) {
+        yield batch.map(normalizeDracoMesh);
+    }
+}
+/** Throws the signal's reason before starting or between native encodes. */
+function throwIfAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    if (signal.reason !== undefined) {
+        throw signal.reason;
+    }
+    const error = new Error('Draco batch encoding aborted');
+    error.name = 'AbortError';
+    throw error;
+}
+/** Returns Draco-writable mesh data without copying ordinary Mesh attributes. */
+function normalizeDracoMesh(data) {
+    if (isMeshArrowTable(data)) {
+        return convertTableToMesh(data);
+    }
+    if (isDracoBuilderMesh(data)) {
+        return data;
+    }
+    const { indices, ...attributes } = data;
+    return { attributes, ...(indices ? { indices } : {}) };
+}
+/** Return true when the input is MeshArrowTable category data. */
+function isMeshArrowTable(data) {
+    return (typeof data === 'object' && data !== null && 'shape' in data && data.shape === 'arrow-table');
+}
+/** Returns true when input uses the nested Mesh attribute representation. */
+function isDracoBuilderMesh(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'attributes' in data &&
+        typeof data.attributes === 'object' &&
+        data.attributes !== null &&
+        !ArrayBuffer.isView(data.attributes));
+}
+//# sourceMappingURL=draco-writer.js.map

package/dist/draco/draco-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"draco-writer.js","sourceRoot":"","sources":["../../src/draco/draco-writer.ts"],"names":[],"mappings":"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"}

package/dist/draco/draco3d/draco3d-types.cjs

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/draco/draco3d/draco3d-types.ts
+var draco3d_types_exports = {};
+__export(draco3d_types_exports, {
+  draco_DataType: () => draco_DataType,
+  draco_EncodedGeometryType: () => draco_EncodedGeometryType,
+  draco_GeometryAttribute_Type: () => draco_GeometryAttribute_Type,
+  draco_StatusCode: () => draco_StatusCode
+});
+module.exports = __toCommonJS(draco3d_types_exports);
+var draco_GeometryAttribute_Type = /* @__PURE__ */ ((draco_GeometryAttribute_Type2) => {
+  draco_GeometryAttribute_Type2[draco_GeometryAttribute_Type2["draco_GeometryAttribute::INVALID"] = 0] = "draco_GeometryAttribute::INVALID";
+  draco_GeometryAttribute_Type2[draco_GeometryAttribute_Type2["draco_GeometryAttribute::POSITION"] = 1] = "draco_GeometryAttribute::POSITION";
+  draco_GeometryAttribute_Type2[draco_GeometryAttribute_Type2["draco_GeometryAttribute::NORMAL"] = 2] = "draco_GeometryAttribute::NORMAL";
+  draco_GeometryAttribute_Type2[draco_GeometryAttribute_Type2["draco_GeometryAttribute::COLOR"] = 3] = "draco_GeometryAttribute::COLOR";
+  draco_GeometryAttribute_Type2[draco_GeometryAttribute_Type2["draco_GeometryAttribute::TEX_COORD"] = 4] = "draco_GeometryAttribute::TEX_COORD";
+  draco_GeometryAttribute_Type2[draco_GeometryAttribute_Type2["draco_GeometryAttribute::GENERIC"] = 5] = "draco_GeometryAttribute::GENERIC";
+  return draco_GeometryAttribute_Type2;
+})(draco_GeometryAttribute_Type || {});
+var draco_EncodedGeometryType = /* @__PURE__ */ ((draco_EncodedGeometryType2) => {
+  draco_EncodedGeometryType2[draco_EncodedGeometryType2["draco::INVALID_GEOMETRY_TYPE"] = 0] = "draco::INVALID_GEOMETRY_TYPE";
+  draco_EncodedGeometryType2[draco_EncodedGeometryType2["draco::POINT_CLOUD"] = 1] = "draco::POINT_CLOUD";
+  draco_EncodedGeometryType2[draco_EncodedGeometryType2["draco::TRIANGULAR_MESH"] = 2] = "draco::TRIANGULAR_MESH";
+  return draco_EncodedGeometryType2;
+})(draco_EncodedGeometryType || {});
+var draco_DataType = /* @__PURE__ */ ((draco_DataType2) => {
+  draco_DataType2[draco_DataType2["draco::DT_INVALID"] = 0] = "draco::DT_INVALID";
+  draco_DataType2[draco_DataType2["draco::DT_INT8"] = 1] = "draco::DT_INT8";
+  draco_DataType2[draco_DataType2["draco::DT_UINT8"] = 2] = "draco::DT_UINT8";
+  draco_DataType2[draco_DataType2["draco::DT_INT16"] = 3] = "draco::DT_INT16";
+  draco_DataType2[draco_DataType2["draco::DT_UINT16"] = 4] = "draco::DT_UINT16";
+  draco_DataType2[draco_DataType2["draco::DT_INT32"] = 5] = "draco::DT_INT32";
+  draco_DataType2[draco_DataType2["draco::DT_UINT32"] = 6] = "draco::DT_UINT32";
+  draco_DataType2[draco_DataType2["draco::DT_INT64"] = 7] = "draco::DT_INT64";
+  draco_DataType2[draco_DataType2["draco::DT_UINT64"] = 8] = "draco::DT_UINT64";
+  draco_DataType2[draco_DataType2["draco::DT_FLOAT32"] = 9] = "draco::DT_FLOAT32";
+  draco_DataType2[draco_DataType2["draco::DT_FLOAT64"] = 10] = "draco::DT_FLOAT64";
+  draco_DataType2[draco_DataType2["draco::DT_BOOL"] = 11] = "draco::DT_BOOL";
+  draco_DataType2[draco_DataType2["draco::DT_TYPES_COUNT"] = 12] = "draco::DT_TYPES_COUNT";
+  return draco_DataType2;
+})(draco_DataType || {});
+var draco_StatusCode = /* @__PURE__ */ ((draco_StatusCode2) => {
+  draco_StatusCode2[draco_StatusCode2["draco_Status::OK"] = 0] = "draco_Status::OK";
+  draco_StatusCode2[draco_StatusCode2["draco_Status::DRACO_ERROR"] = 1] = "draco_Status::DRACO_ERROR";
+  draco_StatusCode2[draco_StatusCode2["draco_Status::IO_ERROR"] = 2] = "draco_Status::IO_ERROR";
+  draco_StatusCode2[draco_StatusCode2["draco_Status::INVALID_PARAMETER"] = 3] = "draco_Status::INVALID_PARAMETER";
+  draco_StatusCode2[draco_StatusCode2["draco_Status::UNSUPPORTED_VERSION"] = 4] = "draco_Status::UNSUPPORTED_VERSION";
+  draco_StatusCode2[draco_StatusCode2["draco_Status::UNKNOWN_VERSION"] = 5] = "draco_Status::UNKNOWN_VERSION";
+  return draco_StatusCode2;
+})(draco_StatusCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  draco_DataType,
+  draco_EncodedGeometryType,
+  draco_GeometryAttribute_Type,
+  draco_StatusCode
+});
+//# sourceMappingURL=draco3d-types.cjs.map

package/dist/draco/draco3d/draco3d-types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/draco/draco3d/draco3d-types.ts"],
+  "sourcesContent": ["// SPDX-License-Identifier: Apache-2.0\n\n// A set of typescript types manually adapted from the Draco 1.5.7 web IDL.\n// Draco JS is a bit tricky to work with due to the C++ emscripten code base\n// sparse documentation, so these types provide an extra safety net.\n\n// Typescript defs adapted from the release-pinned draco3d emscripten IDL:\n// https://raw.githubusercontent.com/google/draco/8786740086a9f4d83f44aa83badfbea4dce7a1b5/src/draco/javascript/emscripten/draco_web_decoder.idl\n// https://raw.githubusercontent.com/google/draco/8786740086a9f4d83f44aa83badfbea4dce7a1b5/src/draco/javascript/emscripten/draco_web_encoder.idl\n// Interface exposed to emscripten's WebIDL Binder.\n// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html\n\n/* eslint-disable camelcase */\n\n/** Byte offset into Draco's WebAssembly memory. */\ntype VoidPtr = number;\n\n// DRACO WEB DECODER IDL\n\n/** Draco3D geometry attribute type */\nexport enum draco_GeometryAttribute_Type {\n  'draco_GeometryAttribute::INVALID',\n  'draco_GeometryAttribute::POSITION',\n  'draco_GeometryAttribute::NORMAL',\n  'draco_GeometryAttribute::COLOR',\n  'draco_GeometryAttribute::TEX_COORD',\n  'draco_GeometryAttribute::GENERIC'\n}\n\n/** Draco3D encoded geometry type */\nexport enum draco_EncodedGeometryType {\n  'draco::INVALID_GEOMETRY_TYPE',\n  'draco::POINT_CLOUD',\n  'draco::TRIANGULAR_MESH'\n}\n\n/** Draco3D data type */\nexport enum draco_DataType {\n  'draco::DT_INVALID',\n  'draco::DT_INT8',\n  'draco::DT_UINT8',\n  'draco::DT_INT16',\n  'draco::DT_UINT16',\n  'draco::DT_INT32',\n  'draco::DT_UINT32',\n  'draco::DT_INT64',\n  'draco::DT_UINT64',\n  'draco::DT_FLOAT32',\n  'draco::DT_FLOAT64',\n  'draco::DT_BOOL',\n  'draco::DT_TYPES_COUNT'\n}\n\n/** Draco3D status code */\nexport enum draco_StatusCode {\n  'draco_Status::OK',\n  'draco_Status::DRACO_ERROR',\n  'draco_Status::IO_ERROR',\n  'draco_Status::INVALID_PARAMETER',\n  'draco_Status::UNSUPPORTED_VERSION',\n  'draco_Status::UNKNOWN_VERSION'\n}\n\n/** Draco3D decoder buffer allocated on emscripten heap */\nexport declare class DecoderBuffer {\n  constructor();\n  Init(data: Int8Array, data_size: number): void;\n}\n\n/** Draco3D attribute transform data */\nexport declare class AttributeTransformData {\n  constructor();\n  transform_type(): number;\n}\n\n/** Draco3D geometry attribute */\nexport declare class GeometryAttribute {\n  constructor();\n}\n\n/** Draco3D point attribute */\nexport declare class PointAttribute {\n  ptr: VoidPtr;\n\n  constructor();\n  size(): number;\n  GetAttributeTransformData(): AttributeTransformData;\n\n  // From GeometryAttribute\n  attribute_type(): number;\n  data_type(): number;\n  num_components(): number;\n  normalized(): boolean;\n  byte_stride(): number;\n  byte_offset(): number;\n  unique_id(): number;\n}\n\n/** Draco3D attribute transform */\nexport declare class AttributeQuantizationTransform {\n  constructor();\n  InitFromAttribute(att: PointAttribute): boolean;\n  quantization_bits(): number;\n  min_value(axis: number): number;\n  range(): number;\n}\n\n/** Draco3D attribute transform */\nexport declare class AttributeOctahedronTransform {\n  constructor();\n  InitFromAttribute(att: PointAttribute): boolean;\n  quantization_bits(): number;\n}\n\n/** Draco3D point cloud */\nexport declare class PointCloud {\n  ptr: VoidPtr;\n\n  constructor();\n  num_attributes(): number;\n  num_points(): number;\n}\n\n/** Draco3D mesh */\nexport declare class Mesh extends PointCloud {\n  constructor();\n  num_faces(): number;\n}\n\n/** Draco3D metadata */\nexport declare class Metadata {\n  ptr: VoidPtr;\n\n  constructor();\n}\n\n/** Draco3D status */\nexport declare class Status {\n  constructor();\n  code(): draco_StatusCode;\n  ok(): boolean;\n  error_msg(): string;\n}\n\n/** Draco3D Float32Array allocated on the emscripten heap */\nexport declare class DracoFloat32Array {\n  constructor();\n  GetValue(index: number): number;\n  size(): number;\n}\n\n/** Draco3D Int8Array allocated on the emscripten heap */\nexport declare class DracoInt8Array {\n  constructor();\n  GetValue(index: number): number;\n  size(): number;\n}\n\n/** Draco3D Uint8Array allocated on the emscripten heap */\nexport declare class DracoUInt8Array {\n  GetValue(index: number): number;\n  size(): number;\n}\n\n/** Draco3D Int16Array allocated on the emscripten heap */\nexport declare class DracoInt16Array {\n  constructor();\n  GetValue(index: number): number;\n  size(): number;\n}\n\n/** Draco3D Uint16Array allocated on the emscripten heap */\nexport declare class DracoUInt16Array {\n  constructor();\n  GetValue(index: number): number;\n  size(): number;\n}\n\n/** Draco3D Int32Array allocated on the emscripten heap */\nexport declare class DracoInt32Array {\n  constructor();\n  GetValue(index: number): number;\n  size(): number;\n}\n\n/** Draco3D Uint32Array allocated on the emscripten heap */\nexport declare class DracoUInt32Array {\n  constructor();\n  GetValue(index: number): number;\n  size(): number;\n}\n\n/** Draco3D metadata querier */\nexport declare class MetadataQuerier {\n  constructor();\n\n  HasEntry(metadata: Metadata, entry_name: string): string;\n  GetIntEntry(metadata: Metadata, entry_name: string);\n  GetIntEntryArray(metadata: Metadata, entry_name: string, out_values: DracoInt32Array);\n  GetDoubleEntry(metadata: Metadata, entry_name: string): number;\n  GetStringEntry(metadata: Metadata, entry_name: string): string;\n\n  NumEntries(metadata: Metadata): number;\n  GetEntryName(metadata: Metadata, entry_id: number): string;\n}\n\n/**\n * Draco3D Decoder class\n */\nexport declare class Decoder {\n  constructor();\n\n  GetEncodedGeometryType(data: Int8Array): draco_EncodedGeometryType;\n\n  DecodeArrayToPointCloud(data: Int8Array, data_size: number, out_point_cloud: PointCloud): Status;\n  DecodeArrayToMesh(data: Int8Array, data_size: number, out_mesh: Mesh): Status;\n\n  /** @deprecated Use `DecodeArrayToPointCloud`. */\n  DecodeBufferToPointCloud(in_buffer: DecoderBuffer, out_point_cloud: PointCloud): Status;\n  /** @deprecated Use `DecodeArrayToMesh`. */\n  DecodeBufferToMesh(in_buffer: DecoderBuffer, out_mesh: Mesh): Status;\n\n  GetAttributeId(pc: PointCloud, type: draco_GeometryAttribute_Type): number;\n  GetAttributeIdByName(pc: PointCloud, name: string): number;\n  GetAttributeIdByMetadataEntry(pc: PointCloud, name: string, value: string): number;\n\n  GetAttribute(pc: PointCloud, att_id: number): PointAttribute;\n  GetAttributeByUniqueId(pc: PointCloud, unique_id: number): PointAttribute;\n\n  GetMetadata(pc: PointCloud): Metadata;\n  GetAttributeMetadata(pc: PointCloud, att_id: number): Metadata;\n\n  GetFaceFromMesh(m: Mesh, face_id: number, out_values: DracoInt32Array): boolean;\n  GetTriangleStripsFromMesh(m: Mesh, strip_values: DracoInt32Array);\n\n  GetTrianglesUInt16Array(m: Mesh, out_size: number, out_values: VoidPtr): boolean;\n  GetTrianglesUInt32Array(m: Mesh, out_size: number, out_values: VoidPtr): boolean;\n\n  GetAttributeFloat(pa: PointAttribute, att_index: number, out_values: DracoFloat32Array): boolean;\n\n  GetAttributeFloatForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoFloat32Array\n  ): boolean;\n\n  // Deprecated, use GetAttributeInt32ForAllPoints instead.\n  GetAttributeIntForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoInt32Array\n  ): boolean;\n\n  GetAttributeInt8ForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoInt8Array\n  ): boolean;\n  GetAttributeUInt8ForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoUInt8Array\n  ): boolean;\n  GetAttributeInt16ForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoInt16Array\n  ): boolean;\n  GetAttributeUInt16ForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoUInt16Array\n  ): boolean;\n  GetAttributeInt32ForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoInt32Array\n  ): boolean;\n  GetAttributeUInt32ForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    out_values: DracoUInt32Array\n  ): boolean;\n\n  GetAttributeDataArrayForAllPoints(\n    pc: PointCloud,\n    pa: PointAttribute,\n    data_type: draco_DataType,\n    out_size: number,\n    out_values: VoidPtr\n  ): boolean;\n\n  SkipAttributeTransform(att_type: draco_GeometryAttribute_Type): void;\n}\n\n// DRACO WEB ENCODER IDL\n\n/** Draco3D metadata builder */\nexport declare class MetadataBuilder {\n  constructor();\n  AddStringEntry(metadata: Metadata, entry_name: string, entry_value: string);\n  AddIntEntry(metadata: Metadata, entry_name: string, entry_value: number);\n  AddDoubleEntry(metadata: Metadata, entry_name: string, entry_value: number);\n  AddIntEntryArray(\n    metadata: Metadata,\n    entry_name: string,\n    entry_value: Int32Array,\n    num_values: number\n  );\n}\n\n/** Draco3D point cloud builder */\n\nexport declare class PointCloudBuilder {\n  constructor();\n  PointCloudBuilder(): void;\n  AddFloatAttribute(\n    pc: PointCloud,\n    type: draco_GeometryAttribute_Type,\n    num_vertices: number,\n    num_components: number,\n    att_values: Float32Array\n  );\n  AddInt8Attribute(\n    pc: PointCloud,\n    type: draco_GeometryAttribute_Type,\n    num_vertices: number,\n    num_components: number,\n    att_values: Int8Array\n  );\n  AddUInt8Attribute(\n    pc: PointCloud,\n    type: draco_GeometryAttribute_Type,\n    num_vertices: number,\n    num_components: number,\n    att_values: Uint8Array\n  );\n  AddInt16Attribute(\n    pc: PointCloud,\n    type: draco_GeometryAttribute_Type,\n    num_vertices: number,\n    num_components: number,\n    att_values: Int16Array\n  );\n  AddUInt16Attribute(\n    pc: PointCloud,\n    type: draco_GeometryAttribute_Type,\n    num_vertices: number,\n    num_components: number,\n    att_values: Uint16Array\n  );\n  AddInt32Attribute(\n    pc: PointCloud,\n    type: draco_GeometryAttribute_Type,\n    num_vertices: number,\n    num_components: number,\n    att_values: Int32Array\n  );\n  AddUInt32Attribute(\n    pc: PointCloud,\n    type: draco_GeometryAttribute_Type,\n    num_vertices: number,\n    num_components: number,\n    att_values: Uint32Array\n  );\n\n  AddMetadata(pc: PointCloud, metadata: Metadata): boolean;\n  SetMetadataForAttribute(pc: PointCloud, attribute_id: number, metadata: Metadata);\n  SetNormalizedFlagForAttribute(pc: PointCloud, attribute_id: number, normalized: boolean): boolean;\n}\n\n/** Draco3D mesh builder */\nexport declare class MeshBuilder extends PointCloudBuilder {\n  constructor();\n  AddFacesToMesh(mesh: Mesh, num_faces: number, faces: Uint16Array | Uint32Array): boolean;\n}\n\n/** Draco3D encoder */\nexport declare class Encoder {\n  constructor();\n  Encoder(): void;\n  SetEncodingMethod(method: number): void;\n  SetAttributeQuantization(type: draco_GeometryAttribute_Type, quantization_bits: number);\n  SetAttributeExplicitQuantization(\n    type: draco_GeometryAttribute_Type,\n    quantization_bits: number,\n    num_components: number,\n    origin: number[],\n    range: number\n  );\n  SetSpeedOptions(encoding_speed: number, decoding_speed: number): void;\n  SetTrackEncodedProperties(flag: boolean): void;\n\n  EncodeMeshToDracoBuffer(mesh: Mesh, encoded_data: DracoInt8Array);\n  EncodePointCloudToDracoBuffer(\n    pc: PointCloud,\n    deduplicate_values: boolean,\n    encoded_data: DracoInt8Array\n  );\n\n  // Returns the number of encoded points or faces from the last Encode\n  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.\n  GetNumberOfEncodedPoints(): number;\n  GetNumberOfEncodedFaces(): number;\n}\n\n/** Draco3D expert encoder */\nexport declare class ExpertEncoder {\n  constructor(pointCloud: PointCloud);\n  SetEncodingMethod(method: number): void;\n  SetAttributeQuantization(att_id: number, quantization_bits: number);\n  SetAttributeExplicitQuantization(\n    att_id: number,\n    quantization_bits: number,\n    num_components: number,\n    origin: number[],\n    range: number\n  );\n  SetSpeedOptions(encoding_speed: number, decoding_speed: number): void;\n  SetTrackEncodedProperties(flag: boolean): void;\n\n  EncodeToDracoBuffer(deduplicate_values: boolean, encoded_data: DracoInt8Array);\n\n  // Returns the number of encoded points or faces from the last Encode\n  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.\n  GetNumberOfEncodedPoints(): number;\n  GetNumberOfEncodedFaces(): number;\n}\n\n/** Draco3D module interface */\nexport interface Draco3D {\n  // ENUMS\n\n  // draco_EncodedGeometryType\n  readonly INVALID_GEOMETRY_TYPE: draco_EncodedGeometryType;\n  readonly POINT_CLOUD: draco_EncodedGeometryType;\n  readonly TRIANGULAR_MESH: draco_EncodedGeometryType;\n\n  // enum draco_GeometryAttribute_Type\n  readonly INVALID: draco_GeometryAttribute_Type;\n  readonly POSITION: draco_GeometryAttribute_Type;\n  readonly NORMAL: draco_GeometryAttribute_Type;\n  readonly COLOR: draco_GeometryAttribute_Type;\n  readonly TEX_COORD: draco_GeometryAttribute_Type;\n  readonly GENERIC: draco_GeometryAttribute_Type;\n\n  readonly MESH_SEQUENTIAL_ENCODING: number;\n  readonly MESH_EDGEBREAKER_ENCODING: number;\n\n  // enum draco_DataType\n  readonly DT_INVALID: draco_DataType;\n  readonly DT_INT8: draco_DataType;\n  readonly DT_UINT8: draco_DataType;\n  readonly DT_INT16: draco_DataType;\n  readonly DT_UINT16: draco_DataType;\n  readonly DT_INT32: draco_DataType;\n  readonly DT_UINT32: draco_DataType;\n  readonly DT_INT64: draco_DataType;\n  readonly DT_UINT64: draco_DataType;\n  readonly DT_FLOAT32: draco_DataType;\n  readonly DT_FLOAT64: draco_DataType;\n  readonly DT_BOOL: draco_DataType;\n  readonly DT_TYPES_COUNT: draco_DataType;\n\n  readonly Mesh: typeof Mesh;\n  readonly PointCloud: typeof PointCloud;\n  readonly Metadata: typeof Metadata;\n\n  readonly Encoder: typeof Encoder;\n  readonly ExpertEncoder: typeof ExpertEncoder;\n  readonly MeshBuilder: typeof MeshBuilder;\n  readonly MetadataBuilder: typeof MetadataBuilder;\n\n  readonly MetadataQuerier: typeof MetadataQuerier;\n  readonly Decoder: typeof Decoder;\n  readonly DecoderBuffer: typeof DecoderBuffer;\n\n  readonly DracoFloat32Array: typeof DracoFloat32Array;\n  readonly DracoInt8Array: typeof DracoInt8Array;\n  readonly DracoUInt8Array: typeof DracoUInt8Array;\n  readonly DracoInt16Array: typeof DracoInt16Array;\n  readonly DracoUInt16Array: typeof DracoUInt16Array;\n  readonly DracoInt32Array: typeof DracoInt32Array;\n  readonly DracoUInt32Array: typeof DracoUInt32Array;\n\n  readonly AttributeQuantizationTransform: typeof AttributeQuantizationTransform;\n  readonly AttributeOctahedronTransform: typeof AttributeOctahedronTransform;\n\n  // createEncoderModule(): Encoder;\n  // createDecoderModule(): Decoder;\n  destroy(resource: object): void;\n  _malloc(byteLength: number): number;\n  _free(ptr: number): void;\n\n  HEAPU8: {\n    buffer: ArrayBuffer;\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,IAAK,+BAAL,kBAAKA,kCAAL;AACL,EAAAA,4DAAA;AACA,EAAAA,4DAAA;AACA,EAAAA,4DAAA;AACA,EAAAA,4DAAA;AACA,EAAAA,4DAAA;AACA,EAAAA,4DAAA;AANU,SAAAA;AAAA,GAAA;AAUL,IAAK,4BAAL,kBAAKC,+BAAL;AACL,EAAAA,sDAAA;AACA,EAAAA,sDAAA;AACA,EAAAA,sDAAA;AAHU,SAAAA;AAAA,GAAA;AAOL,IAAK,iBAAL,kBAAKC,oBAAL;AACL,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AACA,EAAAA,gCAAA;AAbU,SAAAA;AAAA,GAAA;AAiBL,IAAK,mBAAL,kBAAKC,sBAAL;AACL,EAAAA,oCAAA;AACA,EAAAA,oCAAA;AACA,EAAAA,oCAAA;AACA,EAAAA,oCAAA;AACA,EAAAA,oCAAA;AACA,EAAAA,oCAAA;AANU,SAAAA;AAAA,GAAA;",
+  "names": ["draco_GeometryAttribute_Type", "draco_EncodedGeometryType", "draco_DataType", "draco_StatusCode"]
+}