@loaders.gl/scene 5.0.0-beta.4 → 5.0.0-beta.6

package/dist/obj-writer.cjs

@@ -27,7 +27,7 @@ module.exports = __toCommonJS(obj_writer_exports);
 // src/obj/obj-writer.ts
 var import_schema_utils = require("@loaders.gl/core/schema-utils");
 var import_obj_format = require("./obj-format.cjs");
-var VERSION = true ? "5.0.0-beta.4" : "latest";
+var VERSION = true ? "5.0.0-beta.6" : "latest";
 var OBJWriter = {
   ...import_obj_format.OBJFormat,
   dataType: null,

package/dist/stl/parse-stl.cjs

@@ -0,0 +1,100 @@
+"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/stl/parse-stl.ts
+var parse_stl_exports = {};
+__export(parse_stl_exports, {
+  parseSTL: () => parseSTL
+});
+module.exports = __toCommonJS(parse_stl_exports);
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+function parseSTL(data) {
+  const view = new DataView(data);
+  const binary = data.byteLength >= 84 && 84 + view.getUint32(80, true) * 50 === data.byteLength;
+  let positions;
+  let normals;
+  let header;
+  if (binary) {
+    const triangleCount = view.getUint32(80, true);
+    positions = new Float32Array(triangleCount * 9);
+    normals = new Float32Array(triangleCount * 9);
+    header = new TextDecoder().decode(data.slice(0, 80));
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+      const offset = 84 + triangle * 50;
+      for (let component = 0; component < 9; component++) {
+        positions[triangle * 9 + component] = view.getFloat32(offset + 12 + component * 4, true);
+        normals[triangle * 9 + component] = view.getFloat32(offset + component % 3 * 4, true);
+      }
+    }
+  } else {
+    const lines = new TextDecoder().decode(data).trim().split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const vertices = [];
+    const normalValues = [];
+    header = lines[0] || "";
+    let lineIndex = 0;
+    while (lineIndex < lines.length) {
+      if (!/^solid(?:\s|$)/i.test(lines[lineIndex++]))
+        throw new Error("STL: expected solid header or exact binary length");
+      while (lineIndex < lines.length && !/^endsolid(?:\s|$)/i.test(lines[lineIndex])) {
+        const normal = parseVector(lines[lineIndex++], "facet normal");
+        if (!/^outer\s+loop$/i.test(lines[lineIndex++] || ""))
+          throw new Error("STL: expected outer loop");
+        for (let vertex = 0; vertex < 3; vertex++) {
+          vertices.push(...parseVector(lines[lineIndex++], "vertex"));
+          normalValues.push(...normal);
+        }
+        if (!/^endloop$/i.test(lines[lineIndex++] || "") || !/^endfacet$/i.test(lines[lineIndex++] || ""))
+          throw new Error("STL: incomplete facet");
+      }
+      if (lineIndex >= lines.length) throw new Error("STL: missing endsolid");
+      lineIndex++;
+    }
+    if (!lines.length) throw new Error("STL: empty input");
+    positions = new Float32Array(vertices);
+    normals = new Float32Array(normalValues);
+  }
+  if (!positions.every(Number.isFinite) || !normals.every(Number.isFinite))
+    throw new Error("STL: non-finite coordinates");
+  const attributes = { POSITION: { value: positions, size: 3 }, NORMAL: { value: normals, size: 3 } };
+  return {
+    topology: "triangle-list",
+    mode: 4,
+    attributes,
+    schema: (0, import_schema_utils.deduceMeshSchema)(attributes),
+    header: {
+      vertexCount: positions.length / 3,
+      boundingBox: (0, import_schema_utils.getMeshBoundingBox)(attributes) ?? void 0
+    },
+    loaderData: { header, format: binary ? "binary" : "ascii" }
+  };
+}
+function parseVector(line, prefix) {
+  const tokens = line?.split(/\s+/) || [];
+  const prefixTokens = prefix.split(" ");
+  const components = tokens.slice(prefixTokens.length);
+  if (prefixTokens.some((token, index) => tokens[index]?.toLowerCase() !== token) || components.length !== 3 || components.some((value) => !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(value))) {
+    throw new Error(`STL: invalid ${prefix} record`);
+  }
+  return components.map(Number);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSTL
+});
+//# sourceMappingURL=parse-stl.cjs.map

package/dist/stl/parse-stl.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/stl/parse-stl.ts"],
+  "sourcesContent": ["// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// loaders.gl\nimport type {Mesh} from '@loaders.gl/core/schema';\nimport {deduceMeshSchema, getMeshBoundingBox} from '@loaders.gl/core/schema-utils';\n\n/** Parses ASCII or little-endian binary STL without changing authored normals. */\nexport function parseSTL(data: ArrayBuffer): Mesh {\n  const view = new DataView(data);\n  const binary = data.byteLength >= 84 && 84 + view.getUint32(80, true) * 50 === data.byteLength;\n  let positions: Float32Array;\n  let normals: Float32Array;\n  let header: string;\n  if (binary) {\n    const triangleCount = view.getUint32(80, true);\n    positions = new Float32Array(triangleCount * 9);\n    normals = new Float32Array(triangleCount * 9);\n    header = new TextDecoder().decode(data.slice(0, 80));\n    for (let triangle = 0; triangle < triangleCount; triangle++) {\n      const offset = 84 + triangle * 50;\n      for (let component = 0; component < 9; component++) {\n        positions[triangle * 9 + component] = view.getFloat32(offset + 12 + component * 4, true);\n        normals[triangle * 9 + component] = view.getFloat32(offset + (component % 3) * 4, true);\n      }\n    }\n  } else {\n    const lines = new TextDecoder()\n      .decode(data)\n      .trim()\n      .split(/\\r?\\n/)\n      .map(line => line.trim())\n      .filter(Boolean);\n    const vertices: number[] = [];\n    const normalValues: number[] = [];\n    header = lines[0] || '';\n    let lineIndex = 0;\n    while (lineIndex < lines.length) {\n      if (!/^solid(?:\\s|$)/i.test(lines[lineIndex++]))\n        throw new Error('STL: expected solid header or exact binary length');\n      while (lineIndex < lines.length && !/^endsolid(?:\\s|$)/i.test(lines[lineIndex])) {\n        const normal = parseVector(lines[lineIndex++], 'facet normal');\n        if (!/^outer\\s+loop$/i.test(lines[lineIndex++] || ''))\n          throw new Error('STL: expected outer loop');\n        for (let vertex = 0; vertex < 3; vertex++) {\n          vertices.push(...parseVector(lines[lineIndex++], 'vertex'));\n          normalValues.push(...normal);\n        }\n        if (\n          !/^endloop$/i.test(lines[lineIndex++] || '') ||\n          !/^endfacet$/i.test(lines[lineIndex++] || '')\n        )\n          throw new Error('STL: incomplete facet');\n      }\n      if (lineIndex >= lines.length) throw new Error('STL: missing endsolid');\n      lineIndex++;\n    }\n    if (!lines.length) throw new Error('STL: empty input');\n    positions = new Float32Array(vertices);\n    normals = new Float32Array(normalValues);\n  }\n  if (!positions.every(Number.isFinite) || !normals.every(Number.isFinite))\n    throw new Error('STL: non-finite coordinates');\n  const attributes = {POSITION: {value: positions, size: 3}, NORMAL: {value: normals, size: 3}};\n  return {\n    topology: 'triangle-list',\n    mode: 4,\n    attributes,\n    schema: deduceMeshSchema(attributes),\n    header: {\n      vertexCount: positions.length / 3,\n      boundingBox: getMeshBoundingBox(attributes) ?? undefined\n    },\n    loaderData: {header, format: binary ? 'binary' : 'ascii'}\n  };\n}\n\n/** Reads exactly three finite decimal components after an ASCII record prefix. */\nfunction parseVector(line: string | undefined, prefix: string): number[] {\n  const tokens = line?.split(/\\s+/) || [];\n  const prefixTokens = prefix.split(' ');\n  const components = tokens.slice(prefixTokens.length);\n  if (\n    prefixTokens.some((token, index) => tokens[index]?.toLowerCase() !== token) ||\n    components.length !== 3 ||\n    components.some(value => !/^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i.test(value))\n  ) {\n    throw new Error(`STL: invalid ${prefix} record`);\n  }\n  return components.map(Number);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/stl/parse-stl.d.ts

@@ -0,0 +1,4 @@
+import type { Mesh } from '@loaders.gl/core/schema';
+/** Parses ASCII or little-endian binary STL without changing authored normals. */
+export declare function parseSTL(data: ArrayBuffer): Mesh;
+//# sourceMappingURL=parse-stl.d.ts.map

package/dist/stl/parse-stl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-stl.d.ts","sourceRoot":"","sources":["../../src/stl/parse-stl.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,yBAAyB,CAAC;AAGlD,kFAAkF;AAClF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAmEhD"}

package/dist/stl/parse-stl.js

@@ -0,0 +1,84 @@
+import { deduceMeshSchema, getMeshBoundingBox } from '@loaders.gl/core/schema-utils';
+/** Parses ASCII or little-endian binary STL without changing authored normals. */
+export function parseSTL(data) {
+    const view = new DataView(data);
+    const binary = data.byteLength >= 84 && 84 + view.getUint32(80, true) * 50 === data.byteLength;
+    let positions;
+    let normals;
+    let header;
+    if (binary) {
+        const triangleCount = view.getUint32(80, true);
+        positions = new Float32Array(triangleCount * 9);
+        normals = new Float32Array(triangleCount * 9);
+        header = new TextDecoder().decode(data.slice(0, 80));
+        for (let triangle = 0; triangle < triangleCount; triangle++) {
+            const offset = 84 + triangle * 50;
+            for (let component = 0; component < 9; component++) {
+                positions[triangle * 9 + component] = view.getFloat32(offset + 12 + component * 4, true);
+                normals[triangle * 9 + component] = view.getFloat32(offset + (component % 3) * 4, true);
+            }
+        }
+    }
+    else {
+        const lines = new TextDecoder()
+            .decode(data)
+            .trim()
+            .split(/\r?\n/)
+            .map(line => line.trim())
+            .filter(Boolean);
+        const vertices = [];
+        const normalValues = [];
+        header = lines[0] || '';
+        let lineIndex = 0;
+        while (lineIndex < lines.length) {
+            if (!/^solid(?:\s|$)/i.test(lines[lineIndex++]))
+                throw new Error('STL: expected solid header or exact binary length');
+            while (lineIndex < lines.length && !/^endsolid(?:\s|$)/i.test(lines[lineIndex])) {
+                const normal = parseVector(lines[lineIndex++], 'facet normal');
+                if (!/^outer\s+loop$/i.test(lines[lineIndex++] || ''))
+                    throw new Error('STL: expected outer loop');
+                for (let vertex = 0; vertex < 3; vertex++) {
+                    vertices.push(...parseVector(lines[lineIndex++], 'vertex'));
+                    normalValues.push(...normal);
+                }
+                if (!/^endloop$/i.test(lines[lineIndex++] || '') ||
+                    !/^endfacet$/i.test(lines[lineIndex++] || ''))
+                    throw new Error('STL: incomplete facet');
+            }
+            if (lineIndex >= lines.length)
+                throw new Error('STL: missing endsolid');
+            lineIndex++;
+        }
+        if (!lines.length)
+            throw new Error('STL: empty input');
+        positions = new Float32Array(vertices);
+        normals = new Float32Array(normalValues);
+    }
+    if (!positions.every(Number.isFinite) || !normals.every(Number.isFinite))
+        throw new Error('STL: non-finite coordinates');
+    const attributes = { POSITION: { value: positions, size: 3 }, NORMAL: { value: normals, size: 3 } };
+    return {
+        topology: 'triangle-list',
+        mode: 4,
+        attributes,
+        schema: deduceMeshSchema(attributes),
+        header: {
+            vertexCount: positions.length / 3,
+            boundingBox: getMeshBoundingBox(attributes) ?? undefined
+        },
+        loaderData: { header, format: binary ? 'binary' : 'ascii' }
+    };
+}
+/** Reads exactly three finite decimal components after an ASCII record prefix. */
+function parseVector(line, prefix) {
+    const tokens = line?.split(/\s+/) || [];
+    const prefixTokens = prefix.split(' ');
+    const components = tokens.slice(prefixTokens.length);
+    if (prefixTokens.some((token, index) => tokens[index]?.toLowerCase() !== token) ||
+        components.length !== 3 ||
+        components.some(value => !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(value))) {
+        throw new Error(`STL: invalid ${prefix} record`);
+    }
+    return components.map(Number);
+}
+//# sourceMappingURL=parse-stl.js.map

package/dist/stl/parse-stl.js.map

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

package/dist/stl-loader-types.cjs

@@ -0,0 +1,58 @@
+"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/stl-loader-types.ts
+var stl_loader_types_exports = {};
+__export(stl_loader_types_exports, {
+  STLLoader: () => STLLoader
+});
+module.exports = __toCommonJS(stl_loader_types_exports);
+var VERSION = true ? "5.0.0-beta.6" : "latest";
+async function preload() {
+  const { STLLoaderWithParser } = await import("@loaders.gl/scene/stl-loader");
+  return STLLoaderWithParser;
+}
+var STLLoader = {
+  name: "STL",
+  id: "stl",
+  module: "scene",
+  version: VERSION,
+  extensions: ["stl"],
+  mimeTypes: ["model/stl"],
+  binary: true,
+  dataType: null,
+  batchType: null,
+  options: {},
+  preload
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STLLoader
+});
+//# sourceMappingURL=stl-loader-types.cjs.map

package/dist/stl-loader-types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/stl-loader-types.ts"],
+  "sourcesContent": ["// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/** Package version injected by the build. */\n// @ts-ignore __VERSION__ is injected during compilation.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n// loaders.gl\nimport type {Mesh} from '@loaders.gl/core/schema';\n\n/** Loads the STL parser on demand. */\nasync function preload() {\n  const {STLLoaderWithParser} = await import('@loaders.gl/scene/stl-loader');\n  return STLLoaderWithParser;\n}\n\n/** Metadata-only loader for ASCII and binary STL triangle meshes. */\nexport const STLLoader = {\n  name: 'STL',\n  id: 'stl',\n  module: 'scene',\n  version: VERSION,\n  extensions: ['stl'],\n  mimeTypes: ['model/stl'],\n  binary: true,\n  dataType: null as unknown as Mesh,\n  batchType: null as never,\n  options: {},\n  preload\n} as const;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,IAAM,UAAU,OAAqC,iBAAc;AAKnE,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,8BAA8B;AACzE,SAAO;AACT;AAGO,IAAM,YAAY;AAAA,EACvB,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,YAAY,CAAC,KAAK;AAAA,EAClB,WAAW,CAAC,WAAW;AAAA,EACvB,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,WAAW;AAAA,EACX,SAAS,CAAC;AAAA,EACV;AACF;",
+  "names": []
+}

package/dist/stl-loader-types.d.ts

@@ -0,0 +1,32 @@
+import type { Mesh } from '@loaders.gl/core/schema';
+/** Loads the STL parser on demand. */
+declare function preload(): Promise<{
+    readonly parse: (data: ArrayBuffer) => Promise<Mesh>;
+    readonly parseSync: typeof import("./stl/parse-stl").parseSTL;
+    readonly name: "STL";
+    readonly id: "stl";
+    readonly module: "scene";
+    readonly version: any;
+    readonly extensions: readonly ["stl"];
+    readonly mimeTypes: readonly ["model/stl"];
+    readonly binary: true;
+    readonly dataType: Mesh;
+    readonly batchType: never;
+    readonly options: {};
+}>;
+/** Metadata-only loader for ASCII and binary STL triangle meshes. */
+export declare const STLLoader: {
+    readonly name: "STL";
+    readonly id: "stl";
+    readonly module: "scene";
+    readonly version: any;
+    readonly extensions: readonly ["stl"];
+    readonly mimeTypes: readonly ["model/stl"];
+    readonly binary: true;
+    readonly dataType: Mesh;
+    readonly batchType: never;
+    readonly options: {};
+    readonly preload: typeof preload;
+};
+export {};
+//# sourceMappingURL=stl-loader-types.d.ts.map

package/dist/stl-loader-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stl-loader-types.d.ts","sourceRoot":"","sources":["../src/stl-loader-types.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,yBAAyB,CAAC;AAElD,sCAAsC;AACtC,iBAAe,OAAO;;;;;;;;;;uBAcS,IAAI;wBACd,KAAK;;GAZzB;AAED,qEAAqE;AACrE,eAAO,MAAM,SAAS;;;;;;;;uBAQS,IAAI;wBACd,KAAK;;;CAGhB,CAAC"}

package/dist/stl-loader-types.js

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Package version injected by the build. */
+// @ts-ignore __VERSION__ is injected during compilation.
+const VERSION = typeof "5.0.0-beta.6" !== 'undefined' ? "5.0.0-beta.6" : 'latest';
+/** Loads the STL parser on demand. */
+async function preload() {
+    const { STLLoaderWithParser } = await import('@loaders.gl/scene/stl-loader');
+    return STLLoaderWithParser;
+}
+/** Metadata-only loader for ASCII and binary STL triangle meshes. */
+export const STLLoader = {
+    name: 'STL',
+    id: 'stl',
+    module: 'scene',
+    version: VERSION,
+    extensions: ['stl'],
+    mimeTypes: ['model/stl'],
+    binary: true,
+    dataType: null,
+    batchType: null,
+    options: {},
+    preload
+};
+//# sourceMappingURL=stl-loader-types.js.map

package/dist/stl-loader-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stl-loader-types.js","sourceRoot":"","sources":["../src/stl-loader-types.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,oCAAoC;AACpC,6CAA6C;AAC7C,yDAAyD;AACzD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAI5E,sCAAsC;AACtC,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,8BAA8B,CAAC,CAAC;IAC3E,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,qEAAqE;AACrE,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,KAAK;IACX,EAAE,EAAE,KAAK;IACT,MAAM,EAAE,OAAO;IACf,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,CAAC,KAAK,CAAC;IACnB,SAAS,EAAE,CAAC,WAAW,CAAC;IACxB,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,IAAuB;IACjC,SAAS,EAAE,IAAa;IACxB,OAAO,EAAE,EAAE;IACX,OAAO;CACC,CAAC"}

package/dist/stl-loader.cjs

@@ -0,0 +1,38 @@
+"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/stl-loader.ts
+var stl_loader_exports = {};
+__export(stl_loader_exports, {
+  STLLoaderWithParser: () => STLLoaderWithParser
+});
+module.exports = __toCommonJS(stl_loader_exports);
+var import_stl_loader_types = require("./stl-loader-types.cjs");
+var import_parse_stl = require("./stl/parse-stl.cjs");
+var { preload: _preload, ...metadata } = import_stl_loader_types.STLLoader;
+var STLLoaderWithParser = {
+  ...metadata,
+  parse: async (data) => (0, import_parse_stl.parseSTL)(data),
+  parseSync: import_parse_stl.parseSTL
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STLLoaderWithParser
+});
+//# sourceMappingURL=stl-loader.cjs.map

package/dist/stl-loader.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/stl-loader.ts"],
+  "sourcesContent": ["// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// loaders.gl\nimport {STLLoader} from './stl-loader-types';\nimport {parseSTL} from './stl/parse-stl';\nconst {preload: _preload, ...metadata} = STLLoader;\n/** Parser-bearing STL loader returning renderer-independent triangle meshes. */\nexport const STLLoaderWithParser = {\n  ...metadata,\n  parse: async (data: ArrayBuffer) => parseSTL(data),\n  parseSync: parseSTL\n} as const;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,8BAAwB;AACxB,uBAAuB;AACvB,IAAM,EAAC,SAAS,UAAU,GAAG,SAAQ,IAAI;AAElC,IAAM,sBAAsB;AAAA,EACjC,GAAG;AAAA,EACH,OAAO,OAAO,aAAsB,2BAAS,IAAI;AAAA,EACjD,WAAW;AACb;",
+  "names": []
+}

package/dist/stl-loader.d.ts

@@ -0,0 +1,17 @@
+import { parseSTL } from "./stl/parse-stl.js";
+/** Parser-bearing STL loader returning renderer-independent triangle meshes. */
+export declare const STLLoaderWithParser: {
+    readonly parse: (data: ArrayBuffer) => Promise<import("@loaders.gl/core/schema").Mesh>;
+    readonly parseSync: typeof parseSTL;
+    readonly name: "STL";
+    readonly id: "stl";
+    readonly module: "scene";
+    readonly version: any;
+    readonly extensions: readonly ["stl"];
+    readonly mimeTypes: readonly ["model/stl"];
+    readonly binary: true;
+    readonly dataType: import("@loaders.gl/core/schema").Mesh;
+    readonly batchType: never;
+    readonly options: {};
+};
+//# sourceMappingURL=stl-loader.d.ts.map

package/dist/stl-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stl-loader.d.ts","sourceRoot":"","sources":["../src/stl-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAC,2BAAwB;AAEzC,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;2BAEV,WAAW;;;;;;;;;;;;CAEvB,CAAC"}

package/dist/stl-loader.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// loaders.gl
+import { STLLoader } from "./stl-loader-types.js";
+import { parseSTL } from "./stl/parse-stl.js";
+const { preload: _preload, ...metadata } = STLLoader;
+/** Parser-bearing STL loader returning renderer-independent triangle meshes. */
+export const STLLoaderWithParser = {
+    ...metadata,
+    parse: async (data) => parseSTL(data),
+    parseSync: parseSTL
+};
+//# sourceMappingURL=stl-loader.js.map

package/dist/stl-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stl-loader.js","sourceRoot":"","sources":["../src/stl-loader.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,oCAAoC;AACpC,aAAa;AACb,OAAO,EAAC,SAAS,EAAC,8BAA2B;AAC7C,OAAO,EAAC,QAAQ,EAAC,2BAAwB;AACzC,MAAM,EAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAC,GAAG,SAAS,CAAC;AACnD,gFAAgF;AAChF,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,GAAG,QAAQ;IACX,KAAK,EAAE,KAAK,EAAE,IAAiB,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC;IAClD,SAAS,EAAE,QAAQ;CACX,CAAC"}

package/dist/usd/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/usd/index.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nexport {USDLoader} from './usd-loader-types';\nexport type {\n  USDAssetPath,\n  USDAttribute,\n  USDLoaderOptions,\n  USDPrim,\n  USDScenePath,\n  USDStage,\n  USDValue,\n  USDVariant\n} from './lib/usd-types';\n"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nexport {USDLoader} from './usd-loader-types';\nexport type {\n  USDAssetPath,\n  USDAttribute,\n  USDEmbeddedAsset,\n  USDLoaderOptions,\n  USDPrim,\n  USDScenePath,\n  USDStage,\n  USDValue,\n  USDVariant\n} from './lib/usd-types';\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,8BAAwB;",
   "names": []
 }

package/dist/usd/index.d.ts

@@ -1,3 +1,3 @@
 export { USDLoader } from "./usd-loader-types.js";
-export type { USDAssetPath, USDAttribute, USDLoaderOptions, USDPrim, USDScenePath, USDStage, USDValue, USDVariant } from "./lib/usd-types.js";
+export type { USDAssetPath, USDAttribute, USDEmbeddedAsset, USDLoaderOptions, USDPrim, USDScenePath, USDStage, USDValue, USDVariant } from "./lib/usd-types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/usd/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/usd/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,SAAS,EAAC,8BAA2B;AAC7C,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,UAAU,EACX,2BAAwB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/usd/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,SAAS,EAAC,8BAA2B;AAC7C,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,UAAU,EACX,2BAAwB"}

package/dist/usd/lib/parse-usd.cjs

@@ -23,6 +23,7 @@ __export(parse_usd_exports, {
   parseUSD: () => parseUSD
 });
 module.exports = __toCommonJS(parse_usd_exports);
+var import_parse_usdc = require("./parse-usdc.cjs");
 var import_parse_usda = require("./parse-usda.cjs");
 var import_parse_usdz = require("./parse-usdz.cjs");
 var TEXT_DECODER = new TextDecoder();
@@ -52,21 +53,32 @@ async function parseUSD(data, options = {}, context) {
   let stage;
   if (isZIPArchive(data)) {
     const archive = (0, import_parse_usdz.parseUSDZArchive)(data);
-    const rootFilename = Array.from(archive.keys()).find((filename) => /\.usda?$/i.test(filename));
-    if (!rootFilename) {
-      throw new Error("USDZ archives with binary USDC root layers are not implemented yet.");
+    const rootFilename = archive.keys().next().value;
+    if (!rootFilename || !/\.(?:usd[ac]?)$/i.test(rootFilename)) {
+      throw new Error("USDZ archive has no supported USD root layer.");
     }
     const archiveBase = "https://usd.archive/";
+    const assets = /* @__PURE__ */ Object.create(null);
     for (const [filename, content] of archive) {
-      environment.archiveFiles.set(new URL(filename, archiveBase).href, content);
+      const assetUrl = new URL(filename, archiveBase);
+      if (filename.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(filename) || filename.includes("\\") || /[\u0000-\u001f\u007f]/.test(filename) || filename.trim() !== filename || filename.split("/").some((segment) => {
+        const normalizedSegment = segment.replace(/%2e/gi, ".");
+        return normalizedSegment === "." || normalizedSegment === "..";
+      }) || assetUrl.origin !== new URL(archiveBase).origin || assetUrl.search || assetUrl.hash || assets[assetUrl.href]) {
+        throw new Error(`USDZ entry "${filename}" has an ambiguous package URL.`);
+      }
+      environment.archiveFiles.set(assetUrl.href, content);
+      assets[assetUrl.href] = createEmbeddedAsset(filename, content);
     }
     const rootUrl = new URL(rootFilename, archiveBase).href;
     stage = parseUSDLayer(archive.get(rootFilename), rootUrl);
     stage.format = "usdz";
+    stage.assets = assets;
   } else {
     stage = parseUSDLayer(data, url);
   }
   if (stage.url) {
+    setAttributeSourceUrls(stage, stage.url);
     environment.layers.add(stage.url);
   }
   if (environment.options.usd?.compose !== false) {
@@ -78,6 +90,11 @@ async function parseUSD(data, options = {}, context) {
   }
   return stage;
 }
+function createEmbeddedAsset(path, data) {
+  const extension = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+  const mimeType = extension === "png" ? "image/png" : /^(?:jpe?g)$/.test(extension) ? "image/jpeg" : void 0;
+  return mimeType ? { path, data, mimeType } : { path, data };
+}
 function getSourceLocation(configuredLocation, contextLocation) {
   const configuredUrl = getAbsoluteUrl(configuredLocation);
   if (configuredUrl) {
@@ -110,10 +127,29 @@ var USD_LOADER_DEFAULT_OPTIONS = {
 function parseUSDLayer(data, url) {
   const signature = TEXT_DECODER.decode(data.slice(0, 8));
   if (signature === CRATE_SIGNATURE) {
-    throw new Error("Binary USDC crate layers are not implemented yet; use ASCII USDA layers.");
+    return (0, import_parse_usdc.parseUSDC)(data, url);
   }
   return (0, import_parse_usda.parseUSDA)(TEXT_DECODER.decode(data), url);
 }
+function setAttributeSourceUrls(stage, sourceUrl) {
+  const pendingContents = [...stage.rootPrims];
+  while (pendingContents.length) {
+    const contents = pendingContents.pop();
+    for (const attribute of Object.values(contents.attributes)) {
+      attribute.sourceUrl = sourceUrl;
+    }
+    for (const child of contents.children) {
+      pendingContents.push(child);
+    }
+    if ("variants" in contents) {
+      for (const variants of Object.values(contents.variants)) {
+        for (const variant of Object.values(variants)) {
+          pendingContents.push(variant);
+        }
+      }
+    }
+  }
+}
 async function composePrims(prims, sourceUrl, inheritedVariants, environment, depth) {
   if (depth > (environment.options.usd?.maxReferenceDepth ?? 12)) {
     throw new Error("OpenUSD reference composition exceeded the configured depth limit.");
@@ -192,6 +228,7 @@ async function loadReferencedStage(url, environment) {
         content = response.arrayBuffer();
       }
       const stage = parseUSDLayer(await content, url);
+      setAttributeSourceUrls(stage, url);
       environment.layers.add(url);
       return stage;
     })();