@adatechnology/game-items-three 0.1.4 → 0.1.6

package/dist/index.global.js

@@ -72,52 +72,1696 @@ var GameItemsThree = (() => {
     wearableMaterials: () => wearableMaterials
   });
 
+  // ../game-shapes/dist/chunk-R4RY23RH.js
+  function canonicalJson(value) {
+    if (value === null) return "null";
+    if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "boolean") return value ? "true" : "false";
+    if (typeof value === "function") throw new Error("game-shapes: a function cannot be part of a shape (register it as a generator)");
+    if (ArrayBuffer.isView(value)) return canonicalJson(Array.from(value));
+    if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : canonicalJson(item)).join(",")}]`;
+    if (typeof value === "object") {
+      const record = value;
+      const keys = Object.keys(record).filter((key2) => record[key2] !== void 0).sort();
+      return `{${keys.map((key2) => `${JSON.stringify(key2)}:${canonicalJson(record[key2])}`).join(",")}}`;
+    }
+    return "null";
+  }
+  function normalMatrix(me) {
+    const n11 = me[0], n21 = me[1], n31 = me[2];
+    const n12 = me[4], n22 = me[5], n32 = me[6];
+    const n13 = me[8], n23 = me[9], n33 = me[10];
+    const t11 = n33 * n22 - n32 * n23;
+    const t12 = n32 * n13 - n33 * n12;
+    const t13 = n23 * n12 - n22 * n13;
+    const det = n11 * t11 + n21 * t12 + n31 * t13;
+    if (det === 0) return [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const detInv = 1 / det;
+    const te = [
+      t11 * detInv,
+      (n31 * n23 - n33 * n21) * detInv,
+      (n32 * n21 - n31 * n22) * detInv,
+      t12 * detInv,
+      (n33 * n11 - n31 * n13) * detInv,
+      (n31 * n12 - n32 * n11) * detInv,
+      t13 * detInv,
+      (n21 * n13 - n23 * n11) * detInv,
+      (n22 * n11 - n21 * n12) * detInv
+    ];
+    let tmp = te[1];
+    te[1] = te[3];
+    te[3] = tmp;
+    tmp = te[2];
+    te[2] = te[6];
+    te[6] = tmp;
+    tmp = te[5];
+    te[5] = te[7];
+    te[7] = tmp;
+    return te;
+  }
+  function transformPoint(e, x, y, z) {
+    const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+    return [(e[0] * x + e[4] * y + e[8] * z + e[12]) * w, (e[1] * x + e[5] * y + e[9] * z + e[13]) * w, (e[2] * x + e[6] * y + e[10] * z + e[14]) * w];
+  }
+  function needsUint32(array) {
+    for (let i = array.length - 1; i >= 0; --i) if (array[i] >= 65535) return true;
+    return false;
+  }
+  var indexArray = (indices) => needsUint32(indices) ? new Uint32Array(indices) : new Uint16Array(indices);
+  function pack(type, parameters, a) {
+    return {
+      type,
+      parameters,
+      positions: new Float32Array(a.vertices),
+      normals: new Float32Array(a.normals),
+      uvs: new Float32Array(a.uvs),
+      ...a.indices ? { indices: indexArray(a.indices) } : {},
+      groups: a.groups
+    };
+  }
+  var normalize3 = (x, y, z) => {
+    const length = Math.sqrt(x * x + y * y + z * z);
+    const s = 1 / (length || 1);
+    return [x * s, y * s, z * s];
+  };
+  function box(width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1) {
+    const parameters = { width, height, depth, widthSegments, heightSegments, depthSegments };
+    widthSegments = Math.floor(widthSegments);
+    heightSegments = Math.floor(heightSegments);
+    depthSegments = Math.floor(depthSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let numberOfVertices = 0;
+    let groupStart = 0;
+    const buildPlane = (u, v, w, udir, vdir, width2, height2, depth2, gridX, gridY, materialIndex) => {
+      const segmentWidth = width2 / gridX;
+      const segmentHeight = height2 / gridY;
+      const widthHalf = width2 / 2;
+      const heightHalf = height2 / 2;
+      const depthHalf = depth2 / 2;
+      const gridX1 = gridX + 1;
+      const gridY1 = gridY + 1;
+      let vertexCounter = 0;
+      let groupCount = 0;
+      const vector = { x: 0, y: 0, z: 0 };
+      for (let iy = 0; iy < gridY1; iy++) {
+        const y = iy * segmentHeight - heightHalf;
+        for (let ix = 0; ix < gridX1; ix++) {
+          const x = ix * segmentWidth - widthHalf;
+          vector[u] = x * udir;
+          vector[v] = y * vdir;
+          vector[w] = depthHalf;
+          vertices.push(vector.x, vector.y, vector.z);
+          vector[u] = 0;
+          vector[v] = 0;
+          vector[w] = depth2 > 0 ? 1 : -1;
+          normals.push(vector.x, vector.y, vector.z);
+          uvs.push(ix / gridX);
+          uvs.push(1 - iy / gridY);
+          vertexCounter += 1;
+        }
+      }
+      for (let iy = 0; iy < gridY; iy++) {
+        for (let ix = 0; ix < gridX; ix++) {
+          const a = numberOfVertices + ix + gridX1 * iy;
+          const b = numberOfVertices + ix + gridX1 * (iy + 1);
+          const c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1);
+          const d = numberOfVertices + (ix + 1) + gridX1 * iy;
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex });
+      groupStart += groupCount;
+      numberOfVertices += vertexCounter;
+    };
+    buildPlane("z", "y", "x", -1, -1, depth, height, width, depthSegments, heightSegments, 0);
+    buildPlane("z", "y", "x", 1, -1, depth, height, -width, depthSegments, heightSegments, 1);
+    buildPlane("x", "z", "y", 1, 1, width, depth, height, widthSegments, depthSegments, 2);
+    buildPlane("x", "z", "y", 1, -1, width, depth, -height, widthSegments, depthSegments, 3);
+    buildPlane("x", "y", "z", 1, -1, width, height, depth, widthSegments, heightSegments, 4);
+    buildPlane("x", "y", "z", -1, -1, width, height, -depth, widthSegments, heightSegments, 5);
+    return pack("BoxGeometry", parameters, { vertices, normals, uvs, indices, groups });
+  }
+  function cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
+    radialSegments = Math.floor(radialSegments);
+    heightSegments = Math.floor(heightSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let index = 0;
+    const indexArray2 = [];
+    const halfHeight = height / 2;
+    let groupStart = 0;
+    const generateTorso = () => {
+      let groupCount = 0;
+      const slope = (radiusBottom - radiusTop) / height;
+      for (let y = 0; y <= heightSegments; y++) {
+        const indexRow = [];
+        const v = y / heightSegments;
+        const radius = v * (radiusBottom - radiusTop) + radiusTop;
+        for (let x = 0; x <= radialSegments; x++) {
+          const u = x / radialSegments;
+          const theta = u * thetaLength + thetaStart;
+          const sinTheta = Math.sin(theta);
+          const cosTheta = Math.cos(theta);
+          vertices.push(radius * sinTheta, -v * height + halfHeight, radius * cosTheta);
+          const n = normalize3(sinTheta, slope, cosTheta);
+          normals.push(n[0], n[1], n[2]);
+          uvs.push(u, 1 - v);
+          indexRow.push(index++);
+        }
+        indexArray2.push(indexRow);
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        for (let y = 0; y < heightSegments; y++) {
+          const a = indexArray2[y][x];
+          const b = indexArray2[y + 1][x];
+          const c = indexArray2[y + 1][x + 1];
+          const d = indexArray2[y][x + 1];
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: 0 });
+      groupStart += groupCount;
+    };
+    const generateCap = (top) => {
+      const centerIndexStart = index;
+      let groupCount = 0;
+      const radius = top === true ? radiusTop : radiusBottom;
+      const sign2 = top === true ? 1 : -1;
+      for (let x = 1; x <= radialSegments; x++) {
+        vertices.push(0, halfHeight * sign2, 0);
+        normals.push(0, sign2, 0);
+        uvs.push(0.5, 0.5);
+        index++;
+      }
+      const centerIndexEnd = index;
+      for (let x = 0; x <= radialSegments; x++) {
+        const u = x / radialSegments;
+        const theta = u * thetaLength + thetaStart;
+        const cosTheta = Math.cos(theta);
+        const sinTheta = Math.sin(theta);
+        vertices.push(radius * sinTheta, halfHeight * sign2, radius * cosTheta);
+        normals.push(0, sign2, 0);
+        uvs.push(cosTheta * 0.5 + 0.5, sinTheta * 0.5 * sign2 + 0.5);
+        index++;
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        const c = centerIndexStart + x;
+        const i = centerIndexEnd + x;
+        if (top === true) indices.push(i, i + 1, c);
+        else indices.push(i + 1, i, c);
+        groupCount += 3;
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: top === true ? 1 : 2 });
+      groupStart += groupCount;
+    };
+    generateTorso();
+    if (openEnded === false) {
+      if (radiusTop > 0) generateCap(true);
+      if (radiusBottom > 0) generateCap(false);
+    }
+    return { vertices, normals, uvs, indices, groups };
+  }
+  function cylinder(radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("CylinderGeometry", parameters, cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function cone(radius = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("ConeGeometry", parameters, cylinderArrays(0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function sphere(radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI) {
+    const parameters = { radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength };
+    widthSegments = Math.max(3, Math.floor(widthSegments));
+    heightSegments = Math.max(2, Math.floor(heightSegments));
+    const thetaEnd = Math.min(thetaStart + thetaLength, Math.PI);
+    let index = 0;
+    const grid = [];
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy <= heightSegments; iy++) {
+      const verticesRow = [];
+      const v = iy / heightSegments;
+      let uOffset = 0;
+      if (iy === 0 && thetaStart === 0) uOffset = 0.5 / widthSegments;
+      else if (iy === heightSegments && thetaEnd === Math.PI) uOffset = -0.5 / widthSegments;
+      for (let ix = 0; ix <= widthSegments; ix++) {
+        const u = ix / widthSegments;
+        const x = -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        const y = radius * Math.cos(thetaStart + v * thetaLength);
+        const z = radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        vertices.push(x, y, z);
+        const n = normalize3(x, y, z);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(u + uOffset, 1 - v);
+        verticesRow.push(index++);
+      }
+      grid.push(verticesRow);
+    }
+    for (let iy = 0; iy < heightSegments; iy++) {
+      for (let ix = 0; ix < widthSegments; ix++) {
+        const a = grid[iy][ix + 1];
+        const b = grid[iy][ix];
+        const c = grid[iy + 1][ix];
+        const d = grid[iy + 1][ix + 1];
+        if (iy !== 0 || thetaStart > 0) indices.push(a, b, d);
+        if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d);
+      }
+    }
+    return pack("SphereGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function plane(width = 1, height = 1, widthSegments = 1, heightSegments = 1) {
+    const parameters = { width, height, widthSegments, heightSegments };
+    const widthHalf = width / 2;
+    const heightHalf = height / 2;
+    const gridX = Math.floor(widthSegments);
+    const gridY = Math.floor(heightSegments);
+    const gridX1 = gridX + 1;
+    const gridY1 = gridY + 1;
+    const segmentWidth = width / gridX;
+    const segmentHeight = height / gridY;
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy < gridY1; iy++) {
+      const y = iy * segmentHeight - heightHalf;
+      for (let ix = 0; ix < gridX1; ix++) {
+        const x = ix * segmentWidth - widthHalf;
+        vertices.push(x, -y, 0);
+        normals.push(0, 0, 1);
+        uvs.push(ix / gridX);
+        uvs.push(1 - iy / gridY);
+      }
+    }
+    for (let iy = 0; iy < gridY; iy++) {
+      for (let ix = 0; ix < gridX; ix++) {
+        const a = ix + gridX1 * iy;
+        const b = ix + gridX1 * (iy + 1);
+        const c = ix + 1 + gridX1 * (iy + 1);
+        const d = ix + 1 + gridX1 * iy;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("PlaneGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function circle(radius = 1, segments = 32, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, segments, thetaStart, thetaLength };
+    segments = Math.max(3, segments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    vertices.push(0, 0, 0);
+    normals.push(0, 0, 1);
+    uvs.push(0.5, 0.5);
+    for (let s = 0, i = 3; s <= segments; s++, i += 3) {
+      const segment = thetaStart + s / segments * thetaLength;
+      vertices.push(radius * Math.cos(segment), radius * Math.sin(segment), 0);
+      normals.push(0, 0, 1);
+      uvs.push((vertices[i] / radius + 1) / 2, (vertices[i + 1] / radius + 1) / 2);
+    }
+    for (let i = 1; i <= segments; i++) indices.push(i, i + 1, 0);
+    return pack("CircleGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function ring(innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength };
+    thetaSegments = Math.max(3, thetaSegments);
+    phiSegments = Math.max(1, phiSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    let radius = innerRadius;
+    const radiusStep = (outerRadius - innerRadius) / phiSegments;
+    for (let j = 0; j <= phiSegments; j++) {
+      for (let i = 0; i <= thetaSegments; i++) {
+        const segment = thetaStart + i / thetaSegments * thetaLength;
+        const x = radius * Math.cos(segment);
+        const y = radius * Math.sin(segment);
+        vertices.push(x, y, 0);
+        normals.push(0, 0, 1);
+        uvs.push((x / outerRadius + 1) / 2, (y / outerRadius + 1) / 2);
+      }
+      radius += radiusStep;
+    }
+    for (let j = 0; j < phiSegments; j++) {
+      const thetaSegmentLevel = j * (thetaSegments + 1);
+      for (let i = 0; i < thetaSegments; i++) {
+        const segment = i + thetaSegmentLevel;
+        const a = segment;
+        const b = segment + thetaSegments + 1;
+        const c = segment + thetaSegments + 2;
+        const d = segment + 1;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("RingGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function lathe(points, segments = 12, phiStart = 0, phiLength = Math.PI * 2) {
+    const parameters = { points: points.map(([x, y]) => ({ x, y })), segments, phiStart, phiLength };
+    segments = Math.floor(segments);
+    phiLength = Math.max(0, Math.min(Math.PI * 2, phiLength));
+    const indices = [];
+    const vertices = [];
+    const uvs = [];
+    const initNormals = [];
+    const normals = [];
+    const inverseSegments = 1 / segments;
+    const normal = { x: 0, y: 0, z: 0 };
+    const curNormal = { x: 0, y: 0, z: 0 };
+    const prevNormal = { x: 0, y: 0, z: 0 };
+    let dx = 0;
+    let dy = 0;
+    const last = points.length - 1;
+    const px = (j) => points[j][0];
+    const py = (j) => points[j][1];
+    const setNormalized = () => {
+      const n = normalize3(normal.x, normal.y, normal.z);
+      normal.x = n[0];
+      normal.y = n[1];
+      normal.z = n[2];
+    };
+    for (let j = 0; j <= last; j++) {
+      if (j === 0) {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        prevNormal.x = normal.x;
+        prevNormal.y = normal.y;
+        prevNormal.z = normal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+      } else if (j === last) {
+        initNormals.push(prevNormal.x, prevNormal.y, prevNormal.z);
+      } else {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        curNormal.x = normal.x;
+        curNormal.y = normal.y;
+        curNormal.z = normal.z;
+        normal.x += prevNormal.x;
+        normal.y += prevNormal.y;
+        normal.z += prevNormal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+        prevNormal.x = curNormal.x;
+        prevNormal.y = curNormal.y;
+        prevNormal.z = curNormal.z;
+      }
+    }
+    for (let i = 0; i <= segments; i++) {
+      const phi = phiStart + i * inverseSegments * phiLength;
+      const sin = Math.sin(phi);
+      const cos = Math.cos(phi);
+      for (let j = 0; j <= last; j++) {
+        vertices.push(px(j) * sin, py(j), px(j) * cos);
+        uvs.push(i / segments, j / (points.length - 1));
+        const x = initNormals[3 * j + 0] * sin;
+        const y = initNormals[3 * j + 1];
+        const z = initNormals[3 * j + 0] * cos;
+        normals.push(x, y, z);
+      }
+    }
+    for (let i = 0; i < segments; i++) {
+      for (let j = 0; j < points.length - 1; j++) {
+        const base = j + i * points.length;
+        const a = base;
+        const b = base + points.length;
+        const c = base + points.length + 1;
+        const d = base + 1;
+        indices.push(a, b, d);
+        indices.push(c, d, b);
+      }
+    }
+    return pack("LatheGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function torus(radius = 1, tube2 = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) {
+    const parameters = { radius, tube: tube2, radialSegments, tubularSegments, arc };
+    radialSegments = Math.floor(radialSegments);
+    tubularSegments = Math.floor(tubularSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let j = 0; j <= radialSegments; j++) {
+      for (let i = 0; i <= tubularSegments; i++) {
+        const u = i / tubularSegments * arc;
+        const v = j / radialSegments * Math.PI * 2;
+        const x = (radius + tube2 * Math.cos(v)) * Math.cos(u);
+        const y = (radius + tube2 * Math.cos(v)) * Math.sin(u);
+        const z = tube2 * Math.sin(v);
+        vertices.push(x, y, z);
+        const cx = radius * Math.cos(u);
+        const cy = radius * Math.sin(u);
+        const n = normalize3(x - cx, y - cy, z - 0);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(i / tubularSegments);
+        uvs.push(j / radialSegments);
+      }
+    }
+    for (let j = 1; j <= radialSegments; j++) {
+      for (let i = 1; i <= tubularSegments; i++) {
+        const a = (tubularSegments + 1) * j + i - 1;
+        const b = (tubularSegments + 1) * (j - 1) + i - 1;
+        const c = (tubularSegments + 1) * (j - 1) + i;
+        const d = (tubularSegments + 1) * j + i;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("TorusGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function difference(size, subtract) {
+    const [w, h, d] = size;
+    const hw = w / 2;
+    const hh = h / 2;
+    const hd = d / 2;
+    const holes = subtract.map((hole) => ({ x0: Math.max(-hw, Math.min(hole.min[0], hole.max[0])), x1: Math.min(hw, Math.max(hole.min[0], hole.max[0])), y0: Math.max(-hh, Math.min(hole.min[1], hole.max[1])), y1: Math.min(hh, Math.max(hole.min[1], hole.max[1])) })).filter((hole) => hole.x1 > hole.x0 && hole.y1 > hole.y0);
+    const cuts = (lo, hi, values) => [.../* @__PURE__ */ new Set([lo, hi, ...values.filter((v) => v > lo && v < hi)])].sort((a, b) => a - b);
+    const xs = cuts(-hw, hw, holes.flatMap((hole) => [hole.x0, hole.x1]));
+    const ys = cuts(-hh, hh, holes.flatMap((hole) => [hole.y0, hole.y1]));
+    const nx = xs.length - 1;
+    const ny = ys.length - 1;
+    const solid = (i, j) => {
+      if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+      const cx = (xs[i] + xs[i + 1]) / 2;
+      const cy = (ys[j] + ys[j + 1]) / 2;
+      return !holes.some((hole) => cx > hole.x0 && cx < hole.x1 && cy > hole.y0 && cy < hole.y1);
+    };
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    const quad = (corners, normal, uv) => {
+      const base = positions.length / 3;
+      for (let k = 0; k < 4; k++) {
+        positions.push(...corners[k]);
+        normals.push(...normal);
+        uvs.push(...uv[k]);
+      }
+      indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    };
+    const fu = (x) => (x + hw) / w;
+    const fv = (y) => (y + hh) / h;
+    for (let j = 0; j < ny; j++) {
+      for (let i = 0; i < nx; i++) {
+        if (!solid(i, j)) continue;
+        const x0 = xs[i];
+        const x1 = xs[i + 1];
+        const y0 = ys[j];
+        const y1 = ys[j + 1];
+        quad([[x0, y0, hd], [x1, y0, hd], [x1, y1, hd], [x0, y1, hd]], [0, 0, 1], [[fu(x0), fv(y0)], [fu(x1), fv(y0)], [fu(x1), fv(y1)], [fu(x0), fv(y1)]]);
+        quad([[x1, y0, -hd], [x0, y0, -hd], [x0, y1, -hd], [x1, y1, -hd]], [0, 0, -1], [[1 - fu(x1), fv(y0)], [1 - fu(x0), fv(y0)], [1 - fu(x0), fv(y1)], [1 - fu(x1), fv(y1)]]);
+        const zu = (z) => (z + hd) / d;
+        if (!solid(i - 1, j)) quad([[x0, y0, -hd], [x0, y0, hd], [x0, y1, hd], [x0, y1, -hd]], [-1, 0, 0], [[zu(-hd), fv(y0)], [zu(hd), fv(y0)], [zu(hd), fv(y1)], [zu(-hd), fv(y1)]]);
+        if (!solid(i + 1, j)) quad([[x1, y0, hd], [x1, y0, -hd], [x1, y1, -hd], [x1, y1, hd]], [1, 0, 0], [[zu(hd), fv(y0)], [zu(-hd), fv(y0)], [zu(-hd), fv(y1)], [zu(hd), fv(y1)]]);
+        if (!solid(i, j - 1)) quad([[x0, y0, -hd], [x1, y0, -hd], [x1, y0, hd], [x0, y0, hd]], [0, -1, 0], [[fu(x0), zu(-hd)], [fu(x1), zu(-hd)], [fu(x1), zu(hd)], [fu(x0), zu(hd)]]);
+        if (!solid(i, j + 1)) quad([[x0, y1, hd], [x1, y1, hd], [x1, y1, -hd], [x0, y1, -hd]], [0, 1, 0], [[fu(x0), zu(hd)], [fu(x1), zu(hd)], [fu(x1), zu(-hd)], [fu(x0), zu(-hd)]]);
+      }
+    }
+    return {
+      type: "BufferGeometry",
+      parameters: { size: [w, h, d], subtract: holes.map((hole) => ({ min: [hole.x0, hole.y0], max: [hole.x1, hole.y1] })) },
+      positions: new Float32Array(positions),
+      normals: new Float32Array(normals),
+      uvs: new Float32Array(uvs),
+      indices: indexArray(indices),
+      groups: []
+    };
+  }
+  var Earcut = {
+    triangulate: function(data, holeIndices, dim = 2) {
+      const hasHoles = holeIndices && holeIndices.length;
+      const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+      let outerNode = linkedList(data, 0, outerLen, dim, true);
+      const triangles = [];
+      if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+      let minX, minY, maxX, maxY, x, y, invSize;
+      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+      if (data.length > 80 * dim) {
+        minX = maxX = data[0];
+        minY = maxY = data[1];
+        for (let i = dim; i < outerLen; i += dim) {
+          x = data[i];
+          y = data[i + 1];
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+        }
+        invSize = Math.max(maxX - minX, maxY - minY);
+        invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+      return triangles;
+    }
+  };
+  function linkedList(data, start, end, dim, clockwise) {
+    let i, last;
+    if (clockwise === signedArea(data, start, end, dim) > 0) {
+      for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+    } else {
+      for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start) return start;
+    if (!end) end = start;
+    let p = start, again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next) break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear) return;
+    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+    let stop = ear, prev, next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+    let p = ear.prevZ, n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev, b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+    const queue = [];
+    let i, len, start, end, list2;
+    for (i = 0, len = holeIndices.length; i < len; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+      list2 = linkedList(data, start, end, dim, false);
+      if (list2 === list2.next) list2.steiner = true;
+      queue.push(getLeftmost(list2));
+    }
+    queue.sort(compareX);
+    for (i = 0; i < queue.length; i++) {
+      outerNode = eliminateHole(queue[i], outerNode);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+      return outerNode;
+    }
+    const bridgeReverse = splitPolygon(bridge, hole);
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode, qx = -Infinity, m;
+    const hx = hole.x, hy = hole.y;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x <= hx && x > qx) {
+          qx = x;
+          m = p.x < p.next.x ? p : p.next;
+          if (x === hx) return m;
+        }
+      }
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m) return null;
+    const stop = m, mx = m.x, my = m.y;
+    let tanMin = Infinity, tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list2) {
+    let i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+    do {
+      p = list2;
+      list2 = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i = 0; i < inSize; i++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q) break;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail) tail.nextZ = e;
+          else list2 = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list2;
+  }
+  function zOrder(x, y, minX, minY, invSize) {
+    x = (x - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
+    x = (x | x << 8) & 16711935;
+    x = (x | x << 4) & 252645135;
+    x = (x | x << 2) & 858993459;
+    x = (x | x << 1) & 1431655765;
+    y = (y | y << 8) & 16711935;
+    y = (y | y << 4) & 252645135;
+    y = (y | y << 2) & 858993459;
+    y = (y | y << 1) & 1431655765;
+    return x | y << 1;
+  }
+  function getLeftmost(start) {
+    let p = start, leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+    (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+    (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+    equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4) return true;
+    if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+    if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+    if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+    if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num2) {
+    return num2 > 0 ? 1 : num2 < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a, inside = false;
+    const px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i, x, y, last) {
+    const p = new Node(i, x, y);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+  }
+  function Node(i, x, y) {
+    this.i = i;
+    this.x = x;
+    this.y = y;
+    this.prev = null;
+    this.next = null;
+    this.z = 0;
+    this.prevZ = null;
+    this.nextZ = null;
+    this.steiner = false;
+  }
+  function signedArea(data, start, end, dim) {
+    let sum = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+      j = i;
+    }
+    return sum;
+  }
+  var equals2 = (a, b) => a.x === b.x && a.y === b.y;
+  var linePoint = (v1, v2, t) => t === 1 ? { x: v2.x, y: v2.y } : { x: (v2.x - v1.x) * t + v1.x, y: (v2.y - v1.y) * t + v1.y };
+  function pathPoints(points) {
+    const out = [];
+    let last;
+    for (let i = 1; i < points.length; i++) {
+      const v1 = { x: points[i - 1][0], y: points[i - 1][1] };
+      const v2 = { x: points[i][0], y: points[i][1] };
+      for (let d = 0; d <= 1; d++) {
+        const point = linePoint(v1, v2, d / 1);
+        if (last && equals2(last, point)) continue;
+        out.push(point);
+        last = point;
+      }
+    }
+    return out;
+  }
+  function area2(contour) {
+    const n = contour.length;
+    let a = 0;
+    for (let p = n - 1, q = 0; q < n; p = q++) a += contour[p].x * contour[q].y - contour[q].x * contour[p].y;
+    return a * 0.5;
+  }
+  var isClockWise = (pts) => area2(pts) < 0;
+  function removeDupEndPts(points) {
+    const l = points.length;
+    if (l > 2 && equals2(points[l - 1], points[0])) points.pop();
+  }
+  function triangulateShape(contour, holes) {
+    const vertices = [];
+    const holeIndices = [];
+    const faces = [];
+    removeDupEndPts(contour);
+    for (const p of contour) vertices.push(p.x, p.y);
+    let holeIndex = contour.length;
+    holes.forEach(removeDupEndPts);
+    for (let i = 0; i < holes.length; i++) {
+      holeIndices.push(holeIndex);
+      holeIndex += holes[i].length;
+      for (const p of holes[i]) vertices.push(p.x, p.y);
+    }
+    const triangles = Earcut.triangulate(vertices, holeIndices);
+    for (let i = 0; i < triangles.length; i += 3) faces.push(triangles.slice(i, i + 3));
+    return faces;
+  }
+  function computeVertexNormals(positions, indices) {
+    const normals = new Float32Array(positions.length);
+    const get = (array, i) => [array[i * 3], array[i * 3 + 1], array[i * 3 + 2]];
+    const face = (vA, vB, vC) => {
+      const pA = get(positions, vA);
+      const pB = get(positions, vB);
+      const pC = get(positions, vC);
+      const cb = [pC[0] - pB[0], pC[1] - pB[1], pC[2] - pB[2]];
+      const ab = [pA[0] - pB[0], pA[1] - pB[1], pA[2] - pB[2]];
+      return [cb[1] * ab[2] - cb[2] * ab[1], cb[2] * ab[0] - cb[0] * ab[2], cb[0] * ab[1] - cb[1] * ab[0]];
+    };
+    const set = (i, x, y, z) => {
+      normals[i * 3] = x;
+      normals[i * 3 + 1] = y;
+      normals[i * 3 + 2] = z;
+    };
+    if (indices) {
+      for (let i = 0; i < indices.length; i += 3) {
+        const vA = indices[i];
+        const vB = indices[i + 1];
+        const vC = indices[i + 2];
+        const cb = face(vA, vB, vC);
+        for (const v of [vA, vB, vC]) {
+          const n = get(normals, v);
+          set(v, n[0] + cb[0], n[1] + cb[1], n[2] + cb[2]);
+        }
+      }
+    } else {
+      for (let i = 0; i < positions.length / 3; i += 3) {
+        const cb = face(i, i + 1, i + 2);
+        set(i, cb[0], cb[1], cb[2]);
+        set(i + 1, cb[0], cb[1], cb[2]);
+        set(i + 2, cb[0], cb[1], cb[2]);
+      }
+    }
+    for (let i = 0; i < normals.length / 3; i++) {
+      const [x, y, z] = get(normals, i);
+      const s = 1 / (Math.sqrt(x * x + y * y + z * z) || 1);
+      set(i, x * s, y * s, z * s);
+    }
+    return normals;
+  }
+  function extrude(outline, depth = 1, steps = 1, bevel = void 0) {
+    const parameters = { shape: outline, depth, steps, bevel: bevel ?? {} };
+    const verticesArray = [];
+    const uvArray = [];
+    const groups = [];
+    const placeholder = [];
+    const bevelEnabled = bevel !== false;
+    const spec = bevel === false || bevel === void 0 ? {} : bevel;
+    let bevelThickness = spec.thickness !== void 0 ? spec.thickness : 0.2;
+    let bevelSize = spec.size !== void 0 ? spec.size : bevelThickness - 0.1;
+    let bevelOffset = spec.offset !== void 0 ? spec.offset : 0;
+    let bevelSegments = spec.segments !== void 0 ? spec.segments : 3;
+    if (!bevelEnabled) {
+      bevelSegments = 0;
+      bevelThickness = 0;
+      bevelSize = 0;
+      bevelOffset = 0;
+    }
+    let vertices = pathPoints(outline.outer);
+    const holes = (outline.holes ?? []).map(pathPoints);
+    const reverse = !isClockWise(vertices);
+    if (reverse) {
+      vertices = vertices.reverse();
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        if (isClockWise(ahole)) holes[h] = ahole.reverse();
+      }
+    }
+    const faces = triangulateShape(vertices, holes);
+    const contour = vertices;
+    for (const ahole of holes) vertices = vertices.concat(ahole);
+    const scalePt2 = (pt, vec, size) => ({ x: pt.x + vec.x * size, y: pt.y + vec.y * size });
+    const vlen = vertices.length;
+    const flen = faces.length;
+    const getBevelVec = (inPt, inPrev, inNext) => {
+      let vTransX;
+      let vTransY;
+      let shrinkBy;
+      const vPrevX = inPt.x - inPrev.x;
+      const vPrevY = inPt.y - inPrev.y;
+      const vNextX = inNext.x - inPt.x;
+      const vNextY = inNext.y - inPt.y;
+      const vPrevLensq = vPrevX * vPrevX + vPrevY * vPrevY;
+      const collinear0 = vPrevX * vNextY - vPrevY * vNextX;
+      if (Math.abs(collinear0) > Number.EPSILON) {
+        const vPrevLen = Math.sqrt(vPrevLensq);
+        const vNextLen = Math.sqrt(vNextX * vNextX + vNextY * vNextY);
+        const ptPrevShiftX = inPrev.x - vPrevY / vPrevLen;
+        const ptPrevShiftY = inPrev.y + vPrevX / vPrevLen;
+        const ptNextShiftX = inNext.x - vNextY / vNextLen;
+        const ptNextShiftY = inNext.y + vNextX / vNextLen;
+        const sf = ((ptNextShiftX - ptPrevShiftX) * vNextY - (ptNextShiftY - ptPrevShiftY) * vNextX) / (vPrevX * vNextY - vPrevY * vNextX);
+        vTransX = ptPrevShiftX + vPrevX * sf - inPt.x;
+        vTransY = ptPrevShiftY + vPrevY * sf - inPt.y;
+        const vTransLensq = vTransX * vTransX + vTransY * vTransY;
+        if (vTransLensq <= 2) return { x: vTransX, y: vTransY };
+        shrinkBy = Math.sqrt(vTransLensq / 2);
+      } else {
+        let directionEq = false;
+        if (vPrevX > Number.EPSILON) {
+          if (vNextX > Number.EPSILON) directionEq = true;
+        } else if (vPrevX < -Number.EPSILON) {
+          if (vNextX < -Number.EPSILON) directionEq = true;
+        } else if (Math.sign(vPrevY) === Math.sign(vNextY)) {
+          directionEq = true;
+        }
+        if (directionEq) {
+          vTransX = -vPrevY;
+          vTransY = vPrevX;
+          shrinkBy = Math.sqrt(vPrevLensq);
+        } else {
+          vTransX = vPrevX;
+          vTransY = vPrevY;
+          shrinkBy = Math.sqrt(vPrevLensq / 2);
+        }
+      }
+      return { x: vTransX / shrinkBy, y: vTransY / shrinkBy };
+    };
+    const movements = (ring2) => {
+      const out = [];
+      for (let i = 0, il = ring2.length, j = il - 1, k = i + 1; i < il; i++, j++, k++) {
+        if (j === il) j = 0;
+        if (k === il) k = 0;
+        out[i] = getBevelVec(ring2[i], ring2[j], ring2[k]);
+      }
+      return out;
+    };
+    const contourMovements = movements(contour);
+    const holesMovements = [];
+    let verticesMovements = contourMovements.concat();
+    for (const ahole of holes) {
+      const oneHoleMovements = movements(ahole);
+      holesMovements.push(oneHoleMovements);
+      verticesMovements = verticesMovements.concat(oneHoleMovements);
+    }
+    const v = (x, y, z) => {
+      placeholder.push(x);
+      placeholder.push(y);
+      placeholder.push(z);
+    };
+    const bevelLayer = (b, zOf) => {
+      const t = b / bevelSegments;
+      const z = bevelThickness * Math.cos(t * Math.PI / 2);
+      const bs2 = bevelSize * Math.sin(t * Math.PI / 2) + bevelOffset;
+      for (let i = 0; i < contour.length; i++) {
+        const vert = scalePt2(contour[i], contourMovements[i], bs2);
+        v(vert.x, vert.y, zOf(z));
+      }
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        const oneHoleMovements = holesMovements[h];
+        for (let i = 0; i < ahole.length; i++) {
+          const vert = scalePt2(ahole[i], oneHoleMovements[i], bs2);
+          v(vert.x, vert.y, zOf(z));
+        }
+      }
+    };
+    for (let b = 0; b < bevelSegments; b++) bevelLayer(b, (z) => -z);
+    const bs = bevelSize + bevelOffset;
+    for (let i = 0; i < vlen; i++) {
+      const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+      v(vert.x, vert.y, 0);
+    }
+    for (let s = 1; s <= steps; s++) {
+      for (let i = 0; i < vlen; i++) {
+        const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+        v(vert.x, vert.y, depth / steps * s);
+      }
+    }
+    for (let b = bevelSegments - 1; b >= 0; b--) bevelLayer(b, (z) => depth + z);
+    const addVertex = (index) => {
+      verticesArray.push(placeholder[index * 3 + 0]);
+      verticesArray.push(placeholder[index * 3 + 1]);
+      verticesArray.push(placeholder[index * 3 + 2]);
+    };
+    const addUV = (x, y) => {
+      uvArray.push(x);
+      uvArray.push(y);
+    };
+    const at = (index, axis) => verticesArray[index * 3 + axis];
+    const f3 = (a, b, c) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(c);
+      const nextIndex = verticesArray.length / 3;
+      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at(index, 0), at(index, 1));
+    };
+    const f4 = (a, b, c, d) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(d);
+      addVertex(b);
+      addVertex(c);
+      addVertex(d);
+      const nextIndex = verticesArray.length / 3;
+      const iA = nextIndex - 6;
+      const iB = nextIndex - 3;
+      const iC = nextIndex - 2;
+      const iD = nextIndex - 1;
+      const byX = Math.abs(at(iA, 1) - at(iB, 1)) < Math.abs(at(iA, 0) - at(iB, 0));
+      const uv = (index) => [byX ? at(index, 0) : at(index, 1), 1 - at(index, 2)];
+      const uvs = [uv(iA), uv(iB), uv(iC), uv(iD)];
+      for (const k of [0, 1, 3, 1, 2, 3]) addUV(...uvs[k]);
+    };
+    let start = verticesArray.length / 3;
+    if (bevelEnabled) {
+      let offset = 0;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2] + offset, face[1] + offset, face[0] + offset);
+      }
+      const layer = steps + bevelSegments * 2;
+      offset = vlen * layer;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + offset, face[1] + offset, face[2] + offset);
+      }
+    } else {
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2], face[1], face[0]);
+      }
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + vlen * steps, face[1] + vlen * steps, face[2] + vlen * steps);
+      }
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 0 });
+    start = verticesArray.length / 3;
+    const sidewalls = (ring2, layeroffset2) => {
+      let i = ring2.length;
+      while (--i >= 0) {
+        const j = i;
+        let k = i - 1;
+        if (k < 0) k = ring2.length - 1;
+        for (let s = 0, sl = steps + bevelSegments * 2; s < sl; s++) {
+          const slen1 = vlen * s;
+          const slen2 = vlen * (s + 1);
+          f4(layeroffset2 + j + slen1, layeroffset2 + k + slen1, layeroffset2 + k + slen2, layeroffset2 + j + slen2);
+        }
+      }
+    };
+    let layeroffset = 0;
+    sidewalls(contour, layeroffset);
+    layeroffset += contour.length;
+    for (const ahole of holes) {
+      sidewalls(ahole, layeroffset);
+      layeroffset += ahole.length;
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 1 });
+    const positions = new Float32Array(verticesArray);
+    return { type: "ExtrudeGeometry", parameters, positions, normals: computeVertexNormals(positions), uvs: new Float32Array(uvArray), groups };
+  }
+  var PARAMETER_KEYS = {
+    box: ["size", "segments"],
+    cylinder: ["radiusTop", "radiusBottom", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    cone: ["radius", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    sphere: ["radius", "widthSegments", "heightSegments", "phiStart", "phiLength", "thetaStart", "thetaLength"],
+    plane: ["width", "height", "widthSegments", "heightSegments"],
+    circle: ["radius", "segments", "thetaStart", "thetaLength"],
+    ring: ["innerRadius", "outerRadius", "thetaSegments", "phiSegments", "thetaStart", "thetaLength"],
+    lathe: ["points", "segments", "phiStart", "phiLength"],
+    torus: ["radius", "tube", "radialSegments", "tubularSegments", "arc"],
+    extrude: ["shape", "depth", "steps", "bevel"],
+    difference: ["size", "subtract"],
+    mesh: ["positions", "normals", "uvs", "indices"]
+  };
+  var SEGMENT_KEYS = {
+    cylinder: ["radialSegments"],
+    cone: ["radialSegments"],
+    sphere: ["widthSegments", "heightSegments"],
+    circle: ["segments"],
+    ring: ["thetaSegments"],
+    lathe: ["segments"],
+    torus: ["radialSegments", "tubularSegments"]
+  };
+  var SEGMENT_DEFAULTS = { radialSegments: 32, widthSegments: 32, heightSegments: 16, segments: 12, thetaSegments: 32, tubularSegments: 48 };
+  var segmentDefault = (kind, key2) => kind === "circle" && key2 === "segments" ? 32 : kind === "torus" && key2 === "radialSegments" ? 12 : SEGMENT_DEFAULTS[key2];
+  function primitiveParameters(node, options = {}) {
+    const out = {};
+    const source = node;
+    for (const key2 of PARAMETER_KEYS[node.kind]) if (source[key2] !== void 0) out[key2] = source[key2];
+    const detail = options.detail ?? 1;
+    if (detail !== 1) {
+      const floor = options.minSegments ?? 3;
+      for (const key2 of SEGMENT_KEYS[node.kind] ?? []) {
+        const given = out[key2] ?? segmentDefault(node.kind, key2);
+        out[key2] = Math.max(floor, Math.round(given * detail));
+      }
+    }
+    return out;
+  }
+  function mesh(p) {
+    const positions = new Float32Array(p.positions);
+    const indices = p.indices ? indexArray(p.indices) : void 0;
+    return {
+      type: "BufferGeometry",
+      parameters: {},
+      positions,
+      normals: p.normals ? new Float32Array(p.normals) : computeVertexNormals(positions, indices),
+      uvs: p.uvs ? new Float32Array(p.uvs) : new Float32Array(positions.length / 3 * 2),
+      ...indices ? { indices } : {},
+      groups: []
+    };
+  }
+  function make(kind, p) {
+    switch (kind) {
+      case "box": {
+        const size = p.size ?? [1, 1, 1];
+        const segments = p.segments ?? [1, 1, 1];
+        return box(size[0], size[1], size[2], segments[0], segments[1], segments[2]);
+      }
+      case "cylinder":
+        return cylinder(p.radiusTop, p.radiusBottom, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "cone":
+        return cone(p.radius, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "sphere":
+        return sphere(p.radius, p.widthSegments, p.heightSegments, p.phiStart, p.phiLength, p.thetaStart, p.thetaLength);
+      case "plane":
+        return plane(p.width, p.height, p.widthSegments, p.heightSegments);
+      case "circle":
+        return circle(p.radius, p.segments, p.thetaStart, p.thetaLength);
+      case "ring":
+        return ring(p.innerRadius, p.outerRadius, p.thetaSegments, p.phiSegments, p.thetaStart, p.thetaLength);
+      case "lathe":
+        return lathe(p.points, p.segments, p.phiStart, p.phiLength);
+      case "torus":
+        return torus(p.radius, p.tube, p.radialSegments, p.tubularSegments, p.arc);
+      case "extrude":
+        return extrude(p.shape, p.depth, p.steps, p.bevel);
+      case "difference":
+        return difference(p.size, p.subtract ?? []);
+      case "mesh":
+        return mesh(p);
+      default:
+        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+    }
+  }
+  var templates = /* @__PURE__ */ new Map();
+  var templateLimit = 4096;
+  var stats = { hits: 0, misses: 0 };
+  function buildPrimitive(node, options = {}) {
+    const parameters = primitiveParameters(node, options);
+    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    const key2 = `${node.kind}:${canonicalJson(parameters)}`;
+    const cached = templates.get(key2);
+    if (cached) {
+      stats.hits++;
+      templates.delete(key2);
+      templates.set(key2, cached);
+      return cached;
+    }
+    stats.misses++;
+    const built = make(node.kind, parameters);
+    templates.set(key2, built);
+    if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
+    return built;
+  }
+  var num = (v) => typeof v === "number" && Number.isFinite(v) ? null : "expected a finite number";
+  var bool = (v) => typeof v === "boolean" ? null : "expected a boolean";
+  var str = (v) => typeof v === "string" ? null : "expected a string";
+  var int = (min) => (v) => typeof v === "number" && Number.isInteger(v) && v >= min ? null : `expected an integer >= ${min}`;
+  var range = (lo, hi, loOpen = false) => (v) => typeof v === "number" && (loOpen ? v > lo : v >= lo) && v <= hi ? null : `expected a number in ${loOpen ? "(" : "["}${lo}, ${hi}]`;
+  var tuple = (n, item = num) => (v) => {
+    if (!Array.isArray(v) || v.length !== n) return `expected an array of ${n}`;
+    for (const x of v) if (item(x)) return `expected an array of ${n} numbers`;
+    return null;
+  };
+  var list = (item, min = 0) => (v) => {
+    if (!Array.isArray(v)) return "expected an array";
+    if (v.length < min) return `expected at least ${min} items`;
+    for (let i = 0; i < v.length; i++) {
+      const e = item(v[i]);
+      if (e) return `[${i}]: ${e}`;
+    }
+    return null;
+  };
+  var color = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 16777215 || typeof v === "string" && /^#[0-9a-fA-F]{6}$/.test(v) ? null : 'expected 0xRRGGBB or "#rrggbb"';
+  var oneOf = (values) => (v) => values.includes(v) ? null : `expected one of ${values.map((x) => JSON.stringify(x)).join(", ")}`;
+  var object = (fields, required = []) => (v) => {
+    if (!v || typeof v !== "object" || Array.isArray(v)) return "expected an object";
+    const record = v;
+    for (const key2 of required) if (record[key2] === void 0) return `${key2}: required`;
+    for (const key2 of Object.keys(record)) {
+      if (record[key2] === void 0) continue;
+      const check = fields[key2];
+      if (!check) return `${key2}: unknown field`;
+      const e = check(record[key2]);
+      if (e) return `${key2}: ${e}`;
+    }
+    return null;
+  };
+  var ORDERS = ["XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"];
+  var TRANSFORM = {
+    position: tuple(3),
+    rotation: tuple(3),
+    rotationOrder: oneOf(ORDERS),
+    scale: (v) => typeof v === "number" ? num(v) : tuple(3)(v),
+    heading: num,
+    matrix: tuple(16)
+  };
+  var UV = object({ u0: num, v0: num, u1: num, v1: num }, ["u0", "v0", "u1", "v1"]);
+  var INSTANCE = object({ ...TRANSFORM, color });
+  var COMMON = {
+    ...TRANSFORM,
+    kind: str,
+    name: str,
+    part: str,
+    material: str,
+    color,
+    uv: UV,
+    instances: list(INSTANCE),
+    minDetail: range(0, 1, true),
+    tags: list(str)
+  };
+  var vec2 = tuple(2);
+  var BEVEL = (v) => v === false ? null : object({ thickness: num, size: num, offset: num, segments: int(1) })(v);
+  var KINDS = {
+    group: { fields: {} },
+    box: { fields: { size: tuple(3), segments: tuple(3, int(1)) } },
+    cylinder: { fields: { radiusTop: num, radiusBottom: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    cone: { fields: { radius: num, height: num, radialSegments: int(1), heightSegments: int(1), openEnded: bool, thetaStart: num, thetaLength: num } },
+    sphere: { fields: { radius: num, widthSegments: int(3), heightSegments: int(2), phiStart: num, phiLength: num, thetaStart: num, thetaLength: num } },
+    plane: { fields: { width: num, height: num, widthSegments: int(1), heightSegments: int(1) } },
+    circle: { fields: { radius: num, segments: int(3), thetaStart: num, thetaLength: num } },
+    ring: { fields: { innerRadius: num, outerRadius: num, thetaSegments: int(3), phiSegments: int(1), thetaStart: num, thetaLength: num } },
+    lathe: { fields: { points: list(vec2, 2), segments: int(1), phiStart: num, phiLength: num }, required: ["points"] },
+    torus: { fields: { radius: num, tube: num, radialSegments: int(1), tubularSegments: int(1), arc: num } },
+    extrude: {
+      fields: { shape: object({ outer: list(vec2, 3), holes: list(list(vec2, 3)) }, ["outer"]), depth: num, steps: int(1), bevel: BEVEL },
+      required: ["shape"]
+    },
+    difference: { fields: { size: tuple(3), subtract: list(object({ min: vec2, max: vec2 }, ["min", "max"])) }, required: ["size", "subtract"] },
+    mesh: {
+      fields: {
+        positions: (v) => list(num)(v) ?? (v.length % 3 === 0 ? null : "expected a multiple of 3 numbers"),
+        normals: list(num),
+        uvs: list(num),
+        indices: list(int(0))
+      },
+      required: ["positions"]
+    },
+    point: { fields: { data: () => null } },
+    custom: { fields: { generator: str, params: () => null }, required: ["generator"] }
+  };
+  function mergeTransformed(pieces) {
+    let total = 0;
+    for (const piece2 of pieces) total += piece2.indices ? piece2.indices.length : piece2.positions.length / 3;
+    const positions = new Float32Array(total * 3);
+    const normals = new Float32Array(total * 3);
+    const uvs = new Float32Array(total * 2);
+    let at = 0;
+    for (const piece2 of pieces) {
+      const e = piece2.matrix;
+      const nm = normalMatrix(e);
+      const count = piece2.indices ? piece2.indices.length : piece2.positions.length / 3;
+      const p = new Float32Array(count * 3);
+      const n = new Float32Array(count * 3);
+      for (let k = 0; k < count; k++) {
+        const i = piece2.indices ? piece2.indices[k] : k;
+        for (let c = 0; c < 3; c++) {
+          p[k * 3 + c] = piece2.positions[i * 3 + c];
+          if (piece2.normals) n[k * 3 + c] = piece2.normals[i * 3 + c];
+        }
+        if (piece2.uvs) {
+          uvs[(at + k) * 2] = piece2.uvs[i * 2];
+          uvs[(at + k) * 2 + 1] = piece2.uvs[i * 2 + 1];
+        }
+      }
+      for (let k = 0; k < count; k++) {
+        const q = transformPoint(e, p[k * 3], p[k * 3 + 1], p[k * 3 + 2]);
+        positions[(at + k) * 3] = q[0];
+        positions[(at + k) * 3 + 1] = q[1];
+        positions[(at + k) * 3 + 2] = q[2];
+        const x = n[k * 3];
+        const y = n[k * 3 + 1];
+        const z = n[k * 3 + 2];
+        const vx = nm[0] * x + nm[3] * y + nm[6] * z;
+        const vy = nm[1] * x + nm[4] * y + nm[7] * z;
+        const vz = nm[2] * x + nm[5] * y + nm[8] * z;
+        const s = 1 / (Math.sqrt(vx * vx + vy * vy + vz * vz) || 1);
+        normals[(at + k) * 3] = vx * s;
+        normals[(at + k) * 3 + 1] = vy * s;
+        normals[(at + k) * 3 + 2] = vz * s;
+      }
+      at += count;
+    }
+    return { positions, normals, uvs };
+  }
+
+  // ../game-shapes-three/dist/index.js
+  var UV_BEFORE_NORMAL = /* @__PURE__ */ new Set(["LatheGeometry", "ExtrudeGeometry"]);
+  var INDEX_FIRST = /* @__PURE__ */ new Set(["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry"]);
+  var isPrimitive = (value) => typeof value.type === "string";
+  function threeParameters(THREE, p) {
+    if (p.type === "LatheGeometry") {
+      const points = p.parameters.points.map(({ x, y }) => new THREE.Vector2(x, y));
+      return { ...p.parameters, points };
+    }
+    return { ...p.parameters };
+  }
+  function toGeometry(THREE, source, options = {}) {
+    const copy = options.copy !== false;
+    const primitive = isPrimitive(source) ? source : null;
+    const ThreeClass = primitive && primitive.type !== "BufferGeometry" ? THREE[primitive.type] : void 0;
+    const geometry = ThreeClass ? Reflect.construct(THREE.BufferGeometry, [], ThreeClass) : new THREE.BufferGeometry();
+    if (primitive && ThreeClass) {
+      Object.assign(geometry, { type: primitive.type, parameters: threeParameters(THREE, primitive) });
+    }
+    const attribute = (array, size) => copy ? new THREE.Float32BufferAttribute(array, size) : new THREE.BufferAttribute(array, size);
+    const index = source.indices;
+    const setIndex = () => {
+      if (!index) return;
+      geometry.setIndex(copy ? index instanceof Uint32Array ? new THREE.Uint32BufferAttribute(index, 1) : new THREE.Uint16BufferAttribute(index, 1) : new THREE.BufferAttribute(index, 1));
+    };
+    const type = primitive?.type ?? "BufferGeometry";
+    if (INDEX_FIRST.has(type)) setIndex();
+    geometry.setAttribute("position", attribute(source.positions, 3));
+    if (UV_BEFORE_NORMAL.has(type)) {
+      geometry.setAttribute("uv", attribute(source.uvs, 2));
+      geometry.setAttribute("normal", attribute(source.normals, 3));
+    } else {
+      geometry.setAttribute("normal", attribute(source.normals, 3));
+      geometry.setAttribute("uv", attribute(source.uvs, 2));
+    }
+    if (!primitive && source.colors) geometry.setAttribute("color", attribute(source.colors, 3));
+    if (!INDEX_FIRST.has(type)) setIndex();
+    if (primitive) for (const group of primitive.groups) geometry.addGroup(group.start, group.count, group.materialIndex);
+    return geometry;
+  }
+  var SHAPE_GEOMETRY_TYPES = ["BoxGeometry", "CylinderGeometry", "ConeGeometry", "SphereGeometry", "PlaneGeometry", "CircleGeometry", "RingGeometry", "LatheGeometry", "TorusGeometry", "ExtrudeGeometry"];
+  function linePoints(path) {
+    if (path.autoClose || path.curves.length === 0) return null;
+    const points = [];
+    for (const [index, curve] of path.curves.entries()) {
+      if (!curve.isLineCurve || !curve.v1 || !curve.v2) return null;
+      if (index === 0) points.push([curve.v1.x, curve.v1.y]);
+      else {
+        const last = points[points.length - 1];
+        if (last[0] !== curve.v1.x || last[1] !== curve.v1.y) return null;
+      }
+      points.push([curve.v2.x, curve.v2.y]);
+    }
+    return points;
+  }
+  function extrudeOf(shapes, options = {}) {
+    if (Array.isArray(shapes) || !shapes || options.extrudePath !== void 0 || options.UVGenerator !== void 0) return null;
+    const shape = shapes;
+    const outer = linePoints(shape);
+    if (!outer) return null;
+    const holes = [];
+    for (const hole of shape.holes ?? []) {
+      const points = linePoints(hole);
+      if (!points) return null;
+      holes.push(points);
+    }
+    const outline = holes.length ? { outer, holes } : { outer };
+    const bevel = options.bevelEnabled === false ? false : {
+      ...options.bevelThickness !== void 0 ? { thickness: options.bevelThickness } : {},
+      ...options.bevelSize !== void 0 ? { size: options.bevelSize } : {},
+      ...options.bevelOffset !== void 0 ? { offset: options.bevelOffset } : {},
+      ...options.bevelSegments !== void 0 ? { segments: options.bevelSegments } : {}
+    };
+    return extrude(outline, options.depth, options.steps, bevel);
+  }
+  var namespaces = /* @__PURE__ */ new WeakMap();
+  function shapeGeometries(THREE, options = {}) {
+    const cache = options.cache !== false;
+    const key2 = cache ? "cache" : "nocache";
+    let byKey = namespaces.get(THREE);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      namespaces.set(THREE, byKey);
+    }
+    const existing = byKey.get(key2);
+    if (existing) return existing;
+    const made = (p) => toGeometry(THREE, p);
+    const viaCache = (node, direct) => cache ? buildPrimitive(node) : direct();
+    const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+    const constructors = {
+      BoxGeometry: (width, height, depth, ws = 1, hs = 1, ds = 1) => made(viaCache({ kind: "box", size: [width ?? 1, height ?? 1, depth ?? 1], segments: [ws, hs, ds] }, () => box(width, height, depth, ws, hs, ds))),
+      CylinderGeometry: (radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cylinder", ...defined({ radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cylinder(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      ConeGeometry: (radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cone", ...defined({ radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cone(radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      SphereGeometry: (radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) => made(viaCache({ kind: "sphere", ...defined({ radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength }) }, () => sphere(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength))),
+      PlaneGeometry: (width, height, widthSegments, heightSegments) => made(viaCache({ kind: "plane", ...defined({ width, height, widthSegments, heightSegments }) }, () => plane(width, height, widthSegments, heightSegments))),
+      CircleGeometry: (radius, segments, thetaStart, thetaLength) => made(viaCache({ kind: "circle", ...defined({ radius, segments, thetaStart, thetaLength }) }, () => circle(radius, segments, thetaStart, thetaLength))),
+      RingGeometry: (innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength) => made(viaCache({ kind: "ring", ...defined({ innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength }) }, () => ring(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength))),
+      LatheGeometry: (points, segments, phiStart, phiLength) => {
+        if (!points) return new THREE.LatheGeometry(void 0, segments, phiStart, phiLength);
+        const profile = points.map((p) => [p.x, p.y]);
+        return made(viaCache({ kind: "lathe", points: profile, ...defined({ segments, phiStart, phiLength }) }, () => lathe(profile, segments, phiStart, phiLength)));
+      },
+      TorusGeometry: (radius, tube2, radialSegments, tubularSegments, arc) => made(viaCache({ kind: "torus", ...defined({ radius, tube: tube2, radialSegments, tubularSegments, arc }) }, () => torus(radius, tube2, radialSegments, tubularSegments, arc))),
+      ExtrudeGeometry: (shapes, extrudeOptions) => {
+        const buffers = shapes === void 0 ? null : extrudeOf(shapes, extrudeOptions);
+        if (!buffers) return new THREE.ExtrudeGeometry(shapes, extrudeOptions);
+        const geometry = toGeometry(THREE, buffers);
+        geometry.parameters = { shapes, options: extrudeOptions ?? {} };
+        return geometry;
+      }
+    };
+    const namespace = { ...THREE };
+    for (const type of SHAPE_GEOMETRY_TYPES) {
+      const make2 = constructors[type];
+      const Constructor = function(...args) {
+        return make2(...args);
+      };
+      Constructor.prototype = THREE[type].prototype;
+      Object.defineProperty(Constructor, "name", { value: type });
+      namespace[type] = Constructor;
+    }
+    const result = namespace;
+    byKey.set(key2, result);
+    return result;
+  }
+  var isVisible = (object2) => {
+    for (let node = object2; node; node = node.parent) if (!node.visible) return false;
+    return true;
+  };
+  var plain = (attribute) => attribute !== void 0 && !attribute.isInterleavedBufferAttribute && attribute.array instanceof Float32Array && !attribute.normalized;
+  function piece(geometry, matrix) {
+    const position = geometry.getAttribute("position");
+    const normal = geometry.getAttribute("normal");
+    const uv = geometry.getAttribute("uv");
+    const ok = plain(position) && (normal === void 0 || plain(normal)) && (uv === void 0 || plain(uv)) && position.itemSize === 3 && (uv === void 0 || uv.itemSize === 2);
+    if (ok) {
+      return { positions: position.array, ...normal ? { normals: normal.array } : {}, ...uv ? { uvs: uv.array } : {}, indices: geometry.index ? geometry.index.array : null, matrix: matrix.elements };
+    }
+    const flat = geometry.index ? geometry.toNonIndexed() : geometry;
+    const read = (name, size) => {
+      const attribute = flat.getAttribute(name);
+      if (!attribute) return void 0;
+      const out = new Float32Array(attribute.count * size);
+      for (let i = 0; i < attribute.count; i++) for (let c = 0; c < size; c++) out[i * size + c] = c === 0 ? attribute.getX(i) : c === 1 ? attribute.getY(i) : attribute.getZ(i);
+      return out;
+    };
+    const positions = read("position", 3);
+    const normals = read("normal", 3);
+    const uvs = read("uv", 2);
+    if (flat !== geometry) flat.dispose();
+    return { positions, ...normals ? { normals } : {}, ...uvs ? { uvs } : {}, indices: null, matrix: matrix.elements };
+  }
+  function mergeByMaterial(THREE, root, space) {
+    const toSpace = space.matrixWorld.clone().invert();
+    const byMaterial = /* @__PURE__ */ new Map();
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || Array.isArray(mesh2.material) || !isVisible(mesh2)) return;
+      const list2 = byMaterial.get(mesh2.material) ?? [];
+      list2.push(piece(mesh2.geometry, new THREE.Matrix4().multiplyMatrices(toSpace, mesh2.matrixWorld)));
+      byMaterial.set(mesh2.material, list2);
+    });
+    return [...byMaterial].map(([material, pieces]) => {
+      const merged = mergeTransformed(pieces);
+      const geometry = new THREE.BufferGeometry();
+      geometry.setAttribute("position", new THREE.BufferAttribute(merged.positions, 3));
+      geometry.setAttribute("normal", new THREE.BufferAttribute(merged.normals, 3));
+      geometry.setAttribute("uv", new THREE.BufferAttribute(merged.uvs, 2));
+      const mesh2 = new THREE.Mesh(geometry, material);
+      mesh2.castShadow = false;
+      mesh2.receiveShadow = true;
+      return mesh2;
+    });
+  }
+
   // src/kit.ts
   var WEAR_TAGS = ["metal", "wood", "cloth", "plastic", "paper", "food", "glass"];
   var channelsOf = (hex2) => [(hex2 >> 16 & 255) / 255, (hex2 >> 8 & 255) / 255, (hex2 & 255) / 255];
-  function createItemKit(T2) {
+  function createItemKit(three) {
+    const T = shapeGeometries(three);
     const materials = [];
-    const M = (color, tag, options = {}) => {
-      const material = new T2.MeshStandardMaterial(Object.assign({ color, roughness: 0.78, metalness: 0 }, options));
-      const base = new T2.Color(color);
-      const data = { base, baseRgb: channelsOf(color), tag, rough: material.roughness };
+    const M = (color2, tag, options = {}) => {
+      const material = new T.MeshStandardMaterial(Object.assign({ color: color2, roughness: 0.78, metalness: 0 }, options));
+      const base = new T.Color(color2);
+      const data = { base, baseRgb: channelsOf(color2), tag, rough: material.roughness };
       material.userData = data;
       materials.push(material);
       return material;
     };
-    const mesh = (geometry, material, position = [0, 0, 0], rotation = [0, 0, 0], scale) => {
-      const object = new T2.Mesh(geometry, material);
-      object.position.set(...position);
-      object.rotation.set(...rotation);
-      if (scale) object.scale.set(...scale);
-      return object;
+    const mesh2 = (geometry, material, position = [0, 0, 0], rotation = [0, 0, 0], scale) => {
+      const object2 = new T.Mesh(geometry, material);
+      object2.position.set(...position);
+      object2.rotation.set(...rotation);
+      if (scale) object2.scale.set(...scale);
+      return object2;
     };
     return {
-      T: T2,
+      T,
       materials,
       M,
-      mesh,
-      cyl: (radiusTop, radiusBottom, height, segments = 14) => new T2.CylinderGeometry(radiusTop, radiusBottom, height, segments),
-      bx: (width, height, depth) => new T2.BoxGeometry(width, height, depth),
-      lathe: (points, segments = 16) => new T2.LatheGeometry(points.map(([x, y]) => new T2.Vector2(x, y)), segments),
-      torus: (radius, tube2, arc = Math.PI * 2) => new T2.TorusGeometry(radius, tube2, 8, 18, arc),
+      mesh: mesh2,
+      cyl: (radiusTop, radiusBottom, height, segments = 14) => new T.CylinderGeometry(radiusTop, radiusBottom, height, segments),
+      bx: (width, height, depth) => new T.BoxGeometry(width, height, depth),
+      lathe: (points, segments = 16) => new T.LatheGeometry(points.map(([x, y]) => new T.Vector2(x, y)), segments),
+      torus: (radius, tube2, arc = Math.PI * 2) => new T.TorusGeometry(radius, tube2, 8, 18, arc),
       extrude: (points, depth, bevel = 0.015) => {
-        const shape = new T2.Shape();
+        const shape = new T.Shape();
         points.forEach(([x, y], index) => index ? shape.lineTo(x, y) : shape.moveTo(x, y));
-        return new T2.ExtrudeGeometry(shape, { depth, bevelEnabled: true, bevelThickness: bevel, bevelSize: bevel, bevelSegments: 2 });
+        return new T.ExtrudeGeometry(shape, { depth, bevelEnabled: true, bevelThickness: bevel, bevelSize: bevel, bevelSegments: 2 });
       },
       G: (...children) => {
-        const group = new T2.Group();
+        const group = new T.Group();
         children.forEach((child) => group.add(child));
         return group;
       },
-      metal: (color) => M(color, "metal", { metalness: 0.55, roughness: 0.45 }),
-      wood: (color) => M(color, "wood"),
-      cloth: (color) => M(color, "cloth", { roughness: 0.95 }),
-      plastic: (color) => M(color, "plastic", { roughness: 0.6 }),
-      paper: (color) => M(color, "paper", { roughness: 0.9 }),
-      food: (color) => M(color, "food", { roughness: 0.85 }),
-      glass: (color, opacity) => M(color, "glass", { roughness: 0.15, metalness: 0.1, transparent: true, opacity })
+      metal: (color2) => M(color2, "metal", { metalness: 0.55, roughness: 0.45 }),
+      wood: (color2) => M(color2, "wood"),
+      cloth: (color2) => M(color2, "cloth", { roughness: 0.95 }),
+      plastic: (color2) => M(color2, "plastic", { roughness: 0.6 }),
+      paper: (color2) => M(color2, "paper", { roughness: 0.9 }),
+      food: (color2) => M(color2, "food", { roughness: 0.85 }),
+      glass: (color2, opacity) => M(color2, "glass", { roughness: 0.15, metalness: 0.1, transparent: true, opacity })
     };
   }
 
@@ -131,10 +1775,10 @@ var GameItemsThree = (() => {
   };
   function wearableMaterials(root) {
     const found = /* @__PURE__ */ new Set();
-    root.traverse((object) => {
-      const mesh = object;
-      if (!mesh.isMesh) return;
-      for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) if (dataOf(material)) found.add(material);
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh) return;
+      for (const material of Array.isArray(mesh2.material) ? mesh2.material : [mesh2.material]) if (dataOf(material)) found.add(material);
     });
     return [...found];
   }
@@ -185,8 +1829,8 @@ var GameItemsThree = (() => {
   ];
   var DEFAULT_COLOR = 9080724;
   var PI = Math.PI;
-  function shade(color, factor) {
-    const channel = (shift) => Math.max(0, Math.min(255, Math.round((color >> shift & 255) * factor)));
+  function shade(color2, factor) {
+    const channel = (shift) => Math.max(0, Math.min(255, Math.round((color2 >> shift & 255) * factor)));
     return channel(16) << 16 | channel(8) << 8 | channel(0);
   }
   var seg = (c, n) => Math.max(5, Math.round(n * c.detail));
@@ -230,7 +1874,7 @@ var GameItemsThree = (() => {
     const { k, w, h, d } = c;
     return k.G(k.mesh(k.bx(w, h * 0.88, d), k.paper(c.color), [0, -h * 0.06, 0]), k.mesh(k.bx(w * 1, h * 0.12, d * 0.5), k.paper(shade(c.color, 0.85)), [0, h * 0.44, 0]), k.mesh(k.bx(w * 0.7, h * 0.3, d * 1), k.paper(shade(c.color, 1.2)), [0, 0, 0]));
   };
-  var box = (c) => {
+  var box2 = (c) => {
     const { k, w, h, d } = c;
     return k.G(k.mesh(k.bx(w, h, d), k.paper(c.color)), k.mesh(k.bx(w, h * 0.12, d), k.paper(shade(c.color, 0.8)), [0, h * 0.44, 0]), k.mesh(k.bx(w * 0.62, h * 0.4, d), k.paper(shade(c.color, 1.25)), [0, -h * 0.02, 0]));
   };
@@ -246,8 +1890,8 @@ var GameItemsThree = (() => {
   };
   var fruit = (c) => {
     const { k, w, h, d } = c;
-    const sphere = new k.T.SphereGeometry(0.5, seg(c, 12), seg(c, 8));
-    return k.G(k.mesh(sphere, k.food(c.color), [0, -h * 0.04, 0], [0, 0, 0], [w, h * 0.92, d]), k.mesh(k.cyl(h * 0.02, h * 0.02, h * 0.1, 6), k.wood(5913122), [0, h * 0.45, 0]));
+    const sphere2 = new k.T.SphereGeometry(0.5, seg(c, 12), seg(c, 8));
+    return k.G(k.mesh(sphere2, k.food(c.color), [0, -h * 0.04, 0], [0, 0, 0], [w, h * 0.92, d]), k.mesh(k.cyl(h * 0.02, h * 0.02, h * 0.1, 6), k.wood(5913122), [0, h * 0.45, 0]));
   };
   var dish = (c) => {
     const { k, w, h, d } = c;
@@ -329,9 +1973,9 @@ var GameItemsThree = (() => {
   var key = alongLong((c, L, a, b) => {
     const { k } = c;
     const metal = k.metal(12095802);
-    const ring = a * 0.5;
-    const tube2 = Math.min(b * 0.4, ring * 0.2);
-    return k.G(k.mesh(new c.k.T.TorusGeometry(ring * 0.8, tube2, 5, seg(c, 10)), k.metal(10132896), [-L / 2 + ring * 0.8 + tube2, 0, 0]), k.mesh(k.bx(L * 0.62, a * 0.28, b), metal, [L * 0.12, 0, 0]), k.mesh(k.bx(L * 0.08, a * 0.22, b), metal, [L * 0.36, -a * 0.2, 0]), k.mesh(k.bx(L * 0.06, a * 0.22, b), metal, [L * 0.2, -a * 0.2, 0]));
+    const ring2 = a * 0.5;
+    const tube2 = Math.min(b * 0.4, ring2 * 0.2);
+    return k.G(k.mesh(new c.k.T.TorusGeometry(ring2 * 0.8, tube2, 5, seg(c, 10)), k.metal(10132896), [-L / 2 + ring2 * 0.8 + tube2, 0, 0]), k.mesh(k.bx(L * 0.62, a * 0.28, b), metal, [L * 0.12, 0, 0]), k.mesh(k.bx(L * 0.08, a * 0.22, b), metal, [L * 0.36, -a * 0.2, 0]), k.mesh(k.bx(L * 0.06, a * 0.22, b), metal, [L * 0.2, -a * 0.2, 0]));
   });
   var battery = alongLong((c, L, a, b) => {
     const { k } = c;
@@ -351,7 +1995,7 @@ var GameItemsThree = (() => {
   var DRAWERS = {
     can,
     bag,
-    box,
+    box: box2,
     bottle,
     tool,
     roll,
@@ -654,60 +2298,60 @@ var GameItemsThree = (() => {
   ];
 
   // src/models/canned-beans.ts
-  var cannedBeans = ({ mesh, cyl, torus, G, metal, paper: paper2, food }) => {
+  var cannedBeans = ({ mesh: mesh2, cyl, torus: torus2, G, metal, paper: paper2, food }) => {
     const m = metal(9277590);
-    return G(mesh(cyl(0.32, 0.32, 0.52), m), mesh(cyl(0.326, 0.326, 0.34, 14), food(10172964)), mesh(cyl(0.33, 0.33, 0.06), paper2(14861162), [0, 0.02, 0]), mesh(torus(0.31, 0.025), m, [0, 0.26, 0], [Math.PI / 2, 0, 0]), mesh(torus(0.31, 0.025), m, [0, -0.26, 0], [Math.PI / 2, 0, 0]));
+    return G(mesh2(cyl(0.32, 0.32, 0.52), m), mesh2(cyl(0.326, 0.326, 0.34, 14), food(10172964)), mesh2(cyl(0.33, 0.33, 0.06), paper2(14861162), [0, 0.02, 0]), mesh2(torus2(0.31, 0.025), m, [0, 0.26, 0], [Math.PI / 2, 0, 0]), mesh2(torus2(0.31, 0.025), m, [0, -0.26, 0], [Math.PI / 2, 0, 0]));
   };
 
   // src/models/water-bottle.ts
-  var waterBottle = ({ mesh, cyl, lathe, G, plastic, paper: paper2, glass }) => G(mesh(lathe([[0, -0.6], [0.2, -0.6], [0.22, -0.5], [0.22, 0.2], [0.19, 0.32], [0.09, 0.45], [0.08, 0.55], [0, 0.55]]), glass(9421788, 0.55)), mesh(cyl(0.085, 0.085, 0.1, 12), plastic(2907530), [0, 0.6, 0]), mesh(cyl(0.225, 0.225, 0.22, 16), paper2(15330543), [0, -0.15, 0]), mesh(cyl(0.226, 0.226, 0.05, 16), plastic(3831976), [0, -0.12, 0]));
+  var waterBottle = ({ mesh: mesh2, cyl, lathe: lathe2, G, plastic, paper: paper2, glass }) => G(mesh2(lathe2([[0, -0.6], [0.2, -0.6], [0.22, -0.5], [0.22, 0.2], [0.19, 0.32], [0.09, 0.45], [0.08, 0.55], [0, 0.55]]), glass(9421788, 0.55)), mesh2(cyl(0.085, 0.085, 0.1, 12), plastic(2907530), [0, 0.6, 0]), mesh2(cyl(0.225, 0.225, 0.22, 16), paper2(15330543), [0, -0.15, 0]), mesh2(cyl(0.226, 0.226, 0.05, 16), plastic(3831976), [0, -0.12, 0]));
 
   // src/models/rice.ts
-  var rice = ({ mesh, bx, G, paper: paper2, food }) => G(mesh(bx(0.7, 0.95, 0.28), paper2(15129792)), mesh(bx(0.72, 0.12, 0.1), paper2(14010792), [0, 0.52, 0]), mesh(bx(0.5, 0.3, 0.02), food(11883039), [0, 0.05, 0.15]), mesh(bx(0.3, 0.1, 0.02), paper2(4160069), [0, -0.25, 0.15]));
+  var rice = ({ mesh: mesh2, bx, G, paper: paper2, food }) => G(mesh2(bx(0.7, 0.95, 0.28), paper2(15129792)), mesh2(bx(0.72, 0.12, 0.1), paper2(14010792), [0, 0.52, 0]), mesh2(bx(0.5, 0.3, 0.02), food(11883039), [0, 0.05, 0.15]), mesh2(bx(0.3, 0.1, 0.02), paper2(4160069), [0, -0.25, 0.15]));
 
   // src/models/military-ration.ts
-  var militaryRation = ({ mesh, bx, G, plastic, paper: paper2 }) => G(mesh(bx(0.75, 1, 0.22), plastic(5923142)), mesh(bx(0.77, 0.1, 0.23), plastic(4672823), [0, 0.48, 0]), mesh(bx(0.5, 0.14, 0.01), paper2(2237727), [0, 0.18, 0.115]), mesh(bx(0.36, 0.06, 0.01), paper2(2237727), [0, -0.02, 0.115]));
+  var militaryRation = ({ mesh: mesh2, bx, G, plastic, paper: paper2 }) => G(mesh2(bx(0.75, 1, 0.22), plastic(5923142)), mesh2(bx(0.77, 0.1, 0.23), plastic(4672823), [0, 0.48, 0]), mesh2(bx(0.5, 0.14, 0.01), paper2(2237727), [0, 0.18, 0.115]), mesh2(bx(0.36, 0.06, 0.01), paper2(2237727), [0, -0.02, 0.115]));
 
   // src/models/cachaca.ts
-  var cachaca = ({ mesh, cyl, lathe, G, wood, paper: paper2, food, glass }) => G(mesh(lathe([[0, -0.6], [0.25, -0.6], [0.27, -0.52], [0.27, 0.1], [0.2, 0.25], [0.09, 0.35], [0.09, 0.58], [0, 0.58]]), glass(12749354, 0.78)), mesh(cyl(0.08, 0.07, 0.14, 10), wood(9071172), [0, 0.64, 0]), mesh(cyl(0.275, 0.275, 0.34, 16), paper2(15327692), [0, -0.25, 0]), mesh(cyl(0.276, 0.276, 0.06, 16), food(8007455), [0, -0.15, 0]));
+  var cachaca = ({ mesh: mesh2, cyl, lathe: lathe2, G, wood, paper: paper2, food, glass }) => G(mesh2(lathe2([[0, -0.6], [0.25, -0.6], [0.27, -0.52], [0.27, 0.1], [0.2, 0.25], [0.09, 0.35], [0.09, 0.58], [0, 0.58]]), glass(12749354, 0.78)), mesh2(cyl(0.08, 0.07, 0.14, 10), wood(9071172), [0, 0.64, 0]), mesh2(cyl(0.275, 0.275, 0.34, 16), paper2(15327692), [0, -0.25, 0]), mesh2(cyl(0.276, 0.276, 0.06, 16), food(8007455), [0, -0.15, 0]));
 
   // src/models/first-aid-kit.ts
-  var firstAidKit = ({ mesh, bx, torus, G, plastic }) => {
+  var firstAidKit = ({ mesh: mesh2, bx, torus: torus2, G, plastic }) => {
     const r = plastic(11680300);
-    return G(mesh(bx(1.05, 0.72, 0.38), plastic(15131608)), mesh(bx(1.07, 0.06, 0.4), plastic(12433578), [0, 0, 0]), mesh(bx(0.36, 0.1, 0.02), r, [0, 0.1, 0.2]), mesh(bx(0.1, 0.36, 0.02), r, [0, 0.1, 0.2]), mesh(torus(0.16, 0.035, Math.PI), plastic(5591884), [0, 0.36, 0]));
+    return G(mesh2(bx(1.05, 0.72, 0.38), plastic(15131608)), mesh2(bx(1.07, 0.06, 0.4), plastic(12433578), [0, 0, 0]), mesh2(bx(0.36, 0.1, 0.02), r, [0, 0.1, 0.2]), mesh2(bx(0.1, 0.36, 0.02), r, [0, 0.1, 0.2]), mesh2(torus2(0.16, 0.035, Math.PI), plastic(5591884), [0, 0.36, 0]));
   };
 
   // src/models/bandage.ts
-  var bandage = ({ mesh, cyl, bx, G, cloth: cloth2 }) => {
+  var bandage = ({ mesh: mesh2, cyl, bx, G, cloth: cloth2 }) => {
     const c = cloth2(15525330);
-    return G(mesh(cyl(0.34, 0.34, 0.38, 18), c, [0, 0, 0], [Math.PI / 2, 0, 0]), mesh(cyl(0.1, 0.1, 0.4, 12), cloth2(9078135), [0, 0, 0], [Math.PI / 2, 0, 0]), mesh(bx(0.36, 0.02, 0.36), c, [0.2, -0.33, 0.05], [0, 0, -0.25]), mesh(bx(0.3, 0.02, 0.36), c, [0.5, -0.4, 0.05], [0, 0, -0.05]));
+    return G(mesh2(cyl(0.34, 0.34, 0.38, 18), c, [0, 0, 0], [Math.PI / 2, 0, 0]), mesh2(cyl(0.1, 0.1, 0.4, 12), cloth2(9078135), [0, 0, 0], [Math.PI / 2, 0, 0]), mesh2(bx(0.36, 0.02, 0.36), c, [0.2, -0.33, 0.05], [0, 0, -0.25]), mesh2(bx(0.3, 0.02, 0.36), c, [0.5, -0.4, 0.05], [0, 0, -0.05]));
   };
 
   // src/models/amoxicillin.ts
-  var amoxicillin = ({ T: T2, mesh, bx, G, metal, plastic, paper: paper2 }) => G(mesh(bx(0.8, 0.42, 0.24), paper2(15789798)), mesh(bx(0.81, 0.1, 0.25), plastic(5141127), [0, 0.1, 0]), mesh(bx(0.6, 0.04, 0.3), metal(12172736), [0.15, -0.24, 0.25], [0, 0.3, 0]), ...[0, 1, 2, 3].map((k) => mesh(new T2.SphereGeometry(0.05, 10, 8), plastic(14263361), [-0.05 + k * 0.14, -0.21, 0.3], [0, 0, 0], [1, 0.6, 1])));
+  var amoxicillin = ({ T, mesh: mesh2, bx, G, metal, plastic, paper: paper2 }) => G(mesh2(bx(0.8, 0.42, 0.24), paper2(15789798)), mesh2(bx(0.81, 0.1, 0.25), plastic(5141127), [0, 0.1, 0]), mesh2(bx(0.6, 0.04, 0.3), metal(12172736), [0.15, -0.24, 0.25], [0, 0.3, 0]), ...[0, 1, 2, 3].map((k) => mesh2(new T.SphereGeometry(0.05, 10, 8), plastic(14263361), [-0.05 + k * 0.14, -0.21, 0.3], [0, 0, 0], [1, 0.6, 1])));
 
   // src/models/crowbar.ts
-  var crowbar = ({ T: T2, mesh, cyl, G, metal }) => {
-    const c = new T2.CatmullRomCurve3([[0, -0.8, 0], [0, 0.45, 0], [0.02, 0.62, 0], [0.12, 0.72, 0], [0.26, 0.7, 0], [0.32, 0.6, 0]].map((p) => new T2.Vector3(...p)));
-    return G(mesh(new T2.TubeGeometry(c, 30, 0.055, 8), metal(10168863)), mesh(cyl(0.02, 0.055, 0.14, 8), metal(3816510), [0, -0.86, 0]));
+  var crowbar = ({ T, mesh: mesh2, cyl, G, metal }) => {
+    const c = new T.CatmullRomCurve3([[0, -0.8, 0], [0, 0.45, 0], [0.02, 0.62, 0], [0.12, 0.72, 0], [0.26, 0.7, 0], [0.32, 0.6, 0]].map((p) => new T.Vector3(...p)));
+    return G(mesh2(new T.TubeGeometry(c, 30, 0.055, 8), metal(10168863)), mesh2(cyl(0.02, 0.055, 0.14, 8), metal(3816510), [0, -0.86, 0]));
   };
 
   // src/models/hammer.ts
-  var hammer = ({ T: T2, mesh, cyl, bx, G, metal, wood, plastic }) => G(mesh(cyl(0.05, 0.065, 1.1, 10), wood(9069628), [0, -0.15, 0]), mesh(cyl(0.07, 0.07, 0.3, 10), plastic(2237727), [0, -0.6, 0]), mesh(bx(0.28, 0.15, 0.15), metal(5593437), [0.05, 0.45, 0]), mesh(cyl(0.08, 0.08, 0.1, 12), metal(5593437), [0.22, 0.45, 0], [0, 0, Math.PI / 2]), mesh(new T2.ConeGeometry(0.06, 0.3, 6), metal(5593437), [-0.22, 0.5, 0.035], [0, 0, 1.9]), mesh(new T2.ConeGeometry(0.06, 0.3, 6), metal(5593437), [-0.22, 0.5, -0.035], [0, 0, 1.9]));
+  var hammer = ({ T, mesh: mesh2, cyl, bx, G, metal, wood, plastic }) => G(mesh2(cyl(0.05, 0.065, 1.1, 10), wood(9069628), [0, -0.15, 0]), mesh2(cyl(0.07, 0.07, 0.3, 10), plastic(2237727), [0, -0.6, 0]), mesh2(bx(0.28, 0.15, 0.15), metal(5593437), [0.05, 0.45, 0]), mesh2(cyl(0.08, 0.08, 0.1, 12), metal(5593437), [0.22, 0.45, 0], [0, 0, Math.PI / 2]), mesh2(new T.ConeGeometry(0.06, 0.3, 6), metal(5593437), [-0.22, 0.5, 0.035], [0, 0, 1.9]), mesh2(new T.ConeGeometry(0.06, 0.3, 6), metal(5593437), [-0.22, 0.5, -0.035], [0, 0, 1.9]));
 
   // src/models/machete.ts
-  var machete = ({ mesh, cyl, bx, extrude, G, metal, wood }) => G(mesh(extrude([[0, 0], [1.25, 0.05], [1.4, 0.14], [1.3, 0.26], [0, 0.2]], 0.03), metal(11120048), [-0.55, 0, 0]), mesh(bx(0.45, 0.2, 0.1), wood(3877408), [-0.78, 0.1, 0.015]), ...[-0.9, -0.68].map((x) => mesh(cyl(0.025, 0.025, 0.12, 8), metal(12095802), [x, 0.1, 0.015], [Math.PI / 2, 0, 0])));
+  var machete = ({ mesh: mesh2, cyl, bx, extrude: extrude2, G, metal, wood }) => G(mesh2(extrude2([[0, 0], [1.25, 0.05], [1.4, 0.14], [1.3, 0.26], [0, 0.2]], 0.03), metal(11120048), [-0.55, 0, 0]), mesh2(bx(0.45, 0.2, 0.1), wood(3877408), [-0.78, 0.1, 0.015]), ...[-0.9, -0.68].map((x) => mesh2(cyl(0.025, 0.025, 0.12, 8), metal(12095802), [x, 0.1, 0.015], [Math.PI / 2, 0, 0])));
 
   // src/models/axe.ts
-  var axe = ({ M, mesh, cyl, bx, extrude, G, metal, wood }) => G(mesh(cyl(0.05, 0.06, 1.5, 10), wood(10122312), [0, -0.1, 0]), mesh(extrude([[0, 0], [0.42, -0.16], [0.5, 0.05], [0.48, 0.3], [0.4, 0.42], [0, 0.22]], 0.07), metal(7106677), [0.02, 0.38, -0.05]), mesh(bx(0.12, 0.26, 0.14), metal(4869456), [0, 0.5, 0]), mesh(bx(0.1, 0.2, 0.08), M(10168863, "plastic"), [0, 0.55, 0]));
+  var axe = ({ M, mesh: mesh2, cyl, bx, extrude: extrude2, G, metal, wood }) => G(mesh2(cyl(0.05, 0.06, 1.5, 10), wood(10122312), [0, -0.1, 0]), mesh2(extrude2([[0, 0], [0.42, -0.16], [0.5, 0.05], [0.48, 0.3], [0.4, 0.42], [0, 0.22]], 0.07), metal(7106677), [0.02, 0.38, -0.05]), mesh2(bx(0.12, 0.26, 0.14), metal(4869456), [0, 0.5, 0]), mesh2(bx(0.1, 0.2, 0.08), M(10168863, "plastic"), [0, 0.55, 0]));
 
   // src/models/nail-bat.ts
-  var nailBat = ({ mesh, cyl, lathe, G, metal, wood }) => {
-    const g = G(mesh(lathe([[0, -0.85], [0.05, -0.85], [0.05, -0.8], [0.035, -0.75], [0.04, -0.2], [0.09, 0.3], [0.11, 0.7], [0.09, 0.82], [0, 0.84]], 14), wood(11569754)));
+  var nailBat = ({ mesh: mesh2, cyl, lathe: lathe2, G, metal, wood }) => {
+    const g = G(mesh2(lathe2([[0, -0.85], [0.05, -0.85], [0.05, -0.8], [0.035, -0.75], [0.04, -0.2], [0.09, 0.3], [0.11, 0.7], [0.09, 0.82], [0, 0.84]], 14), wood(11569754)));
     const nm = metal(8225158);
     for (let k = 0; k < 9; k++) {
       const a = k * 2.4, y = 0.25 + k % 5 * 0.12;
-      const n = mesh(cyl(0.012, 0.012, 0.2, 6), nm, [Math.cos(a) * 0.12, y, Math.sin(a) * 0.12], [0, 0, 0]);
+      const n = mesh2(cyl(0.012, 0.012, 0.2, 6), nm, [Math.cos(a) * 0.12, y, Math.sin(a) * 0.12], [0, 0, 0]);
       n.lookAt(Math.cos(a) * 2, y, Math.sin(a) * 2);
       n.rotateX(Math.PI / 2);
       g.add(n);
@@ -716,56 +2360,56 @@ var GameItemsThree = (() => {
   };
 
   // src/models/hiking-backpack-40l.ts
-  var hikingBackpack40L = ({ T: T2, mesh, bx, G, cloth: cloth2, plastic }) => {
+  var hikingBackpack40L = ({ T, mesh: mesh2, bx, G, cloth: cloth2, plastic }) => {
     const c = cloth2(5204794), d = cloth2(3557162);
-    return G(mesh(bx(0.78, 0.9, 0.42), c), mesh(new T2.SphereGeometry(0.4, 14, 8, 0, Math.PI * 2, 0, Math.PI / 2), c, [0, 0.44, 0], [0, 0, 0], [0.98, 0.45, 0.53]), mesh(bx(0.56, 0.4, 0.16), d, [0, -0.15, 0.27]), mesh(bx(0.8, 0.12, 0.46), d, [0, 0.2, 0]), mesh(bx(0.06, 0.9, 0.06), cloth2(2237727), [-0.22, 0, -0.24]), mesh(bx(0.06, 0.9, 0.06), cloth2(2237727), [0.22, 0, -0.24]), mesh(bx(0.1, 0.08, 0.04), plastic(14263361), [0, 0.2, 0.24]));
+    return G(mesh2(bx(0.78, 0.9, 0.42), c), mesh2(new T.SphereGeometry(0.4, 14, 8, 0, Math.PI * 2, 0, Math.PI / 2), c, [0, 0.44, 0], [0, 0, 0], [0.98, 0.45, 0.53]), mesh2(bx(0.56, 0.4, 0.16), d, [0, -0.15, 0.27]), mesh2(bx(0.8, 0.12, 0.46), d, [0, 0.2, 0]), mesh2(bx(0.06, 0.9, 0.06), cloth2(2237727), [-0.22, 0, -0.24]), mesh2(bx(0.06, 0.9, 0.06), cloth2(2237727), [0.22, 0, -0.24]), mesh2(bx(0.1, 0.08, 0.04), plastic(14263361), [0, 0.2, 0.24]));
   };
 
   // src/models/flashlight.ts
-  var flashlight = ({ M, mesh, cyl, bx, torus, G, metal, plastic }) => G(mesh(cyl(0.11, 0.11, 0.8, 14), metal(2763822), [0, -0.15, 0]), mesh(cyl(0.19, 0.12, 0.28, 16), metal(3816768), [0, 0.37, 0]), mesh(cyl(0.17, 0.17, 0.02, 16), M(16773568, "glass", { emissive: 16769162, emissiveIntensity: 0.9 }), [0, 0.52, 0]), mesh(bx(0.06, 0.1, 0.05), plastic(11883039), [0, 0.05, 0.11]), ...[-0.4, -0.3, -0.2].map((y) => mesh(torus(0.112, 0.012), plastic(1776669), [0, y, 0], [Math.PI / 2, 0, 0])));
+  var flashlight = ({ M, mesh: mesh2, cyl, bx, torus: torus2, G, metal, plastic }) => G(mesh2(cyl(0.11, 0.11, 0.8, 14), metal(2763822), [0, -0.15, 0]), mesh2(cyl(0.19, 0.12, 0.28, 16), metal(3816768), [0, 0.37, 0]), mesh2(cyl(0.17, 0.17, 0.02, 16), M(16773568, "glass", { emissive: 16769162, emissiveIntensity: 0.9 }), [0, 0.52, 0]), mesh2(bx(0.06, 0.1, 0.05), plastic(11883039), [0, 0.05, 0.11]), ...[-0.4, -0.3, -0.2].map((y) => mesh2(torus2(0.112, 0.012), plastic(1776669), [0, y, 0], [Math.PI / 2, 0, 0])));
 
   // src/models/portable-radio.ts
-  var portableRadio = ({ M, mesh, cyl, bx, torus, G, metal, plastic }) => {
-    const g = G(mesh(bx(1.05, 0.62, 0.3), plastic(3816757)), mesh(cyl(0.2, 0.2, 0.02, 18), plastic(1974043), [-0.24, -0.04, 0.16], [Math.PI / 2, 0, 0]), mesh(bx(0.36, 0.14, 0.02), M(14263361, "glass", { emissive: 6965776, emissiveIntensity: 0.6 }), [0.26, 0.1, 0.16]), mesh(cyl(0.06, 0.06, 0.06, 12), plastic(9276032), [0.18, -0.15, 0.17], [Math.PI / 2, 0, 0]), mesh(cyl(0.06, 0.06, 0.06, 12), plastic(9276032), [0.36, -0.15, 0.17], [Math.PI / 2, 0, 0]), mesh(torus(0.24, 0.03, Math.PI), plastic(2237727), [0, 0.3, 0]));
-    const a = mesh(cyl(0.012, 0.02, 0.95, 6), metal(12172736), [0.4, 0.72, 0], [0, 0, -0.35]);
+  var portableRadio = ({ M, mesh: mesh2, cyl, bx, torus: torus2, G, metal, plastic }) => {
+    const g = G(mesh2(bx(1.05, 0.62, 0.3), plastic(3816757)), mesh2(cyl(0.2, 0.2, 0.02, 18), plastic(1974043), [-0.24, -0.04, 0.16], [Math.PI / 2, 0, 0]), mesh2(bx(0.36, 0.14, 0.02), M(14263361, "glass", { emissive: 6965776, emissiveIntensity: 0.6 }), [0.26, 0.1, 0.16]), mesh2(cyl(0.06, 0.06, 0.06, 12), plastic(9276032), [0.18, -0.15, 0.17], [Math.PI / 2, 0, 0]), mesh2(cyl(0.06, 0.06, 0.06, 12), plastic(9276032), [0.36, -0.15, 0.17], [Math.PI / 2, 0, 0]), mesh2(torus2(0.24, 0.03, Math.PI), plastic(2237727), [0, 0.3, 0]));
+    const a = mesh2(cyl(0.012, 0.02, 0.95, 6), metal(12172736), [0.4, 0.72, 0], [0, 0, -0.35]);
     g.add(a);
     return g;
   };
 
   // src/models/house-key.ts
-  var houseKey = ({ mesh, bx, torus, extrude, G, metal, plastic }) => {
+  var houseKey = ({ mesh: mesh2, bx, torus: torus2, extrude: extrude2, G, metal, plastic }) => {
     const b = metal(12095802);
-    return G(mesh(torus(0.22, 0.04), metal(10132896), [-0.55, 0.1, 0]), mesh(extrude([[0, -0.2], [0.25, -0.22], [0.3, -0.1], [0.3, 0.1], [0.25, 0.22], [0, 0.2]], 0.05), b, [-0.38, 0.02, -0.025]), mesh(extrude([[0, 0], [0.75, 0], [0.75, -0.08], [0.66, -0.08], [0.66, -0.14], [0.56, -0.08], [0.46, -0.14], [0.4, -0.08], [0, -0.08]], 0.035), b, [-0.1, 0.06, -0.017]), mesh(bx(0.24, 0.34, 0.03), plastic(11883039), [-0.72, -0.28, 0], [0, 0, 0.25]));
+    return G(mesh2(torus2(0.22, 0.04), metal(10132896), [-0.55, 0.1, 0]), mesh2(extrude2([[0, -0.2], [0.25, -0.22], [0.3, -0.1], [0.3, 0.1], [0.25, 0.22], [0, 0.2]], 0.05), b, [-0.38, 0.02, -0.025]), mesh2(extrude2([[0, 0], [0.75, 0], [0.75, -0.08], [0.66, -0.08], [0.66, -0.14], [0.56, -0.08], [0.46, -0.14], [0.4, -0.08], [0, -0.08]], 0.035), b, [-0.1, 0.06, -0.017]), mesh2(bx(0.24, 0.34, 0.03), plastic(11883039), [-0.72, -0.28, 0], [0, 0, 0.25]));
   };
 
   // src/models/survivor-diary.ts
-  var survivorDiary = ({ mesh, bx, G, cloth: cloth2, paper: paper2 }) => G(mesh(bx(0.78, 1.02, 0.05), paper2(7028522), [0, 0, 0.1]), mesh(bx(0.78, 1.02, 0.05), paper2(7028522), [0, 0, -0.1]), mesh(bx(0.74, 0.98, 0.16), paper2(15327692), [0.01, 0, 0]), mesh(bx(0.06, 1.02, 0.25), paper2(5911330), [-0.38, 0, 0]), mesh(bx(0.03, 1.04, 0.27), cloth2(2237727), [0.25, 0, 0]), mesh(bx(0.18, 0.3, 2e-3), paper2(14010792), [0.05, 0.2, 0.126], [0, 0, 0.08]));
+  var survivorDiary = ({ mesh: mesh2, bx, G, cloth: cloth2, paper: paper2 }) => G(mesh2(bx(0.78, 1.02, 0.05), paper2(7028522), [0, 0, 0.1]), mesh2(bx(0.78, 1.02, 0.05), paper2(7028522), [0, 0, -0.1]), mesh2(bx(0.74, 0.98, 0.16), paper2(15327692), [0.01, 0, 0]), mesh2(bx(0.06, 1.02, 0.25), paper2(5911330), [-0.38, 0, 0]), mesh2(bx(0.03, 1.04, 0.27), cloth2(2237727), [0.25, 0, 0]), mesh2(bx(0.18, 0.3, 2e-3), paper2(14010792), [0.05, 0.2, 0.126], [0, 0, 0.08]));
 
   // src/models/motorcycle-helmet.ts
-  var motorcycleHelmet = ({ T: T2, M, mesh, cyl, bx, G, plastic }) => G(mesh(new T2.SphereGeometry(0.55, 18, 12), plastic(2830138), [0, 0, 0], [0, 0, 0], [1, 0.95, 1.08]), mesh(new T2.SphereGeometry(0.56, 18, 10, -0.9, 1.8, 1.05, 0.75), M(1316636, "glass", { roughness: 0.15, metalness: 0.4 }), [0, 0.02, 0.02], [0, 0, 0], [1, 0.95, 1.08]), mesh(bx(0.2, 0.12, 0.02), plastic(14710591), [0.42, 0.2, 0.22], [0, 0.95, 0]), mesh(cyl(0.5, 0.55, 0.12, 18), plastic(1908776), [0, -0.5, 0]));
+  var motorcycleHelmet = ({ T, M, mesh: mesh2, cyl, bx, G, plastic }) => G(mesh2(new T.SphereGeometry(0.55, 18, 12), plastic(2830138), [0, 0, 0], [0, 0, 0], [1, 0.95, 1.08]), mesh2(new T.SphereGeometry(0.56, 18, 10, -0.9, 1.8, 1.05, 0.75), M(1316636, "glass", { roughness: 0.15, metalness: 0.4 }), [0, 0.02, 0.02], [0, 0, 0], [1, 0.95, 1.08]), mesh2(bx(0.2, 0.12, 0.02), plastic(14710591), [0.42, 0.2, 0.22], [0, 0.95, 0]), mesh2(cyl(0.5, 0.55, 0.12, 18), plastic(1908776), [0, -0.5, 0]));
 
   // src/models/lpg-cylinder-13kg.ts
-  var lpgCylinder13Kg = ({ mesh, cyl, bx, lathe, torus, G, metal }) => G(mesh(lathe([[0, -0.6], [0.38, -0.6], [0.42, -0.55], [0.45, -0.3], [0.45, 0.15], [0.4, 0.32], [0.28, 0.42], [0.12, 0.46], [0, 0.46]], 18), metal(3497862)), mesh(cyl(0.47, 0.47, 0.1, 18), metal(2705514), [0, -0.62, 0]), mesh(torus(0.24, 0.035), metal(2705514), [0, 0.58, 0], [Math.PI / 2, 0, 0]), mesh(cyl(0.07, 0.07, 0.14, 10), metal(12095802), [0, 0.5, 0]), mesh(bx(0.04, 0.2, 0.04), metal(2705514), [0.22, 0.5, 0]), mesh(bx(0.04, 0.2, 0.04), metal(2705514), [-0.22, 0.5, 0]));
+  var lpgCylinder13Kg = ({ mesh: mesh2, cyl, bx, lathe: lathe2, torus: torus2, G, metal }) => G(mesh2(lathe2([[0, -0.6], [0.38, -0.6], [0.42, -0.55], [0.45, -0.3], [0.45, 0.15], [0.4, 0.32], [0.28, 0.42], [0.12, 0.46], [0, 0.46]], 18), metal(3497862)), mesh2(cyl(0.47, 0.47, 0.1, 18), metal(2705514), [0, -0.62, 0]), mesh2(torus2(0.24, 0.035), metal(2705514), [0, 0.58, 0], [Math.PI / 2, 0, 0]), mesh2(cyl(0.07, 0.07, 0.14, 10), metal(12095802), [0, 0.5, 0]), mesh2(bx(0.04, 0.2, 0.04), metal(2705514), [0.22, 0.5, 0]), mesh2(bx(0.04, 0.2, 0.04), metal(2705514), [-0.22, 0.5, 0]));
 
   // src/models/fuel-jerrycan.ts
-  var fuelJerrycan = ({ mesh, cyl, bx, G, plastic }) => G(mesh(bx(0.85, 1, 0.42), plastic(10695210)), mesh(bx(0.6, 0.1, 0.3), plastic(8267296), [0, 0.45, 0]), mesh(bx(0.36, 0.2, 0.1), plastic(10695210), [-0.12, 0.62, 0]), mesh(cyl(0.05, 0.07, 0.35, 10), plastic(14263361), [0.3, 0.66, 0], [0, 0, -0.6]), mesh(bx(0.6, 0.5, 0.02), plastic(9054754), [0, -0.1, 0.22]));
+  var fuelJerrycan = ({ mesh: mesh2, cyl, bx, G, plastic }) => G(mesh2(bx(0.85, 1, 0.42), plastic(10695210)), mesh2(bx(0.6, 0.1, 0.3), plastic(8267296), [0, 0.45, 0]), mesh2(bx(0.36, 0.2, 0.1), plastic(10695210), [-0.12, 0.62, 0]), mesh2(cyl(0.05, 0.07, 0.35, 10), plastic(14263361), [0.3, 0.66, 0], [0, 0, -0.6]), mesh2(bx(0.6, 0.5, 0.02), plastic(9054754), [0, -0.1, 0.22]));
 
   // src/models/walkie-talkies.ts
-  var walkieTalkies = ({ M, mesh, cyl, bx, G, plastic }) => G(mesh(bx(0.42, 0.9, 0.2), plastic(2764071)), mesh(bx(0.34, 0.3, 0.02), plastic(1447956), [0, -0.12, 0.11]), mesh(bx(0.24, 0.12, 0.02), M(10469258, "glass", { emissive: 3099170, emissiveIntensity: 0.7 }), [0, 0.22, 0.11]), mesh(cyl(0.035, 0.045, 0.6, 8), plastic(1776666), [0.12, 0.72, 0]), mesh(cyl(0.04, 0.04, 0.08, 10), plastic(11883039), [-0.12, 0.48, 0]), mesh(bx(0.05, 0.2, 0.1), plastic(3816757), [-0.23, 0.05, 0]));
+  var walkieTalkies = ({ M, mesh: mesh2, cyl, bx, G, plastic }) => G(mesh2(bx(0.42, 0.9, 0.2), plastic(2764071)), mesh2(bx(0.34, 0.3, 0.02), plastic(1447956), [0, -0.12, 0.11]), mesh2(bx(0.24, 0.12, 0.02), M(10469258, "glass", { emissive: 3099170, emissiveIntensity: 0.7 }), [0, 0.22, 0.11]), mesh2(cyl(0.035, 0.045, 0.6, 8), plastic(1776666), [0.12, 0.72, 0]), mesh2(cyl(0.04, 0.04, 0.08, 10), plastic(11883039), [-0.12, 0.48, 0]), mesh2(bx(0.05, 0.2, 0.1), plastic(3816757), [-0.23, 0.05, 0]));
 
   // src/models/batteries.ts
-  var batteries = ({ mesh, cyl, G, metal }) => {
+  var batteries = ({ mesh: mesh2, cyl, G, metal }) => {
     const g = G();
-    [-0.2, 0.2].forEach((x, k) => g.add(mesh(cyl(0.17, 0.17, 0.95, 16), metal(k ? 11883039 : 2763822), [x, 0, 0]), mesh(cyl(0.172, 0.172, 0.3, 16), metal(13214247), [x, 0.33, 0]), mesh(cyl(0.06, 0.06, 0.06, 10), metal(12172736), [x, 0.5, 0])));
+    [-0.2, 0.2].forEach((x, k) => g.add(mesh2(cyl(0.17, 0.17, 0.95, 16), metal(k ? 11883039 : 2763822), [x, 0, 0]), mesh2(cyl(0.172, 0.172, 0.3, 16), metal(13214247), [x, 0.33, 0]), mesh2(cyl(0.06, 0.06, 0.06, 10), metal(12172736), [x, 0.5, 0])));
     return g;
   };
 
   // src/models/wooden-plank.ts
-  var woodenPlank = ({ mesh, cyl, bx, G, metal, wood }) => {
+  var woodenPlank = ({ mesh: mesh2, cyl, bx, G, metal, wood }) => {
     const g = G();
-    [11043929, 9333829, 11833960].forEach((c, k) => g.add(mesh(bx(1.5, 0.07, 0.26), wood(c), [0, -0.15 + k * 0.12, (k - 1) * 0.05], [0, (k - 1) * 0.12, 0])));
+    [11043929, 9333829, 11833960].forEach((c, k) => g.add(mesh2(bx(1.5, 0.07, 0.26), wood(c), [0, -0.15 + k * 0.12, (k - 1) * 0.05], [0, (k - 1) * 0.12, 0])));
     const nm = metal(8225158);
-    [-0.5, -0.3, 0.4].forEach((x, k) => g.add(mesh(cyl(0.012, 0.012, 0.18, 6), nm, [x, 0.18 + k * 0.01, 0.2], [0, 0, (k - 1) * 0.3])));
+    [-0.5, -0.3, 0.4].forEach((x, k) => g.add(mesh2(cyl(0.012, 0.012, 0.18, 6), nm, [x, 0.18 + k * 0.01, 0.2], [0, 0, (k - 1) * 0.3])));
     return g;
   };
 
@@ -819,15 +2463,15 @@ var GameItemsThree = (() => {
   var listItemModels = () => [...entries.keys()];
 
   // src/build-item.ts
-  function restOnBase(T2, inner) {
-    const box2 = new T2.Box3().setFromObject(inner);
-    const centre = box2.getCenter(new T2.Vector3());
-    inner.position.set(-centre.x, -box2.min.y, -centre.z);
+  function restOnBase(T, inner) {
+    const box3 = new T.Box3().setFromObject(inner);
+    const centre = box3.getCenter(new T.Vector3());
+    inner.position.set(-centre.x, -box3.min.y, -centre.z);
   }
-  function buildItem(T2, item, options = {}) {
-    const kit = options.kit ?? createItemKit(T2);
+  function buildItem(T, item, options = {}) {
+    const kit = options.kit ?? createItemKit(T);
     const first = kit.materials.length;
-    const root = new T2.Group();
+    const root = new T.Group();
     root.name = item.id;
     const entry = item.model === void 0 ? void 0 : itemModelEntry(item.model);
     const builder = item.model === void 0 ? void 0 : itemModelBuilder(item.model);
@@ -839,13 +2483,13 @@ var GameItemsThree = (() => {
       inner.name = entry.teamId;
       root.scale.setScalar(entry.scale);
       root.add(inner);
-      restOnBase(T2, inner);
+      restOnBase(T, inner);
     } else {
       shape = shapeOf(item);
       const inner = drawShape(kit, shape, item.size, { ...item.color === void 0 ? {} : { color: item.color }, ...options.detail === void 0 ? {} : { detail: options.detail } });
       inner.name = shape;
       root.add(inner);
-      restOnBase(T2, inner);
+      restOnBase(T, inner);
     }
     const materials = kit.materials.slice(first);
     if (options.wear) setWear(materials, options.wear);
@@ -853,126 +2497,14 @@ var GameItemsThree = (() => {
     return { root, kind, ...shape ? { shape } : {}, size: item.size, materials };
   }
 
-  // ../game-props3d/dist/index.js
-  var T = (id, interior, w, d, h, y, solid, group) => ({ id, interior, w, d, h, y, solid, group });
-  var TYPE_DEFS = [
-    T("ceiling_light", true, 0.4, 0.4, 0.07, 0, false, "ceiling"),
-    T("pendant", true, 0.34, 0.34, 1, 0, false, "ceiling"),
-    T("track_spot", true, 1.2, 0.1, 0.2, 0, false, "ceiling"),
-    T("chandelier", true, 0.7, 0.7, 0.7, 0, false, "ceiling"),
-    T("wall_ac", true, 0.9, 0.2, 0.28, 2.15, false, "wall"),
-    T("picture_small", true, 0.35, 0.03, 0.45, 1.3, false, "wall"),
-    T("picture_large", true, 1, 0.04, 0.7, 1.2, false, "wall"),
-    T("mirror", true, 0.6, 0.03, 1.2, 0.9, false, "wall"),
-    T("curtain", true, 1.6, 0.12, 2.3, 0.1, false, "wall"),
-    T("blinds", true, 1.2, 0.08, 1.3, 1, false, "wall"),
-    T("flat_tv", true, 1.2, 0.06, 0.7, 1, false, "wall"),
-    T("floor_plant", true, 0.5, 0.5, 1.1, 0, true, "plants"),
-    T("table_plant", true, 0.2, 0.2, 0.3, 0, false, "plants"),
-    T("hanging_plant", true, 0.5, 0.5, 1, 0, false, "plants"),
-    T("tv_stand", true, 1.6, 0.42, 1.05, 0, true, "furniture"),
-    T("breakfast_bar", true, 2, 1.6, 0.95, 0, true, "furniture"),
-    T("sofa_l", true, 2.8, 1.7, 0.85, 0, true, "furniture"),
-    T("double_bed_modern", true, 1.6, 2.1, 1.2, 0, true, "furniture"),
-    T("home_office", true, 1.4, 0.75, 1.2, 0, true, "furniture"),
-    T("closet", true, 2.2, 0.6, 2.3, 0, true, "furniture"),
-    T("vanity", true, 0.6, 0.45, 1.5, 0, true, "furniture"),
-    T("ac_condenser", false, 0.8, 0.3, 0.55, 0.5, true, "yard"),
-    T("lawn", false, 4, 4, 0.02, 0, false, "floor"),
-    T("tile_floor", false, 4, 3, 0.03, 0, false, "floor"),
-    T("concrete", false, 4, 4, 0.03, 0, false, "floor"),
-    T("deck_floor", false, 4, 3, 0.04, 0, false, "floor"),
-    T("dirt", false, 4, 4, 0.02, 0, false, "floor"),
-    T("gourmet_counter", false, 4.2, 3, 2.9, 0, true, "yard"),
-    T("sauna", false, 2, 1.8, 2.1, 0, true, "yard"),
-    T("soaking_tub", false, 1.3, 1.3, 0.8, 0, true, "yard"),
-    T("pool", false, 4.5, 2.8, 0.1, 0, true, "yard"),
-    T("deck", false, 3.5, 3, 0.22, 0, true, "yard"),
-    T("sun_lounger", false, 0.62, 1.9, 0.5, 0, true, "yard"),
-    T("garden_bed", false, 2, 1, 0.9, 0, true, "yard"),
-    T("fruit_tree", false, 2.4, 2.4, 3.2, 0, true, "yard"),
-    T("palm_tree", false, 2, 2, 4.5, 0, true, "yard"),
-    T("pergola", false, 3.5, 3, 2.4, 0, true, "yard"),
-    T("slide", false, 0.8, 2.6, 1.5, 0, true, "yard"),
-    T("swing", false, 2.2, 1.7, 2.2, 0, true, "yard"),
-    T("bbq_simple", false, 0.9, 0.6, 1, 0, true, "yard"),
-    T("garage_car", false, 1.8, 4.2, 1.45, 0, true, "yard"),
-    T("window_boards", true, 1.2, 0.06, 1.15, 1, false, "house_state"),
-    T("barricade", true, 1.5, 0.7, 1.8, 0, true, "house_state"),
-    T("sandbags", false, 1.6, 0.5, 0.6, 0, true, "house_state"),
-    T("barbed_wire", false, 4, 0.2, 0.6, 0, false, "house_state"),
-    T("razor_wire", false, 4, 0.6, 0.6, 0, false, "house_state"),
-    T("water_bottle_crates", true, 0.9, 0.6, 0.65, 0, true, "house_state"),
-    T("canned_food", true, 0.4, 0.3, 0.3, 0, false, "house_state"),
-    T("water_jug", true, 0.3, 0.3, 0.5, 0, true, "house_state"),
-    T("floor_mattress", true, 0.9, 1.9, 0.3, 0, false, "house_state"),
-    T("lantern", true, 0.16, 0.16, 0.3, 0, false, "house_state"),
-    T("candles", true, 0.25, 0.25, 0.2, 0, false, "house_state"),
-    T("open_suitcases", true, 1.5, 0.7, 0.6, 0, false, "house_state"),
-    T("clothes_on_floor", true, 1.2, 1, 0.05, 0, false, "house_state"),
-    T("fallen_chair", true, 0.5, 0.5, 0.5, 0, false, "house_state"),
-    T("blood_stains", true, 1.2, 1.2, 0.01, 0, false, "house_state"),
-    T("open_door", true, 0.9, 0.15, 2.15, 0, false, "house_state")
-  ];
-  var DEFS = Object.fromEntries(TYPE_DEFS.map((t) => [t.id, t]));
-  var ATTRIBUTES = ["position", "normal", "uv"];
-  var isVisible = (object) => {
-    for (let node = object; node; node = node.parent) if (!node.visible) return false;
-    return true;
-  };
-  var bake = (THREE, mesh, matrix) => {
-    const source = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.geometry.clone();
-    const baked = new THREE.BufferGeometry();
-    const count = source.getAttribute("position").count;
-    for (const name of ATTRIBUTES) {
-      const attribute = source.getAttribute(name);
-      baked.setAttribute(name, attribute ?? new THREE.BufferAttribute(new Float32Array(count * (name === "uv" ? 2 : 3)), name === "uv" ? 2 : 3));
-    }
-    source.dispose();
-    return baked.applyMatrix4(matrix);
-  };
-  var join = (THREE, geometries) => {
-    const merged = new THREE.BufferGeometry();
-    for (const name of ATTRIBUTES) {
-      const size = (geometries[0]?.getAttribute(name)).itemSize;
-      const total = geometries.reduce((sum, geometry) => sum + geometry.getAttribute(name).count, 0);
-      const array = new Float32Array(total * size);
-      let offset = 0;
-      for (const geometry of geometries) {
-        array.set(geometry.getAttribute(name).array, offset);
-        offset += geometry.getAttribute(name).count * size;
-      }
-      merged.setAttribute(name, new THREE.BufferAttribute(array, size));
-    }
-    return merged;
-  };
-  function mergeByMaterial(THREE, root, space) {
-    const toSpace = space.matrixWorld.clone().invert();
-    const byMaterial = /* @__PURE__ */ new Map();
-    root.traverse((object) => {
-      const mesh = object;
-      if (!mesh.isMesh || Array.isArray(mesh.material) || !isVisible(mesh)) return;
-      const list = byMaterial.get(mesh.material) ?? [];
-      list.push(bake(THREE, mesh, new THREE.Matrix4().multiplyMatrices(toSpace, mesh.matrixWorld)));
-      byMaterial.set(mesh.material, list);
-    });
-    return [...byMaterial].map(([material, geometries]) => {
-      const merged = new THREE.Mesh(join(THREE, geometries), material);
-      for (const geometry of geometries) geometry.dispose();
-      merged.castShadow = false;
-      merged.receiveShadow = true;
-      return merged;
-    });
-  }
-
   // src/merge.ts
-  function mergeItem(T2, model) {
+  function mergeItem(T, model) {
     model.root.updateMatrixWorld(true);
-    const merged = new T2.Group();
+    const merged = new T.Group();
     merged.name = model.root.name;
     merged.scale.copy(model.root.scale);
     merged.userData = { ...model.root.userData };
-    merged.add(...mergeByMaterial(T2, model.root, model.root));
+    merged.add(...mergeByMaterial(T, model.root, model.root));
     return { ...model, root: merged };
   }
 
@@ -989,20 +2521,20 @@ var GameItemsThree = (() => {
   var cullDistanceOf = (size, budgets = ITEM_BUDGETS) => budgets[sizeClassOf(size, budgets)].cullDistance;
   function countTriangles(root) {
     let total = 0;
-    root.traverse((object) => {
-      const mesh = object;
-      if (!mesh.isMesh || !mesh.visible) return;
-      const geometry = mesh.geometry;
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || !mesh2.visible) return;
+      const geometry = mesh2.geometry;
       total += geometry.index ? geometry.index.count / 3 : geometry.getAttribute("position").count / 3;
     });
     return Math.round(total);
   }
   function countDrawCalls(root) {
     let total = 0;
-    root.traverse((object) => {
-      const mesh = object;
-      if (!mesh.isMesh || !mesh.visible) return;
-      total += Array.isArray(mesh.material) ? Math.max(1, mesh.geometry.groups.length) : 1;
+    root.traverse((object2) => {
+      const mesh2 = object2;
+      if (!mesh2.isMesh || !mesh2.visible) return;
+      total += Array.isArray(mesh2.material) ? Math.max(1, mesh2.geometry.groups.length) : 1;
     });
     return total;
   }
@@ -1013,19 +2545,19 @@ var GameItemsThree = (() => {
   }
 
   // src/lod.ts
-  function buildItemLod(T2, item, options = {}) {
+  function buildItemLod(T, item, options = {}) {
     const budgets = options.budgets ?? ITEM_BUDGETS;
     const cullDistance = cullDistanceOf(item.size, budgets);
     const lod1Distance = options.lod1Distance ?? cullDistance / 3;
-    const joined = (model) => options.merge === false ? model : mergeItem(T2, model);
+    const joined = (model) => options.merge === false ? model : mergeItem(T, model);
     const wear = options.wear === void 0 ? {} : { wear: options.wear };
-    const near = joined(buildItem(T2, item, { ...wear, kit: createItemKit(T2) }));
-    const far = joined(buildItem(T2, item, { ...wear, simple: true, detail: budgets.lod1Ratio, kit: createItemKit(T2) }));
-    const root = new T2.LOD();
+    const near = joined(buildItem(T, item, { ...wear, kit: createItemKit(T) }));
+    const far = joined(buildItem(T, item, { ...wear, simple: true, detail: budgets.lod1Ratio, kit: createItemKit(T) }));
+    const root = new T.LOD();
     root.name = item.id;
     root.addLevel(near.root, 0);
     root.addLevel(far.root, lod1Distance);
-    root.addLevel(new T2.Group(), cullDistance);
+    root.addLevel(new T.Group(), cullDistance);
     root.userData.wear = options.wear ?? 0;
     return { root, near, far, cullDistance, lod1Distance };
   }
@@ -1042,7 +2574,7 @@ var GameItemsThree = (() => {
   };
 
   // src/thumbnails.ts
-  var hex = (color) => `#${(color & 16777215).toString(16).padStart(6, "0")}`;
+  var hex = (color2) => `#${(color2 & 16777215).toString(16).padStart(6, "0")}`;
   var DEFAULT_COLOR2 = 9080724;
   var STEEL = "#9aa0a6";
   var BRASS = "#b8913a";
@@ -1075,9 +2607,9 @@ var GameItemsThree = (() => {
     plank: (c) => `<rect x="5" y="26" width="54" height="13" fill="${WOOD}"/><rect x="5" y="30" width="54" height="2" fill="${c === "#808080" ? "#6b4a2c" : c}" fill-opacity=".5"/><circle cx="12" cy="32" r="2" fill="#7d8186"/><circle cx="52" cy="32" r="2" fill="#7d8186"/>`,
     device: (c) => `<rect x="15" y="7" width="34" height="50" rx="5" fill="${c}"/><rect x="20" y="13" width="24" height="18" rx="2" fill="#9fbf8a"/><circle cx="26" cy="43" r="4" fill="#b9bdc0"/><rect x="35" y="40" width="9" height="6" rx="1" fill="#b9bdc0"/>`
   };
-  function shapeThumbnailSvg(shape, color = DEFAULT_COLOR2) {
+  function shapeThumbnailSvg(shape, color2 = DEFAULT_COLOR2) {
     const art = ART[shape];
-    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">${art(hex(color), hex(shade(color, 0.7)), hex(shade(color, 1.3)))}</svg>`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">${art(hex(color2), hex(shade(color2, 0.7)), hex(shade(color2, 1.3)))}</svg>`;
   }
   function itemThumbnail(item) {
     if (item.model !== void 0 && hasItemModel(item.model)) return { render: true };
@@ -1091,23 +2623,23 @@ var GameItemsThree = (() => {
   }
   var FIT_MARGIN = 1.15;
   var FIELD_OF_VIEW = 30;
-  function composeThumbnailScene(T2, item, options = {}) {
+  function composeThumbnailScene(T, item, options = {}) {
     const { yaw = -0.6, pitch = 0.45, distance = 1, wear = 0 } = options;
-    const scene = new T2.Scene();
-    const model = buildItem(T2, item);
+    const scene = new T.Scene();
+    const model = buildItem(T, item);
     if (wear) setWear(model.root, wear);
     scene.add(model.root);
-    scene.add(new T2.HemisphereLight(14673646, 3814440, 0.85));
-    const sun = new T2.DirectionalLight(16769727, 1.1);
+    scene.add(new T.HemisphereLight(14673646, 3814440, 0.85));
+    const sun = new T.DirectionalLight(16769727, 1.1);
     sun.position.set(2.5, 3.5, 2.5);
     scene.add(sun);
-    const rim = new T2.DirectionalLight(9417430, 0.45);
+    const rim = new T.DirectionalLight(9417430, 0.45);
     rim.position.set(-3, 1, -2.5);
     scene.add(rim);
-    const box2 = new T2.Box3().setFromObject(model.root);
-    const centre = box2.getCenter(new T2.Vector3());
-    const radius = box2.getSize(new T2.Vector3()).length() / 2;
-    const camera = new T2.PerspectiveCamera(FIELD_OF_VIEW, 1, radius / 50, radius * 40);
+    const box3 = new T.Box3().setFromObject(model.root);
+    const centre = box3.getCenter(new T.Vector3());
+    const radius = box3.getSize(new T.Vector3()).length() / 2;
+    const camera = new T.PerspectiveCamera(FIELD_OF_VIEW, 1, radius / 50, radius * 40);
     const fit = radius * FIT_MARGIN / Math.sin(FIELD_OF_VIEW * Math.PI / 360);
     const away = fit * distance;
     camera.position.set(centre.x + away * Math.cos(pitch) * Math.sin(yaw), centre.y + away * Math.sin(pitch), centre.z + away * Math.cos(pitch) * Math.cos(yaw));
@@ -1115,8 +2647,8 @@ var GameItemsThree = (() => {
     camera.updateMatrixWorld(true);
     return { scene, camera };
   }
-  function renderItemThumbnail(T2, renderer, item, options = {}) {
-    const { scene, camera } = composeThumbnailScene(T2, item, options);
+  function renderItemThumbnail(T, renderer, item, options = {}) {
+    const { scene, camera } = composeThumbnailScene(T, item, options);
     const size = options.size ?? 128;
     renderer.setSize(size, size);
     renderer.setClearColor?.(0, 0);
@@ -1440,7 +2972,7 @@ var GameItemsThree = (() => {
   };
   var WEARING_DURABILITY = ["condition", "hits", "cuts"];
   var hasCondition = (item) => item.protection !== void 0 || item.weapon !== void 0 || WEARING_DURABILITY.includes(item.durability?.kind ?? "");
-  var between = (range, random) => range[0] + random() * (range[1] - range[0]);
+  var between = (range2, random) => range2[0] + random() * (range2[1] - range2[0]);
   var spawnAgeDays = (item, outbreakDays, random, catalog) => item.shelfLife === void 0 ? void 0 : outbreakDays + between(catalog.rules.spawn.ageShare, random) * item.shelfLife;
   var isRetailStock = (query, catalog) => {
     const { spawn } = catalog.rules;
@@ -1728,15 +3260,15 @@ var GameItemsThree = (() => {
       name: fill(text.shelf, { category: categoryName(plan.category) }),
       movable: false,
       build: (THREE) => {
-        const T2 = THREE;
-        const group = new T2.Group();
-        const wood = new T2.MeshStandardMaterial({ color: 9071173, roughness: 0.85 });
-        const frame = new T2.MeshStandardMaterial({ color: 4869458, roughness: 0.7, metalness: 0.3 });
-        const top = new T2.Mesh(new T2.BoxGeometry(plan.length, 0.04, plan.depth), wood);
+        const T = THREE;
+        const group = new T.Group();
+        const wood = new T.MeshStandardMaterial({ color: 9071173, roughness: 0.85 });
+        const frame = new T.MeshStandardMaterial({ color: 4869458, roughness: 0.7, metalness: 0.3 });
+        const top = new T.Mesh(new T.BoxGeometry(plan.length, 0.04, plan.depth), wood);
         top.position.y = SHELF_HEIGHT - 0.02;
         group.add(top);
         for (const sx of [-1, 1]) for (const sz of [-1, 1]) {
-          const leg = new T2.Mesh(new T2.BoxGeometry(0.05, SHELF_HEIGHT - 0.04, 0.05), frame);
+          const leg = new T.Mesh(new T.BoxGeometry(0.05, SHELF_HEIGHT - 0.04, 0.05), frame);
           leg.position.set(sx * (plan.length - 0.1) / 2, (SHELF_HEIGHT - 0.04) / 2, sz * (plan.depth - 0.1) / 2);
           group.add(leg);
         }
@@ -1753,9 +3285,9 @@ var GameItemsThree = (() => {
       movable: true,
       thumbnail: itemThumbnailSvg(drawable(def)),
       build: (THREE) => {
-        const T2 = THREE;
-        latestTHREE = T2;
-        const model = buildItem(T2, drawable(def), { wear: stageFor(def) });
+        const T = THREE;
+        latestTHREE = T;
+        const model = buildItem(T, drawable(def), { wear: stageFor(def) });
         register({ id: `${ITEM_PREFIX}${def.id}`, itemId: def.id, group: "shelf", category: def.category, def, kind: model.kind, size: def.size, root: model.root });
         return model.root;
       }
@@ -1765,9 +3297,9 @@ var GameItemsThree = (() => {
       name: model.def ? nameOf(model.def) : label(`item.${model.id}`, humanize(model.id)),
       movable: false,
       build: (THREE) => {
-        const T2 = THREE;
+        const T = THREE;
         const subject = { id: model.id, category: model.def?.category ?? "", size: model.size, model: model.id };
-        const built = buildItem(T2, subject, { wear: stageFor(model.def) });
+        const built = buildItem(T, subject, { wear: stageFor(model.def) });
         register({ id: `${SHOWCASE_PREFIX}${model.id}`, itemId: model.id, group: "showcase", category: model.def?.category ?? "", def: model.def, kind: built.kind, size: model.size, root: built.root });
         return built.root;
       }
@@ -1777,11 +3309,11 @@ var GameItemsThree = (() => {
       name: text.stand,
       movable: false,
       build: (THREE) => {
-        const T2 = THREE;
-        const group = new T2.Group();
-        const base = new T2.Mesh(new T2.CylinderGeometry(STAND.radius, STAND.radius + 0.1, STAND.height - 0.04, 40), new T2.MeshStandardMaterial({ color: 3816772, roughness: 0.8 }));
+        const T = THREE;
+        const group = new T.Group();
+        const base = new T.Mesh(new T.CylinderGeometry(STAND.radius, STAND.radius + 0.1, STAND.height - 0.04, 40), new T.MeshStandardMaterial({ color: 3816772, roughness: 0.8 }));
         base.position.y = (STAND.height - 0.04) / 2;
-        const top = new T2.Mesh(new T2.CylinderGeometry(STAND.radius, STAND.radius, 0.04, 40), new T2.MeshStandardMaterial({ color: 13617848, roughness: 0.6 }));
+        const top = new T.Mesh(new T.CylinderGeometry(STAND.radius, STAND.radius, 0.04, 40), new T.MeshStandardMaterial({ color: 13617848, roughness: 0.6 }));
         top.position.y = STAND.height - 0.02;
         group.add(base, top);
         return group;
@@ -1792,19 +3324,19 @@ var GameItemsThree = (() => {
       name: text.ruler,
       movable: false,
       build: (THREE) => {
-        const T2 = THREE;
-        const group = new T2.Group();
-        const post = new T2.Mesh(new T2.BoxGeometry(0.06, RULER_HEIGHT, 0.02), new T2.MeshStandardMaterial({ color: 15262408, roughness: 0.7 }));
+        const T = THREE;
+        const group = new T.Group();
+        const post = new T.Mesh(new T.BoxGeometry(0.06, RULER_HEIGHT, 0.02), new T.MeshStandardMaterial({ color: 15262408, roughness: 0.7 }));
         post.position.y = RULER_HEIGHT / 2;
         group.add(post);
-        const tick = new T2.MeshStandardMaterial({ color: 1776411 });
+        const tick = new T.MeshStandardMaterial({ color: 1776411 });
         for (let cm = 0; cm <= 155; cm += 5) {
           const long = cm % 10 === 0;
-          const mark = new T2.Mesh(new T2.BoxGeometry(long ? 0.05 : 0.03, 4e-3, 0.024), tick);
+          const mark = new T.Mesh(new T.BoxGeometry(long ? 0.05 : 0.03, 4e-3, 0.024), tick);
           mark.position.set(0.03 + (long ? 0.025 : 0.015), cm / 100, 0);
           group.add(mark);
         }
-        const base = new T2.Mesh(new T2.BoxGeometry(0.3, 0.03, 0.3), new T2.MeshStandardMaterial({ color: 5593180 }));
+        const base = new T.Mesh(new T.BoxGeometry(0.3, 0.03, 0.3), new T.MeshStandardMaterial({ color: 5593180 }));
         base.position.y = 0.015;
         group.add(base);
         group.userData.height = RULER_HEIGHT;
@@ -1816,19 +3348,19 @@ var GameItemsThree = (() => {
       name: text.human,
       movable: false,
       build: (THREE) => {
-        const T2 = THREE;
-        const group = new T2.Group();
-        const skin = new T2.MeshStandardMaterial({ color: 10134445, roughness: 0.9 });
+        const T = THREE;
+        const group = new T.Group();
+        const skin = new T.MeshStandardMaterial({ color: 10134445, roughness: 0.9 });
         const part = (geometry, x, y) => {
-          const mesh = new T2.Mesh(geometry, skin);
-          mesh.position.set(x, y, 0);
-          group.add(mesh);
+          const mesh2 = new T.Mesh(geometry, skin);
+          mesh2.position.set(x, y, 0);
+          group.add(mesh2);
         };
-        for (const x of [-0.09, 0.09]) part(new T2.CylinderGeometry(0.075, 0.06, 0.88, 10), x, 0.44);
-        part(new T2.BoxGeometry(0.4, 0.62, 0.22), 0, 0.88 + 0.31);
-        for (const x of [-0.26, 0.26]) part(new T2.CylinderGeometry(0.045, 0.04, 0.6, 8), x, 1.2);
-        part(new T2.CylinderGeometry(0.05, 0.055, 0.07, 8), 0, 1.535);
-        part(new T2.SphereGeometry(0.115, 14, 10), 0, 1.685);
+        for (const x of [-0.09, 0.09]) part(new T.CylinderGeometry(0.075, 0.06, 0.88, 10), x, 0.44);
+        part(new T.BoxGeometry(0.4, 0.62, 0.22), 0, 0.88 + 0.31);
+        for (const x of [-0.26, 0.26]) part(new T.CylinderGeometry(0.045, 0.04, 0.6, 8), x, 1.2);
+        part(new T.CylinderGeometry(0.05, 0.055, 0.07, 8), 0, 1.535);
+        part(new T.SphereGeometry(0.115, 14, 10), 0, 1.685);
         group.userData.height = HUMAN_HEIGHT;
         return group;
       }
@@ -1838,14 +3370,14 @@ var GameItemsThree = (() => {
       name: text.table,
       movable: false,
       build: (THREE) => {
-        const T2 = THREE;
-        const group = new T2.Group();
-        const top = new T2.Mesh(new T2.BoxGeometry(TABLE.length, 0.05, TABLE.depth), new T2.MeshStandardMaterial({ color: 8022613, roughness: 0.8 }));
+        const T = THREE;
+        const group = new T.Group();
+        const top = new T.Mesh(new T.BoxGeometry(TABLE.length, 0.05, TABLE.depth), new T.MeshStandardMaterial({ color: 8022613, roughness: 0.8 }));
         top.position.y = TABLE.height - 0.025;
         group.add(top);
-        const frame = new T2.MeshStandardMaterial({ color: 4013892 });
+        const frame = new T.MeshStandardMaterial({ color: 4013892 });
         for (const sx of [-1, 1]) for (const sz of [-1, 1]) {
-          const leg = new T2.Mesh(new T2.BoxGeometry(0.06, TABLE.height - 0.05, 0.06), frame);
+          const leg = new T.Mesh(new T.BoxGeometry(0.06, TABLE.height - 0.05, 0.06), frame);
           leg.position.set(sx * (TABLE.length - 0.12) / 2, (TABLE.height - 0.05) / 2, sz * (TABLE.depth - 0.12) / 2);
           group.add(leg);
         }
@@ -1863,10 +3395,10 @@ var GameItemsThree = (() => {
     };
     const applyHighlight = () => {
       for (const entry of entries2) {
-        entry.root.traverse((object) => {
-          const mesh = object;
-          if (!mesh.isMesh) return;
-          for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
+        entry.root.traverse((object2) => {
+          const mesh2 = object2;
+          if (!mesh2.isMesh) return;
+          for (const material of Array.isArray(mesh2.material) ? mesh2.material : [mesh2.material]) {
             const standard = material;
             if (standard.emissive) standard.emissive.setHex(layers.simple_shapes && entry.kind === "shape" ? HIGHLIGHT : 0);
           }
@@ -1874,21 +3406,21 @@ var GameItemsThree = (() => {
       }
     };
     const clearBoxes = () => {
-      for (const box2 of boxes) {
-        box2.parent?.remove(box2);
+      for (const box3 of boxes) {
+        box3.parent?.remove(box3);
       }
       boxes = [];
     };
     const applyBoxes = () => {
       clearBoxes();
       if (!layers.boxes || !host || !latestTHREE) return;
-      const T2 = latestTHREE;
+      const T = latestTHREE;
       const scene = host.scene;
       for (const entry of liveEntries()) {
         if (!entry.root.visible) continue;
-        const box2 = new T2.Box3().setFromObject(entry.root);
-        if (box2.isEmpty()) continue;
-        const helper = new T2.Box3Helper(box2, BOX_COLOR);
+        const box3 = new T.Box3().setFromObject(entry.root);
+        if (box3.isEmpty()) continue;
+        const helper = new T.Box3Helper(box3, BOX_COLOR);
         scene.add(helper);
         boxes.push(helper);
       }
@@ -1899,7 +3431,7 @@ var GameItemsThree = (() => {
         findsGroup = null;
       }
     };
-    const labelSprite = (T2, content) => {
+    const labelSprite = (T, content) => {
       if (typeof document === "undefined") return null;
       const canvas = document.createElement("canvas");
       const context = canvas.getContext("2d");
@@ -1913,8 +3445,8 @@ var GameItemsThree = (() => {
       context.textAlign = "center";
       context.textBaseline = "middle";
       context.fillText(content.length > 22 ? `${content.slice(0, 21)}\u2026` : content, 128, 32);
-      const texture = new T2.CanvasTexture(canvas);
-      const sprite = new T2.Sprite(new T2.SpriteMaterial({ map: texture, depthTest: false, transparent: true }));
+      const texture = new T.CanvasTexture(canvas);
+      const sprite = new T.Sprite(new T.SpriteMaterial({ map: texture, depthTest: false, transparent: true }));
       sprite.scale.set(0.5, 0.125, 1);
       sprite.renderOrder = 10;
       return sprite;
@@ -1922,8 +3454,8 @@ var GameItemsThree = (() => {
     const showFinds = () => {
       clearFinds();
       if (!host || !latestTHREE) return;
-      const T2 = latestTHREE;
-      const group = new T2.Group();
+      const T = latestTHREE;
+      const group = new T.Group();
       group.position.set(TABLE.at[0], TABLE.height + 5e-3, TABLE.at[2]);
       let cursor = -TABLE.length / 2 + 0.1;
       const scale = 1;
@@ -1932,12 +3464,12 @@ var GameItemsThree = (() => {
         const copies = Math.min(found.count, MAX_COPIES);
         const start = cursor;
         for (let i = 0; i < copies; i++) {
-          const model = buildItem(T2, drawable(def), { wear: stageFor(def) });
+          const model = buildItem(T, drawable(def), { wear: stageFor(def) });
           model.root.position.set(cursor + def.size[0] * scale / 2, 0, 0);
           group.add(model.root);
           cursor += def.size[0] + 0.03;
         }
-        const sprite = labelSprite(T2, `${nameOf(def)} x${found.count}`);
+        const sprite = labelSprite(T, `${nameOf(def)} x${found.count}`);
         if (sprite) {
           sprite.position.set((start + cursor) / 2, Math.max(def.size[1], 0.1) + 0.12, 0);
           sprite.visible = layers.labels;
@@ -1951,8 +3483,8 @@ var GameItemsThree = (() => {
       findsGroup = group;
     };
     const applyLabels = () => {
-      findsGroup?.traverse((object) => {
-        if (object.userData.label) object.visible = layers.labels;
+      findsGroup?.traverse((object2) => {
+        if (object2.userData.label) object2.visible = layers.labels;
       });
     };
     const rollFinds = () => {