@holoscript/core 6.0.3 → 7.0.0

package/dist/USDZExporter-MHEHXZB4.cjs

@@ -1,709 +0,0 @@
-'use strict';
-
-require('./chunk-EGIZHYJP.cjs');
-
-// src/export/usdz/USDTypes.ts
-function createUSDXform(name, path) {
-  return {
-    path,
-    type: "Xform",
-    name,
-    attributes: [],
-    children: []
-  };
-}
-function createUSDPreviewSurfaceMaterial(name, path, inputs) {
-  const shaderPath = `${path}/PreviewSurface`;
-  const shaderInputs = [];
-  if (inputs.diffuseColor) {
-    shaderInputs.push({
-      name: "diffuseColor",
-      type: "color3f",
-      value: inputs.diffuseColor
-    });
-  }
-  if (inputs.metallic !== void 0) {
-    shaderInputs.push({
-      name: "metallic",
-      type: "float",
-      value: inputs.metallic
-    });
-  }
-  if (inputs.roughness !== void 0) {
-    shaderInputs.push({
-      name: "roughness",
-      type: "float",
-      value: inputs.roughness
-    });
-  }
-  if (inputs.emissiveColor) {
-    shaderInputs.push({
-      name: "emissiveColor",
-      type: "color3f",
-      value: inputs.emissiveColor
-    });
-  }
-  const material = {
-    path,
-    type: "Material",
-    name,
-    attributes: [],
-    surfaceShader: shaderPath,
-    children: [
-      {
-        path: shaderPath,
-        type: "Shader",
-        name: "PreviewSurface",
-        attributes: [
-          {
-            name: "info:id",
-            type: "token",
-            value: "UsdPreviewSurface"
-          }
-        ]
-      }
-    ]
-  };
-  const shaderPrim = material.children[0];
-  shaderPrim.inputs = shaderInputs;
-  return material;
-}
-function quaternionToEuler(quat) {
-  const [x, y, z, w] = quat;
-  const sinr_cosp = 2 * (w * x + y * z);
-  const cosr_cosp = 1 - 2 * (x * x + y * y);
-  const roll = Math.atan2(sinr_cosp, cosr_cosp);
-  const sinp = 2 * (w * y - z * x);
-  const pitch = Math.abs(sinp) >= 1 ? Math.sign(sinp) * Math.PI / 2 : Math.asin(sinp);
-  const siny_cosp = 2 * (w * z + x * y);
-  const cosy_cosp = 1 - 2 * (y * y + z * z);
-  const yaw = Math.atan2(siny_cosp, cosy_cosp);
-  return [roll * 180 / Math.PI, pitch * 180 / Math.PI, yaw * 180 / Math.PI];
-}
-function sanitizeUSDName(name) {
-  return name.replace(/[^a-zA-Z0-9_]/g, "_");
-}
-
-// src/export/usdz/USDZExporter.ts
-var _USDZExporter = class _USDZExporter {
-  constructor(options = {}) {
-    this.primCounter = 0;
-    this.materialMap = /* @__PURE__ */ new Map();
-    // materialId -> USD path
-    this.meshMap = /* @__PURE__ */ new Map();
-    // meshId -> USD path
-    this.textureFiles = [];
-    this.options = { ..._USDZExporter.DEFAULT_OPTIONS, ...options };
-  }
-  /**
-   * Export scene graph to USDZ format
-   * Returns ArrayBuffer containing .usdz package
-   */
-  async export(sceneGraph) {
-    const startTime = performance.now();
-    this.reset();
-    this.stage = this.createStage(sceneGraph);
-    await this.convertSceneGraph(sceneGraph);
-    if (this.options.lookAtCamera || this.options.placementMode) {
-      this.addARMetadata();
-    }
-    const usdzBuffer = await this.packageUSDZ();
-    const endTime = performance.now();
-    const stats = this.calculateStats(usdzBuffer.byteLength, endTime - startTime);
-    return {
-      usdz: usdzBuffer,
-      stage: this.stage,
-      stats
-    };
-  }
-  /**
-   * Convert from GLTF intermediate representation
-   */
-  async convertFromGLTF(_gltfResult) {
-    throw new Error("Direct GLTF conversion not yet implemented. Use export() with scene graph.");
-  }
-  // ========================================================================
-  // Private Methods - Stage Creation
-  // ========================================================================
-  createStage(sceneGraph) {
-    return {
-      metadata: {
-        version: "0.10.0",
-        upAxis: this.options.upAxis,
-        metersPerUnit: this.options.metersPerUnit,
-        comment: `Generated by ${sceneGraph.generator || "HoloScript USDZExporter"}`
-      },
-      defaultPrim: "Root",
-      prims: [],
-      customLayerData: {
-        creator: sceneGraph.generator,
-        holoscriptVersion: sceneGraph.version
-      }
-    };
-  }
-  async convertSceneGraph(sceneGraph) {
-    const rootPrim = createUSDXform("Root", "/Root");
-    this.stage.prims.push(rootPrim);
-    await this.convertMaterials(sceneGraph.materials || []);
-    await this.convertMeshes(sceneGraph.meshes || [], sceneGraph);
-    this.convertNode(sceneGraph.root, rootPrim, sceneGraph);
-    if (this.options.includeAnimations && sceneGraph.animations?.length) {
-      this.convertAnimations(sceneGraph.animations);
-    }
-  }
-  // ========================================================================
-  // Private Methods - Node Conversion
-  // ========================================================================
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Deep nested scene graph node access
-  convertNode(node, parentPrim, sceneGraph, depth = 0) {
-    if (!node || depth > 100) return;
-    const nodeName = sanitizeUSDName(node.name || `Node_${this.primCounter++}`);
-    const nodePath = `${parentPrim.path}/${nodeName}`;
-    const xformPrim = createUSDXform(nodeName, nodePath);
-    if (node.transform) {
-      this.addTransform(xformPrim, node.transform);
-    }
-    if (!parentPrim.children) parentPrim.children = [];
-    parentPrim.children.push(xformPrim);
-    const meshComp = node.components?.find((c) => c.type === "mesh");
-    if (meshComp?.meshRef) {
-      const meshPath = this.meshMap.get(meshComp.meshRef);
-      if (meshPath) {
-        xformPrim.relationships = [
-          {
-            name: "mesh",
-            targets: [meshPath]
-          }
-        ];
-      }
-    }
-    if (node.children?.length) {
-      for (const child of node.children) {
-        this.convertNode(child, xformPrim, sceneGraph, depth + 1);
-      }
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Deep nested transform object access (position.x/y/z, rotation.x/y/z/w, scale.x/y/z)
-  addTransform(prim, transform) {
-    const ops = [];
-    if (transform.position) {
-      ops.push({
-        type: "translate",
-        value: [transform.position.x, transform.position.y, transform.position.z]
-      });
-    }
-    if (transform.rotation) {
-      const euler = quaternionToEuler([
-        transform.rotation.x,
-        transform.rotation.y,
-        transform.rotation.z,
-        transform.rotation.w
-      ]);
-      ops.push({
-        type: "rotateXYZ",
-        value: euler
-      });
-    }
-    if (transform.scale) {
-      ops.push({
-        type: "scale",
-        value: [transform.scale.x, transform.scale.y, transform.scale.z]
-      });
-    }
-    if (ops.length > 0) {
-      prim.attributes.push({
-        name: "xformOpOrder",
-        type: "token[]",
-        value: ops.map((op) => `xformOp:${op.type}`)
-      });
-      for (const op of ops) {
-        prim.attributes.push({
-          name: `xformOp:${op.type}`,
-          type: this.getXformOpType(op.type),
-          value: op.value
-        });
-      }
-    }
-  }
-  getXformOpType(opType) {
-    switch (opType) {
-      case "translate":
-        return "float3";
-      case "rotateXYZ":
-        return "float3";
-      case "rotateX":
-      case "rotateY":
-      case "rotateZ":
-        return "float";
-      case "scale":
-        return "float3";
-      case "transform":
-        return "matrix4d";
-      default:
-        return "float3";
-    }
-  }
-  // ========================================================================
-  // Private Methods - Material Conversion
-  // ========================================================================
-  async convertMaterials(materials) {
-    for (const material of materials) {
-      await this.convertMaterial(material);
-    }
-  }
-  async convertMaterial(material) {
-    const matName = sanitizeUSDName(material.name || `Material_${this.primCounter++}`);
-    const matPath = `/Root/Materials/${matName}`;
-    const mapping = this.createMaterialMapping(material);
-    const inputs = {
-      diffuseColor: mapping.baseColor.slice(0, 3),
-      // RGB only
-      metallic: mapping.metallic,
-      roughness: mapping.roughness,
-      emissiveColor: mapping.emissive
-    };
-    if (material.alphaMode === "blend" || material.alphaMode === "mask") {
-      inputs.opacity = mapping.baseColor[3];
-      if (material.alphaMode === "mask") {
-        inputs.opacityThreshold = mapping.alphaCutoff || 0.5;
-      }
-    }
-    const usdMaterial = createUSDPreviewSurfaceMaterial(matName, matPath, inputs);
-    if (mapping.baseColorTexture) {
-      await this.addTextureToMaterial(usdMaterial, "diffuseColor", mapping.baseColorTexture);
-    }
-    if (mapping.normalTexture) {
-      await this.addTextureToMaterial(usdMaterial, "normal", mapping.normalTexture);
-    }
-    if (mapping.occlusionTexture) {
-      await this.addTextureToMaterial(usdMaterial, "occlusion", mapping.occlusionTexture);
-    }
-    if (!this.stage.prims[0].children) this.stage.prims[0].children = [];
-    let materialsScope = this.stage.prims[0].children.find((p) => p.name === "Materials");
-    if (!materialsScope) {
-      materialsScope = {
-        path: "/Root/Materials",
-        type: "Scope",
-        name: "Materials",
-        attributes: [],
-        children: []
-      };
-      this.stage.prims[0].children.push(materialsScope);
-    }
-    materialsScope.children.push(usdMaterial);
-    this.materialMap.set(material.id, matPath);
-  }
-  createMaterialMapping(material) {
-    return {
-      baseColor: material.baseColor || [1, 1, 1, 1],
-      metallic: material.metallic ?? 0,
-      roughness: material.roughness ?? 0.5,
-      emissive: material.emissiveColor || [0, 0, 0],
-      alphaMode: material.alphaMode,
-      alphaCutoff: material.alphaCutoff
-    };
-  }
-  async addTextureToMaterial(material, inputName, textureRef) {
-    const shader = material.children?.[0];
-    if (shader?.inputs) {
-      shader.inputs.push({
-        name: inputName,
-        type: "asset",
-        value: { path: textureRef }
-      });
-    }
-  }
-  // ========================================================================
-  // Private Methods - Mesh Conversion
-  // ========================================================================
-  async convertMeshes(meshes, sceneGraph) {
-    for (const mesh of meshes) {
-      await this.convertMesh(mesh, sceneGraph);
-    }
-  }
-  async convertMesh(mesh, sceneGraph) {
-    const meshName = sanitizeUSDName(mesh.name || `Mesh_${this.primCounter++}`);
-    const meshPath = `/Root/Geometry/${meshName}`;
-    let geometryScope = this.stage.prims[0].children?.find((p) => p.name === "Geometry");
-    if (!geometryScope) {
-      geometryScope = {
-        path: "/Root/Geometry",
-        type: "Scope",
-        name: "Geometry",
-        attributes: [],
-        children: []
-      };
-      if (!this.stage.prims[0].children) this.stage.prims[0].children = [];
-      this.stage.prims[0].children.push(geometryScope);
-    }
-    for (let i = 0; i < mesh.primitives.length; i++) {
-      const primitive = mesh.primitives[i];
-      const primName = mesh.primitives.length > 1 ? `${meshName}_${i}` : meshName;
-      const primPath = mesh.primitives.length > 1 ? `${meshPath}_${i}` : meshPath;
-      const usdMesh = await this.convertMeshPrimitive(primitive, primName, primPath, sceneGraph);
-      geometryScope.children.push(usdMesh);
-      this.meshMap.set(mesh.id, primPath);
-    }
-  }
-  async convertMeshPrimitive(primitive, name, path, sceneGraph) {
-    const positions = this.extractAccessorData(primitive.attributes.POSITION, sceneGraph);
-    const normals = primitive.attributes.NORMAL ? this.extractAccessorData(primitive.attributes.NORMAL, sceneGraph) : void 0;
-    const uvs = primitive.attributes.TEXCOORD_0 ? this.extractAccessorData(primitive.attributes.TEXCOORD_0, sceneGraph) : void 0;
-    const indices = primitive.indices !== void 0 ? this.extractAccessorData(primitive.indices, sceneGraph) : void 0;
-    const { faceVertexCounts, faceVertexIndices } = this.buildFaceData(
-      indices,
-      positions.length / 3
-    );
-    const usdMesh = {
-      path,
-      type: "Mesh",
-      name,
-      attributes: [],
-      faceVertexCounts,
-      faceVertexIndices,
-      points: positions
-    };
-    if (normals) {
-      usdMesh.normals = normals;
-      usdMesh.attributes.push({
-        name: "primvars:normals",
-        type: "normal3f[]",
-        value: normals
-      });
-      usdMesh.attributes.push({
-        name: "primvars:normals:interpolation",
-        type: "token",
-        value: "vertex"
-      });
-    }
-    if (uvs) {
-      usdMesh.primvars = [
-        {
-          name: "st",
-          type: "texCoord2f[]",
-          interpolation: "vertex",
-          values: uvs
-        }
-      ];
-    }
-    if (primitive.materialRef) {
-      const matPath = this.materialMap.get(primitive.materialRef);
-      if (matPath) {
-        usdMesh.relationships = [
-          {
-            name: "material:binding",
-            targets: [matPath]
-          }
-        ];
-      }
-    }
-    return usdMesh;
-  }
-  extractAccessorData(accessorIndex, sceneGraph) {
-    const accessor = sceneGraph.accessors[accessorIndex];
-    if (!accessor) return [];
-    const bufferView = sceneGraph.bufferViews[accessor.bufferViewIndex];
-    const buffer = sceneGraph.buffers[bufferView.bufferIndex];
-    if (!buffer.data) return [];
-    const arrayView = this.getTypedArray(
-      buffer.data,
-      bufferView.byteOffset + accessor.byteOffset,
-      accessor.count * this.getComponentCount(accessor.type),
-      accessor.componentType
-    );
-    return Array.from(arrayView);
-  }
-  getTypedArray(buffer, offset, length, componentType) {
-    switch (componentType) {
-      case "float":
-        return new Float32Array(buffer, offset, length);
-      case "ushort":
-        return new Uint16Array(buffer, offset, length);
-      case "uint":
-        return new Uint32Array(buffer, offset, length);
-      default:
-        return new Float32Array(buffer, offset, length);
-    }
-  }
-  getComponentCount(type) {
-    switch (type.toLowerCase()) {
-      case "scalar":
-        return 1;
-      case "vec2":
-        return 2;
-      case "vec3":
-        return 3;
-      case "vec4":
-        return 4;
-      case "mat2":
-        return 4;
-      case "mat3":
-        return 9;
-      case "mat4":
-        return 16;
-      default:
-        return 1;
-    }
-  }
-  buildFaceData(indices, vertexCount) {
-    if (indices && indices.length > 0) {
-      const faceCount = Math.floor(indices.length / 3);
-      return {
-        faceVertexCounts: new Array(faceCount).fill(3),
-        faceVertexIndices: indices
-      };
-    } else if (vertexCount > 0) {
-      const faceCount = Math.floor(vertexCount / 3);
-      return {
-        faceVertexCounts: new Array(faceCount).fill(3),
-        faceVertexIndices: Array.from({ length: vertexCount }, (_, i) => i)
-      };
-    } else {
-      return {
-        faceVertexCounts: [],
-        faceVertexIndices: []
-      };
-    }
-  }
-  // ========================================================================
-  // Private Methods - Animation Conversion
-  // ========================================================================
-  convertAnimations(_animations) {
-    console.warn("Animation export not yet implemented");
-  }
-  // ========================================================================
-  // Private Methods - AR Metadata
-  // ========================================================================
-  addARMetadata() {
-    const metadata = {
-      arBehaviors: {
-        allowsContentScaling: this.options.allowContentScaling,
-        hasLookAtCamera: this.options.lookAtCamera,
-        initialPlacementMode: this.options.placementMode,
-        enableOcclusion: this.options.enableOcclusion
-      },
-      canonicalCameraDistance: this.options.canonicalCameraDistance
-    };
-    if (!this.stage.customLayerData) this.stage.customLayerData = {};
-    this.stage.customLayerData.arQuickLook = metadata;
-    if (this.stage.prims[0]) {
-      if (!this.stage.prims[0].metadata) this.stage.prims[0].metadata = {};
-      this.stage.prims[0].metadata.arQuickLook = metadata;
-    }
-  }
-  // ========================================================================
-  // Private Methods - USDZ Packaging
-  // ========================================================================
-  async packageUSDZ() {
-    const usdContent = this.serializeUSD(this.stage);
-    const mainFile = {
-      path: "scene.usda",
-      data: new TextEncoder().encode(usdContent).buffer,
-      mimeType: "text/plain"
-    };
-    const package_ = {
-      mainFile,
-      files: this.textureFiles
-    };
-    return this.createZipArchive(package_);
-  }
-  serializeUSD(stage) {
-    const lines = [];
-    lines.push("#usda 1.0");
-    lines.push("(");
-    if (stage.defaultPrim) {
-      lines.push(`    defaultPrim = "${stage.defaultPrim}"`);
-    }
-    if (stage.metadata.upAxis) {
-      lines.push(`    upAxis = "${stage.metadata.upAxis}"`);
-    }
-    if (stage.metadata.metersPerUnit) {
-      lines.push(`    metersPerUnit = ${stage.metadata.metersPerUnit}`);
-    }
-    lines.push(")");
-    lines.push("");
-    for (const prim of stage.prims) {
-      this.serializePrim(prim, lines, 0);
-    }
-    return lines.join("\n");
-  }
-  serializePrim(prim, lines, indent) {
-    const ind = "    ".repeat(indent);
-    lines.push(`${ind}def ${prim.type} "${prim.name}"`);
-    lines.push(`${ind}{`);
-    for (const attr of prim.attributes) {
-      this.serializeAttribute(attr, lines, indent + 1);
-    }
-    if (prim.relationships) {
-      for (const rel of prim.relationships) {
-        const relInd = "    ".repeat(indent + 1);
-        const targets = rel.targets.map((t) => `<${t}>`).join(", ");
-        lines.push(`${relInd}rel ${rel.name} = [${targets}]`);
-      }
-    }
-    if (prim.children) {
-      for (const child of prim.children) {
-        lines.push("");
-        this.serializePrim(child, lines, indent + 1);
-      }
-    }
-    lines.push(`${ind}}`);
-  }
-  serializeAttribute(attr, lines, indent) {
-    const ind = "    ".repeat(indent);
-    const value = this.serializeValue(attr.value, attr.type);
-    lines.push(`${ind}${attr.type} ${attr.name} = ${value}`);
-  }
-  serializeValue(value, type) {
-    if (Array.isArray(value)) {
-      if (type.includes("[]")) {
-        return `[${value.map((v) => this.serializeScalar(v, type.replace("[]", ""))).join(", ")}]`;
-      } else {
-        return `(${value.join(", ")})`;
-      }
-    } else if (typeof value === "string") {
-      return `"${value}"`;
-    } else if (typeof value === "object" && value !== null && "path" in value) {
-      return `@${value.path}@`;
-    } else {
-      return String(value);
-    }
-  }
-  serializeScalar(value, _type) {
-    if (typeof value === "string") {
-      return `"${value}"`;
-    }
-    return String(value);
-  }
-  async createZipArchive(package_) {
-    const files = [package_.mainFile, ...package_.files];
-    let totalSize = 0;
-    const fileEntries = [];
-    const localHeaderSize = 30;
-    const centralHeaderSize = 46;
-    const endCentralSize = 22;
-    for (const file of files) {
-      const nameBytes = new TextEncoder().encode(file.path);
-      fileEntries.push({
-        name: file.path,
-        data: file.data,
-        offset: totalSize
-      });
-      totalSize += localHeaderSize + nameBytes.length + file.data.byteLength;
-    }
-    const centralDirOffset = totalSize;
-    let centralDirSize = 0;
-    for (const entry of fileEntries) {
-      const nameBytes = new TextEncoder().encode(entry.name);
-      centralDirSize += centralHeaderSize + nameBytes.length;
-    }
-    totalSize += centralDirSize + endCentralSize;
-    const buffer = new ArrayBuffer(totalSize);
-    const view = new DataView(buffer);
-    const bytes = new Uint8Array(buffer);
-    let offset = 0;
-    for (const entry of fileEntries) {
-      const nameBytes = new TextEncoder().encode(entry.name);
-      view.setUint32(offset, 67324752, true);
-      view.setUint16(offset + 4, 20, true);
-      view.setUint16(offset + 6, 0, true);
-      view.setUint16(offset + 8, 0, true);
-      view.setUint16(offset + 10, 0, true);
-      view.setUint16(offset + 12, 0, true);
-      view.setUint32(offset + 14, 0, true);
-      view.setUint32(offset + 18, entry.data.byteLength, true);
-      view.setUint32(offset + 22, entry.data.byteLength, true);
-      view.setUint16(offset + 26, nameBytes.length, true);
-      view.setUint16(offset + 28, 0, true);
-      offset += 30;
-      bytes.set(nameBytes, offset);
-      offset += nameBytes.length;
-      bytes.set(new Uint8Array(entry.data), offset);
-      offset += entry.data.byteLength;
-    }
-    for (const entry of fileEntries) {
-      const nameBytes = new TextEncoder().encode(entry.name);
-      view.setUint32(offset, 33639248, true);
-      view.setUint16(offset + 4, 20, true);
-      view.setUint16(offset + 6, 20, true);
-      view.setUint16(offset + 8, 0, true);
-      view.setUint16(offset + 10, 0, true);
-      view.setUint16(offset + 12, 0, true);
-      view.setUint16(offset + 14, 0, true);
-      view.setUint32(offset + 16, 0, true);
-      view.setUint32(offset + 20, entry.data.byteLength, true);
-      view.setUint32(offset + 24, entry.data.byteLength, true);
-      view.setUint16(offset + 28, nameBytes.length, true);
-      view.setUint16(offset + 30, 0, true);
-      view.setUint16(offset + 32, 0, true);
-      view.setUint16(offset + 34, 0, true);
-      view.setUint16(offset + 36, 0, true);
-      view.setUint32(offset + 38, 0, true);
-      view.setUint32(offset + 42, entry.offset, true);
-      offset += 46;
-      bytes.set(nameBytes, offset);
-      offset += nameBytes.length;
-    }
-    view.setUint32(offset, 101010256, true);
-    view.setUint16(offset + 4, 0, true);
-    view.setUint16(offset + 6, 0, true);
-    view.setUint16(offset + 8, fileEntries.length, true);
-    view.setUint16(offset + 10, fileEntries.length, true);
-    view.setUint32(offset + 12, centralDirSize, true);
-    view.setUint32(offset + 16, centralDirOffset, true);
-    view.setUint16(offset + 20, 0, true);
-    return buffer;
-  }
-  // ========================================================================
-  // Private Methods - Utilities
-  // ========================================================================
-  reset() {
-    this.primCounter = 0;
-    this.materialMap.clear();
-    this.meshMap.clear();
-    this.textureFiles = [];
-  }
-  calculateStats(usdzSize, exportTime) {
-    let primCount = 0;
-    let meshCount = 0;
-    let materialCount = 0;
-    const countPrims = (prim) => {
-      primCount++;
-      if (prim.type === "Mesh") meshCount++;
-      if (prim.type === "Material") materialCount++;
-      if (prim.children) {
-        for (const child of prim.children) countPrims(child);
-      }
-    };
-    for (const prim of this.stage.prims) {
-      countPrims(prim);
-    }
-    return {
-      primCount,
-      meshCount,
-      materialCount,
-      textureCount: this.textureFiles.length,
-      fileCount: 1 + this.textureFiles.length,
-      usdzSize,
-      exportTime
-    };
-  }
-};
-_USDZExporter.DEFAULT_OPTIONS = {
-  includeAudio: false,
-  lookAtCamera: false,
-  placementMode: "floor",
-  materialQuality: "standard",
-  includeAnimations: true,
-  realityComposerMode: false,
-  metersPerUnit: 1,
-  upAxis: "Y",
-  enableOcclusion: true,
-  allowContentScaling: true,
-  canonicalCameraDistance: 2.5
-};
-var USDZExporter = _USDZExporter;
-
-exports.USDZExporter = USDZExporter;
-//# sourceMappingURL=USDZExporter-MHEHXZB4.cjs.map
-//# sourceMappingURL=USDZExporter-MHEHXZB4.cjs.map