@loaders.gl/obj 3.1.3 → 4.0.0-alpha.5

package/dist/bundle.js

@@ -1,5 +1,5 @@
-"use strict";
-// @ts-nocheck
 const moduleExports = require('./index');
+
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/dist.min.js

@@ -562,10 +562,160 @@
     }
   });
 
-  // src/lib/parse-obj.ts
-  var OBJECT_RE, MATERIAL_RE, MATERIAL_USE_RE, MeshMaterial, MeshObject, ParserState, parse_obj_default;
-  var init_parse_obj = __esm({
-    "src/lib/parse-obj.ts"() {
+  // src/lib/parse-obj-meshes.ts
+  function parseOBJMeshes(text) {
+    const state = new ParserState();
+    if (text.indexOf("\r\n") !== -1) {
+      text = text.replace(/\r\n/g, "\n");
+    }
+    if (text.indexOf("\\\n") !== -1) {
+      text = text.replace(/\\\n/g, "");
+    }
+    const lines = text.split("\n");
+    let line = "";
+    let lineFirstChar = "";
+    let lineLength = 0;
+    let result = [];
+    const trimLeft = typeof "".trimLeft === "function";
+    for (let i = 0, l = lines.length; i < l; i++) {
+      line = lines[i];
+      line = trimLeft ? line.trimLeft() : line.trim();
+      lineLength = line.length;
+      if (lineLength === 0)
+        continue;
+      lineFirstChar = line.charAt(0);
+      if (lineFirstChar === "#")
+        continue;
+      if (lineFirstChar === "v") {
+        const data = line.split(/\s+/);
+        switch (data[0]) {
+          case "v":
+            state.vertices.push(parseFloat(data[1]), parseFloat(data[2]), parseFloat(data[3]));
+            if (data.length === 8) {
+              state.colors.push(parseFloat(data[4]), parseFloat(data[5]), parseFloat(data[6]));
+            }
+            break;
+          case "vn":
+            state.normals.push(parseFloat(data[1]), parseFloat(data[2]), parseFloat(data[3]));
+            break;
+          case "vt":
+            state.uvs.push(parseFloat(data[1]), parseFloat(data[2]));
+            break;
+          default:
+        }
+      } else if (lineFirstChar === "f") {
+        const lineData = line.substr(1).trim();
+        const vertexData = lineData.split(/\s+/);
+        const faceVertices = [];
+        for (let j = 0, jl = vertexData.length; j < jl; j++) {
+          const vertex = vertexData[j];
+          if (vertex.length > 0) {
+            const vertexParts = vertex.split("/");
+            faceVertices.push(vertexParts);
+          }
+        }
+        const v1 = faceVertices[0];
+        for (let j = 1, jl = faceVertices.length - 1; j < jl; j++) {
+          const v2 = faceVertices[j];
+          const v3 = faceVertices[j + 1];
+          state.addFace(v1[0], v2[0], v3[0], v1[1], v2[1], v3[1], v1[2], v2[2], v3[2]);
+        }
+      } else if (lineFirstChar === "l") {
+        const lineParts = line.substring(1).trim().split(" ");
+        let lineVertices;
+        const lineUVs = [];
+        if (line.indexOf("/") === -1) {
+          lineVertices = lineParts;
+        } else {
+          lineVertices = [];
+          for (let li = 0, llen = lineParts.length; li < llen; li++) {
+            const parts = lineParts[li].split("/");
+            if (parts[0] !== "")
+              lineVertices.push(parts[0]);
+            if (parts[1] !== "")
+              lineUVs.push(parts[1]);
+          }
+        }
+        state.addLineGeometry(lineVertices, lineUVs);
+      } else if (lineFirstChar === "p") {
+        const lineData = line.substr(1).trim();
+        const pointData = lineData.split(" ");
+        state.addPointGeometry(pointData);
+      } else if ((result = OBJECT_RE.exec(line)) !== null) {
+        const name = (" " + result[0].substr(1).trim()).substr(1);
+        state.startObject(name);
+      } else if (MATERIAL_USE_RE.test(line)) {
+        state.object.startMaterial(line.substring(7).trim(), state.materialLibraries);
+      } else if (MATERIAL_RE.test(line)) {
+        state.materialLibraries.push(line.substring(7).trim());
+      } else if (lineFirstChar === "s") {
+        result = line.split(" ");
+        if (result.length > 1) {
+          const value = result[1].trim().toLowerCase();
+          state.object.smooth = value !== "0" && value !== "off";
+        } else {
+          state.object.smooth = true;
+        }
+        const material = state.object.currentMaterial();
+        if (material)
+          material.smooth = state.object.smooth;
+      } else {
+        if (line === "\0")
+          continue;
+        throw new Error(`Unexpected line: "${line}"`);
+      }
+    }
+    state.finalize();
+    const meshes = [];
+    const materials = [];
+    for (const object of state.objects) {
+      const { geometry } = object;
+      if (geometry.vertices.length === 0)
+        continue;
+      const mesh = {
+        header: {
+          vertexCount: geometry.vertices.length / 3
+        },
+        attributes: {}
+      };
+      switch (geometry.type) {
+        case "Points":
+          mesh.mode = 0;
+          break;
+        case "Line":
+          mesh.mode = 1;
+          break;
+        default:
+          mesh.mode = 4;
+          break;
+      }
+      mesh.attributes.POSITION = { value: new Float32Array(geometry.vertices), size: 3 };
+      if (geometry.normals.length > 0) {
+        mesh.attributes.NORMAL = { value: new Float32Array(geometry.normals), size: 3 };
+      }
+      if (geometry.colors.length > 0) {
+        mesh.attributes.COLOR_0 = { value: new Float32Array(geometry.colors), size: 3 };
+      }
+      if (geometry.uvs.length > 0) {
+        mesh.attributes.TEXCOORD_0 = { value: new Float32Array(geometry.uvs), size: 2 };
+      }
+      mesh.materials = [];
+      for (const sourceMaterial of object.materials) {
+        const _material = {
+          name: sourceMaterial.name,
+          flatShading: !sourceMaterial.smooth
+        };
+        mesh.materials.push(_material);
+        materials.push(_material);
+      }
+      mesh.name = object.name;
+      meshes.push(mesh);
+    }
+    return { meshes, materials };
+  }
+  var OBJECT_RE, MATERIAL_RE, MATERIAL_USE_RE, MeshMaterial, MeshObject, ParserState;
+  var init_parse_obj_meshes = __esm({
+    "src/lib/parse-obj-meshes.ts"() {
       OBJECT_RE = /^[og]\s*(.+)?/;
       MATERIAL_RE = /^mtllib /;
       MATERIAL_USE_RE = /^usemtl /;
@@ -780,156 +930,6 @@
           }
         }
       };
-      parse_obj_default = (text) => {
-        const state = new ParserState();
-        if (text.indexOf("\r\n") !== -1) {
-          text = text.replace(/\r\n/g, "\n");
-        }
-        if (text.indexOf("\\\n") !== -1) {
-          text = text.replace(/\\\n/g, "");
-        }
-        const lines = text.split("\n");
-        let line = "";
-        let lineFirstChar = "";
-        let lineLength = 0;
-        let result = [];
-        const trimLeft = typeof "".trimLeft === "function";
-        for (let i = 0, l = lines.length; i < l; i++) {
-          line = lines[i];
-          line = trimLeft ? line.trimLeft() : line.trim();
-          lineLength = line.length;
-          if (lineLength === 0)
-            continue;
-          lineFirstChar = line.charAt(0);
-          if (lineFirstChar === "#")
-            continue;
-          if (lineFirstChar === "v") {
-            const data = line.split(/\s+/);
-            switch (data[0]) {
-              case "v":
-                state.vertices.push(parseFloat(data[1]), parseFloat(data[2]), parseFloat(data[3]));
-                if (data.length === 8) {
-                  state.colors.push(parseFloat(data[4]), parseFloat(data[5]), parseFloat(data[6]));
-                }
-                break;
-              case "vn":
-                state.normals.push(parseFloat(data[1]), parseFloat(data[2]), parseFloat(data[3]));
-                break;
-              case "vt":
-                state.uvs.push(parseFloat(data[1]), parseFloat(data[2]));
-                break;
-              default:
-            }
-          } else if (lineFirstChar === "f") {
-            const lineData = line.substr(1).trim();
-            const vertexData = lineData.split(/\s+/);
-            const faceVertices = [];
-            for (let j = 0, jl = vertexData.length; j < jl; j++) {
-              const vertex = vertexData[j];
-              if (vertex.length > 0) {
-                const vertexParts = vertex.split("/");
-                faceVertices.push(vertexParts);
-              }
-            }
-            const v1 = faceVertices[0];
-            for (let j = 1, jl = faceVertices.length - 1; j < jl; j++) {
-              const v2 = faceVertices[j];
-              const v3 = faceVertices[j + 1];
-              state.addFace(v1[0], v2[0], v3[0], v1[1], v2[1], v3[1], v1[2], v2[2], v3[2]);
-            }
-          } else if (lineFirstChar === "l") {
-            const lineParts = line.substring(1).trim().split(" ");
-            let lineVertices;
-            const lineUVs = [];
-            if (line.indexOf("/") === -1) {
-              lineVertices = lineParts;
-            } else {
-              lineVertices = [];
-              for (let li = 0, llen = lineParts.length; li < llen; li++) {
-                const parts = lineParts[li].split("/");
-                if (parts[0] !== "")
-                  lineVertices.push(parts[0]);
-                if (parts[1] !== "")
-                  lineUVs.push(parts[1]);
-              }
-            }
-            state.addLineGeometry(lineVertices, lineUVs);
-          } else if (lineFirstChar === "p") {
-            const lineData = line.substr(1).trim();
-            const pointData = lineData.split(" ");
-            state.addPointGeometry(pointData);
-          } else if ((result = OBJECT_RE.exec(line)) !== null) {
-            const name = (" " + result[0].substr(1).trim()).substr(1);
-            state.startObject(name);
-          } else if (MATERIAL_USE_RE.test(line)) {
-            state.object.startMaterial(line.substring(7).trim(), state.materialLibraries);
-          } else if (MATERIAL_RE.test(line)) {
-            state.materialLibraries.push(line.substring(7).trim());
-          } else if (lineFirstChar === "s") {
-            result = line.split(" ");
-            if (result.length > 1) {
-              const value = result[1].trim().toLowerCase();
-              state.object.smooth = value !== "0" && value !== "off";
-            } else {
-              state.object.smooth = true;
-            }
-            const material = state.object.currentMaterial();
-            if (material)
-              material.smooth = state.object.smooth;
-          } else {
-            if (line === "\0")
-              continue;
-            throw new Error(`Unexpected line: "${line}"`);
-          }
-        }
-        state.finalize();
-        const meshes = [];
-        const materials = [];
-        for (const object of state.objects) {
-          const { geometry } = object;
-          if (geometry.vertices.length === 0)
-            continue;
-          const mesh = {
-            header: {
-              vertexCount: geometry.vertices.length / 3
-            },
-            attributes: {}
-          };
-          switch (geometry.type) {
-            case "Points":
-              mesh.mode = 0;
-              break;
-            case "Line":
-              mesh.mode = 1;
-              break;
-            default:
-              mesh.mode = 4;
-              break;
-          }
-          mesh.attributes.POSITION = { value: new Float32Array(geometry.vertices), size: 3 };
-          if (geometry.normals.length > 0) {
-            mesh.attributes.NORMAL = { value: new Float32Array(geometry.normals), size: 3 };
-          }
-          if (geometry.colors.length > 0) {
-            mesh.attributes.COLOR_0 = { value: new Float32Array(geometry.colors), size: 3 };
-          }
-          if (geometry.uvs.length > 0) {
-            mesh.attributes.TEXCOORD_0 = { value: new Float32Array(geometry.uvs), size: 2 };
-          }
-          mesh.materials = [];
-          for (const sourceMaterial of object.materials) {
-            const _material = {
-              name: sourceMaterial.name,
-              flatShading: !sourceMaterial.smooth
-            };
-            mesh.materials.push(_material);
-            materials.push(_material);
-          }
-          mesh.name = object.name;
-          meshes.push(mesh);
-        }
-        return { meshes, materials };
-      };
     }
   });
 
@@ -967,9 +967,9 @@
     }
   });
 
-  // src/lib/load-obj.ts
-  function loadOBJ(text, options) {
-    const { meshes } = parse_obj_default(text);
+  // src/lib/parse-obj.ts
+  function parseOBJ(text, options) {
+    const { meshes } = parseOBJMeshes(text);
     const vertexCount = meshes.reduce((s, mesh) => s + mesh.header.vertexCount, 0);
     const attributes = mergeAttributes(meshes, vertexCount);
     const header = {
@@ -1026,14 +1026,88 @@
     }
     return attributes;
   }
-  var init_load_obj = __esm({
-    "src/lib/load-obj.ts"() {
+  var init_parse_obj = __esm({
+    "src/lib/parse-obj.ts"() {
       init_src();
-      init_parse_obj();
+      init_parse_obj_meshes();
       init_get_obj_schema();
     }
   });
 
+  // src/lib/parse-mtl.ts
+  function parseMTL(text, options) {
+    const materials = [];
+    let currentMaterial = { name: "placeholder" };
+    const lines = text.split("\n");
+    for (let line of lines) {
+      line = line.trim();
+      if (line.length === 0 || line.charAt(0) === "#") {
+        continue;
+      }
+      const pos = line.indexOf(" ");
+      let key = pos >= 0 ? line.substring(0, pos) : line;
+      key = key.toLowerCase();
+      let value = pos >= 0 ? line.substring(pos + 1) : "";
+      value = value.trim();
+      switch (key) {
+        case "newmtl":
+          currentMaterial = { name: value };
+          materials.push(currentMaterial);
+          break;
+        case "ka":
+          currentMaterial.ambientColor = parseColor(value);
+          break;
+        case "kd":
+          currentMaterial.diffuseColor = parseColor(value);
+          break;
+        case "map_kd":
+          currentMaterial.diffuseTextureUrl = value;
+          break;
+        case "ks":
+          currentMaterial.specularColor = parseColor(value);
+          break;
+        case "map_ks":
+          currentMaterial.specularTextureUrl = value;
+          break;
+        case "ke":
+          currentMaterial.emissiveColor = parseColor(value);
+          break;
+        case "map_ke":
+          currentMaterial.emissiveTextureUrl = value;
+          break;
+        case "ns":
+          currentMaterial.shininess = parseFloat(value);
+          break;
+        case "map_ns":
+          break;
+        case "ni":
+          currentMaterial.refraction = parseFloat(value);
+          break;
+        case "illum":
+          currentMaterial.illumination = parseFloat(value);
+          break;
+        default:
+          break;
+      }
+    }
+    return materials;
+  }
+  function parseColor(value, options) {
+    const rgb = value.split(DELIMITER_PATTERN, 3);
+    const color = [
+      parseFloat(rgb[0]),
+      parseFloat(rgb[1]),
+      parseFloat(rgb[2])
+    ];
+    return color;
+  }
+  var DELIMITER_PATTERN;
+  var init_parse_mtl = __esm({
+    "src/lib/parse-mtl.ts"() {
+      DELIMITER_PATTERN = /\s+/;
+    }
+  });
+
   // src/obj-loader.ts
   function testOBJFile(text) {
     return text[0] === "v";
@@ -1058,24 +1132,55 @@
     }
   });
 
+  // src/mtl-loader.ts
+  var VERSION2, MTLLoader;
+  var init_mtl_loader = __esm({
+    "src/mtl-loader.ts"() {
+      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      MTLLoader = {
+        name: "MTL",
+        id: "mtl",
+        module: "mtl",
+        version: VERSION2,
+        worker: true,
+        extensions: ["mtl"],
+        mimeTypes: ["text/plain"],
+        testText: (text) => text.includes("newmtl"),
+        options: {
+          mtl: {}
+        }
+      };
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
+    MTLLoader: () => MTLLoader2,
     OBJLoader: () => OBJLoader2,
     OBJWorkerLoader: () => OBJLoader,
+    _typecheckMTLLoader: () => _typecheckMTLLoader,
     _typecheckOBJLoader: () => _typecheckOBJLoader
   });
-  var OBJLoader2, _typecheckOBJLoader;
+  var OBJLoader2, MTLLoader2, _typecheckOBJLoader, _typecheckMTLLoader;
   var init_src2 = __esm({
     "src/index.ts"() {
-      init_load_obj();
+      init_parse_obj();
+      init_parse_mtl();
       init_obj_loader();
+      init_mtl_loader();
       OBJLoader2 = {
         ...OBJLoader,
-        parse: async (arrayBuffer, options) => loadOBJ(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: loadOBJ
+        parse: async (arrayBuffer, options) => parseOBJ(new TextDecoder().decode(arrayBuffer), options),
+        parseTextSync: (text, options) => parseOBJ(text, options)
+      };
+      MTLLoader2 = {
+        ...MTLLoader,
+        parse: async (arrayBuffer, options) => parseMTL(new TextDecoder().decode(arrayBuffer), options?.mtl),
+        parseTextSync: (text, options) => parseMTL(text, options?.mtl)
       };
       _typecheckOBJLoader = OBJLoader2;
+      _typecheckMTLLoader = MTLLoader2;
     }
   });
 

package/dist/index.d.ts

@@ -1,12 +1,16 @@
 import type { LoaderWithParser } from '@loaders.gl/loader-utils';
-import loadOBJ from './lib/load-obj';
+import type { OBJLoaderOptions } from './obj-loader';
 import { OBJLoader as OBJWorkerLoader } from './obj-loader';
+import type { MTLLoaderOptions } from './mtl-loader';
 export { OBJWorkerLoader };
 /**
  * Loader for the OBJ geometry format
  */
 export declare const OBJLoader: {
-    parse: (arrayBuffer: any, options: any) => Promise<{
+    parse: (arrayBuffer: ArrayBuffer, options?: OBJLoaderOptions | undefined) => Promise<{
+        /**
+         * Loader for the MTL material format
+         */
         loaderData: {
             header: {};
         };
@@ -18,7 +22,21 @@ export declare const OBJLoader: {
         mode: number;
         attributes: import("@loaders.gl/schema").MeshAttributes;
     }>;
-    parseTextSync: typeof loadOBJ;
+    parseTextSync: (text: string, options?: OBJLoaderOptions | undefined) => {
+        /**
+         * Loader for the MTL material format
+         */
+        loaderData: {
+            header: {};
+        };
+        schema: import("@loaders.gl/schema").Schema;
+        header: {
+            vertexCount: number;
+            boundingBox: [[number, number, number], [number, number, number]];
+        };
+        mode: number;
+        attributes: import("@loaders.gl/schema").MeshAttributes;
+    };
     name: string;
     id: string;
     module: string;
@@ -26,10 +44,29 @@ export declare const OBJLoader: {
     worker: boolean;
     extensions: string[];
     mimeTypes: string[];
-    testText: (text: any) => boolean;
+    testText: (text: string) => boolean;
     options: {
         obj: {};
     };
 };
+/**
+ * Loader for the MTL material format
+ */
+export declare const MTLLoader: {
+    parse: (arrayBuffer: ArrayBuffer, options?: MTLLoaderOptions | undefined) => Promise<import("./lib/parse-mtl").MTLMaterial[]>;
+    parseTextSync: (text: string, options?: MTLLoaderOptions | undefined) => import("./lib/parse-mtl").MTLMaterial[];
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    extensions: string[];
+    mimeTypes: string[];
+    testText: (text: string) => boolean;
+    options: {
+        mtl: {};
+    };
+};
 export declare const _typecheckOBJLoader: LoaderWithParser;
+export declare const _typecheckMTLLoader: LoaderWithParser;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAC,SAAS,IAAI,eAAe,EAAC,MAAM,cAAc,CAAC;AAI1D,OAAO,EAAC,eAAe,EAAC,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;CAIrB,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAG/D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AACnD,OAAO,EAAC,SAAS,IAAI,eAAe,EAAC,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAKnD,OAAO,EAAC,eAAe,EAAC,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,SAAS;yBAEO,WAAW;QAOxC;;WAEG;;;;;;;;;;;;0BAPqB,MAAM;QAK9B;;WAEG;;;;;;;;;;;;;;;;;;;;;;;CANF,CAAC;AAIF;;GAEG;AACH,eAAO,MAAM,SAAS;yBAEO,WAAW;0BAEhB,MAAM;;;;;;;;;;;;CAC7B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC;AAC/D,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC"}

package/dist/index.js

@@ -1,18 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { parseOBJ } from './lib/parse-obj';
+import { parseMTL } from './lib/parse-mtl';
+import { OBJLoader as OBJWorkerLoader } from './obj-loader';
+import { MTLLoader as MTLWorkerLoader } from './mtl-loader';
+export { OBJWorkerLoader };
+export const OBJLoader = { ...OBJWorkerLoader,
+  parse: async (arrayBuffer, options) => parseOBJ(new TextDecoder().decode(arrayBuffer), options),
+  parseTextSync: (text, options) => parseOBJ(text, options)
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckOBJLoader = exports.OBJLoader = exports.OBJWorkerLoader = void 0;
-const load_obj_1 = __importDefault(require("./lib/load-obj"));
-const obj_loader_1 = require("./obj-loader");
-Object.defineProperty(exports, "OBJWorkerLoader", { enumerable: true, get: function () { return obj_loader_1.OBJLoader; } });
-/**
- * Loader for the OBJ geometry format
- */
-exports.OBJLoader = {
-    ...obj_loader_1.OBJLoader,
-    parse: async (arrayBuffer, options) => (0, load_obj_1.default)(new TextDecoder().decode(arrayBuffer), options),
-    parseTextSync: load_obj_1.default
+export const MTLLoader = { ...MTLWorkerLoader,
+  parse: async (arrayBuffer, options) => parseMTL(new TextDecoder().decode(arrayBuffer), options === null || options === void 0 ? void 0 : options.mtl),
+  parseTextSync: (text, options) => parseMTL(text, options === null || options === void 0 ? void 0 : options.mtl)
 };
-exports._typecheckOBJLoader = exports.OBJLoader;
+export const _typecheckOBJLoader = OBJLoader;
+export const _typecheckMTLLoader = MTLLoader;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["parseOBJ","parseMTL","OBJLoader","OBJWorkerLoader","MTLLoader","MTLWorkerLoader","parse","arrayBuffer","options","TextDecoder","decode","parseTextSync","text","mtl","_typecheckOBJLoader","_typecheckMTLLoader"],"mappings":"AACA,SAAQA,QAAR,QAAuB,iBAAvB;AACA,SAAQC,QAAR,QAAuB,iBAAvB;AAEA,SAAQC,SAAS,IAAIC,eAArB,QAA2C,cAA3C;AAEA,SAAQC,SAAS,IAAIC,eAArB,QAA2C,cAA3C;AAIA,SAAQF,eAAR;AAKA,OAAO,MAAMD,SAAS,GAAG,EACvB,GAAGC,eADoB;AAEvBG,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAiCC,OAAjC,KACLR,QAAQ,CAAC,IAAIS,WAAJ,GAAkBC,MAAlB,CAAyBH,WAAzB,CAAD,EAAwCC,OAAxC,CAHa;AAIvBG,EAAAA,aAAa,EAAE,CAACC,IAAD,EAAeJ,OAAf,KAA8CR,QAAQ,CAACY,IAAD,EAAOJ,OAAP;AAJ9C,CAAlB;AAYP,OAAO,MAAMJ,SAAS,GAAG,EACvB,GAAGC,eADoB;AAEvBC,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAiCC,OAAjC,KACLP,QAAQ,CAAC,IAAIQ,WAAJ,GAAkBC,MAAlB,CAAyBH,WAAzB,CAAD,EAAwCC,OAAxC,aAAwCA,OAAxC,uBAAwCA,OAAO,CAAEK,GAAjD,CAHa;AAIvBF,EAAAA,aAAa,EAAE,CAACC,IAAD,EAAeJ,OAAf,KAA8CP,QAAQ,CAACW,IAAD,EAAOJ,OAAP,aAAOA,OAAP,uBAAOA,OAAO,CAAEK,GAAhB;AAJ9C,CAAlB;AAOP,OAAO,MAAMC,mBAAqC,GAAGZ,SAA9C;AACP,OAAO,MAAMa,mBAAqC,GAAGX,SAA9C","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseOBJ} from './lib/parse-obj';\nimport {parseMTL} from './lib/parse-mtl';\nimport type {OBJLoaderOptions} from './obj-loader';\nimport {OBJLoader as OBJWorkerLoader} from './obj-loader';\nimport type {MTLLoaderOptions} from './mtl-loader';\nimport {MTLLoader as MTLWorkerLoader} from './mtl-loader';\n\n// OBJLoader\n\nexport {OBJWorkerLoader};\n\n/**\n * Loader for the OBJ geometry format\n */\nexport const OBJLoader = {\n  ...OBJWorkerLoader,\n  parse: async (arrayBuffer: ArrayBuffer, options?: OBJLoaderOptions) =>\n    parseOBJ(new TextDecoder().decode(arrayBuffer), options),\n  parseTextSync: (text: string, options?: OBJLoaderOptions) => parseOBJ(text, options)\n};\n\n// MTLLoader\n\n/**\n * Loader for the MTL material format\n */\nexport const MTLLoader = {\n  ...MTLWorkerLoader,\n  parse: async (arrayBuffer: ArrayBuffer, options?: MTLLoaderOptions) =>\n    parseMTL(new TextDecoder().decode(arrayBuffer), options?.mtl),\n  parseTextSync: (text: string, options?: MTLLoaderOptions) => parseMTL(text, options?.mtl)\n};\n\nexport const _typecheckOBJLoader: LoaderWithParser = OBJLoader;\nexport const _typecheckMTLLoader: LoaderWithParser = MTLLoader;\n"],"file":"index.js"}