@loaders.gl/draco 4.0.2 → 4.0.3

package/dist/draco-writer-worker.js

@@ -1,4 +1,721 @@
-"use strict";(()=>{var S=Object.create;var O=Object.defineProperty;var N=Object.getOwnPropertyDescriptor;var F=Object.getOwnPropertyNames;var $=Object.getPrototypeOf,v=Object.prototype.hasOwnProperty;var V=(r,e)=>()=>(e||r((e={exports:{}}).exports,e),e.exports);var G=(r,e,t,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of F(e))!v.call(r,a)&&a!==t&&O(r,a,{get:()=>e[a],enumerable:!(o=N(e,a))||o.enumerable});return r};var j=(r,e,t)=>(t=r!=null?S($(r)):{},G(e||!r||!r.__esModule?O(t,"default",{value:r,enumerable:!0}):t,r));var B=V(()=>{"use strict"});function q(){return globalThis._loadersgl_?.version||(globalThis._loadersgl_=globalThis._loadersgl_||{},globalThis._loadersgl_.version="4.0.2"),globalThis._loadersgl_.version}var b=q();function T(r,e){if(!r)throw new Error(e||"loaders.gl assertion failed.")}var l={self:typeof self<"u"&&self,window:typeof window<"u"&&window,global:typeof global<"u"&&global,document:typeof document<"u"&&document},ie=l.self||l.window||l.global||{},de=l.window||l.self||l.global||{},ce=l.global||l.self||l.window||{},le=l.document||{};var h=typeof process!="object"||String(process)!=="[object process]"||process.browser,E=typeof importScripts=="function",ue=typeof window<"u"&&typeof window.orientation<"u",R=typeof process<"u"&&process.version&&/v([0-9]*)/.exec(process.version),fe=R&&parseFloat(R[1])||0;function A(r,e=!0,t){let o=t||new Set;if(r){if(P(r))o.add(r);else if(P(r.buffer))o.add(r.buffer);else if(!ArrayBuffer.isView(r)){if(e&&typeof r=="object")for(let a in r)A(r[a],e,o)}}return t===void 0?Array.from(o):[]}function P(r){return r?r instanceof ArrayBuffer||typeof MessagePort<"u"&&r instanceof MessagePort||typeof ImageBitmap<"u"&&r instanceof ImageBitmap||typeof OffscreenCanvas<"u"&&r instanceof OffscreenCanvas:!1}async function y(){let parentPort;try{eval("globalThis.parentPort = require('worker_threads').parentPort"),parentPort=globalThis.parentPort}catch{try{eval("globalThis.workerThreadsPromise = import('worker_threads')");let workerThreads=await globalThis.workerThreadsPromise;parentPort=workerThreads.parentPort}catch(r){console.error(r.message)}}return parentPort}var D=new Map,f=class{static async inWorkerThread(){return typeof self<"u"||Boolean(await y())}static set onmessage(e){async function t(o){let a=await y(),{type:s,payload:i}=a?o:o.data;e(s,i)}y().then(o=>{o?(o.on("message",t),o.on("exit",()=>console.debug("Node worker closing"))):globalThis.onmessage=t})}static async addEventListener(e){let t=D.get(e);t||(t=async a=>{if(!z(a))return;let s=await y(),{type:i,payload:n}=s?a:a.data;e(i,n)}),await y()?console.error("not implemented"):globalThis.addEventListener("message",t)}static async removeEventListener(e){let t=D.get(e);D.delete(e),await y()?console.error("not implemented"):globalThis.removeEventListener("message",t)}static async postMessage(e,t){let o={source:"loaders.gl",type:e,payload:t},a=A(t),s=await y();s?s.postMessage(o,a):globalThis.postMessage(o,a)}};function z(r){let{type:e,data:t}=r;return e==="message"&&t&&typeof t.source=="string"&&t.source.startsWith("loaders.gl")}var d=j(B(),1);var _={};async function M(r,e=null,t={},o=null){return e&&(r=C(r,e,t,o)),_[r]=_[r]||U(r),await _[r]}function C(r,e,t={},o=null){if(!t.useLocalLibraries&&r.startsWith("http"))return r;o=o||r;let a=t.modules||{};return a[o]?a[o]:h?t.CDN?(T(t.CDN.startsWith("http")),`${t.CDN}/${e}@${b}/dist/libs/${o}`):E?`../src/libs/${o}`:`modules/${e}/src/libs/${o}`:`modules/${e}/dist/libs/${o}`}async function U(r){if(r.endsWith("wasm"))return await X(r);if(!h)try{return d&&void 0&&await(void 0)(r)}catch(t){return console.error(t),null}if(E)return importScripts(r);let e=await Q(r);return K(e,r)}function K(r,e){if(!h)return void 0&&(void 0)(r,e);if(E)return eval.call(globalThis,r),null;let t=document.createElement("script");t.id=e;try{t.appendChild(document.createTextNode(r))}catch{t.text=r}return document.body.appendChild(t),null}async function X(r){return h||!void 0||r.startsWith("http")?await(await fetch(r)).arrayBuffer():await(void 0)(r)}async function Q(r){return h||!void 0||r.startsWith("http")?await(await fetch(r)).text():await(void 0)(r)}var W={POSITION:"POSITION",NORMAL:"NORMAL",COLOR_0:"COLOR",TEXCOORD_0:"TEX_COORD"},H=()=>{},g=class{draco;dracoEncoder;dracoMeshBuilder;dracoMetadataBuilder;log;constructor(e){this.draco=e,this.dracoEncoder=new this.draco.Encoder,this.dracoMeshBuilder=new this.draco.MeshBuilder,this.dracoMetadataBuilder=new this.draco.MetadataBuilder}destroy(){this.destroyEncodedObject(this.dracoMeshBuilder),this.destroyEncodedObject(this.dracoEncoder),this.destroyEncodedObject(this.dracoMetadataBuilder),this.dracoMeshBuilder=null,this.dracoEncoder=null,this.draco=null}destroyEncodedObject(e){e&&this.draco.destroy(e)}encodeSync(e,t={}){return this.log=H,this._setOptions(t),t.pointcloud?this._encodePointCloud(e,t):this._encodeMesh(e,t)}_getAttributesFromMesh(e){let t={...e,...e.attributes};return e.indices&&(t.indices=e.indices),t}_encodePointCloud(e,t){let o=new this.draco.PointCloud;t.metadata&&this._addGeometryMetadata(o,t.metadata);let a=this._getAttributesFromMesh(e);this._createDracoPointCloud(o,a,t);let s=new this.draco.DracoInt8Array;try{let i=this.dracoEncoder.EncodePointCloudToDracoBuffer(o,!1,s);if(!(i>0))throw new Error("Draco encoding failed.");return this.log(`DRACO encoded ${o.num_points()} points
-        with ${o.num_attributes()} attributes into ${i} bytes`),I(s)}finally{this.destroyEncodedObject(s),this.destroyEncodedObject(o)}}_encodeMesh(e,t){let o=new this.draco.Mesh;t.metadata&&this._addGeometryMetadata(o,t.metadata);let a=this._getAttributesFromMesh(e);this._createDracoMesh(o,a,t);let s=new this.draco.DracoInt8Array;try{let i=this.dracoEncoder.EncodeMeshToDracoBuffer(o,s);if(i<=0)throw new Error("Draco encoding failed.");return this.log(`DRACO encoded ${o.num_points()} points
-        with ${o.num_attributes()} attributes into ${i} bytes`),I(s)}finally{this.destroyEncodedObject(s),this.destroyEncodedObject(o)}}_setOptions(e){if("speed"in e&&this.dracoEncoder.SetSpeedOptions(...e.speed),"method"in e){let t=this.draco[e.method||"MESH_SEQUENTIAL_ENCODING"];this.dracoEncoder.SetEncodingMethod(t)}if("quantization"in e)for(let t in e.quantization){let o=e.quantization[t],a=this.draco[t];this.dracoEncoder.SetAttributeQuantization(a,o)}}_createDracoMesh(e,t,o){let a=o.attributesMetadata||{};try{let s=this._getPositionAttribute(t);if(!s)throw new Error("positions");let i=s.length/3;for(let n in t){let c=t[n];n=W[n]||n;let p=this._addAttributeToMesh(e,n,c,i);p!==-1&&this._addAttributeMetadata(e,p,{name:n,...a[n]||{}})}}catch(s){throw this.destroyEncodedObject(e),s}return e}_createDracoPointCloud(e,t,o){let a=o.attributesMetadata||{};try{let s=this._getPositionAttribute(t);if(!s)throw new Error("positions");let i=s.length/3;for(let n in t){let c=t[n];n=W[n]||n;let p=this._addAttributeToMesh(e,n,c,i);p!==-1&&this._addAttributeMetadata(e,p,{name:n,...a[n]||{}})}}catch(s){throw this.destroyEncodedObject(e),s}return e}_addAttributeToMesh(e,t,o,a){if(!ArrayBuffer.isView(o))return-1;let s=this._getDracoAttributeType(t),i=o.length/a;if(s==="indices"){let p=o.length/3;return this.log(`Adding attribute ${t}, size ${p}`),this.dracoMeshBuilder.AddFacesToMesh(e,p,o),-1}this.log(`Adding attribute ${t}, size ${i}`);let n=this.dracoMeshBuilder,{buffer:c}=o;switch(o.constructor){case Int8Array:return n.AddInt8Attribute(e,s,a,i,new Int8Array(c));case Int16Array:return n.AddInt16Attribute(e,s,a,i,new Int16Array(c));case Int32Array:return n.AddInt32Attribute(e,s,a,i,new Int32Array(c));case Uint8Array:case Uint8ClampedArray:return n.AddUInt8Attribute(e,s,a,i,new Uint8Array(c));case Uint16Array:return n.AddUInt16Attribute(e,s,a,i,new Uint16Array(c));case Uint32Array:return n.AddUInt32Attribute(e,s,a,i,new Uint32Array(c));case Float32Array:default:return n.AddFloatAttribute(e,s,a,i,new Float32Array(c))}}_getDracoAttributeType(e){switch(e.toLowerCase()){case"indices":return"indices";case"position":case"positions":case"vertices":return this.draco.POSITION;case"normal":case"normals":return this.draco.NORMAL;case"color":case"colors":return this.draco.COLOR;case"texcoord":case"texcoords":return this.draco.TEX_COORD;default:return this.draco.GENERIC}}_getPositionAttribute(e){for(let t in e){let o=e[t];if(this._getDracoAttributeType(t)===this.draco.POSITION)return o}return null}_addGeometryMetadata(e,t){let o=new this.draco.Metadata;this._populateDracoMetadata(o,t),this.dracoMeshBuilder.AddMetadata(e,o)}_addAttributeMetadata(e,t,o){let a=new this.draco.Metadata;this._populateDracoMetadata(a,o),this.dracoMeshBuilder.SetMetadataForAttribute(e,t,a)}_populateDracoMetadata(e,t){for(let[o,a]of J(t))switch(typeof a){case"number":Math.trunc(a)===a?this.dracoMetadataBuilder.AddIntEntry(e,o,a):this.dracoMetadataBuilder.AddDoubleEntry(e,o,a);break;case"object":a instanceof Int32Array&&this.dracoMetadataBuilder.AddIntEntryArray(e,o,a,a.length);break;case"string":default:this.dracoMetadataBuilder.AddStringEntry(e,o,a)}}};function I(r){let e=r.size(),t=new ArrayBuffer(e),o=new Int8Array(t);for(let a=0;a<e;++a)o[a]=r.GetValue(a);return t}function J(r){return r.entries&&!r.hasOwnProperty("entries")?r.entries():Object.entries(r)}var Y="1.5.6",Z="1.4.1",w=`https://www.gstatic.com/draco/versioned/decoders/${Y}`,u={DECODER:"draco_wasm_wrapper.js",DECODER_WASM:"draco_decoder.wasm",FALLBACK_DECODER:"draco_decoder.js",ENCODER:"draco_encoder.js"},ee={[u.DECODER]:`${w}/${u.DECODER}`,[u.DECODER_WASM]:`${w}/${u.DECODER_WASM}`,[u.FALLBACK_DECODER]:`${w}/${u.FALLBACK_DECODER}`,[u.ENCODER]:`https://raw.githubusercontent.com/google/draco/${Z}/javascript/${u.ENCODER}`};var m;async function k(r){let e=r.modules||{};return e.draco3d?m=m||e.draco3d.createEncoderModule({}).then(t=>({draco:t})):m=m||te(r),await m}async function te(r){let e=await M(ee[u.ENCODER],"draco",r,u.ENCODER);return e=e||globalThis.DracoEncoderModule,new Promise(t=>{e({onModuleLoaded:o=>t({draco:o})})})}var L="4.0.2";var re={pointcloud:!1,attributeNameEntry:"name"},x={name:"DRACO",id:"draco",module:"draco",version:L,extensions:["drc"],options:{draco:re},encode:oe};async function oe(r,e={}){let{draco:t}=await k(e),o=new g(t);try{return o.encodeSync(r,e.draco)}finally{o.destroy()}}(async()=>await f.inWorkerThread()&&(f.onmessage=async(r,e)=>{switch(r){case"process":try{let{input:t,options:o}=e,a=await x.encode(t,o);f.postMessage("done",{result:a})}catch(t){let o=t instanceof Error?t.message:"";f.postMessage("error",{error:o})}break;default:}}))();})();
+"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 __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  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
+  ));
+
+  // (disabled):../worker-utils/src/lib/node/require-utils.node
+  var require_require_utils = __commonJS({
+    "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
+      "use strict";
+    }
+  });
+
+  // ../worker-utils/src/lib/env-utils/version.ts
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+      if (false) {
+        console.warn(
+          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
+        );
+        globalThis._loadersgl_.version = NPM_TAG;
+      } else {
+        globalThis._loadersgl_.version = "4.0.3";
+      }
+    }
+    return globalThis._loadersgl_.version;
+  }
+  var VERSION = getVersion();
+
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
+
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = (
+    // @ts-ignore process.browser
+    typeof process !== "object" || String(process) !== "[object process]" || process.browser
+  );
+  var isWorker = typeof importScripts === "function";
+  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  async function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+      try {
+        eval("globalThis.workerThreadsPromise = import('worker_threads')");
+        const workerThreads = await globalThis.workerThreadsPromise;
+        parentPort = workerThreads.parentPort;
+      } catch (error) {
+        console.error(error.message);
+      }
+    }
+    return parentPort;
+  }
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
+  var WorkerBody = class {
+    /** Check that we are actually in a worker thread */
+    static async inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(await getParentPort());
+    }
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
+    static set onmessage(onMessage) {
+      async function handleMessage(message) {
+        const parentPort2 = await getParentPort();
+        const { type, payload } = parentPort2 ? message : message.data;
+        onMessage(type, payload);
+      }
+      getParentPort().then((parentPort2) => {
+        if (parentPort2) {
+          parentPort2.on("message", handleMessage);
+          parentPort2.on("exit", () => console.debug("Node worker closing"));
+        } else {
+          globalThis.onmessage = handleMessage;
+        }
+      });
+    }
+    static async addEventListener(onMessage) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      if (!onMessageWrapper) {
+        onMessageWrapper = async (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const parentPort3 = await getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
+          onMessage(type, payload);
+        };
+      }
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
+    }
+    static async removeEventListener(onMessage) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
+    }
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
+    static async postMessage(type, payload) {
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
+      }
+    }
+  };
+  function isKnownMessage(message) {
+    const { type, data } = message;
+    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
+  }
+
+  // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var node = __toESM(require_require_utils(), 1);
+  var loadLibraryPromises = {};
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
+    if (moduleName) {
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
+    }
+    loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
+  }
+  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (!options.useLocalLibraries && library.startsWith("http")) {
+      return library;
+    }
+    libraryName = libraryName || library;
+    const modules = options.modules || {};
+    if (modules[libraryName]) {
+      return modules[libraryName];
+    }
+    if (!isBrowser) {
+      return `modules/${moduleName}/dist/libs/${libraryName}`;
+    }
+    if (options.CDN) {
+      assert(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+    }
+    if (isWorker) {
+      return `../src/libs/${libraryName}`;
+    }
+    return `modules/${moduleName}/src/libs/${libraryName}`;
+  }
+  async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      return await loadAsArrayBuffer(libraryUrl);
+    }
+    if (!isBrowser) {
+      try {
+        return node && void 0 && await (void 0)(libraryUrl);
+      } catch (error) {
+        console.error(error);
+        return null;
+      }
+    }
+    if (isWorker) {
+      return importScripts(libraryUrl);
+    }
+    const scriptSource = await loadAsText(libraryUrl);
+    return loadLibraryFromString(scriptSource, libraryUrl);
+  }
+  function loadLibraryFromString(scriptSource, id) {
+    if (!isBrowser) {
+      return void 0 && (void 0)(scriptSource, id);
+    }
+    if (isWorker) {
+      eval.call(globalThis, scriptSource);
+      return null;
+    }
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (e) {
+      script.text = scriptSource;
+    }
+    document.body.appendChild(script);
+    return null;
+  }
+  async function loadAsArrayBuffer(url) {
+    if (isBrowser || !void 0 || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.arrayBuffer();
+    }
+    return await (void 0)(url);
+  }
+  async function loadAsText(url) {
+    if (isBrowser || !void 0 || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.text();
+    }
+    return await (void 0)(url);
+  }
+
+  // src/lib/draco-builder.ts
+  var GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP = {
+    POSITION: "POSITION",
+    NORMAL: "NORMAL",
+    COLOR_0: "COLOR",
+    TEXCOORD_0: "TEX_COORD"
+  };
+  var noop = () => {
+  };
+  var DracoBuilder = class {
+    draco;
+    dracoEncoder;
+    dracoMeshBuilder;
+    dracoMetadataBuilder;
+    log;
+    // draco - the draco decoder, either import `draco3d` or load dynamically
+    constructor(draco) {
+      this.draco = draco;
+      this.dracoEncoder = new this.draco.Encoder();
+      this.dracoMeshBuilder = new this.draco.MeshBuilder();
+      this.dracoMetadataBuilder = new this.draco.MetadataBuilder();
+    }
+    destroy() {
+      this.destroyEncodedObject(this.dracoMeshBuilder);
+      this.destroyEncodedObject(this.dracoEncoder);
+      this.destroyEncodedObject(this.dracoMetadataBuilder);
+      this.dracoMeshBuilder = null;
+      this.dracoEncoder = null;
+      this.draco = null;
+    }
+    // TBD - when does this need to be called?
+    destroyEncodedObject(object) {
+      if (object) {
+        this.draco.destroy(object);
+      }
+    }
+    /**
+     * Encode mesh or point cloud
+     * @param mesh =({})
+     * @param options
+     */
+    encodeSync(mesh, options = {}) {
+      this.log = noop;
+      this._setOptions(options);
+      return options.pointcloud ? this._encodePointCloud(mesh, options) : this._encodeMesh(mesh, options);
+    }
+    // PRIVATE
+    _getAttributesFromMesh(mesh) {
+      const attributes = { ...mesh, ...mesh.attributes };
+      if (mesh.indices) {
+        attributes.indices = mesh.indices;
+      }
+      return attributes;
+    }
+    _encodePointCloud(pointcloud, options) {
+      const dracoPointCloud = new this.draco.PointCloud();
+      if (options.metadata) {
+        this._addGeometryMetadata(dracoPointCloud, options.metadata);
+      }
+      const attributes = this._getAttributesFromMesh(pointcloud);
+      this._createDracoPointCloud(dracoPointCloud, attributes, options);
+      const dracoData = new this.draco.DracoInt8Array();
+      try {
+        const encodedLen = this.dracoEncoder.EncodePointCloudToDracoBuffer(
+          dracoPointCloud,
+          false,
+          dracoData
+        );
+        if (!(encodedLen > 0)) {
+          throw new Error("Draco encoding failed.");
+        }
+        this.log(`DRACO encoded ${dracoPointCloud.num_points()} points
+        with ${dracoPointCloud.num_attributes()} attributes into ${encodedLen} bytes`);
+        return dracoInt8ArrayToArrayBuffer(dracoData);
+      } finally {
+        this.destroyEncodedObject(dracoData);
+        this.destroyEncodedObject(dracoPointCloud);
+      }
+    }
+    _encodeMesh(mesh, options) {
+      const dracoMesh = new this.draco.Mesh();
+      if (options.metadata) {
+        this._addGeometryMetadata(dracoMesh, options.metadata);
+      }
+      const attributes = this._getAttributesFromMesh(mesh);
+      this._createDracoMesh(dracoMesh, attributes, options);
+      const dracoData = new this.draco.DracoInt8Array();
+      try {
+        const encodedLen = this.dracoEncoder.EncodeMeshToDracoBuffer(dracoMesh, dracoData);
+        if (encodedLen <= 0) {
+          throw new Error("Draco encoding failed.");
+        }
+        this.log(`DRACO encoded ${dracoMesh.num_points()} points
+        with ${dracoMesh.num_attributes()} attributes into ${encodedLen} bytes`);
+        return dracoInt8ArrayToArrayBuffer(dracoData);
+      } finally {
+        this.destroyEncodedObject(dracoData);
+        this.destroyEncodedObject(dracoMesh);
+      }
+    }
+    /**
+     * Set encoding options.
+     * @param {{speed?: any; method?: any; quantization?: any;}} options
+     */
+    _setOptions(options) {
+      if ("speed" in options) {
+        this.dracoEncoder.SetSpeedOptions(...options.speed);
+      }
+      if ("method" in options) {
+        const dracoMethod = this.draco[options.method || "MESH_SEQUENTIAL_ENCODING"];
+        this.dracoEncoder.SetEncodingMethod(dracoMethod);
+      }
+      if ("quantization" in options) {
+        for (const attribute in options.quantization) {
+          const bits = options.quantization[attribute];
+          const dracoPosition = this.draco[attribute];
+          this.dracoEncoder.SetAttributeQuantization(dracoPosition, bits);
+        }
+      }
+    }
+    /**
+     * @param {Mesh} dracoMesh
+     * @param {object} attributes
+     * @returns {Mesh}
+     */
+    _createDracoMesh(dracoMesh, attributes, options) {
+      const optionalMetadata = options.attributesMetadata || {};
+      try {
+        const positions = this._getPositionAttribute(attributes);
+        if (!positions) {
+          throw new Error("positions");
+        }
+        const vertexCount = positions.length / 3;
+        for (let attributeName in attributes) {
+          const attribute = attributes[attributeName];
+          attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName] || attributeName;
+          const uniqueId = this._addAttributeToMesh(dracoMesh, attributeName, attribute, vertexCount);
+          if (uniqueId !== -1) {
+            this._addAttributeMetadata(dracoMesh, uniqueId, {
+              name: attributeName,
+              ...optionalMetadata[attributeName] || {}
+            });
+          }
+        }
+      } catch (error) {
+        this.destroyEncodedObject(dracoMesh);
+        throw error;
+      }
+      return dracoMesh;
+    }
+    /**
+     * @param {} dracoPointCloud
+     * @param {object} attributes
+     */
+    _createDracoPointCloud(dracoPointCloud, attributes, options) {
+      const optionalMetadata = options.attributesMetadata || {};
+      try {
+        const positions = this._getPositionAttribute(attributes);
+        if (!positions) {
+          throw new Error("positions");
+        }
+        const vertexCount = positions.length / 3;
+        for (let attributeName in attributes) {
+          const attribute = attributes[attributeName];
+          attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName] || attributeName;
+          const uniqueId = this._addAttributeToMesh(
+            dracoPointCloud,
+            attributeName,
+            attribute,
+            vertexCount
+          );
+          if (uniqueId !== -1) {
+            this._addAttributeMetadata(dracoPointCloud, uniqueId, {
+              name: attributeName,
+              ...optionalMetadata[attributeName] || {}
+            });
+          }
+        }
+      } catch (error) {
+        this.destroyEncodedObject(dracoPointCloud);
+        throw error;
+      }
+      return dracoPointCloud;
+    }
+    /**
+     * @param mesh
+     * @param attributeName
+     * @param attribute
+     * @param vertexCount
+     */
+    _addAttributeToMesh(mesh, attributeName, attribute, vertexCount) {
+      if (!ArrayBuffer.isView(attribute)) {
+        return -1;
+      }
+      const type = this._getDracoAttributeType(attributeName);
+      const size = attribute.length / vertexCount;
+      if (type === "indices") {
+        const numFaces = attribute.length / 3;
+        this.log(`Adding attribute ${attributeName}, size ${numFaces}`);
+        this.dracoMeshBuilder.AddFacesToMesh(mesh, numFaces, attribute);
+        return -1;
+      }
+      this.log(`Adding attribute ${attributeName}, size ${size}`);
+      const builder = this.dracoMeshBuilder;
+      const { buffer } = attribute;
+      switch (attribute.constructor) {
+        case Int8Array:
+          return builder.AddInt8Attribute(mesh, type, vertexCount, size, new Int8Array(buffer));
+        case Int16Array:
+          return builder.AddInt16Attribute(mesh, type, vertexCount, size, new Int16Array(buffer));
+        case Int32Array:
+          return builder.AddInt32Attribute(mesh, type, vertexCount, size, new Int32Array(buffer));
+        case Uint8Array:
+        case Uint8ClampedArray:
+          return builder.AddUInt8Attribute(mesh, type, vertexCount, size, new Uint8Array(buffer));
+        case Uint16Array:
+          return builder.AddUInt16Attribute(mesh, type, vertexCount, size, new Uint16Array(buffer));
+        case Uint32Array:
+          return builder.AddUInt32Attribute(mesh, type, vertexCount, size, new Uint32Array(buffer));
+        case Float32Array:
+        default:
+          return builder.AddFloatAttribute(mesh, type, vertexCount, size, new Float32Array(buffer));
+      }
+    }
+    /**
+     * DRACO can compress attributes of know type better
+     * TODO - expose an attribute type map?
+     * @param attributeName
+     */
+    _getDracoAttributeType(attributeName) {
+      switch (attributeName.toLowerCase()) {
+        case "indices":
+          return "indices";
+        case "position":
+        case "positions":
+        case "vertices":
+          return this.draco.POSITION;
+        case "normal":
+        case "normals":
+          return this.draco.NORMAL;
+        case "color":
+        case "colors":
+          return this.draco.COLOR;
+        case "texcoord":
+        case "texcoords":
+          return this.draco.TEX_COORD;
+        default:
+          return this.draco.GENERIC;
+      }
+    }
+    _getPositionAttribute(attributes) {
+      for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const dracoType = this._getDracoAttributeType(attributeName);
+        if (dracoType === this.draco.POSITION) {
+          return attribute;
+        }
+      }
+      return null;
+    }
+    /**
+     * Add metadata for the geometry.
+     * @param dracoGeometry - WASM Draco Object
+     * @param metadata
+     */
+    _addGeometryMetadata(dracoGeometry, metadata) {
+      const dracoMetadata = new this.draco.Metadata();
+      this._populateDracoMetadata(dracoMetadata, metadata);
+      this.dracoMeshBuilder.AddMetadata(dracoGeometry, dracoMetadata);
+    }
+    /**
+     * Add metadata for an attribute to geometry.
+     * @param dracoGeometry - WASM Draco Object
+     * @param uniqueAttributeId
+     * @param metadata
+     */
+    _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata) {
+      const dracoAttributeMetadata = new this.draco.Metadata();
+      this._populateDracoMetadata(dracoAttributeMetadata, metadata);
+      this.dracoMeshBuilder.SetMetadataForAttribute(
+        dracoGeometry,
+        uniqueAttributeId,
+        dracoAttributeMetadata
+      );
+    }
+    /**
+     * Add contents of object or map to a WASM Draco Metadata Object
+     * @param dracoMetadata - WASM Draco Object
+     * @param metadata
+     */
+    _populateDracoMetadata(dracoMetadata, metadata) {
+      for (const [key, value] of getEntries(metadata)) {
+        switch (typeof value) {
+          case "number":
+            if (Math.trunc(value) === value) {
+              this.dracoMetadataBuilder.AddIntEntry(dracoMetadata, key, value);
+            } else {
+              this.dracoMetadataBuilder.AddDoubleEntry(dracoMetadata, key, value);
+            }
+            break;
+          case "object":
+            if (value instanceof Int32Array) {
+              this.dracoMetadataBuilder.AddIntEntryArray(dracoMetadata, key, value, value.length);
+            }
+            break;
+          case "string":
+          default:
+            this.dracoMetadataBuilder.AddStringEntry(dracoMetadata, key, value);
+        }
+      }
+    }
+  };
+  function dracoInt8ArrayToArrayBuffer(dracoData) {
+    const byteLength = dracoData.size();
+    const outputBuffer = new ArrayBuffer(byteLength);
+    const outputData = new Int8Array(outputBuffer);
+    for (let i = 0; i < byteLength; ++i) {
+      outputData[i] = dracoData.GetValue(i);
+    }
+    return outputBuffer;
+  }
+  function getEntries(container) {
+    const hasEntriesFunc = container.entries && !container.hasOwnProperty("entries");
+    return hasEntriesFunc ? container.entries() : Object.entries(container);
+  }
+
+  // src/lib/draco-module-loader.ts
+  var DRACO_DECODER_VERSION = "1.5.6";
+  var DRACO_ENCODER_VERSION = "1.4.1";
+  var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
+  var DRACO_EXTERNAL_LIBRARIES = {
+    /** The primary Draco3D encoder, javascript wrapper part */
+    DECODER: "draco_wasm_wrapper.js",
+    /** The primary draco decoder, compiled web assembly part */
+    DECODER_WASM: "draco_decoder.wasm",
+    /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
+    FALLBACK_DECODER: "draco_decoder.js",
+    /** Draco encoder */
+    ENCODER: "draco_encoder.js"
+  };
+  var DRACO_EXTERNAL_LIBRARY_URLS = {
+    [DRACO_EXTERNAL_LIBRARIES.DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER}`,
+    [DRACO_EXTERNAL_LIBRARIES.DECODER_WASM]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER_WASM}`,
+    [DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER}`,
+    [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
+  };
+  var loadEncoderPromise;
+  async function loadDracoEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.draco3d) {
+      loadEncoderPromise = loadEncoderPromise || modules.draco3d.createEncoderModule({}).then((draco) => {
+        return { draco };
+      });
+    } else {
+      loadEncoderPromise = loadEncoderPromise || loadDracoEncoder(options);
+    }
+    return await loadEncoderPromise;
+  }
+  async function loadDracoEncoder(options) {
+    let DracoEncoderModule = await loadLibrary(
+      DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.ENCODER],
+      "draco",
+      options,
+      DRACO_EXTERNAL_LIBRARIES.ENCODER
+    );
+    DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;
+    return new Promise((resolve) => {
+      DracoEncoderModule({
+        onModuleLoaded: (draco) => resolve({ draco })
+        // Module is Promise-like. Wrap in object to avoid loop.
+      });
+    });
+  }
+
+  // src/lib/utils/version.ts
+  var VERSION2 = true ? "4.0.3" : "latest";
+
+  // src/draco-writer.ts
+  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 DracoWriter = {
+    name: "DRACO",
+    id: "draco",
+    module: "draco",
+    version: VERSION2,
+    extensions: ["drc"],
+    options: {
+      draco: DEFAULT_DRACO_WRITER_OPTIONS
+    },
+    encode
+  };
+  async function encode(data, options = {}) {
+    const { draco } = await loadDracoEncoderModule(options);
+    const dracoBuilder = new DracoBuilder(draco);
+    try {
+      return dracoBuilder.encodeSync(data, options.draco);
+    } finally {
+      dracoBuilder.destroy();
+    }
+  }
+
+  // src/workers/draco-writer-worker.ts
+  (async () => {
+    if (!await WorkerBody.inWorkerThread()) {
+      return;
+    }
+    WorkerBody.onmessage = async (type, payload) => {
+      switch (type) {
+        case "process":
+          try {
+            const { input, options } = payload;
+            const result = await DracoWriter.encode(input, options);
+            WorkerBody.postMessage("done", { result });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            WorkerBody.postMessage("error", { error: message });
+          }
+          break;
+        default:
+      }
+    };
+  })();
+})();
 //# sourceMappingURL=draco-writer-worker.js.map