@loaders.gl/scene 5.0.0-alpha.1

package/dist/dist.dev.js

@@ -0,0 +1,831 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
+"use strict";
+var __exports__ = (() => {
+  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 __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  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);
+
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
+  // src/lib/parse-usda.ts
+  function parseUSDA(source, url) {
+    if (!source.trimStart().startsWith("#usda")) {
+      throw new Error("OpenUSD ASCII layers must begin with the #usda header.");
+    }
+    return new USDAParser(source, url).parse();
+  }
+  var NUMBER_PATTERN, QUALIFIERS, USDAParser, USDTokenizer;
+  var init_parse_usda = __esm({
+    "src/lib/parse-usda.ts"() {
+      "use strict";
+      NUMBER_PATTERN = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/;
+      QUALIFIERS = /* @__PURE__ */ new Set([
+        "uniform",
+        "varying",
+        "custom",
+        "prepend",
+        "append",
+        "add",
+        "delete",
+        "reorder"
+      ]);
+      USDAParser = class {
+        /** Token stream for the source layer. */
+        tokenizer;
+        /** URL of the source layer. */
+        url;
+        /** Creates a USDA parser. */
+        constructor(source, url) {
+          this.tokenizer = new USDTokenizer(source);
+          this.url = url;
+        }
+        /** Parses the complete USDA layer. */
+        parse() {
+          const metadata = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
+          const rootPrims = [];
+          while (!this.tokenizer.isAtEnd()) {
+            if (this.isPrimDeclaration()) {
+              rootPrims.push(this.parsePrim(""));
+            } else {
+              this.tokenizer.read();
+            }
+          }
+          return {
+            format: "usda",
+            url: this.url,
+            metadata,
+            rootPrims,
+            layers: this.url ? [this.url] : []
+          };
+        }
+        /** Parses a prim and its descendants. */
+        parsePrim(parentPath) {
+          const declaration = this.tokenizer.read();
+          const specifier = declaration.value;
+          const firstToken = this.tokenizer.read();
+          const hasExplicitType = this.tokenizer.peek().kind === "string";
+          const type = hasExplicitType ? firstToken.value : "";
+          const name = hasExplicitType ? this.tokenizer.read().value : firstToken.value;
+          const path = `${parentPath}/${name}`;
+          const metadata = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
+          this.tokenizer.expect("{");
+          const contents = this.parsePrimContents(path);
+          return {
+            name,
+            path,
+            sourceUrl: this.url,
+            type,
+            specifier,
+            attributes: contents.attributes,
+            metadata: { ...metadata, ...contents.metadata },
+            variants: contents.variants,
+            children: contents.children
+          };
+        }
+        /** Parses the attributes, variants, and child prims inside a prim body. */
+        parsePrimContents(parentPath) {
+          const attributes = {};
+          const metadata = {};
+          const children = [];
+          const variants = {};
+          while (!this.tokenizer.isAtEnd() && !this.tokenizer.match("}")) {
+            if (this.isPrimDeclaration()) {
+              children.push(this.parsePrim(parentPath));
+            } else if (this.tokenizer.peek().value === "variantSet") {
+              this.parseVariantSet(parentPath, variants);
+            } else {
+              const attribute = this.parseAttribute();
+              if (attribute) {
+                attributes[attribute.name] = attribute;
+              }
+            }
+          }
+          return { attributes, metadata, children, variants };
+        }
+        /** Parses one named variant set. */
+        parseVariantSet(parentPath, variants) {
+          this.tokenizer.expect("variantSet");
+          const variantSetName = this.tokenizer.read().value;
+          this.tokenizer.expect("=");
+          this.tokenizer.expect("{");
+          const variantSet = {};
+          while (!this.tokenizer.isAtEnd() && !this.tokenizer.match("}")) {
+            const variantName = this.tokenizer.read().value;
+            this.tokenizer.expect("{");
+            const contents = this.parsePrimContents(parentPath);
+            variantSet[variantName] = {
+              attributes: contents.attributes,
+              metadata: contents.metadata,
+              children: contents.children
+            };
+          }
+          variants[variantSetName] = variantSet;
+        }
+        /** Parses an attribute declaration at the current token. */
+        parseAttribute() {
+          const firstToken = this.tokenizer.read();
+          if (firstToken.kind === "end") {
+            return null;
+          }
+          const declarationTokens = [firstToken];
+          while (!this.tokenizer.isAtEnd() && this.tokenizer.peek().line === firstToken.line) {
+            const nextToken = this.tokenizer.peek();
+            if (nextToken.value === "=") {
+              this.tokenizer.read();
+              break;
+            }
+            if (nextToken.value === "{" || nextToken.value === "}") {
+              return null;
+            }
+            declarationTokens.push(this.tokenizer.read());
+          }
+          const hasAssignment = this.tokenizer.previousValue === "=";
+          if (!hasAssignment) {
+            return null;
+          }
+          const significantTokens = declarationTokens.filter((token) => !QUALIFIERS.has(token.value));
+          if (significantTokens.length === 0) {
+            return null;
+          }
+          const name = significantTokens[significantTokens.length - 1].value;
+          const type = significantTokens.slice(0, -1).map((token) => token.value).join("");
+          const value = this.parseValue();
+          const metadata = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
+          return { name, type, value, metadata };
+        }
+        /** Parses a metadata dictionary through the requested terminator. */
+        parseMetadata(terminator) {
+          const metadata = {};
+          while (!this.tokenizer.isAtEnd() && !this.tokenizer.match(terminator)) {
+            this.tokenizer.match(",");
+            if (this.tokenizer.peek().value === terminator) {
+              this.tokenizer.read();
+              break;
+            }
+            const firstToken = this.tokenizer.read();
+            const declarationTokens = [firstToken];
+            while (!this.tokenizer.isAtEnd() && this.tokenizer.peek().line === firstToken.line) {
+              if (this.tokenizer.peek().value === "=" || this.tokenizer.peek().value === ":") {
+                this.tokenizer.read();
+                break;
+              }
+              if (this.tokenizer.peek().value === terminator) {
+                break;
+              }
+              declarationTokens.push(this.tokenizer.read());
+            }
+            if (this.tokenizer.previousValue !== "=" && this.tokenizer.previousValue !== ":") {
+              continue;
+            }
+            const name = declarationTokens[declarationTokens.length - 1].value;
+            metadata[name] = this.parseValue();
+            this.tokenizer.match(",");
+          }
+          return metadata;
+        }
+        /** Parses one scalar, list, tuple, dictionary, asset path, or scene path value. */
+        parseValue() {
+          const token = this.tokenizer.read();
+          if (token.value === "[") {
+            return this.parseList("]");
+          }
+          if (token.value === "(") {
+            return this.parseList(")");
+          }
+          if (token.value === "{") {
+            return this.parseMetadata("}");
+          }
+          if (token.kind === "asset") {
+            const reference = { assetPath: token.value };
+            if (this.tokenizer.peek().kind === "path" && this.tokenizer.peek().line === token.line) {
+              reference.primPath = this.tokenizer.read().value;
+            }
+            return reference;
+          }
+          if (token.kind === "path") {
+            return { path: token.value };
+          }
+          if (token.kind === "number") {
+            return Number(token.value);
+          }
+          if (token.value === "true") {
+            return true;
+          }
+          if (token.value === "false") {
+            return false;
+          }
+          if (token.value === "None" || token.value === "null") {
+            return null;
+          }
+          return token.value;
+        }
+        /** Parses a comma-separated list or tuple. */
+        parseList(terminator) {
+          const values = [];
+          while (!this.tokenizer.isAtEnd() && !this.tokenizer.match(terminator)) {
+            if (this.tokenizer.match(",")) {
+              continue;
+            }
+            values.push(this.parseValue());
+            this.tokenizer.match(",");
+          }
+          return values;
+        }
+        /** Returns whether the current token starts a prim declaration. */
+        isPrimDeclaration() {
+          const value = this.tokenizer.peek().value;
+          return value === "def" || value === "over" || value === "class";
+        }
+      };
+      USDTokenizer = class {
+        /** Complete source text. */
+        source;
+        /** Current character offset. */
+        offset = 0;
+        /** Current one-based line number. */
+        line = 1;
+        /** Lookahead token, when one has been read. */
+        bufferedToken = null;
+        /** Value of the most recently consumed token. */
+        previousValue = "";
+        /** Creates a tokenizer for USDA source text. */
+        constructor(source) {
+          this.source = source;
+        }
+        /** Returns the next token without consuming it. */
+        peek() {
+          this.bufferedToken ||= this.readToken();
+          return this.bufferedToken;
+        }
+        /** Consumes and returns the next token. */
+        read() {
+          const token = this.peek();
+          this.bufferedToken = null;
+          this.previousValue = token.value;
+          return token;
+        }
+        /** Consumes a token when its value matches. */
+        match(value) {
+          if (this.peek().value !== value) {
+            return false;
+          }
+          this.read();
+          return true;
+        }
+        /** Consumes an expected token or throws a line-numbered parse error. */
+        expect(value) {
+          const token = this.read();
+          if (token.value !== value) {
+            throw new Error(`Expected "${value}" at USDA line ${token.line}, received "${token.value}".`);
+          }
+        }
+        /** Returns whether the token stream is exhausted. */
+        isAtEnd() {
+          return this.peek().kind === "end";
+        }
+        /** Reads the next token from the current character offset. */
+        readToken() {
+          this.skipIgnoredText();
+          const line = this.line;
+          const character = this.source[this.offset];
+          if (character === void 0) {
+            return { value: "", line, kind: "end" };
+          }
+          if ("{}[](),=".includes(character)) {
+            this.offset++;
+            return { value: character, line, kind: "punctuation" };
+          }
+          if (character === '"' || character === "'") {
+            return { value: this.readQuotedString(character), line, kind: "string" };
+          }
+          if (character === "@") {
+            return { value: this.readDelimitedValue("@"), line, kind: "asset" };
+          }
+          if (character === "<") {
+            return { value: this.readDelimitedValue(">"), line, kind: "path" };
+          }
+          const numericMatch = this.source.slice(this.offset).match(NUMBER_PATTERN);
+          if (numericMatch) {
+            this.offset += numericMatch[0].length;
+            return { value: numericMatch[0], line, kind: "number" };
+          }
+          const startOffset = this.offset;
+          while (this.offset < this.source.length) {
+            const nextCharacter = this.source[this.offset];
+            if (/\s/.test(nextCharacter) || "{}[](),=@<>".includes(nextCharacter)) {
+              break;
+            }
+            this.offset++;
+          }
+          if (this.offset === startOffset) {
+            this.offset++;
+          }
+          return { value: this.source.slice(startOffset, this.offset), line, kind: "word" };
+        }
+        /** Skips whitespace, comments, and triple-quoted documentation blocks. */
+        skipIgnoredText() {
+          while (this.offset < this.source.length) {
+            const character = this.source[this.offset];
+            if (character === "\n") {
+              this.line++;
+              this.offset++;
+            } else if (/\s/.test(character)) {
+              this.offset++;
+            } else if (character === "#") {
+              while (this.offset < this.source.length && this.source[this.offset] !== "\n") {
+                this.offset++;
+              }
+            } else if (character === "/" && this.source[this.offset + 1] === "*") {
+              this.offset += 2;
+              while (this.offset < this.source.length && !this.source.startsWith("*/", this.offset)) {
+                if (this.source[this.offset] === "\n") {
+                  this.line++;
+                }
+                this.offset++;
+              }
+              this.offset += 2;
+            } else if (this.source.startsWith('"""', this.offset)) {
+              this.offset += 3;
+              while (this.offset < this.source.length && !this.source.startsWith('"""', this.offset)) {
+                if (this.source[this.offset] === "\n") {
+                  this.line++;
+                }
+                this.offset++;
+              }
+              this.offset += 3;
+            } else {
+              break;
+            }
+          }
+        }
+        /** Reads a quoted string and decodes common escapes. */
+        readQuotedString(delimiter) {
+          this.offset++;
+          let value = "";
+          while (this.offset < this.source.length) {
+            const character = this.source[this.offset++];
+            if (character === delimiter) {
+              break;
+            }
+            if (character === "\\" && this.offset < this.source.length) {
+              const escapedCharacter = this.source[this.offset++];
+              value += escapedCharacter === "n" ? "\n" : escapedCharacter;
+            } else {
+              value += character;
+            }
+          }
+          return value;
+        }
+        /** Reads an asset or scene path through its closing delimiter. */
+        readDelimitedValue(delimiter) {
+          this.offset++;
+          const startOffset = this.offset;
+          while (this.offset < this.source.length && this.source[this.offset] !== delimiter) {
+            this.offset++;
+          }
+          const value = this.source.slice(startOffset, this.offset);
+          this.offset++;
+          return value;
+        }
+      };
+    }
+  });
+
+  // src/lib/parse-usdz.ts
+  function parseUSDZArchive(arrayBuffer) {
+    const view = new DataView(arrayBuffer);
+    const directoryOffset = findCentralDirectory(view);
+    const entryCount = view.getUint16(directoryOffset + 10, true);
+    let entryOffset = view.getUint32(directoryOffset + 16, true);
+    const files = /* @__PURE__ */ new Map();
+    const textDecoder = new TextDecoder();
+    for (let entryIndex = 0; entryIndex < entryCount; entryIndex++) {
+      if (view.getUint32(entryOffset, true) !== CENTRAL_DIRECTORY_ENTRY) {
+        throw new Error("USDZ archive contains an invalid ZIP central-directory entry.");
+      }
+      const compression = view.getUint16(entryOffset + 10, true);
+      const compressedLength = view.getUint32(entryOffset + 20, true);
+      const filenameLength = view.getUint16(entryOffset + 28, true);
+      const extraLength = view.getUint16(entryOffset + 30, true);
+      const commentLength = view.getUint16(entryOffset + 32, true);
+      const localOffset = view.getUint32(entryOffset + 42, true);
+      const filename = textDecoder.decode(
+        new Uint8Array(arrayBuffer, entryOffset + 46, filenameLength)
+      );
+      if (compression !== 0) {
+        throw new Error(`USDZ entry "${filename}" is compressed; USDZ requires stored ZIP entries.`);
+      }
+      if (view.getUint32(localOffset, true) !== LOCAL_FILE_HEADER) {
+        throw new Error(`USDZ entry "${filename}" has an invalid local ZIP header.`);
+      }
+      const localNameLength = view.getUint16(localOffset + 26, true);
+      const localExtraLength = view.getUint16(localOffset + 28, true);
+      const contentOffset = localOffset + 30 + localNameLength + localExtraLength;
+      files.set(filename, arrayBuffer.slice(contentOffset, contentOffset + compressedLength));
+      entryOffset += 46 + filenameLength + extraLength + commentLength;
+    }
+    return files;
+  }
+  function findCentralDirectory(view) {
+    const minimumOffset = Math.max(0, view.byteLength - 65557);
+    for (let offset = view.byteLength - 22; offset >= minimumOffset; offset--) {
+      if (view.getUint32(offset, true) === END_OF_CENTRAL_DIRECTORY) {
+        return offset;
+      }
+    }
+    throw new Error("USDZ archive does not contain a ZIP end-of-central-directory record.");
+  }
+  var END_OF_CENTRAL_DIRECTORY, CENTRAL_DIRECTORY_ENTRY, LOCAL_FILE_HEADER;
+  var init_parse_usdz = __esm({
+    "src/lib/parse-usdz.ts"() {
+      "use strict";
+      END_OF_CENTRAL_DIRECTORY = 101010256;
+      CENTRAL_DIRECTORY_ENTRY = 33639248;
+      LOCAL_FILE_HEADER = 67324752;
+    }
+  });
+
+  // src/lib/parse-usd.ts
+  async function parseUSD(data, options = {}, context) {
+    const url = getSourceLocation(options.core?.baseUrl, context?.url);
+    const environment = {
+      fetch: async (resourceUrl) => {
+        const response = await (context?.fetch || fetch)(resourceUrl);
+        if (!(response instanceof Response)) {
+          throw new Error(`OpenUSD reference "${resourceUrl}" did not return an HTTP response.`);
+        }
+        if (!response.ok) {
+          throw new Error(`Unable to load OpenUSD reference "${resourceUrl}": ${response.status}.`);
+        }
+        return response;
+      },
+      cache: /* @__PURE__ */ new Map(),
+      archiveFiles: /* @__PURE__ */ new Map(),
+      layers: /* @__PURE__ */ new Set(),
+      options: {
+        ...options,
+        usd: { ...USD_LOADER_DEFAULT_OPTIONS, ...options.usd }
+      }
+    };
+    let stage;
+    if (isZIPArchive(data)) {
+      const archive = 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 archiveBase = "https://usd.archive/";
+      for (const [filename, content] of archive) {
+        environment.archiveFiles.set(new URL(filename, archiveBase).href, content);
+      }
+      const rootUrl = new URL(rootFilename, archiveBase).href;
+      stage = parseUSDLayer(archive.get(rootFilename), rootUrl);
+      stage.format = "usdz";
+    } else {
+      stage = parseUSDLayer(data, url);
+    }
+    if (stage.url) {
+      environment.layers.add(stage.url);
+    }
+    if (environment.options.usd?.compose !== false) {
+      stage.rootPrims = await composePrims(stage.rootPrims, stage.url, {}, environment, 0);
+    }
+    stage.layers = Array.from(environment.layers);
+    if (url) {
+      stage.url = url;
+    }
+    return stage;
+  }
+  function getSourceLocation(configuredLocation, contextLocation) {
+    const configuredUrl = getAbsoluteUrl(configuredLocation);
+    if (configuredUrl) {
+      return configuredUrl;
+    }
+    const contextUrl = getAbsoluteUrl(contextLocation);
+    return contextUrl || configuredLocation || contextLocation;
+  }
+  function getAbsoluteUrl(candidate) {
+    try {
+      return candidate ? new URL(candidate).href : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  function resolveAssetPath(assetPath, sourceLocation) {
+    try {
+      return new URL(assetPath, sourceLocation).href;
+    } catch {
+      const slashIndex = Math.max(sourceLocation.lastIndexOf("/"), sourceLocation.lastIndexOf("\\"));
+      return slashIndex >= 0 ? `${sourceLocation.slice(0, slashIndex + 1)}${assetPath}` : assetPath;
+    }
+  }
+  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 parseUSDA(TEXT_DECODER.decode(data), url);
+  }
+  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.");
+    }
+    const composedPrims = [];
+    for (const sourcePrim of prims) {
+      if (sourcePrim.specifier === "class") {
+        continue;
+      }
+      const localSelections = getVariantSelections(sourcePrim.metadata["variants"]);
+      const selections = {
+        ...localSelections,
+        ...inheritedVariants,
+        ...environment.options.usd?.variantSelections
+      };
+      const primSourceUrl = sourcePrim.sourceUrl || sourceUrl;
+      let composedPrim = clonePrim(sourcePrim);
+      for (const [variantSetName, variantSet] of Object.entries(composedPrim.variants)) {
+        const selection = selections[variantSetName] || Object.keys(variantSet)[0];
+        const variant = variantSet[selection];
+        if (variant) {
+          composedPrim = mergePrim(composedPrim, {
+            ...composedPrim,
+            attributes: variant.attributes,
+            metadata: variant.metadata,
+            children: variant.children,
+            variants: {}
+          });
+        }
+      }
+      const references = getPrimReferences(composedPrim);
+      if (environment.options.usd?.loadReferences !== false && references.length > 0) {
+        for (const reference of references) {
+          if (!primSourceUrl) {
+            throw new Error("OpenUSD references require a source URL or options.core.baseUrl.");
+          }
+          const referencedUrl = resolveAssetPath(reference.assetPath, primSourceUrl);
+          const stage = await loadReferencedStage(referencedUrl, environment);
+          const referencedPrims = selectReferencedPrims(stage, reference.primPath);
+          const resolvedPrims = await composePrims(
+            referencedPrims,
+            referencedUrl,
+            selections,
+            environment,
+            depth + 1
+          );
+          for (const referencedPrim of resolvedPrims) {
+            composedPrim = mergePrim(rebasePrim(referencedPrim, composedPrim.path), composedPrim);
+          }
+        }
+      }
+      composedPrim.children = await composePrims(
+        composedPrim.children,
+        primSourceUrl,
+        selections,
+        environment,
+        depth
+      );
+      composedPrims.push(composedPrim);
+    }
+    return composedPrims;
+  }
+  async function loadReferencedStage(url, environment) {
+    let pendingStage = environment.cache.get(url);
+    if (!pendingStage) {
+      pendingStage = (async () => {
+        const archiveContent = environment.archiveFiles.get(url);
+        let content = archiveContent;
+        if (!content) {
+          let response;
+          try {
+            response = await environment.fetch(url);
+          } catch (error) {
+            throw new Error(`Unable to fetch USD layer "${url}": ${String(error)}`);
+          }
+          content = response.arrayBuffer();
+        }
+        const stage = parseUSDLayer(await content, url);
+        environment.layers.add(url);
+        return stage;
+      })();
+      environment.cache.set(url, pendingStage);
+    }
+    return pendingStage;
+  }
+  function selectReferencedPrims(stage, primPath) {
+    const targetPath = primPath || stage.metadata["defaultPrim"];
+    if (typeof targetPath !== "string") {
+      return stage.rootPrims;
+    }
+    const normalizedPath = targetPath.startsWith("/") ? targetPath : `/${targetPath}`;
+    const target = findPrim(stage.rootPrims, normalizedPath);
+    return target ? [target] : [];
+  }
+  function findPrim(prims, path) {
+    for (const prim of prims) {
+      if (prim.path === path) {
+        return prim;
+      }
+      const child = findPrim(prim.children, path);
+      if (child) {
+        return child;
+      }
+    }
+    return void 0;
+  }
+  function getPrimReferences(prim) {
+    const references = [];
+    for (const value of [
+      prim.metadata["references"],
+      prim.metadata["payload"],
+      prim.metadata["payloads"]
+    ]) {
+      if (Array.isArray(value)) {
+        references.push(...value.filter(isAssetPath));
+      } else if (isAssetPath(value)) {
+        references.push(value);
+      }
+    }
+    return references;
+  }
+  function getVariantSelections(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || isAssetPath(value)) {
+      return {};
+    }
+    return Object.fromEntries(
+      Object.entries(value).filter((entry) => typeof entry[1] === "string")
+    );
+  }
+  function isAssetPath(value) {
+    return Boolean(
+      value && typeof value === "object" && !Array.isArray(value) && "assetPath" in value
+    );
+  }
+  function clonePrim(prim) {
+    return {
+      ...prim,
+      attributes: { ...prim.attributes },
+      metadata: { ...prim.metadata },
+      variants: { ...prim.variants },
+      children: prim.children.map(clonePrim)
+    };
+  }
+  function rebasePrim(prim, path) {
+    const rebased = clonePrim(prim);
+    rebased.path = path;
+    rebased.children = rebased.children.map((child) => rebasePrim(child, `${path}/${child.name}`));
+    return rebased;
+  }
+  function mergePrim(reference, override) {
+    const children = reference.children.map(clonePrim);
+    for (const overridingChild of override.children) {
+      const matchingIndex = children.findIndex((child) => child.name === overridingChild.name);
+      if (matchingIndex >= 0) {
+        children[matchingIndex] = mergePrim(children[matchingIndex], overridingChild);
+      } else {
+        children.push(clonePrim(overridingChild));
+      }
+    }
+    return {
+      ...reference,
+      ...override,
+      sourceUrl: getPrimReferences(override).length > 0 ? override.sourceUrl : reference.sourceUrl || override.sourceUrl,
+      type: override.type || reference.type,
+      attributes: { ...reference.attributes, ...override.attributes },
+      metadata: { ...reference.metadata, ...override.metadata },
+      variants: { ...reference.variants, ...override.variants },
+      children
+    };
+  }
+  function isZIPArchive(arrayBuffer) {
+    return arrayBuffer.byteLength >= 4 && new DataView(arrayBuffer).getUint32(0, true) === ZIP_SIGNATURE;
+  }
+  var TEXT_DECODER, CRATE_SIGNATURE, ZIP_SIGNATURE, USD_LOADER_DEFAULT_OPTIONS;
+  var init_parse_usd = __esm({
+    "src/lib/parse-usd.ts"() {
+      "use strict";
+      init_parse_usda();
+      init_parse_usdz();
+      TEXT_DECODER = new TextDecoder();
+      CRATE_SIGNATURE = "PXR-USDC";
+      ZIP_SIGNATURE = 67324752;
+      USD_LOADER_DEFAULT_OPTIONS = {
+        compose: true,
+        loadReferences: true,
+        maxReferenceDepth: 12,
+        variantSelections: {}
+      };
+    }
+  });
+
+  // src/usd-loader.ts
+  var usd_loader_exports = {};
+  __export(usd_loader_exports, {
+    USDLoaderWithParser: () => USDLoaderWithParser
+  });
+  async function parseText(text, options, context) {
+    return parseUSD(new TextEncoder().encode(text).buffer, options, context);
+  }
+  var _USDLoaderPreload, USDLoaderMetadataWithoutPreload, USDLoaderWithParser;
+  var init_usd_loader = __esm({
+    "src/usd-loader.ts"() {
+      "use strict";
+      init_parse_usd();
+      init_usd_loader_types();
+      ({ preload: _USDLoaderPreload, ...USDLoaderMetadataWithoutPreload } = USDLoader);
+      USDLoaderWithParser = {
+        ...USDLoaderMetadataWithoutPreload,
+        parse: parseUSD,
+        parseText
+      };
+    }
+  });
+
+  // src/usd-loader-types.ts
+  async function preload() {
+    const { USDLoaderWithParser: USDLoaderWithParser2 } = await Promise.resolve().then(() => (init_usd_loader(), usd_loader_exports));
+    return USDLoaderWithParser2;
+  }
+  var VERSION, USDLoader;
+  var init_usd_loader_types = __esm({
+    "src/usd-loader-types.ts"() {
+      "use strict";
+      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      USDLoader = {
+        dataType: null,
+        batchType: null,
+        name: "Universal Scene Description",
+        id: "usd",
+        module: "scene",
+        version: VERSION,
+        extensions: ["usd", "usda", "usdz"],
+        mimeTypes: ["model/vnd.usd", "model/vnd.usda", "model/vnd.usdz+zip"],
+        text: true,
+        binary: true,
+        tests: ["#usda", "PK"],
+        options: {
+          usd: {
+            compose: true,
+            loadReferences: true,
+            maxReferenceDepth: 12,
+            variantSelections: {}
+          }
+        },
+        preload
+      };
+    }
+  });
+
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
+    USDLoader: () => USDLoader
+  });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
+
+  // src/index.ts
+  init_usd_loader_types();
+  return __toCommonJS(bundle_exports);
+})();
+      return __exports__;
+      });