@adatechnology/game-vehicles 0.2.0 → 0.4.0

package/dist/index.global.js

@@ -51,6 +51,1523 @@ var GameVehicles = (() => {
     wrapThreeForLod: () => wrapThreeForLod
   });
 
+  // ../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((key) => record[key] !== void 0).sort();
+      return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return "null";
+  }
+  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, tube = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) {
+    const parameters = { radius, tube, 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 + tube * Math.cos(v)) * Math.cos(u);
+        const y = (radius + tube * Math.cos(v)) * Math.sin(u);
+        const z = tube * 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, key) => kind === "circle" && key === "segments" ? 32 : kind === "torus" && key === "radialSegments" ? 12 : SEGMENT_DEFAULTS[key];
+  function primitiveParameters(node, options = {}) {
+    const out = {};
+    const source = node;
+    for (const key of PARAMETER_KEYS[node.kind]) if (source[key] !== void 0) out[key] = source[key];
+    const detail = options.detail ?? 1;
+    if (detail !== 1) {
+      const floor = options.minSegments ?? 3;
+      for (const key of SEGMENT_KEYS[node.kind] ?? []) {
+        const given = out[key] ?? segmentDefault(node.kind, key);
+        out[key] = 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 key = `${node.kind}:${canonicalJson(parameters)}`;
+    const cached = templates.get(key);
+    if (cached) {
+      stats.hits++;
+      templates.delete(key);
+      templates.set(key, cached);
+      return cached;
+    }
+    stats.misses++;
+    const built = make(node.kind, parameters);
+    templates.set(key, 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 key of required) if (record[key] === void 0) return `${key}: required`;
+    for (const key of Object.keys(record)) {
+      if (record[key] === void 0) continue;
+      const check = fields[key];
+      if (!check) return `${key}: unknown field`;
+      const e = check(record[key]);
+      if (e) return `${key}: ${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"] }
+  };
+
+  // ../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();
+  var shims = /* @__PURE__ */ new WeakSet();
+  function shapeGeometries(THREE, options = {}) {
+    if (shims.has(THREE)) return THREE;
+    const cache = options.cache !== false;
+    const key = cache ? "cache" : "nocache";
+    let byKey = namespaces.get(THREE);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      namespaces.set(THREE, byKey);
+    }
+    const existing = byKey.get(key);
+    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, tube, radialSegments, tubularSegments, arc) => made(viaCache({ kind: "torus", ...defined({ radius, tube, radialSegments, tubularSegments, arc }) }, () => torus(radius, tube, 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(key, result);
+    shims.add(result);
+    return result;
+  }
+
   // src/locales/en.json
   var en_default = {
     plate: {
@@ -746,9 +2263,9 @@ var GameVehicles = (() => {
       return envTex;
     }
     kit.studioEnvironment = studioEnvironment;
-    function makeMaterial(color, o) {
+    function makeMaterial(color2, o) {
       o = o || {};
-      const c = color instanceof THREE.Color ? color : new THREE.Color(color);
+      const c = color2 instanceof THREE.Color ? color2 : new THREE.Color(color2);
       const key = "s" + c.getHexString() + JSON.stringify(o, function(k, v) {
         return v && v.isColor ? "#" + v.getHexString() : v && v.isTexture ? v.uuid : v;
       });
@@ -764,8 +2281,8 @@ var GameVehicles = (() => {
       }
       return cache[key];
     }
-    function makeFlatMaterial(color, o) {
-      return makeMaterial(color, Object.assign({ flatShading: true, roughness: 0.92 }, o || {}));
+    function makeFlatMaterial(color2, o) {
+      return makeMaterial(color2, Object.assign({ flatShading: true, roughness: 0.92 }, o || {}));
     }
     const DOUBLE_SIDE = THREE.DoubleSide;
     function toColor(hex) {
@@ -984,46 +2501,79 @@ var GameVehicles = (() => {
       }
       const p = geo.attributes.position;
       const n = p.count;
-      const FN = [];
-      const map = {};
-      const A = new V3();
-      const B = new V3();
-      const C = new V3();
-      const e1 = new V3();
-      const e2 = new V3();
+      const faces = n / 3;
+      const FN = new Float64Array(faces * 3);
+      const map = /* @__PURE__ */ new Map();
+      const RANGE = 65536;
       function key(i) {
-        return Math.round(p.getX(i) * 2e3) + "," + Math.round(p.getY(i) * 2e3) + "," + Math.round(p.getZ(i) * 2e3);
+        const x = Math.round(p.getX(i) * 2e3);
+        const y = Math.round(p.getY(i) * 2e3);
+        const z = Math.round(p.getZ(i) * 2e3);
+        if (Math.abs(x) < RANGE && Math.abs(y) < RANGE && Math.abs(z) < RANGE) return ((x + RANGE) * 131072 + (y + RANGE)) * 131072 + (z + RANGE);
+        return x + "," + y + "," + z;
       }
       const keys = new Array(n);
-      for (let f = 0; f < n / 3; f++) {
-        A.fromBufferAttribute(p, 3 * f);
-        B.fromBufferAttribute(p, 3 * f + 1);
-        C.fromBufferAttribute(p, 3 * f + 2);
-        const nn = new V3().crossVectors(e1.subVectors(C, B), e2.subVectors(A, B));
-        if (nn.lengthSq() > 1e-20) nn.normalize();
-        FN.push(nn);
+      for (let f = 0; f < faces; f++) {
+        const ax = p.getX(3 * f);
+        const ay = p.getY(3 * f);
+        const az = p.getZ(3 * f);
+        const bx = p.getX(3 * f + 1);
+        const by = p.getY(3 * f + 1);
+        const bz = p.getZ(3 * f + 1);
+        const cx = p.getX(3 * f + 2);
+        const cy = p.getY(3 * f + 2);
+        const cz = p.getZ(3 * f + 2);
+        const e1x = cx - bx;
+        const e1y = cy - by;
+        const e1z = cz - bz;
+        const e2x = ax - bx;
+        const e2y = ay - by;
+        const e2z = az - bz;
+        let nx = e1y * e2z - e1z * e2y;
+        let ny = e1z * e2x - e1x * e2z;
+        let nz = e1x * e2y - e1y * e2x;
+        if (nx * nx + ny * ny + nz * nz > 1e-20) {
+          const inv = 1 / (Math.sqrt(nx * nx + ny * ny + nz * nz) || 1);
+          nx *= inv;
+          ny *= inv;
+          nz *= inv;
+        }
+        FN[3 * f] = nx;
+        FN[3 * f + 1] = ny;
+        FN[3 * f + 2] = nz;
         for (let k = 0; k < 3; k++) {
           const kk = key(3 * f + k);
           keys[3 * f + k] = kk;
-          (map[kk] || (map[kk] = [])).push(f);
+          const list2 = map.get(kk);
+          if (list2) list2.push(f);
+          else map.set(kk, [f]);
         }
       }
       const cs = Math.cos(deg * PI / 180);
       const out = new Float32Array(n * 3);
-      const s = new V3();
       for (let i = 0; i < n; i++) {
-        const fi = i / 3 | 0;
-        const list = map[keys[i]];
-        s.set(0, 0, 0);
-        for (let j = 0; j < list.length; j++) {
-          const g = FN[list[j]];
-          if (g.dot(FN[fi]) >= cs) s.add(g);
-        }
-        if (s.lengthSq() < 1e-20) s.copy(FN[fi]);
-        s.normalize();
-        out[3 * i] = s.x;
-        out[3 * i + 1] = s.y;
-        out[3 * i + 2] = s.z;
+        const fi = (i / 3 | 0) * 3;
+        const list2 = map.get(keys[i]);
+        let sx = 0;
+        let sy = 0;
+        let sz = 0;
+        for (let j = 0; j < list2.length; j++) {
+          const g = list2[j] * 3;
+          if (FN[g] * FN[fi] + FN[g + 1] * FN[fi + 1] + FN[g + 2] * FN[fi + 2] >= cs) {
+            sx += FN[g];
+            sy += FN[g + 1];
+            sz += FN[g + 2];
+          }
+        }
+        if (sx * sx + sy * sy + sz * sz < 1e-20) {
+          sx = FN[fi];
+          sy = FN[fi + 1];
+          sz = FN[fi + 2];
+        }
+        const inv = 1 / (Math.sqrt(sx * sx + sy * sy + sz * sz) || 1);
+        out[3 * i] = sx * inv;
+        out[3 * i + 1] = sy * inv;
+        out[3 * i + 2] = sz * inv;
       }
       geo.setAttribute("normal", new THREE.BufferAttribute(out, 3));
       geo.userData.crease = true;
@@ -1082,7 +2632,7 @@ var GameVehicles = (() => {
       const pos = [];
       const col = [];
       const idx = [];
-      const ring = seg + 1;
+      const ring2 = seg + 1;
       st.forEach(function(s) {
         for (let j = 0; j <= seg; j++) {
           const a = j / seg * PI * 2;
@@ -1100,8 +2650,8 @@ var GameVehicles = (() => {
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const a0 = i * ring + k;
-          const b0 = a0 + ring;
+          const a0 = i * ring2 + k;
+          const b0 = a0 + ring2;
           idx.push(a0, a0 + 1, b0, a0 + 1, b0 + 1, b0);
         }
       ;
@@ -1115,7 +2665,7 @@ var GameVehicles = (() => {
           col.push(cc.r, cc.g, cc.b);
         }
         for (let k = 0; k < seg; k++) {
-          const a = si * ring + k;
+          const a = si * ring2 + k;
           if (e === 0) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
         }
@@ -1253,13 +2803,13 @@ var GameVehicles = (() => {
         });
         tris = next;
       });
-      function build(list) {
+      function build(list2) {
         const g = new THREE.BufferGeometry();
         let off = 0;
         names.forEach(function(nm, a) {
-          const arr = new Float32Array(list.length * 3 * sizes[a]);
+          const arr = new Float32Array(list2.length * 3 * sizes[a]);
           let w = 0;
-          list.forEach(function(t) {
+          list2.forEach(function(t) {
             for (let k = 0; k < 3; k++) for (let q = 0; q < sizes[a]; q++) arr[w++] = t[k][off + q];
           });
           g.setAttribute(nm, new THREE.BufferAttribute(arr, sizes[a]));
@@ -1274,10 +2824,10 @@ var GameVehicles = (() => {
       });
       return out;
     }
-    function mergeGeometries(list) {
+    function mergeGeometries(list2) {
       const pos = [];
       const nor = [];
-      list.forEach(function(g2) {
+      list2.forEach(function(g2) {
         const n = g2.index ? g2.toNonIndexed() : g2;
         if (!n.attributes.normal) n.computeVertexNormals();
         const pa = n.attributes.position.array;
@@ -1336,13 +2886,13 @@ var GameVehicles = (() => {
     };
     kit.holeSide = function(poly, o) {
       o = o || {};
-      let area = 0;
+      let area3 = 0;
       for (let i = 0; i < poly.length; i++) {
         const a = poly[i];
         const b = poly[(i + 1) % poly.length];
-        area += a[0] * b[1] - b[0] * a[1];
+        area3 += a[0] * b[1] - b[0] * a[1];
       }
-      const sg = area > 0 ? 1 : -1;
+      const sg = area3 > 0 ? 1 : -1;
       const E2 = poly.map(function(a, i) {
         const b = poly[(i + 1) % poly.length];
         const dx = b[0] - a[0];
@@ -1645,11 +3195,11 @@ var GameVehicles = (() => {
         return d.clone().applyQuaternion(this.vehicle.quaternion);
       }
       /** Declares or refines a damage zone: `c.zone(id, label, box, parts, options)`. Pass `label === false` to remove an auto-derived zone. */
-      zone(id, label, box, parts, o) {
+      zone(id, label, box2, parts, o) {
         const d = Object.assign({ id }, o || {});
         if (label === false) d.remove = true;
         else if (label) d.name = label;
-        if (box) d.box = I.normalizeBox(box);
+        if (box2) d.box = I.normalizeBox(box2);
         if (parts) d.objs = Array.isArray(parts) ? parts.slice() : [parts];
         this.zoneDefs.push(d);
         return d;
@@ -1800,7 +3350,7 @@ var GameVehicles = (() => {
       const seg = o.seg || 24;
       const pos = [];
       const idx = [];
-      const ring = seg + 1;
+      const ring2 = seg + 1;
       const axisY = o.axis === "y";
       st.forEach(function(s) {
         const a0 = s[1];
@@ -1822,8 +3372,8 @@ var GameVehicles = (() => {
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const A = i * ring + k;
-          const B = A + ring;
+          const A = i * ring2 + k;
+          const B = A + ring2;
           if (axisY) idx.push(A, B, A + 1, A + 1, B, B + 1);
           else idx.push(A, A + 1, B, A + 1, B + 1, B);
         }
@@ -1836,7 +3386,7 @@ var GameVehicles = (() => {
         if (axisY) pos.push(cc, s[0], s[5] || 0);
         else pos.push(s[0], cc, s[5] || 0);
         for (let k = 0; k < seg; k++) {
-          const a = si * ring + k;
+          const a = si * ring2 + k;
           const flip = e === 0 !== axisY;
           if (flip) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
@@ -2068,15 +3618,15 @@ var GameVehicles = (() => {
       c.part("glass", L, m, pos, o.reach || 0.9);
       return m;
     };
-    kit.asGlass = function(c, mesh, label, type, o) {
+    kit.asGlass = function(c, mesh2, label, type, o) {
       o = o || {};
-      const i = c.deform.indexOf(mesh);
+      const i = c.deform.indexOf(mesh2);
       if (i >= 0) c.deform.splice(i, 1);
-      if (mesh.parent) mesh.parent.remove(mesh);
-      const geo = mesh.geometry;
-      geo.applyMatrix4(new THREE.Matrix4().compose(mesh.position, mesh.quaternion, mesh.scale));
+      if (mesh2.parent) mesh2.parent.remove(mesh2);
+      const geo = mesh2.geometry;
+      geo.applyMatrix4(new THREE.Matrix4().compose(mesh2.position, mesh2.quaternion, mesh2.scale));
       if (o.reuv !== false) o.reuv = true;
-      return kit.addGlass(c, geo, label, type, Object.assign({ mat: mesh.material }, o));
+      return kit.addGlass(c, geo, label, type, Object.assign({ mat: mesh2.material }, o));
     };
     kit.sideWindows = function(c, polys, Wg, T, label, o) {
       o = o || {};
@@ -2122,12 +3672,12 @@ var GameVehicles = (() => {
         });
       });
     };
-    kit.cutMesh = function(mesh, tests, deg, o) {
-      const src = o && o.sub ? subdivide(mesh.geometry, o.sub) : mesh.geometry;
+    kit.cutMesh = function(mesh2, tests, deg, o) {
+      const src = o && o.sub ? subdivide(mesh2.geometry, o.sub) : mesh2.geometry;
       const r = cutGeometry(src, tests);
       crease(r.geo, deg || 42);
-      mesh.geometry.dispose();
-      mesh.geometry = r.geo;
+      mesh2.geometry.dispose();
+      mesh2.geometry = r.geo;
       return r.cut;
     };
     kit.quadDef = function(pb, pt, Wg, T, which, bev, o) {
@@ -2327,8 +3877,8 @@ var GameVehicles = (() => {
           const pz = nR === 1 ? 0 : (i ? 1 : -1) * w / 4;
           const back = gm(g, new THREE.CylinderGeometry(r * 1.06, r * 1.06, d * 0.8, 22), MATERIALS.housing, 0, 0, pz);
           back.rotation.z = PI / 2;
-          const ring = gm(g, new THREE.TorusGeometry(r * 1.02, 0.013, 8, 30), MATERIALS.chrome, d / 2 - 6e-3, 0, pz);
-          ring.rotation.y = PI / 2;
+          const ring2 = gm(g, new THREE.TorusGeometry(r * 1.02, 0.013, 8, 30), MATERIALS.chrome, d / 2 - 6e-3, 0, pz);
+          ring2.rotation.y = PI / 2;
           const bowl = gm(g, new THREE.SphereGeometry(r * 0.96, 18, 10, 0, PI * 2, 0, PI / 2), MATERIALS.reflectorLit, d / 2 - 0.012, 0, pz);
           bowl.rotation.z = PI / 2;
           bowl.scale.y = 0.55;
@@ -2405,8 +3955,8 @@ var GameVehicles = (() => {
           const e = gm(g, new THREE.CylinderGeometry(r * 0.9, r * 0.9, 0.012, 20), q * ls > 0 ? MATERIALS.tail : MATERIALS.tail, d / 2 - 0.02, 0, pz);
           e.rotation.z = PI / 2;
           inner.push(e);
-          const ring = gm(g, new THREE.TorusGeometry(r, 0.01, 6, 24), MATERIALS.chrome, d / 2 - 4e-3, 0, pz);
-          ring.rotation.y = PI / 2;
+          const ring2 = gm(g, new THREE.TorusGeometry(r, 0.01, 6, 24), MATERIALS.chrome, d / 2 - 4e-3, 0, pz);
+          ring2.rotation.y = PI / 2;
           const ln = gm(g, new THREE.SphereGeometry(r, 16, 8, 0, PI * 2, 0, PI / 2), MATERIALS.lensRed, d / 2 - 0.01, 0, pz);
           ln.rotation.z = -PI / 2;
           ln.scale.y = 0.25;
@@ -2499,7 +4049,7 @@ var GameVehicles = (() => {
       } else if (st === "mesh") {
         gm(g, roundedBoxGeometry(0.05, h, w, Math.min(0.03, h * 0.3)), MATERIALS.housing);
         const cell = 0.026;
-        const list = [];
+        const list2 = [];
         const rows = Math.floor(h * 0.85 / (cell * 1.6));
         const cols = Math.floor(w * 0.9 / (cell * 1.8));
         for (let rI = 0; rI < rows; rI++)
@@ -2508,9 +4058,9 @@ var GameVehicles = (() => {
             hg.rotateZ(PI / 2);
             hg.rotateX(PI / 6);
             hg.translate(0.026, -h * 0.42 + (rI + 0.5) * h * 0.85 / rows, -w * 0.45 + (cI + 0.5 + rI % 2 * 0.5 - 0.25) * w * 0.9 / cols);
-            list.push(hg);
+            list2.push(hg);
           }
-        if (list.length) gm(g, mergeGeometries(list), MATERIALS.trim);
+        if (list2.length) gm(g, mergeGeometries(list2), MATERIALS.trim);
         gm(g, roundedBoxGeometry(0.022, 0.014, w, 6e-3), MATERIALS.chrome, 0.03, h / 2 - 8e-3, 0);
       } else if (st === "big") {
         const fr = roundedBoxGeometry(0.06, h, w, 0.03);
@@ -3351,7 +4901,7 @@ var GameVehicles = (() => {
       m.underbodyGroup = ug;
       const DK = makeMaterial("#1a1b1c", { roughness: 0.75, metalness: 0.3 });
       const ST = MATERIALS.steel;
-      function box(w, h, d, mat, x, y, z) {
+      function box2(w, h, d, mat, x, y, z) {
         return c.roundBox(w, h, d, Math.min(0.02, h * 0.4), mat, x, y, z, { parent: ug });
       }
       function rod(a, b, r, mat) {
@@ -3368,9 +4918,9 @@ var GameVehicles = (() => {
         rod(new V3(rx, rr, -zW), new V3(rx, rr, zW), 0.045, ST);
         c.sphere(0.13, ST, rx, rr, 0, 1, 0.85, 1, { parent: ug });
         rod(new V3(rx + 0.1, rr, 0), new V3(fx - 0.6, yU + 0.04, 0), 0.035, ST);
-      } else box(0.09, 0.08, zW * 2, DK, rx + 0.08, Math.max(yU, rr - 0.12), 0);
+      } else box2(0.09, 0.08, zW * 2, DK, rx + 0.08, Math.max(yU, rr - 0.12), 0);
       if (!ev) {
-        box(Math.min(0.5, (fx - rx) * 0.2), 0.1, 0.38, DK, fx - 0.25, yU + 0.01, -0.05);
+        box2(Math.min(0.5, (fx - rx) * 0.2), 0.1, 0.38, DK, fx - 0.25, yU + 0.01, -0.05);
         const tz = W * 0.3;
         const mx = rx - 0.15;
         const ty = Math.max(0.14, by - 0.06);
@@ -3387,10 +4937,10 @@ var GameVehicles = (() => {
           { parent: ug, seg: 30, rs: 6 }
         );
         c.cylinder(0.1, 0.1, 0.42, ST, mx, ty + 0.02, tz, "x", { parent: ug });
-        box(0.24, 0.06, 0.2, DK, (fx + rx) / 2 + 0.1, ty, 0.16);
-        box(0.55, 0.18, W * 0.5, makeMaterial("#232527", { roughness: 0.7 }), rx + 0.62, Math.max(0.16, by - 0.02), -W * 0.1);
+        box2(0.24, 0.06, 0.2, DK, (fx + rx) / 2 + 0.1, ty, 0.16);
+        box2(0.55, 0.18, W * 0.5, makeMaterial("#232527", { roughness: 0.7 }), rx + 0.62, Math.max(0.16, by - 0.02), -W * 0.1);
       } else {
-        box(
+        box2(
           (fx - rx) * 0.72,
           0.1,
           W - 0.4,
@@ -3399,7 +4949,7 @@ var GameVehicles = (() => {
           Math.max(0.14, by - 0.03),
           0
         );
-        for (let k = 0; k < 6; k++) box(0.03, 0.02, W - 0.45, ST, rx + 0.4 + k * (fx - rx - 0.8) / 5, Math.max(0.14, by - 0.03) - 0.06, 0);
+        for (let k = 0; k < 6; k++) box2(0.03, 0.02, W - 0.45, ST, rx + 0.4 + k * (fx - rx - 0.8) / 5, Math.max(0.14, by - 0.03) - 0.06, 0);
       }
       if (o.spare && m.rear < rx - 0.7) {
         c.cylinder(0.32, 0.32, 0.2, MATERIALS.rubber, rx - 0.55, Math.max(0.2, by - 0.05), 0, null, { parent: ug });
@@ -3727,16 +5277,16 @@ var GameVehicles = (() => {
         }
       } else {
         const ns = o.spokes || 28;
-        const list = [];
+        const list2 = [];
         for (let jj = 0; jj < ns; jj++) {
           const a2 = jj / ns * PI * 2;
           const cg = new THREE.CylinderGeometry(25e-4, 25e-4, sl, 4);
           cg.applyMatrix4(
             new THREE.Matrix4().makeRotationZ(a2 - PI / 2).setPosition(Math.cos(a2) * sl / 2, Math.sin(a2) * sl / 2, (jj % 2 ? 1 : -1) * 0.012)
           );
-          list.push(cg);
+          list2.push(cg);
         }
-        g.add(new THREE.Mesh(mergeGeometries(list), MATERIALS.chrome));
+        g.add(new THREE.Mesh(mergeGeometries(list2), MATERIALS.chrome));
       }
       const hub = new THREE.Mesh(new THREE.CylinderGeometry(0.035, 0.035, 0.1, 12), MATERIALS.steel);
       hub.rotation.x = PI / 2;
@@ -3918,9 +5468,9 @@ var GameVehicles = (() => {
           return puffTexture(k * 17, true);
         });
       }
-      const list = fire ? FIRE_TEXTURES : SMOKE_TEXTURES;
+      const list2 = fire ? FIRE_TEXTURES : SMOKE_TEXTURES;
       const mat = new THREE.SpriteMaterial({
-        map: list[Math.floor(Math.random() * list.length)],
+        map: list2[Math.floor(Math.random() * list2.length)],
         color: new THREE.Color(col),
         transparent: true,
         depthWrite: false,
@@ -5229,7 +6779,7 @@ var GameVehicles = (() => {
         }
       });
       const dset = new Set(c.deform);
-      const box = new THREE.Box3();
+      const box2 = new THREE.Box3();
       c.vehicle.children.forEach(function(o) {
         if (dset.has(o) || o.userData.noFollow) return;
         if (!(o.isMesh || o.isGroup && o.userData.rigid)) return;
@@ -5240,10 +6790,10 @@ var GameVehicles = (() => {
             if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
             o.userData.bb0 = o.geometry.boundingBox.clone().applyMatrix4(o.matrix);
           } else {
-            box.setFromObject(o);
-            box.applyMatrix4(gInv);
-            o.userData.c0 = box.getCenter(new V3());
-            o.userData.bb0 = box.clone();
+            box2.setFromObject(o);
+            box2.applyMatrix4(gInv);
+            o.userData.c0 = box2.getCenter(new V3());
+            o.userData.bb0 = box2.clone();
           }
           o.userData.pos0 = o.position.clone();
         }
@@ -5539,11 +7089,11 @@ var GameVehicles = (() => {
         [12, "#d8322a", kit.t("blast.lethal", { m: 12 })],
         [30, "#e0a548", kit.t("blast.injury", { m: 30 })]
       ].forEach(function(r) {
-        const ring = new THREE.Mesh(new THREE.RingGeometry(r[0] - 0.25, r[0], 96), boomMat(r[1], 0.85));
-        ring.rotation.x = -PI / 2;
-        ring.position.y = 0.06;
-        ring.renderOrder = 5;
-        g.add(ring);
+        const ring2 = new THREE.Mesh(new THREE.RingGeometry(r[0] - 0.25, r[0], 96), boomMat(r[1], 0.85));
+        ring2.rotation.x = -PI / 2;
+        ring2.position.y = 0.06;
+        ring2.renderOrder = 5;
+        g.add(ring2);
         const fill = new THREE.Mesh(new THREE.CircleGeometry(r[0], 96), boomMat(r[1], 0.07));
         fill.rotation.x = -PI / 2;
         fill.position.y = 0.05;
@@ -5560,7 +7110,7 @@ var GameVehicles = (() => {
         lb.rotation.x = -PI / 2;
         lb.position.set(0, 0.08, r[0] + r[0] * 0.06);
         g.add(lb);
-        c.bigFx.rings.push(ring, fill, lb);
+        c.bigFx.rings.push(ring2, fill, lb);
       });
     }
     function detonate(c) {
@@ -5835,7 +7385,7 @@ var GameVehicles = (() => {
     const I = kit._;
     const { MATERIALS } = I;
     function rollMeshes(c) {
-      const list = [];
+      const list2 = [];
       const thin = [];
       c.root.updateMatrixWorld(true);
       const inv = new THREE.Matrix4().copy(c.vehicle.matrixWorld).invert();
@@ -5853,9 +7403,9 @@ var GameVehicles = (() => {
           thin.push({ o: ob, M });
           return;
         }
-        list.push({ o: ob, M });
+        list2.push({ o: ob, M });
       });
-      return { list, thin };
+      return { list: list2, thin };
     }
     function convexHull(pts) {
       pts.sort(function(a, b) {
@@ -5938,7 +7488,7 @@ var GameVehicles = (() => {
     };
     function rollContact(c, A, q) {
       const m = c.meta;
-      const list = [];
+      const list2 = [];
       const dy = A.cen[0] - q[0];
       const dz = A.cen[1] - q[1];
       const dl = Math.hypot(dy, dz) || 1;
@@ -5946,17 +7496,17 @@ var GameVehicles = (() => {
       const f = 0.75;
       const bike = m.kind === "bike";
       (bike ? [0] : [-0.28, 0, 0.28]).forEach(function(k) {
-        list.push([new V3(A.x + k * A.L, q[0], q[1]), dir]);
+        list2.push([new V3(A.x + k * A.L, q[0], q[1]), dir]);
       });
       if (!bike && Math.abs(dir.z) > 0.75 && m.top - m.belt > 0.25 && A.hits < 3) {
         const sd = -Math.sign(dir.z);
         const yw = m.belt + (m.top - m.belt) * 0.45;
         [-0.25, 0.2].forEach(function(k) {
           const h = I.probe(c, new V3(A.x + k * A.L, yw, sd * (m.width / 2 + 2)), new V3(0, 0, -sd), 2 + m.width);
-          if (h) list.push([h.p, new V3(0, 0, -sd)]);
+          if (h) list2.push([h.p, new V3(0, 0, -sd)]);
         });
       }
-      list.forEach(function(e) {
+      list2.forEach(function(e) {
         I.impact(c, e[0], e[1], f, { noStain: true, maxDepth: 0.1 });
         const pf = c.toEffects(e[0]);
         pf.y = Math.max(0.03, pf.y);
@@ -5966,15 +7516,15 @@ var GameVehicles = (() => {
       });
       A.hits++;
       A.bounce = A.hits === 1 ? 0.06 : 0.1;
-      if (m.kind === "boat") I.burst(c, "water", c.toEffects(list[0][0]).setY(0.05), 30, { speed: 3 });
+      if (m.kind === "boat") I.burst(c, "water", c.toEffects(list2[0][0]).setY(0.05), 30, { speed: 3 });
     }
-    function exactMinY(c, list) {
+    function exactMinY(c, list2) {
       c.root.updateMatrixWorld(true);
       const inv = new THREE.Matrix4().copy(c.root.matrixWorld).invert();
       const M = new THREE.Matrix4();
       const v = new V3();
       let mn = 1e9;
-      list.forEach(function(e) {
+      list2.forEach(function(e) {
         const ob = e.o;
         if (!ob.parent || !I.shown(c, ob)) return;
         M.multiplyMatrices(inv, ob.matrixWorld);
@@ -6681,6 +8231,153 @@ var GameVehicles = (() => {
       return hole;
     }
     const _zr = new THREE.Raycaster();
+    const PROXY_MIN_TRIANGLES = 500;
+    const STROKE_REACH = 0.6;
+    const _pv = new V3();
+    const _pm = new THREE.Matrix4();
+    function decalRegion(c, z) {
+      const B = z.box;
+      const lo = [0, 1, 2].map(function(k) {
+        return I.boxLo(B, k) - STROKE_REACH;
+      });
+      const hi = [0, 1, 2].map(function(k) {
+        return I.boxHi(B, k) + STROKE_REACH;
+      });
+      const a = axisOf(z.dir);
+      const dn = z.dir.clone().normalize();
+      const sg = z.dir.getComponent(a) > 0 ? 1 : -1;
+      const outer = sg > 0 ? I.boxLo(B, a) - 0.6 : I.boxHi(B, a) + 0.6;
+      const far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
+      for (let i = 0; i < 8; i++) {
+        const p = new V3();
+        p.setComponent(a, outer);
+        [0, 1, 2].filter(function(k) {
+          return k !== a;
+        }).forEach(function(k, j) {
+          p.setComponent(k, i >> j & 1 ? I.boxHi(B, k) : I.boxLo(B, k));
+        });
+        for (let e = 0; e < 2; e++) {
+          const q = e ? p.clone().addScaledVector(dn, far) : p;
+          for (let k = 0; k < 3; k++) {
+            lo[k] = Math.min(lo[k], q.getComponent(k) - 0.05);
+            hi[k] = Math.max(hi[k], q.getComponent(k) + 0.05);
+          }
+        }
+      }
+      return { lo, hi };
+    }
+    function regionCands(c, z, cands) {
+      if (!cands.some(heavy)) return cands;
+      const R = decalRegion(c, z);
+      const Mw = c.vehicle.matrixWorld;
+      return cands.map(function(o) {
+        if (!heavy(o)) return o;
+        if (!o.geometry.boundingSphere) o.geometry.computeBoundingSphere();
+        if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
+        return proxyIn(o, Mw, R);
+      });
+    }
+    function heavy(o) {
+      const g = o.geometry;
+      const pos = g && g.attributes && g.attributes.position;
+      return o.raycast === THREE.Mesh.prototype.raycast && !o.isSkinnedMesh && !Array.isArray(o.material) && pos && !pos.isInterleavedBufferAttribute && pos.itemSize === 3 && !g.groups.length && !(g.morphAttributes && g.morphAttributes.position) && (g.index ? g.index.count : pos.count) / 3 >= PROXY_MIN_TRIANGLES;
+    }
+    function proxyIn(o, Mw, R) {
+      _pm.copy(o.matrixWorld).invert().multiply(Mw);
+      const lo = [Infinity, Infinity, Infinity];
+      const hi = [-Infinity, -Infinity, -Infinity];
+      for (let i = 0; i < 8; i++) {
+        _pv.set(i & 1 ? R.hi[0] : R.lo[0], i & 2 ? R.hi[1] : R.lo[1], i & 4 ? R.hi[2] : R.lo[2]).applyMatrix4(_pm);
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], _pv.getComponent(k));
+          hi[k] = Math.max(hi[k], _pv.getComponent(k));
+        }
+      }
+      const g = o.geometry;
+      const P = g.attributes.position.array;
+      const ix = g.index ? g.index.array : null;
+      const n = ix ? ix.length : P.length / 3;
+      const keep = new Uint32Array(n - n % 3);
+      let nk = 0;
+      for (let t = 0; t + 2 < n; t += 3) {
+        const a = (ix ? ix[t] : t) * 3;
+        const b = (ix ? ix[t + 1] : t + 1) * 3;
+        const d = (ix ? ix[t + 2] : t + 2) * 3;
+        let out = false;
+        for (let k = 0; k < 3 && !out; k++) {
+          const u = P[a + k];
+          const v = P[b + k];
+          const w = P[d + k];
+          out = Math.max(u, v, w) < lo[k] || Math.min(u, v, w) > hi[k];
+        }
+        if (!out) {
+          keep[nk++] = ix ? ix[t] : t;
+          keep[nk++] = ix ? ix[t + 1] : t + 1;
+          keep[nk++] = ix ? ix[t + 2] : t + 2;
+        }
+      }
+      if (!nk) return null;
+      const kept = keep.slice(0, nk);
+      const box2 = new Float32Array(kept.length / 3 * 6);
+      for (let t = 0, j = 0; t < kept.length; t += 3, j += 6) {
+        const a = kept[t] * 3;
+        const b = kept[t + 1] * 3;
+        const d = kept[t + 2] * 3;
+        for (let k = 0; k < 3; k++) {
+          box2[j + k] = Math.min(P[a + k], P[b + k], P[d + k]);
+          box2[j + 3 + k] = Math.max(P[a + k], P[b + k], P[d + k]);
+        }
+      }
+      const pg = new THREE.BufferGeometry();
+      pg.setAttribute("position", g.attributes.position);
+      pg.setIndex(new THREE.BufferAttribute(new Uint32Array(kept.length), 1));
+      pg.boundingSphere = g.boundingSphere;
+      pg.boundingBox = g.boundingBox;
+      const proxy = new THREE.Mesh(pg, o.material);
+      proxy.layers.mask = o.layers.mask;
+      proxy.proxyOf = o;
+      proxy.kept = kept;
+      proxy.keptBox = box2;
+      return proxy;
+    }
+    function narrowTo(rc, proxy) {
+      const o = proxy.proxyOf;
+      const ray = rc.ray;
+      _pm.copy(o.matrixWorld).invert();
+      _pv.copy(ray.origin).applyMatrix4(_pm);
+      const x0 = _pv.x;
+      const y0 = _pv.y;
+      const z0 = _pv.z;
+      _pv.copy(ray.direction).multiplyScalar(rc.far).add(ray.origin).applyMatrix4(_pm);
+      const lo0 = Math.min(x0, _pv.x) - 1e-4;
+      const lo1 = Math.min(y0, _pv.y) - 1e-4;
+      const lo2 = Math.min(z0, _pv.z) - 1e-4;
+      const hi0 = Math.max(x0, _pv.x) + 1e-4;
+      const hi1 = Math.max(y0, _pv.y) + 1e-4;
+      const hi2 = Math.max(z0, _pv.z) + 1e-4;
+      const K = proxy.kept;
+      const X = proxy.keptBox;
+      const dst = proxy.geometry.index.array;
+      let m = 0;
+      for (let t = 0, j = 0; t < K.length; t += 3, j += 6) {
+        if (X[j + 3] < lo0 || X[j] > hi0 || X[j + 4] < lo1 || X[j + 1] > hi1 || X[j + 5] < lo2 || X[j + 2] > hi2) continue;
+        dst[m++] = K[t];
+        dst[m++] = K[t + 1];
+        dst[m++] = K[t + 2];
+      }
+      proxy.geometry.setDrawRange(0, m);
+    }
+    function castAt(rc, cands) {
+      for (let i = 0; i < cands.length; i++) {
+        const q = cands[i];
+        if (!q.proxyOf) continue;
+        q.matrixWorld.copy(q.proxyOf.matrixWorld);
+        narrowTo(rc, q);
+      }
+      const hits = rc.intersectObjects(cands, false);
+      for (let i = 0; i < hits.length; i++) if (hits[i].object.proxyOf) hits[i].object = hits[i].object.proxyOf;
+      return hits;
+    }
     function zoneCands(c, z, inv, glassToo) {
       const out = [];
       c.vehicle.traverse(function(o) {
@@ -6733,7 +8430,7 @@ var GameVehicles = (() => {
         });
         _zr.set(org.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
         _zr.far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
-        const hits = _zr.intersectObjects(cands, false);
+        const hits = castAt(_zr, cands);
         for (let i = 0; i < hits.length; i++) {
           const h = hits[i];
           if (!h.face) continue;
@@ -6761,7 +8458,7 @@ var GameVehicles = (() => {
         const q = s.p.clone().addScaledVector(t, len * 0.5 * k / M);
         _rt.set(q.clone().addScaledVector(n, 0.08).applyMatrix4(Mw), n.clone().negate().transformDirection(Mw));
         _rt.far = 0.2;
-        const h = _rt.intersectObjects(cands, false).find(function(x) {
+        const h = castAt(_rt, cands).find(function(x) {
           return x.face;
         });
         if (!h) return null;
@@ -6832,6 +8529,7 @@ var GameVehicles = (() => {
       const R = c.rand;
       const need = (spec.fine || 0) + (spec.deep || 0) + (spec.chip || 0) + (spec.rust || 0) + (spec.tear || 0) + (spec.ding || 0) + (spec.soot || 0) + (spec.crater || 0);
       if (!need) return [];
+      cands = regionCands(c, z, cands).filter(Boolean);
       const S = zoneSurf(c, z, need + 2, R, cands);
       let k = 0;
       const ang0 = R() * PI;
@@ -6912,8 +8610,25 @@ var GameVehicles = (() => {
     }
     function subdivIn(geo, rel, B, maxLen) {
       const a = geo.attributes.position.array;
-      const out = [];
-      const v = new V3();
+      let out = new Float32Array(a.length + 4096);
+      let used = 0;
+      const push = function(a0, a1, a2, b0, b1, b2, c0, c1, c2) {
+        if (used + 9 > out.length) {
+          const bigger = new Float32Array(out.length * 2);
+          bigger.set(out);
+          out = bigger;
+        }
+        out[used] = a0;
+        out[used + 1] = a1;
+        out[used + 2] = a2;
+        out[used + 3] = b0;
+        out[used + 4] = b1;
+        out[used + 5] = b2;
+        out[used + 6] = c0;
+        out[used + 7] = c1;
+        out[used + 8] = c2;
+        used += 9;
+      };
       const e = 0.15;
       function d(p, q) {
         return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
@@ -6927,7 +8642,7 @@ var GameVehicles = (() => {
         const ca = d(C, A);
         const mx = Math.max(ab, bc, ca);
         if (mx <= maxLen || depth > 9) {
-          out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
+          push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
           return;
         }
         if (mx === ab) {
@@ -6944,31 +8659,26 @@ var GameVehicles = (() => {
           tri(F2, Bv, C, depth + 1);
         }
       }
+      const M = rel.elements;
+      const at = function(x, y, z, k) {
+        const w = 1 / (M[3] * x + M[7] * y + M[11] * z + M[15]);
+        return k === 0 ? (M[0] * x + M[4] * y + M[8] * z + M[12]) * w : k === 1 ? (M[1] * x + M[5] * y + M[9] * z + M[13]) * w : (M[2] * x + M[6] * y + M[10] * z + M[14]) * w;
+      };
+      const lo = [B.x0 - e, B.y0 - e, B.z0 - e];
+      const hi = [B.x1 + e, B.y1 + e, B.z1 + e];
       for (let i = 0; i < a.length; i += 9) {
-        const A = [a[i], a[i + 1], a[i + 2]];
-        const Bv = [a[i + 3], a[i + 4], a[i + 5]];
-        const C = [a[i + 6], a[i + 7], a[i + 8]];
-        let x0 = 1e9;
-        let x1 = -1e9;
-        let y0 = 1e9;
-        let y1 = -1e9;
-        let z0 = 1e9;
-        let z1 = -1e9;
-        [A, Bv, C].forEach(function(p) {
-          v.set(p[0], p[1], p[2]).applyMatrix4(rel);
-          x0 = Math.min(x0, v.x);
-          x1 = Math.max(x1, v.x);
-          y0 = Math.min(y0, v.y);
-          y1 = Math.max(y1, v.y);
-          z0 = Math.min(z0, v.z);
-          z1 = Math.max(z1, v.z);
-        });
-        if (x1 < B.x0 - e || x0 > B.x1 + e || y1 < B.y0 - e || y0 > B.y1 + e || z1 < B.z0 - e || z0 > B.z1 + e)
-          out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
-        else tri(A, Bv, C, 0);
+        let outside = false;
+        for (let k = 0; k < 3 && !outside; k++) {
+          const p = at(a[i], a[i + 1], a[i + 2], k);
+          const q = at(a[i + 3], a[i + 4], a[i + 5], k);
+          const r = at(a[i + 6], a[i + 7], a[i + 8], k);
+          outside = Math.max(p, q, r) < lo[k] || Math.min(p, q, r) > hi[k];
+        }
+        if (outside) push(a[i], a[i + 1], a[i + 2], a[i + 3], a[i + 4], a[i + 5], a[i + 6], a[i + 7], a[i + 8]);
+        else tri([a[i], a[i + 1], a[i + 2]], [a[i + 3], a[i + 4], a[i + 5]], [a[i + 6], a[i + 7], a[i + 8]], 0);
       }
       const g = new THREE.BufferGeometry();
-      g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+      g.setAttribute("position", new THREE.BufferAttribute(out.slice(0, used), 3));
       g.userData.crease = true;
       g.userData.p0 = null;
       return g;
@@ -6991,6 +8701,17 @@ var GameVehicles = (() => {
       });
       return out;
     }
+    function boxInFrame(B, m, tmp) {
+      const r = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+      for (let i = 0; i < 8; i++) {
+        tmp.set(i & 1 ? B.x1 : B.x0, i & 2 ? B.y1 : B.y0, i & 4 ? B.z1 : B.z0).applyMatrix4(m);
+        for (let k = 0; k < 3; k++) {
+          r[k] = Math.min(r[k], tmp.getComponent(k) - 1e-4);
+          r[k + 3] = Math.max(r[k + 3], tmp.getComponent(k) + 1e-4);
+        }
+      }
+      return r;
+    }
     function zoneDent(c, z, dents, dirty, opt) {
       opt = opt || {};
       const B = z.box;
@@ -7045,6 +8766,7 @@ var GameVehicles = (() => {
           g = msh.geometry = g.clone();
           msh.userData.zCloned = true;
         }
+        let boundsDue = false;
         const nonIdx = !g.index;
         const onlyPos = Object.keys(g.attributes).every(function(k) {
           return k === "position" || k === "normal";
@@ -7053,15 +8775,17 @@ var GameVehicles = (() => {
           const ng = subdivIn(g, rel, B, opt.sub || 0.075);
           g.dispose();
           g = msh.geometry = ng;
-          ng.computeBoundingSphere();
-          ng.computeBoundingBox();
+          boundsDue = true;
           dirty.add(msh);
         }
         irel.copy(rel).invert();
         const pos = g.attributes.position;
         let changed = false;
+        const near = boxInFrame(B, irel, v);
         for (let i = 0; i < pos.count; i++) {
-          v.fromBufferAttribute(pos, i).applyMatrix4(rel);
+          v.fromBufferAttribute(pos, i);
+          if (v.x < near[0] || v.x > near[3] || v.y < near[1] || v.y > near[4] || v.z < near[2] || v.z > near[5]) continue;
+          v.applyMatrix4(rel);
           const f = field(v);
           if (f <= 1e-5) continue;
           v.addScaledVector(d, f);
@@ -7082,9 +8806,11 @@ var GameVehicles = (() => {
         }
         if (changed) {
           pos.needsUpdate = true;
+          dirty.add(msh);
+        }
+        if (changed || boundsDue) {
           g.computeBoundingSphere();
           g.computeBoundingBox();
-          dirty.add(msh);
         }
       });
       const dset = new Set(c.deform);
@@ -8170,9 +9896,9 @@ var GameVehicles = (() => {
         down: new V3(0, 1, 0)
       }[d] || null;
     }
-    function resolveObjs(c, list, z) {
+    function resolveObjs(c, list2, z) {
       const out = [];
-      (list || []).forEach(function(o) {
+      (list2 || []).forEach(function(o) {
         if (!o) return;
         if (typeof o === "string") {
           c.parts.forEach(function(p) {
@@ -8200,22 +9926,22 @@ var GameVehicles = (() => {
     }
     function deriveZones(c) {
       const m = c.meta;
-      let list = [];
+      let list2 = [];
       const byId = {};
       (m.zones === false ? [] : I.autoZones(c)).forEach(function(z) {
         byId[z.id] = z;
-        list.push(z);
+        list2.push(z);
       });
       (c.zoneDefs || []).forEach(function(d) {
         let z = byId[d.id];
         if (d.remove) {
           if (z) {
-            list.splice(list.indexOf(z), 1);
+            list2.splice(list2.indexOf(z), 1);
             delete byId[d.id];
           }
-          list.slice().forEach(function(q) {
+          list2.slice().forEach(function(q) {
             if (q.id.indexOf(d.id + "_") === 0 && /^\d+$/.test(q.id.slice(d.id.length + 1))) {
-              list.splice(list.indexOf(q), 1);
+              list2.splice(list2.indexOf(q), 1);
               delete byId[q.id];
             }
           });
@@ -8228,7 +9954,7 @@ var GameVehicles = (() => {
         } else {
           z = Object.assign({ type: "panel" }, d);
           byId[d.id] = z;
-          list.push(z);
+          list2.push(z);
         }
       });
       const inv = I.worldInverseOf(c);
@@ -8261,10 +9987,10 @@ var GameVehicles = (() => {
         }
         z.box = I.normalizeBox(bb);
       });
-      list = list.filter(function(z) {
+      list2 = list2.filter(function(z) {
         return z.box && z.name;
       });
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         z.glass = (z.glass || []).slice();
         z.lights = (z.lights || []).slice();
         z.wheels = (z.wheels || []).slice();
@@ -8301,7 +10027,7 @@ var GameVehicles = (() => {
         if (owner.has(g) || !g.parent || !g.userData.glass || g.userData.ghost) return;
         const cg = I.localBox(c, g, inv).getCenter(new V3());
         let best = null;
-        list.forEach(function(z) {
+        list2.forEach(function(z) {
           if (z.internal || z.type === "wheel" || z.type === "light") return;
           if (I.boxContains(z.box, cg.x, cg.y, cg.z, 0.05) && (!best || I.boxVolume(z.box) < I.boxVolume(best.box))) best = z;
         });
@@ -8310,7 +10036,7 @@ var GameVehicles = (() => {
           owner.set(g, best);
         }
       });
-      const looseParts = list.filter(function(z) {
+      const looseParts = list2.filter(function(z) {
         return z.type === "part";
       });
       if (looseParts.length)
@@ -8335,7 +10061,7 @@ var GameVehicles = (() => {
             });
           }
         });
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         if (!z.mirror) return;
         z.mirrors = [];
         const B = z.box;
@@ -8367,21 +10093,21 @@ var GameVehicles = (() => {
           });
         }
       });
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         const B = z.box;
         z.map = z.map || [Math.max(B.x0, R - 0.3), Math.min(B.x1, F + 0.3), Math.max(B.z0, -W / 2 - 0.35), Math.min(B.z1, W / 2 + 0.35)];
       });
-      carMap(c, list);
+      carMap(c, list2);
       c.zoneOwners = owner;
-      return list;
+      return list2;
     }
-    function carMap(c, list) {
+    function carMap(c, list2) {
       const m = c.meta;
       const W = m.width || 1.7;
       const hw = W / 2;
       const gh = m.glasshouse;
       if ((m.kind || "car") !== "car" || !gh || gh.fb == null) return;
-      list.forEach(function(z) {
+      list2.forEach(function(z) {
         if (z.mapSet) return;
         const B = z.box;
         const s = z.side;
@@ -8446,8 +10172,8 @@ var GameVehicles = (() => {
       const top = m.top || belt + 0.5;
       const hw = W / 2;
       const WH = I.wheelInfo(c);
-      function add(id, name, type, box, o) {
-        const z = Object.assign({ id, name, type, box: I.normalizeBox(box) }, o || {});
+      function add(id, name, type, box2, o) {
+        const z = Object.assign({ id, name, type, box: I.normalizeBox(box2) }, o || {});
         Z.push(z);
         return z;
       }
@@ -9951,9 +11677,9 @@ var GameVehicles = (() => {
         const kind = kindOf2(zone);
         if (!kind || !zone.box) continue;
         const b = zone.box;
-        const box = new THREE.Box3(new THREE.Vector3(b.x0, b.y0, b.z0), new THREE.Vector3(b.x1, b.y1, b.z1));
-        if (matrix) box.applyMatrix4(matrix);
-        out.push({ material: kind.material, zone: zone.id, part: kind.part, side: zone.side === 0 ? "center" : zone.side < 0 ? "left" : "right", box });
+        const box2 = new THREE.Box3(new THREE.Vector3(b.x0, b.y0, b.z0), new THREE.Vector3(b.x1, b.y1, b.z1));
+        if (matrix) box2.applyMatrix4(matrix);
+        out.push({ material: kind.material, zone: zone.id, part: kind.part, side: zone.side === 0 ? "center" : zone.side < 0 ? "left" : "right", box: box2 });
       }
       return out;
     };
@@ -9964,7 +11690,7 @@ var GameVehicles = (() => {
     const opts = options || {};
     if (!opts.THREE || !opts.THREE.Vector3) throw new Error("createVehicleKit: options.THREE (the three.js namespace) is required");
     const lod = createLod(opts.lod);
-    const THREE = wrapThreeForLod(opts.THREE, lod);
+    const THREE = wrapThreeForLod(shapeGeometries(opts.THREE), lod);
     const strings = resolveStrings(opts.locale);
     const t = createTranslate(strings);
     const doc = opts.document || (typeof document !== "undefined" ? document : void 0);
@@ -10187,6 +11913,20 @@ var GameVehicles = (() => {
         else kit.applyArmor(c);
       }
       if (zoneState == null && st === "damaged" && kit.config.damagedScenario) zoneState = kit.zoneScenario(c, kit.config.damagedScenario);
+      else if (zoneState && zoneState.scenario != null) {
+        c.scenario = zoneState.scenario;
+        let fromScenario = { health: {}, flags: {} };
+        try {
+          fromScenario = kit.zoneScenario(c, zoneState.scenario);
+        } catch (e) {
+          ;
+          (c.zoneErrors = c.zoneErrors || []).push("scenario: " + (e && e.message));
+        }
+        zoneState = {
+          health: Object.assign({}, fromScenario.health, zoneState.health),
+          flags: Object.assign({}, fromScenario.flags, zoneState.flags)
+        };
+      }
       if (zoneState) kit.applyZones(c, zoneState);
       else {
         c.zoneState = { health: {}, flags: {} };
@@ -10225,6 +11965,51 @@ var GameVehicles = (() => {
     return kit;
   }
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_IGNITION_RULES = {
+    fillCurve: [
+      [0, 0.6],
+      [0.1, 1],
+      [0.35, 0.6],
+      [0.65, 0.3],
+      [0.9, 0.15],
+      [1, 0.12]
+    ],
+    flameFillInfluence: 0.5,
+    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
+    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
+    sparkMetalDefault: 0.5,
+    sparkFluid: { diesel: 0.15 },
+    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
+  };
+  var resolveIgnitionRules = (rules) => ({
+    ...DEFAULT_IGNITION_RULES,
+    ...rules,
+    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
+    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
+    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
+    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
+  });
+  var fillFactor = (fill, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
+    if (curve.length === 0) return 1;
+    const f = Math.min(1, Math.max(0, fill));
+    if (f <= curve[0][0]) return curve[0][1];
+    for (let i = 1; i < curve.length; i++) {
+      const [x1, y1] = curve[i];
+      const [x0, y0] = curve[i - 1];
+      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    }
+    return curve[curve.length - 1][1];
+  };
+  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
+  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
+    const k = fillFactor(target.fill, rules.fillCurve);
+    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
+    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
+    const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
+    return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
+  };
+
   // src/destructible/model.ts
   var JOINT_RULES = {
     hinge: { strength: 5e3, tools: ["wrench", "screwdriver"], seconds: 3 },
@@ -10352,19 +12137,19 @@ var GameVehicles = (() => {
     for (const z of zones) {
       let role = roleOfZone(z);
       if (z === hubZone) role = "frame";
-      const box = boxOf(z);
-      const area = areaOf(box.size);
+      const box2 = boxOf(z);
+      const area3 = areaOf(box2.size);
       const id = z.id;
       const label = String(z.name ?? id);
       const tags = [...z.tags ?? []];
       if (role === "rim") {
         const wheels = z.wheels ?? [];
         const r = Math.max(0.2, ...wheels.map((w) => w.userData?.r ?? 0.3));
-        const sz = Math.sign(box.center[2]) || 1;
-        const rimBox = { center: [box.center[0], box.center[1], box.center[2] - sz * box.size[2] * 0.25], size: [box.size[0] * 0.7, box.size[1] * 0.7, box.size[2] * 0.5] };
+        const sz = Math.sign(box2.center[2]) || 1;
+        const rimBox = { center: [box2.center[0], box2.center[1], box2.center[2] - sz * box2.size[2] * 0.25], size: [box2.size[0] * 0.7, box2.size[1] * 0.7, box2.size[2] * 0.5] };
         add({ id, role, name: label, material: kind === "plane" || kind === "heli" ? "aluminium" : "steel", box: rimBox, mass: 22 * r * Math.max(1, wheels.length), hp: 12e3 * armour, zoneId: id, visual: kind !== "plane" && !/landing/.test(id), tags: ["wheel", ...tags] });
         const tyreId = id.replace(/^wheels?/, "tyre").replace(/^(?!tyre)/, "tyre_");
-        const tyreBox = { center: box.center, size: [box.size[0] * 0.98, box.size[1] * 0.98, box.size[2]] };
+        const tyreBox = { center: box2.center, size: [box2.size[0] * 0.98, box2.size[1] * 0.98, box2.size[2]] };
         add({
           id: tyreId,
           role: "tyre",
@@ -10384,29 +12169,29 @@ var GameVehicles = (() => {
       if (role === "glass") {
         const glass = (z.glass ?? [])[0];
         const laminated = glass?.userData?.glass?.type === "laminated" || m.bullet;
-        add({ id, role, name: label, material: "glass", box, mass: 10 * area, hp: laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
+        add({ id, role, name: label, material: "glass", box: box2, mass: 10 * area3, hp: laminated ? 4e3 : 450, zoneId: id, visual: false, tags: ["glass", ...tags] });
         continue;
       }
       if (role === "light") {
-        add({ id, role, name: label, material: "glass", box, mass: 1.2 + 4 * area, hp: 320, zoneId: id, visual: true, tags: ["light", ...tags] });
+        add({ id, role, name: label, material: "glass", box: box2, mass: 1.2 + 4 * area3, hp: 320, zoneId: id, visual: true, tags: ["light", ...tags] });
         continue;
       }
       if (role === "bumper") {
-        add({ id, role, name: label, material: "plastic", box, mass: 6 + 5 * area, hp: 9e3, ignitionC: 400, zoneId: id, visual: true, tags: ["bumper", ...tags] });
+        add({ id, role, name: label, material: "plastic", box: box2, mass: 6 + 5 * area3, hp: 9e3, ignitionC: 400, zoneId: id, visual: true, tags: ["bumper", ...tags] });
         continue;
       }
       if (role === "engine") {
         const kg2 = { bike: 55, quad: 90, car: 150, tractor: 450, truck: 600, bus: 450, tank: 900, boat: 90, plane: 160, heli: 150 }[kind];
-        add({ id, role, name: label, material: kind === "plane" || kind === "heli" ? "aluminium" : "steel", box, mass: kg2, hp: 6e4 * armour, ignitionC: 260, zoneId: id, visual: false, tags: ["engine", ...tags] });
+        add({ id, role, name: label, material: kind === "plane" || kind === "heli" ? "aluminium" : "steel", box: box2, mass: kg2, hp: 6e4 * armour, ignitionC: 260, zoneId: id, visual: false, tags: ["engine", ...tags] });
         continue;
       }
       if (role === "radiator") {
-        add({ id, role, name: label, material: "aluminium", box, mass: 8, hp: 3e3, zoneId: id, visual: false, contains: { fluid: "coolant", liters: kind === "truck" || kind === "bus" ? 18 : 7, pressurized: true }, tags: ["radiator", ...tags] });
+        add({ id, role, name: label, material: "aluminium", box: box2, mass: 8, hp: 3e3, zoneId: id, visual: false, contains: { fluid: "coolant", liters: kind === "truck" || kind === "bus" ? 18 : 7, pressurized: true }, tags: ["radiator", ...tags] });
         continue;
       }
       if (role === "fuel_tank") {
         if (fuelless) {
-          add({ id, role: "other", name: label, material: "steel", box, mass: 20, hp: 25e3, zoneId: id, visual: false, tags });
+          add({ id, role: "other", name: label, material: "steel", box: box2, mass: 20, hp: 25e3, zoneId: id, visual: false, tags });
           continue;
         }
         const liters = { bike: 14, quad: 16, car: 55, tractor: 150, truck: 300, bus: 200, tank: 600, boat: 90, plane: 120, heli: 300 }[kind];
@@ -10416,7 +12201,7 @@ var GameVehicles = (() => {
           role,
           name: label,
           material: "steel",
-          box,
+          box: box2,
           mass: 14 + liters * 0.8,
           hp: 25e3 * armour,
           zoneId: id,
@@ -10429,21 +12214,21 @@ var GameVehicles = (() => {
         continue;
       }
       if (role === "battery") {
-        add({ id, role, name: label, material: "plastic", box, mass: 14, hp: 1500, zoneId: id, visual: true, ignitionC: 200, tags: ["battery", ...tags] });
+        add({ id, role, name: label, material: "plastic", box: box2, mass: 14, hp: 1500, zoneId: id, visual: true, ignitionC: 200, tags: ["battery", ...tags] });
         continue;
       }
       if (role === "frame") {
-        add({ id, role, name: label, material: "steel", box: floorPan(box), mass: mass * 0.25, hp: 15e4 * armour, zoneId: id, visual: false, tags: ["frame", ...tags] });
+        add({ id, role, name: label, material: "steel", box: floorPan(box2), mass: mass * 0.25, hp: 15e4 * armour, zoneId: id, visual: false, tags: ["frame", ...tags] });
         continue;
       }
       const roofLike = role === "roof";
-      const kg = (skin === "steel" ? STEEL_KG_M2 : ALU_KG_M2) * area * (role === "door" ? 1.6 : 1);
+      const kg = (skin === "steel" ? STEEL_KG_M2 : ALU_KG_M2) * area3 * (role === "door" ? 1.6 : 1);
       add({
         id,
         role,
         name: label,
         material: skin,
-        box,
+        box: box2,
         mass: Math.max(2, kg),
         hp: (roofLike ? 3e4 : 2e4) * armour,
         zoneId: id,
@@ -10665,7 +12450,7 @@ var GameVehicles = (() => {
       const my = kind === "bike" || kind === "quad" ? (m.top ?? belt + 0.25) - 0.1 : belt + 0.12;
       for (const s of [-1, 1]) {
         const door = zones.find((z) => z.type === "door" && z.side === s && (z.mirrors ?? []).length);
-        let box = { center: [mx, my, s * half], size: [0.14, 0.12, 0.2] };
+        let box2 = { center: [mx, my, s * half], size: [0.14, 0.12, 0.2] };
         if (door) {
           const bb = door.mirrors.reduce(
             (acc, o) => {
@@ -10678,14 +12463,14 @@ var GameVehicles = (() => {
             },
             null
           );
-          if (bb) box = { center: [(bb[0] + bb[1]) / 2, (bb[2] + bb[3]) / 2, (bb[4] + bb[5]) / 2], size: [Math.max(0.06, bb[1] - bb[0]), Math.max(0.06, bb[3] - bb[2]), Math.max(0.06, bb[5] - bb[4])] };
+          if (bb) box2 = { center: [(bb[0] + bb[1]) / 2, (bb[2] + bb[3]) / 2, (bb[4] + bb[5]) / 2], size: [Math.max(0.06, bb[1] - bb[0]), Math.max(0.06, bb[3] - bb[2]), Math.max(0.06, bb[5] - bb[4])] };
         }
         add({
           id: `mirror_${side(s)}`,
           role: "mirror",
           name: t("mechanics.mirror", { side: t(`sides.${side(s)}`), sideM: t(`sides.${side(s)}M`) }),
           material: "plastic",
-          box,
+          box: box2,
           mass: 1.1,
           hp: 1500,
           ignitionC: 400,
@@ -10875,13 +12660,13 @@ var GameVehicles = (() => {
       (parent ?? this.c.vehicle).add(m);
       return m;
     }
-    surface(axis, sign, B, samples) {
+    surface(axis, sign2, B, samples) {
       const V3 = this.THREE.Vector3;
       const hits = [];
       const far = 3;
       for (const [u, v] of samples) {
-        const o = axis === "z" ? new V3(u, v, sign * (Math.max(Math.abs(B.z0), Math.abs(B.z1)) + 1)) : new V3(sign * (Math.max(Math.abs(B.x0), Math.abs(B.x1)) + 1), u, v);
-        const d = axis === "z" ? new V3(0, 0, -sign) : new V3(-sign, 0, 0);
+        const o = axis === "z" ? new V3(u, v, sign2 * (Math.max(Math.abs(B.z0), Math.abs(B.z1)) + 1)) : new V3(sign2 * (Math.max(Math.abs(B.x0), Math.abs(B.x1)) + 1), u, v);
+        const d = axis === "z" ? new V3(0, 0, -sign2) : new V3(-sign2, 0, 0);
         const h = this.I.probe(this.c, o, d, far);
         if (h) hits.push(axis === "z" ? h.p.z : h.p.x);
       }
@@ -11031,12 +12816,12 @@ var GameVehicles = (() => {
       const z = this.zone(p);
       if (!z) return false;
       const V3 = this.THREE.Vector3;
-      const list = z.glass.filter((g) => g.parent && g.visible);
-      if (!list.length) return false;
+      const list2 = z.glass.filter((g) => g.parent && g.visible);
+      if (!list2.length) return false;
       const pt = new V3(...point);
-      let best = list[0];
+      let best = list2[0];
       let bd = Infinity;
-      for (const g of list) {
+      for (const g of list2) {
         g.geometry.computeBoundingBox();
         const bb = g.geometry.boundingBox.clone().applyMatrix4(g.matrix);
         const d = bb.distanceToPoint(pt);
@@ -11337,6 +13122,9 @@ var GameVehicles = (() => {
     const headless = !!options.headless;
     const seedBase = strHash(`${c.key}|${id}|${options.seed ?? 0}`);
     let rand = rng(seedBase);
+    const ignitionRules = resolveIgnitionRules(options.ignition);
+    const fuelFraction = clamp(options.fuel ?? 1, 0, 1);
+    let igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
     let clock = 0;
     let model;
     let vis = null;
@@ -11404,7 +13192,7 @@ var GameVehicles = (() => {
           dents: [],
           holes: [],
           cracks: [],
-          liters: d.contains?.liters,
+          liters: d.contains ? d.role === "fuel_tank" ? d.contains.liters * fuelFraction : d.contains.liters : void 0,
           lost: false,
           status: "intact",
           flat: false,
@@ -11422,6 +13210,7 @@ var GameVehicles = (() => {
       wasLit = true;
       deadEngine = false;
       rand = rng(seedBase);
+      igniteRand = rng(strHash(`${c.key}|${id}|ignition|${options.seed ?? 0}`));
       steerSign = rand() < 0.5 ? -1 : 1;
       vis = headless ? null : new VehicleVisuals(kit, c, model);
       recomputeGroups();
@@ -11443,8 +13232,8 @@ var GameVehicles = (() => {
         comps.get(r).push(p);
       }
       const hubRoot = parent.has(model.hub) ? find(model.hub) : "";
-      const list = [...comps.entries()].sort((a, b) => a[0] === hubRoot ? -1 : b[0] === hubRoot ? 1 : 0);
-      groupsCache = list.map(([, v]) => v);
+      const list2 = [...comps.entries()].sort((a, b) => a[0] === hubRoot ? -1 : b[0] === hubRoot ? 1 : 0);
+      groupsCache = list2.map(([, v]) => v);
       groupOf = /* @__PURE__ */ new Map();
       groupsCache.forEach((g, i) => g.forEach((p) => groupOf.set(p, i)));
       return groupsCache;
@@ -11716,8 +13505,19 @@ var GameVehicles = (() => {
         if (!p.burning && p.temp > AMBIENT) p.temp = Math.max(AMBIENT, p.temp - dt * 6);
       }
       for (const f of flames) heat(centreOf(f.def), 0.8, 500, dt * 0.5, out, 0);
+      fireNearLeak(flames, dt, out);
       thermal(out);
     };
+    const fireNearLeak = (flames, dt, out) => {
+      const tank = tankPart();
+      const leak = tank ? leaks.get(tank.def.id) : void 0;
+      if (!tank || !leak || tank.lost || tank.burning || exploded || leak.fluid !== "fuel" && leak.fluid !== "diesel") return;
+      if (leak.pud?.fire) return light(tank, out);
+      const { radius, chancePerSecond } = ignitionRules.fireNear;
+      if (chancePerSecond <= 0) return;
+      const near = flames.some((f) => f !== tank && distToBox(tank.def, centreOf(f.def)) - Math.max(...f.def.box.size) / 2 <= radius);
+      if (near && igniteRand() < 1 - Math.exp(-chancePerSecond * dt)) light(tank, out);
+    };
     const normalOf = (d, v) => faceNormal(d, v);
     const ballistic = (h, out) => {
       sync();
@@ -11785,10 +13585,21 @@ var GameVehicles = (() => {
           let amount = through ? E * 0.6 : E * 0.25;
           if (through && (d.role === "battery" || d.role === "alternator")) amount = Math.max(amount, p.hp * 0.65);
           damage(p, amount, "ballistic", h.source, out, worldPoint);
-          if (d.role === "fuel_tank" && E > 1500 && (p.liters ?? 0) > 1) p.temp = Math.max(p.temp, d.ignitionC ?? 260);
+          if (through && d.role === "fuel_tank") rollIgnition(p, h, metal, out);
         }
       }
     };
+    const light = (tank, out) => {
+      tank.temp = Math.max(tank.temp, (tank.def.ignitionC ?? 260) + 1);
+      if ((tank.liters ?? 0) > 0.5) ignite(tank, out);
+    };
+    const rollIgnition = (tank, h, metal, out) => {
+      const d = tank.def;
+      if (!d.contains || tank.burning || (tank.liters ?? 0) <= 0.05) return;
+      const fill = d.contains.liters > 0 ? (tank.liters ?? 0) / d.contains.liters : 0;
+      const chance = ignitionChance(h, { sparkTarget: sparkTargetFactor(d.material, metal, ignitionRules), fill, fluid: d.contains.fluid }, ignitionRules);
+      if (chance > 0 && igniteRand() < chance) light(tank, out);
+    };
     const blunt = (h, out) => {
       sync();
       const M = toFrameMatrix();
@@ -11852,7 +13663,7 @@ var GameVehicles = (() => {
           const verdict = kit.blastDamage(c, E / (1 + dist * dist * 4) / 50);
           if (verdict === "explosion") explode(tank, h.source, out);
           else if (verdict === "fire") {
-            tank.temp = Math.max(tank.temp, tank.def.ignitionC ?? 260);
+            light(tank, out);
             startLeak(tank, centreOf(tank.def).setY(tank.def.box.center[1] - tank.def.box.size[1] / 2 + 0.05), 12, out, dir);
           }
         }
@@ -11866,9 +13677,9 @@ var GameVehicles = (() => {
       thermal(out);
     };
     const sound = (role) => {
-      const list = [...ps.values()].filter((p) => p.def.role === role);
-      if (!list.length) return true;
-      return list.every((p) => !p.lost && attached(p.def.id) && p.hp >= p.def.hp * 0.5);
+      const list2 = [...ps.values()].filter((p) => p.def.role === role);
+      if (!list2.length) return true;
+      return list2.every((p) => !p.lost && attached(p.def.id) && p.hp >= p.def.hp * 0.5);
     };
     const tankPart = () => [...ps.values()].find((p) => p.def.role === "fuel_tank" && p.def.contains);
     const computeStatus = () => {
@@ -12060,8 +13871,8 @@ var GameVehicles = (() => {
       queue = [];
       const hood = c.hood;
       if (hood) {
-        const sign = hood.sign || 1;
-        const cur = hood.piv.rotation.z / sign;
+        const sign2 = hood.sign || 1;
+        const cur = hood.piv.rotation.z / sign2;
         if (Math.abs(cur - hood.ang) > 1e-4) {
           hood.ang = cur;
           hood.target = cur;
@@ -12114,7 +13925,7 @@ var GameVehicles = (() => {
     const reset = () => {
       const old = c;
       const parent = old.root.parent;
-      const next = kit.build(old.key, old.state);
+      const next = kit.build(old.key, old.state, old.scenario != null ? { scenario: old.scenario } : void 0);
       if (parent) {
         next.root.position.copy(old.root.position);
         next.root.quaternion.copy(old.root.quaternion);
@@ -12171,7 +13982,8 @@ var GameVehicles = (() => {
   // src/destructible/item.ts
   function buildVehicleItem(kit, key, options = {}) {
     const THREE = kit.THREE;
-    const vehicle = options.lod ? kit.build(key, options.state ?? "intact", void 0, { lod: true }) : kit.build(key, options.state ?? "intact");
+    const zoneState = options.scenario != null ? { scenario: options.scenario } : void 0;
+    const vehicle = options.lod ? kit.build(key, options.state ?? "intact", zoneState, { lod: true }) : kit.build(key, options.state ?? "intact", zoneState);
     const m = vehicle.meta;
     const root = new THREE.Group();
     root.name = key;