@nice2dev/ui-3d 1.3.15 → 1.3.16

package/dist/cjs/uv/uvEditorUtils.js

@@ -1,661 +1,587 @@
-'use strict';
-
-var THREE = require('three');
-
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
 function _interopNamespaceDefault(e) {
-   var n = Object.create(null);
-   if (e) {
-      Object.keys(e).forEach(function (k) {
-         if (k !== 'default') {
-            var d = Object.getOwnPropertyDescriptor(e, k);
-            Object.defineProperty(n, k, d.get ? d : {
-               enumerable: true,
-               get: function () { return e[k]; }
-            });
-         }
-      });
-   }
-   n.default = e;
-   return Object.freeze(n);
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
 }
-
-var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
-
-/**
- * UV Editor Utilities
- *
- * Core algorithms and utilities for UV mapping operations.
- * @module @nice2dev/ui-3d
- */
-/* ═══════════════════════════════════════════
-   ID Generation
-   ═══════════════════════════════════════════ */
+const THREE__namespace = /* @__PURE__ */ _interopNamespaceDefault(THREE);
 let idCounter = 0;
 const generateId = (prefix) => `${prefix}_${Date.now()}_${++idCounter}`;
-/* ═══════════════════════════════════════════
-   UV Math Utilities
-   ═══════════════════════════════════════════ */
 const uvDistance = (a, b) => Math.sqrt((a.u - b.u) ** 2 + (a.v - b.v) ** 2);
 const uvLerp = (a, b, t) => ({
-    u: a.u + (b.u - a.u) * t,
-    v: a.v + (b.v - a.v) * t,
+  u: a.u + (b.u - a.u) * t,
+  v: a.v + (b.v - a.v) * t
 });
 const uvAdd = (a, b) => ({
-    u: a.u + b.u,
-    v: a.v + b.v,
+  u: a.u + b.u,
+  v: a.v + b.v
 });
 const uvSub = (a, b) => ({
-    u: a.u - b.u,
-    v: a.v - b.v,
+  u: a.u - b.u,
+  v: a.v - b.v
 });
 const uvScale = (p, s) => ({
-    u: p.u * s,
-    v: p.v * s,
+  u: p.u * s,
+  v: p.v * s
 });
 const uvRotate = (p, angle, center = { u: 0.5, v: 0.5 }) => {
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    const du = p.u - center.u;
-    const dv = p.v - center.v;
-    return {
-        u: center.u + du * cos - dv * sin,
-        v: center.v + du * sin + dv * cos,
-    };
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const du = p.u - center.u;
+  const dv = p.v - center.v;
+  return {
+    u: center.u + du * cos - dv * sin,
+    v: center.v + du * sin + dv * cos
+  };
 };
 const uvCross = (a, b) => a.u * b.v - a.v * b.u;
-/* ═══════════════════════════════════════════
-   Bounds Utilities
-   ═══════════════════════════════════════════ */
 const createEmptyBounds = () => ({
-    minU: Infinity,
-    maxU: -Infinity,
-    minV: Infinity,
-    maxV: -Infinity,
+  minU: Infinity,
+  maxU: -Infinity,
+  minV: Infinity,
+  maxV: -Infinity
 });
 const expandBounds = (bounds, point) => ({
-    minU: Math.min(bounds.minU, point.u),
-    maxU: Math.max(bounds.maxU, point.u),
-    minV: Math.min(bounds.minV, point.v),
-    maxV: Math.max(bounds.maxV, point.v),
+  minU: Math.min(bounds.minU, point.u),
+  maxU: Math.max(bounds.maxU, point.u),
+  minV: Math.min(bounds.minV, point.v),
+  maxV: Math.max(bounds.maxV, point.v)
 });
 const mergeBounds = (a, b) => ({
-    minU: Math.min(a.minU, b.minU),
-    maxU: Math.max(a.maxU, b.maxU),
-    minV: Math.min(a.minV, b.minV),
-    maxV: Math.max(a.maxV, b.maxV),
+  minU: Math.min(a.minU, b.minU),
+  maxU: Math.max(a.maxU, b.maxU),
+  minV: Math.min(a.minV, b.minV),
+  maxV: Math.max(a.maxV, b.maxV)
 });
 const getBoundsCenter = (bounds) => ({
-    u: (bounds.minU + bounds.maxU) / 2,
-    v: (bounds.minV + bounds.maxV) / 2,
+  u: (bounds.minU + bounds.maxU) / 2,
+  v: (bounds.minV + bounds.maxV) / 2
 });
 const getBoundsSize = (bounds) => ({
-    u: bounds.maxU - bounds.minU,
-    v: bounds.maxV - bounds.minV,
+  u: bounds.maxU - bounds.minU,
+  v: bounds.maxV - bounds.minV
 });
 const getBoundsArea = (bounds) => (bounds.maxU - bounds.minU) * (bounds.maxV - bounds.minV);
-const boundsContains = (bounds, point) => point.u >= bounds.minU &&
-    point.u <= bounds.maxU &&
-    point.v >= bounds.minV &&
-    point.v <= bounds.maxV;
+const boundsContains = (bounds, point) => point.u >= bounds.minU && point.u <= bounds.maxU && point.v >= bounds.minV && point.v <= bounds.maxV;
 const boundsOverlap = (a, b) => a.minU <= b.maxU && a.maxU >= b.minU && a.minV <= b.maxV && a.maxV >= b.minV;
-/* ═══════════════════════════════════════════
-   Geometry Extraction
-   ═══════════════════════════════════════════ */
-function extractUVMeshData(geometry, channel = 'uv') {
-    const uvAttr = geometry.getAttribute(channel);
-    const posAttr = geometry.getAttribute('position');
-    const indexAttr = geometry.getIndex();
-    if (!uvAttr || !posAttr) {
-        return null;
-    }
-    const vertices = new Map();
-    const edges = new Map();
-    const faces = new Map();
-    // Extract vertices
-    for (let i = 0; i < uvAttr.count; i++) {
-        const id = generateId('v');
-        vertices.set(id, {
-            id,
-            position: { u: uvAttr.getX(i), v: uvAttr.getY(i) },
-            index: i,
-            pinned: false,
-            selected: false,
-            vertexIndex: i,
-        });
+function extractUVMeshData(geometry, channel = "uv") {
+  const uvAttr = geometry.getAttribute(channel);
+  const posAttr = geometry.getAttribute("position");
+  const indexAttr = geometry.getIndex();
+  if (!uvAttr || !posAttr) {
+    return null;
+  }
+  const vertices = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const faces = /* @__PURE__ */ new Map();
+  for (let i = 0; i < uvAttr.count; i++) {
+    const id = generateId("v");
+    vertices.set(id, {
+      id,
+      position: { u: uvAttr.getX(i), v: uvAttr.getY(i) },
+      index: i,
+      pinned: false,
+      selected: false,
+      vertexIndex: i
+    });
+  }
+  const vertexIds = Array.from(vertices.keys());
+  const edgeMap = /* @__PURE__ */ new Map();
+  const faceCount = indexAttr ? indexAttr.count / 3 : posAttr.count / 3;
+  for (let i = 0; i < faceCount; i++) {
+    const faceVertexIds = [];
+    const indices = [];
+    for (let j = 0; j < 3; j++) {
+      const idx = indexAttr ? indexAttr.getX(i * 3 + j) : i * 3 + j;
+      indices.push(idx);
+      faceVertexIds.push(vertexIds[idx]);
     }
-    // Extract faces and edges
-    const vertexIds = Array.from(vertices.keys());
-    const edgeMap = new Map(); // "v1_v2" -> edgeId
-    const faceCount = indexAttr ? indexAttr.count / 3 : posAttr.count / 3;
-    for (let i = 0; i < faceCount; i++) {
-        const faceVertexIds = [];
-        const indices = [];
-        for (let j = 0; j < 3; j++) {
-            const idx = indexAttr ? indexAttr.getX(i * 3 + j) : i * 3 + j;
-            indices.push(idx);
-            faceVertexIds.push(vertexIds[idx]);
-        }
-        // Calculate face area in UV space
-        const v0 = vertices.get(faceVertexIds[0]).position;
-        const v1 = vertices.get(faceVertexIds[1]).position;
-        const v2 = vertices.get(faceVertexIds[2]).position;
-        const uvArea = Math.abs(uvCross(uvSub(v1, v0), uvSub(v2, v0))) / 2;
-        // Calculate face area in 3D space
-        const p0 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[0]);
-        const p1 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[1]);
-        const p2 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[2]);
-        const e1 = p1.clone().sub(p0);
-        const e2 = p2.clone().sub(p0);
-        const area3D = e1.cross(e2).length() / 2;
-        const faceId = generateId('f');
-        faces.set(faceId, {
-            id: faceId,
-            vertices: faceVertexIds,
-            area: uvArea,
-            area3D,
-            distortion: area3D > 0 ? uvArea / area3D : 1,
-            selected: false,
-            faceIndex: i,
+    const v0 = vertices.get(faceVertexIds[0]).position;
+    const v1 = vertices.get(faceVertexIds[1]).position;
+    const v2 = vertices.get(faceVertexIds[2]).position;
+    const uvArea = Math.abs(uvCross(uvSub(v1, v0), uvSub(v2, v0))) / 2;
+    const p0 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[0]);
+    const p1 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[1]);
+    const p2 = new THREE__namespace.Vector3().fromBufferAttribute(posAttr, indices[2]);
+    const e1 = p1.clone().sub(p0);
+    const e2 = p2.clone().sub(p0);
+    const area3D = e1.cross(e2).length() / 2;
+    const faceId = generateId("f");
+    faces.set(faceId, {
+      id: faceId,
+      vertices: faceVertexIds,
+      area: uvArea,
+      area3D,
+      distortion: area3D > 0 ? uvArea / area3D : 1,
+      selected: false,
+      faceIndex: i
+    });
+    for (let j = 0; j < 3; j++) {
+      const v1Id = faceVertexIds[j];
+      const v2Id = faceVertexIds[(j + 1) % 3];
+      const edgeKey = [v1Id, v2Id].sort().join("_");
+      if (!edgeMap.has(edgeKey)) {
+        const edgeId = generateId("e");
+        const v1Pos = vertices.get(v1Id).position;
+        const v2Pos = vertices.get(v2Id).position;
+        edges.set(edgeId, {
+          id: edgeId,
+          startVertex: v1Id,
+          endVertex: v2Id,
+          seam: false,
+          selected: false,
+          length: uvDistance(v1Pos, v2Pos)
         });
-        // Create edges
-        for (let j = 0; j < 3; j++) {
-            const v1Id = faceVertexIds[j];
-            const v2Id = faceVertexIds[(j + 1) % 3];
-            const edgeKey = [v1Id, v2Id].sort().join('_');
-            if (!edgeMap.has(edgeKey)) {
-                const edgeId = generateId('e');
-                const v1Pos = vertices.get(v1Id).position;
-                const v2Pos = vertices.get(v2Id).position;
-                edges.set(edgeId, {
-                    id: edgeId,
-                    startVertex: v1Id,
-                    endVertex: v2Id,
-                    seam: false,
-                    selected: false,
-                    length: uvDistance(v1Pos, v2Pos),
-                });
-                edgeMap.set(edgeKey, edgeId);
-            }
-        }
+        edgeMap.set(edgeKey, edgeId);
+      }
     }
-    // Compute islands
-    const islands = computeIslands(vertices, edges, faces);
-    return {
-        vertices,
-        edges,
-        faces,
-        islands,
-        geometryId: geometry.uuid,
-        dirty: false,
-    };
+  }
+  const islands = computeIslands(vertices, edges, faces);
+  return {
+    vertices,
+    edges,
+    faces,
+    islands,
+    geometryId: geometry.uuid,
+    dirty: false
+  };
 }
-/* ═══════════════════════════════════════════
-   Island Detection
-   ═══════════════════════════════════════════ */
 function computeIslands(vertices, edges, faces) {
-    const islands = new Map();
-    const visited = new Set();
-    const faceToIsland = new Map();
-    // Build adjacency graph (faces connected by non-seam edges)
-    const adjacency = new Map();
-    for (const face of faces.values()) {
-        adjacency.set(face.id, new Set());
+  const islands = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const faceToIsland = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const face of faces.values()) {
+    adjacency.set(face.id, /* @__PURE__ */ new Set());
+  }
+  const vertexToFaces = /* @__PURE__ */ new Map();
+  for (const face of faces.values()) {
+    for (const vId of face.vertices) {
+      if (!vertexToFaces.has(vId)) {
+        vertexToFaces.set(vId, /* @__PURE__ */ new Set());
+      }
+      vertexToFaces.get(vId).add(face.id);
     }
-    // Find adjacent faces (sharing vertices)
-    const vertexToFaces = new Map();
-    for (const face of faces.values()) {
-        for (const vId of face.vertices) {
-            if (!vertexToFaces.has(vId)) {
-                vertexToFaces.set(vId, new Set());
-            }
-            vertexToFaces.get(vId).add(face.id);
+  }
+  for (const face of faces.values()) {
+    for (const vId of face.vertices) {
+      const connectedFaces = vertexToFaces.get(vId);
+      for (const otherFaceId of connectedFaces) {
+        if (otherFaceId !== face.id) {
+          adjacency.get(face.id).add(otherFaceId);
         }
+      }
     }
-    for (const face of faces.values()) {
-        for (const vId of face.vertices) {
-            const connectedFaces = vertexToFaces.get(vId);
-            for (const otherFaceId of connectedFaces) {
-                if (otherFaceId !== face.id) {
-                    adjacency.get(face.id).add(otherFaceId);
-                }
-            }
+  }
+  const floodFill = (startFaceId) => {
+    const stack = [startFaceId];
+    const islandFaces = [];
+    while (stack.length > 0) {
+      const faceId = stack.pop();
+      if (visited.has(faceId)) {
+        continue;
+      }
+      visited.add(faceId);
+      islandFaces.push(faceId);
+      for (const neighborId of adjacency.get(faceId) ?? []) {
+        if (!visited.has(neighborId)) {
+          stack.push(neighborId);
         }
+      }
     }
-    // Flood fill to find islands
-    const floodFill = (startFaceId) => {
-        var _a;
-        const stack = [startFaceId];
-        const islandFaces = [];
-        while (stack.length > 0) {
-            const faceId = stack.pop();
-            if (visited.has(faceId)) {
-                continue;
-            }
-            visited.add(faceId);
-            islandFaces.push(faceId);
-            for (const neighborId of (_a = adjacency.get(faceId)) !== null && _a !== void 0 ? _a : []) {
-                if (!visited.has(neighborId)) {
-                    stack.push(neighborId);
-                }
-            }
-        }
-        return islandFaces;
-    };
-    for (const face of faces.values()) {
-        if (visited.has(face.id)) {
-            continue;
-        }
-        const islandFaces = floodFill(face.id);
-        const islandId = generateId('i');
-        // Gather island vertices and edges
-        const islandVertices = new Set();
-        const islandEdges = new Set();
-        for (const faceId of islandFaces) {
-            faceToIsland.set(faceId, islandId);
-            const f = faces.get(faceId);
-            for (const vId of f.vertices) {
-                islandVertices.add(vId);
-            }
-        }
-        for (const edge of edges.values()) {
-            if (islandVertices.has(edge.startVertex) && islandVertices.has(edge.endVertex)) {
-                islandEdges.add(edge.id);
-            }
-        }
-        // Calculate bounds
-        let bounds = createEmptyBounds();
-        let totalArea = 0;
-        let centerU = 0, centerV = 0;
-        for (const vId of islandVertices) {
-            const v = vertices.get(vId);
-            bounds = expandBounds(bounds, v.position);
-            centerU += v.position.u;
-            centerV += v.position.v;
-        }
-        for (const faceId of islandFaces) {
-            totalArea += faces.get(faceId).area;
-        }
-        const vertexCount = islandVertices.size;
-        islands.set(islandId, {
-            id: islandId,
-            faces: islandFaces,
-            vertices: Array.from(islandVertices),
-            edges: Array.from(islandEdges),
-            bounds,
-            area: totalArea,
-            selected: false,
-            center: { u: centerU / vertexCount, v: centerV / vertexCount },
-            rotation: 0,
-            scale: { u: 1, v: 1 },
-        });
+    return islandFaces;
+  };
+  for (const face of faces.values()) {
+    if (visited.has(face.id)) {
+      continue;
     }
-    return islands;
-}
-/* ═══════════════════════════════════════════
-   Projection Functions
-   ═══════════════════════════════════════════ */
-function applyProjection(geometry, settings, selectedFaces) {
-    const posAttr = geometry.getAttribute('position');
-    let uvAttr = geometry.getAttribute('uv');
-    if (!uvAttr) {
-        uvAttr = new THREE__namespace.BufferAttribute(new Float32Array(posAttr.count * 2), 2);
-        geometry.setAttribute('uv', uvAttr);
+    const islandFaces = floodFill(face.id);
+    const islandId = generateId("i");
+    const islandVertices = /* @__PURE__ */ new Set();
+    const islandEdges = /* @__PURE__ */ new Set();
+    for (const faceId of islandFaces) {
+      faceToIsland.set(faceId, islandId);
+      const f = faces.get(faceId);
+      for (const vId of f.vertices) {
+        islandVertices.add(vId);
+      }
+    }
+    for (const edge of edges.values()) {
+      if (islandVertices.has(edge.startVertex) && islandVertices.has(edge.endVertex)) {
+        islandEdges.add(edge.id);
+      }
+    }
+    let bounds = createEmptyBounds();
+    let totalArea = 0;
+    let centerU = 0, centerV = 0;
+    for (const vId of islandVertices) {
+      const v = vertices.get(vId);
+      bounds = expandBounds(bounds, v.position);
+      centerU += v.position.u;
+      centerV += v.position.v;
     }
-    const indices = selectedFaces !== null && selectedFaces !== void 0 ? selectedFaces : Array.from({ length: posAttr.count }, (_, i) => i);
-    switch (settings.type) {
-        case 'planar':
-            applyPlanarProjection(geometry, settings, indices);
-            break;
-        case 'cylindrical':
-            applyCylindricalProjection(geometry, settings, indices);
-            break;
-        case 'spherical':
-            applySphericalProjection(geometry, settings, indices);
-            break;
-        case 'box':
-            applyBoxProjection(geometry, settings, indices);
-            break;
-        default:
-            applyPlanarProjection(geometry, { ...settings, axis: 'z'}, indices);
+    for (const faceId of islandFaces) {
+      totalArea += faces.get(faceId).area;
     }
-    uvAttr.needsUpdate = true;
+    const vertexCount = islandVertices.size;
+    islands.set(islandId, {
+      id: islandId,
+      faces: islandFaces,
+      vertices: Array.from(islandVertices),
+      edges: Array.from(islandEdges),
+      bounds,
+      area: totalArea,
+      selected: false,
+      center: { u: centerU / vertexCount, v: centerV / vertexCount },
+      rotation: 0,
+      scale: { u: 1, v: 1 }
+    });
+  }
+  return islands;
+}
+function applyProjection(geometry, settings, selectedFaces) {
+  const posAttr = geometry.getAttribute("position");
+  let uvAttr = geometry.getAttribute("uv");
+  if (!uvAttr) {
+    uvAttr = new THREE__namespace.BufferAttribute(new Float32Array(posAttr.count * 2), 2);
+    geometry.setAttribute("uv", uvAttr);
+  }
+  const indices = selectedFaces ?? Array.from({ length: posAttr.count }, (_, i) => i);
+  switch (settings.type) {
+    case "planar":
+      applyPlanarProjection(geometry, settings, indices);
+      break;
+    case "cylindrical":
+      applyCylindricalProjection(geometry, settings, indices);
+      break;
+    case "spherical":
+      applySphericalProjection(geometry, settings, indices);
+      break;
+    case "box":
+      applyBoxProjection(geometry, settings, indices);
+      break;
+    default:
+      applyPlanarProjection(
+        geometry,
+        { ...settings, axis: "z" },
+        indices
+      );
+  }
+  uvAttr.needsUpdate = true;
 }
 function applyPlanarProjection(geometry, settings, indices) {
-    const posAttr = geometry.getAttribute('position');
-    const uvAttr = geometry.getAttribute('uv');
-    const { scale, offset, axis } = settings;
-    for (const i of indices) {
-        const x = posAttr.getX(i);
-        const y = posAttr.getY(i);
-        const z = posAttr.getZ(i);
-        let u, v;
-        switch (axis) {
-            case 'x':
-                u = (z - offset.z) * scale.z;
-                v = (y - offset.y) * scale.y;
-                break;
-            case 'y':
-                u = (x - offset.x) * scale.x;
-                v = (z - offset.z) * scale.z;
-                break;
-            case 'z':
-            default:
-                u = (x - offset.x) * scale.x;
-                v = (y - offset.y) * scale.y;
-                break;
-        }
-        uvAttr.setXY(i, u, v);
+  const posAttr = geometry.getAttribute("position");
+  const uvAttr = geometry.getAttribute("uv");
+  const { scale, offset, axis } = settings;
+  for (const i of indices) {
+    const x = posAttr.getX(i);
+    const y = posAttr.getY(i);
+    const z = posAttr.getZ(i);
+    let u, v;
+    switch (axis) {
+      case "x":
+        u = (z - offset.z) * scale.z;
+        v = (y - offset.y) * scale.y;
+        break;
+      case "y":
+        u = (x - offset.x) * scale.x;
+        v = (z - offset.z) * scale.z;
+        break;
+      case "z":
+      default:
+        u = (x - offset.x) * scale.x;
+        v = (y - offset.y) * scale.y;
+        break;
     }
+    uvAttr.setXY(i, u, v);
+  }
 }
 function applyCylindricalProjection(geometry, settings, indices) {
-    const posAttr = geometry.getAttribute('position');
-    const uvAttr = geometry.getAttribute('uv');
-    const { scale, offset, axis } = settings;
-    for (const i of indices) {
-        const x = posAttr.getX(i) - offset.x;
-        const y = posAttr.getY(i) - offset.y;
-        const z = posAttr.getZ(i) - offset.z;
-        let u, v;
-        switch (axis) {
-            case 'x':
-                u = (Math.atan2(z, y) / (2 * Math.PI) + 0.5) * scale.x;
-                v = x * scale.y;
-                break;
-            case 'y':
-                u = (Math.atan2(x, z) / (2 * Math.PI) + 0.5) * scale.x;
-                v = y * scale.y;
-                break;
-            case 'z':
-            default:
-                u = (Math.atan2(y, x) / (2 * Math.PI) + 0.5) * scale.x;
-                v = z * scale.y;
-                break;
-        }
-        uvAttr.setXY(i, u, v);
+  const posAttr = geometry.getAttribute("position");
+  const uvAttr = geometry.getAttribute("uv");
+  const { scale, offset, axis } = settings;
+  for (const i of indices) {
+    const x = posAttr.getX(i) - offset.x;
+    const y = posAttr.getY(i) - offset.y;
+    const z = posAttr.getZ(i) - offset.z;
+    let u, v;
+    switch (axis) {
+      case "x":
+        u = (Math.atan2(z, y) / (2 * Math.PI) + 0.5) * scale.x;
+        v = x * scale.y;
+        break;
+      case "y":
+        u = (Math.atan2(x, z) / (2 * Math.PI) + 0.5) * scale.x;
+        v = y * scale.y;
+        break;
+      case "z":
+      default:
+        u = (Math.atan2(y, x) / (2 * Math.PI) + 0.5) * scale.x;
+        v = z * scale.y;
+        break;
     }
+    uvAttr.setXY(i, u, v);
+  }
 }
 function applySphericalProjection(geometry, settings, indices) {
-    const posAttr = geometry.getAttribute('position');
-    const uvAttr = geometry.getAttribute('uv');
-    const { scale, offset } = settings;
-    for (const i of indices) {
-        const x = posAttr.getX(i) - offset.x;
-        const y = posAttr.getY(i) - offset.y;
-        const z = posAttr.getZ(i) - offset.z;
-        const r = Math.sqrt(x * x + y * y + z * z);
-        const theta = Math.acos(y / r);
-        const phi = Math.atan2(z, x);
-        const u = (phi / (2 * Math.PI) + 0.5) * scale.x;
-        const v = (theta / Math.PI) * scale.y;
-        uvAttr.setXY(i, u, v);
-    }
+  const posAttr = geometry.getAttribute("position");
+  const uvAttr = geometry.getAttribute("uv");
+  const { scale, offset } = settings;
+  for (const i of indices) {
+    const x = posAttr.getX(i) - offset.x;
+    const y = posAttr.getY(i) - offset.y;
+    const z = posAttr.getZ(i) - offset.z;
+    const r = Math.sqrt(x * x + y * y + z * z);
+    const theta = Math.acos(y / r);
+    const phi = Math.atan2(z, x);
+    const u = (phi / (2 * Math.PI) + 0.5) * scale.x;
+    const v = theta / Math.PI * scale.y;
+    uvAttr.setXY(i, u, v);
+  }
 }
 function applyBoxProjection(geometry, settings, indices) {
-    var _a, _b, _c;
-    const posAttr = geometry.getAttribute('position');
-    const normalAttr = geometry.getAttribute('normal');
-    const uvAttr = geometry.getAttribute('uv');
-    if (!normalAttr) {
-        geometry.computeVertexNormals();
-    }
-    const { scale, offset } = settings;
-    for (const i of indices) {
-        const x = posAttr.getX(i) - offset.x;
-        const y = posAttr.getY(i) - offset.y;
-        const z = posAttr.getZ(i) - offset.z;
-        const nx = Math.abs((_a = normalAttr === null || normalAttr === void 0 ? void 0 : normalAttr.getX(i)) !== null && _a !== void 0 ? _a : 0);
-        const ny = Math.abs((_b = normalAttr === null || normalAttr === void 0 ? void 0 : normalAttr.getY(i)) !== null && _b !== void 0 ? _b : 1);
-        const nz = Math.abs((_c = normalAttr === null || normalAttr === void 0 ? void 0 : normalAttr.getZ(i)) !== null && _c !== void 0 ? _c : 0);
-        let u, v;
-        if (nx >= ny && nx >= nz) {
-            // Project on YZ plane
-            u = z * scale.z;
-            v = y * scale.y;
-        }
-        else if (ny >= nx && ny >= nz) {
-            // Project on XZ plane
-            u = x * scale.x;
-            v = z * scale.z;
-        }
-        else {
-            // Project on XY plane
-            u = x * scale.x;
-            v = y * scale.y;
-        }
-        uvAttr.setXY(i, u, v);
+  const posAttr = geometry.getAttribute("position");
+  const normalAttr = geometry.getAttribute("normal");
+  const uvAttr = geometry.getAttribute("uv");
+  if (!normalAttr) {
+    geometry.computeVertexNormals();
+  }
+  const { scale, offset } = settings;
+  for (const i of indices) {
+    const x = posAttr.getX(i) - offset.x;
+    const y = posAttr.getY(i) - offset.y;
+    const z = posAttr.getZ(i) - offset.z;
+    const nx = Math.abs(normalAttr?.getX(i) ?? 0);
+    const ny = Math.abs(normalAttr?.getY(i) ?? 1);
+    const nz = Math.abs(normalAttr?.getZ(i) ?? 0);
+    let u, v;
+    if (nx >= ny && nx >= nz) {
+      u = z * scale.z;
+      v = y * scale.y;
+    } else if (ny >= nx && ny >= nz) {
+      u = x * scale.x;
+      v = z * scale.z;
+    } else {
+      u = x * scale.x;
+      v = y * scale.y;
     }
+    uvAttr.setXY(i, u, v);
+  }
 }
-/* ═══════════════════════════════════════════
-   UV Packing
-   ═══════════════════════════════════════════ */
 function packIslands(meshData, options) {
-    const transforms = new Map();
-    const islands = Array.from(meshData.islands.values());
-    if (islands.length === 0) {
-        return { transforms, utilization: 0, success: true, iterations: 0 };
-    }
-    // Sort islands by area (largest first) for better packing
-    if (options.areaPriority) {
-        islands.sort((a, b) => b.area - a.area);
-    }
-    // Simple shelf-based packing algorithm
-    const padding = options.padding / options.resolution;
-    const margin = options.margin;
-    let currentX = margin;
-    let currentY = margin;
-    let rowHeight = 0;
-    let maxX = 0;
-    let maxY = 0;
-    for (const island of islands) {
-        const size = getBoundsSize(island.bounds);
-        const width = size.u + padding * 2;
-        const height = size.v + padding * 2;
-        // Check if fits in current row
-        if (currentX + width > 1 - margin) {
-            // Move to next row
-            currentX = margin;
-            currentY += rowHeight + padding;
-            rowHeight = 0;
-        }
-        // Calculate translation to move island to current position
-        const translation = {
-            u: currentX + padding - island.bounds.minU,
-            v: currentY + padding - island.bounds.minV,
-        };
-        transforms.set(island.id, {
-            translation,
-            rotation: 0,
-            scale: 1,
-        });
-        currentX += width;
-        rowHeight = Math.max(rowHeight, height);
-        maxX = Math.max(maxX, currentX);
-        maxY = Math.max(maxY, currentY + height);
+  const transforms = /* @__PURE__ */ new Map();
+  const islands = Array.from(meshData.islands.values());
+  if (islands.length === 0) {
+    return { transforms, utilization: 0, success: true, iterations: 0 };
+  }
+  if (options.areaPriority) {
+    islands.sort((a, b) => b.area - a.area);
+  }
+  const padding = options.padding / options.resolution;
+  const margin = options.margin;
+  let currentX = margin;
+  let currentY = margin;
+  let rowHeight = 0;
+  let maxX = 0;
+  let maxY = 0;
+  for (const island of islands) {
+    const size = getBoundsSize(island.bounds);
+    const width = size.u + padding * 2;
+    const height = size.v + padding * 2;
+    if (currentX + width > 1 - margin) {
+      currentX = margin;
+      currentY += rowHeight + padding;
+      rowHeight = 0;
     }
-    // Calculate utilization
-    const totalIslandArea = islands.reduce((sum, i) => sum + i.area, 0);
-    const usedArea = maxX * maxY;
-    const utilization = usedArea > 0 ? totalIslandArea / usedArea : 0;
-    return {
-        transforms,
-        utilization,
-        success: maxX <= 1 && maxY <= 1,
-        iterations: 1,
+    const translation = {
+      u: currentX + padding - island.bounds.minU,
+      v: currentY + padding - island.bounds.minV
     };
+    transforms.set(island.id, {
+      translation,
+      rotation: 0,
+      scale: 1
+    });
+    currentX += width;
+    rowHeight = Math.max(rowHeight, height);
+    maxX = Math.max(maxX, currentX);
+    maxY = Math.max(maxY, currentY + height);
+  }
+  const totalIslandArea = islands.reduce((sum, i) => sum + i.area, 0);
+  const usedArea = maxX * maxY;
+  const utilization = usedArea > 0 ? totalIslandArea / usedArea : 0;
+  return {
+    transforms,
+    utilization,
+    success: maxX <= 1 && maxY <= 1,
+    iterations: 1
+  };
 }
 function applyIslandTransforms(meshData, transforms) {
-    for (const [islandId, transform] of transforms) {
-        const island = meshData.islands.get(islandId);
-        if (!island) {
-            continue;
-        }
-        const center = island.center;
-        for (const vertexId of island.vertices) {
-            const vertex = meshData.vertices.get(vertexId);
-            if (!vertex) {
-                continue;
-            }
-            let pos = vertex.position;
-            // Apply rotation around center
-            if (transform.rotation !== 0) {
-                pos = uvRotate(pos, transform.rotation, center);
-            }
-            // Apply scale from center
-            if (transform.scale !== 1) {
-                pos = {
-                    u: center.u + (pos.u - center.u) * transform.scale,
-                    v: center.v + (pos.v - center.v) * transform.scale,
-                };
-            }
-            // Apply translation
-            pos = uvAdd(pos, transform.translation);
-            vertex.position = pos;
-        }
-        // Update island bounds
-        let bounds = createEmptyBounds();
-        for (const vertexId of island.vertices) {
-            bounds = expandBounds(bounds, meshData.vertices.get(vertexId).position);
-        }
-        island.bounds = bounds;
-        island.center = getBoundsCenter(bounds);
+  for (const [islandId, transform] of transforms) {
+    const island = meshData.islands.get(islandId);
+    if (!island) {
+      continue;
     }
-    meshData.dirty = true;
+    const center = island.center;
+    for (const vertexId of island.vertices) {
+      const vertex = meshData.vertices.get(vertexId);
+      if (!vertex) {
+        continue;
+      }
+      let pos = vertex.position;
+      if (transform.rotation !== 0) {
+        pos = uvRotate(pos, transform.rotation, center);
+      }
+      if (transform.scale !== 1) {
+        pos = {
+          u: center.u + (pos.u - center.u) * transform.scale,
+          v: center.v + (pos.v - center.v) * transform.scale
+        };
+      }
+      pos = uvAdd(pos, transform.translation);
+      vertex.position = pos;
+    }
+    let bounds = createEmptyBounds();
+    for (const vertexId of island.vertices) {
+      bounds = expandBounds(bounds, meshData.vertices.get(vertexId).position);
+    }
+    island.bounds = bounds;
+    island.center = getBoundsCenter(bounds);
+  }
+  meshData.dirty = true;
 }
-/* ═══════════════════════════════════════════
-   UV Relaxation
-   ═══════════════════════════════════════════ */
 function relaxUVs(meshData, options, selectedVertices) {
-    const verticesToRelax = selectedVertices !== null && selectedVertices !== void 0 ? selectedVertices : new Set(meshData.vertices.keys());
-    const affectedVertices = [];
-    for (let iter = 0; iter < options.iterations; iter++) {
-        for (const vertexId of verticesToRelax) {
-            const vertex = meshData.vertices.get(vertexId);
-            if (!vertex || (options.preservePinned && vertex.pinned)) {
-                continue;
-            }
-            // Find connected vertices
-            const neighbors = [];
-            for (const edge of meshData.edges.values()) {
-                if (edge.startVertex === vertexId) {
-                    neighbors.push(meshData.vertices.get(edge.endVertex).position);
-                }
-                else if (edge.endVertex === vertexId) {
-                    neighbors.push(meshData.vertices.get(edge.startVertex).position);
-                }
-            }
-            if (neighbors.length === 0) {
-                continue;
-            }
-            // Move towards average of neighbors (Laplacian smoothing)
-            const avg = {
-                u: neighbors.reduce((s, n) => s + n.u, 0) / neighbors.length,
-                v: neighbors.reduce((s, n) => s + n.v, 0) / neighbors.length,
-            };
-            const factor = 0.5; // Relaxation factor
-            vertex.position = uvLerp(vertex.position, avg, factor);
-            if (!affectedVertices.includes(vertexId)) {
-                affectedVertices.push(vertexId);
-            }
+  const verticesToRelax = selectedVertices ?? new Set(meshData.vertices.keys());
+  const affectedVertices = [];
+  for (let iter = 0; iter < options.iterations; iter++) {
+    for (const vertexId of verticesToRelax) {
+      const vertex = meshData.vertices.get(vertexId);
+      if (!vertex || options.preservePinned && vertex.pinned) {
+        continue;
+      }
+      const neighbors = [];
+      for (const edge of meshData.edges.values()) {
+        if (edge.startVertex === vertexId) {
+          neighbors.push(meshData.vertices.get(edge.endVertex).position);
+        } else if (edge.endVertex === vertexId) {
+          neighbors.push(meshData.vertices.get(edge.startVertex).position);
         }
+      }
+      if (neighbors.length === 0) {
+        continue;
+      }
+      const avg = {
+        u: neighbors.reduce((s, n) => s + n.u, 0) / neighbors.length,
+        v: neighbors.reduce((s, n) => s + n.v, 0) / neighbors.length
+      };
+      const factor = 0.5;
+      vertex.position = uvLerp(vertex.position, avg, factor);
+      if (!affectedVertices.includes(vertexId)) {
+        affectedVertices.push(vertexId);
+      }
     }
-    meshData.dirty = true;
-    return {
-        success: true,
-        affectedVertices,
-    };
+  }
+  meshData.dirty = true;
+  return {
+    success: true,
+    affectedVertices
+  };
 }
-/* ═══════════════════════════════════════════
-   Selection Utilities
-   ═══════════════════════════════════════════ */
 function selectVerticesInRect(meshData, rect, additive = false) {
-    const selected = [];
-    for (const [id, vertex] of meshData.vertices) {
-        if (boundsContains(rect, vertex.position)) {
-            vertex.selected = true;
-            selected.push(id);
-        }
-        else if (!additive) {
-            vertex.selected = false;
-        }
+  const selected = [];
+  for (const [id, vertex] of meshData.vertices) {
+    if (boundsContains(rect, vertex.position)) {
+      vertex.selected = true;
+      selected.push(id);
+    } else if (!additive) {
+      vertex.selected = false;
     }
-    return selected;
+  }
+  return selected;
 }
 function selectIsland(meshData, islandId, additive = false) {
-    if (!additive) {
-        for (const v of meshData.vertices.values()) {
-            v.selected = false;
-        }
-        for (const e of meshData.edges.values()) {
-            e.selected = false;
-        }
-        for (const f of meshData.faces.values()) {
-            f.selected = false;
-        }
-        for (const i of meshData.islands.values()) {
-            i.selected = false;
-        }
+  if (!additive) {
+    for (const v of meshData.vertices.values()) {
+      v.selected = false;
     }
-    const island = meshData.islands.get(islandId);
-    if (!island) {
-        return;
+    for (const e of meshData.edges.values()) {
+      e.selected = false;
     }
-    island.selected = true;
-    for (const vId of island.vertices) {
-        const v = meshData.vertices.get(vId);
-        if (v) {
-            v.selected = true;
-        }
+    for (const f of meshData.faces.values()) {
+      f.selected = false;
     }
-    for (const eId of island.edges) {
-        const e = meshData.edges.get(eId);
-        if (e) {
-            e.selected = true;
-        }
+    for (const i of meshData.islands.values()) {
+      i.selected = false;
     }
-    for (const fId of island.faces) {
-        const f = meshData.faces.get(fId);
-        if (f) {
-            f.selected = true;
-        }
+  }
+  const island = meshData.islands.get(islandId);
+  if (!island) {
+    return;
+  }
+  island.selected = true;
+  for (const vId of island.vertices) {
+    const v = meshData.vertices.get(vId);
+    if (v) {
+      v.selected = true;
     }
+  }
+  for (const eId of island.edges) {
+    const e = meshData.edges.get(eId);
+    if (e) {
+      e.selected = true;
+    }
+  }
+  for (const fId of island.faces) {
+    const f = meshData.faces.get(fId);
+    if (f) {
+      f.selected = true;
+    }
+  }
 }
 function getSelectedVertices(meshData) {
-    return Array.from(meshData.vertices.values()).filter((v) => v.selected);
+  return Array.from(meshData.vertices.values()).filter((v) => v.selected);
 }
 function getSelectedIslands(meshData) {
-    return Array.from(meshData.islands.values()).filter((i) => i.selected);
+  return Array.from(meshData.islands.values()).filter((i) => i.selected);
 }
-/* ═══════════════════════════════════════════
-   Seam Operations
-   ═══════════════════════════════════════════ */
 function markSeam(meshData, edgeId, isSeam) {
-    const edge = meshData.edges.get(edgeId);
-    if (edge) {
-        edge.seam = isSeam;
-        meshData.dirty = true;
-    }
+  const edge = meshData.edges.get(edgeId);
+  if (edge) {
+    edge.seam = isSeam;
+    meshData.dirty = true;
+  }
 }
 function clearAllSeams(meshData) {
-    for (const edge of meshData.edges.values()) {
-        edge.seam = false;
-    }
-    meshData.dirty = true;
+  for (const edge of meshData.edges.values()) {
+    edge.seam = false;
+  }
+  meshData.dirty = true;
 }
-/* ═══════════════════════════════════════════
-   Sync Back to Geometry
-   ═══════════════════════════════════════════ */
-function syncToGeometry(meshData, geometry, channel = 'uv') {
-    const uvAttr = geometry.getAttribute(channel);
-    if (!uvAttr) {
-        return;
-    }
-    for (const vertex of meshData.vertices.values()) {
-        uvAttr.setXY(vertex.index, vertex.position.u, vertex.position.v);
-    }
-    uvAttr.needsUpdate = true;
-    meshData.dirty = false;
+function syncToGeometry(meshData, geometry, channel = "uv") {
+  const uvAttr = geometry.getAttribute(channel);
+  if (!uvAttr) {
+    return;
+  }
+  for (const vertex of meshData.vertices.values()) {
+    uvAttr.setXY(vertex.index, vertex.position.u, vertex.position.v);
+  }
+  uvAttr.needsUpdate = true;
+  meshData.dirty = false;
 }
-
 exports.applyIslandTransforms = applyIslandTransforms;
 exports.applyProjection = applyProjection;
 exports.boundsContains = boundsContains;