@adatechnology/game-urban-three 0.1.0 → 0.2.1

package/dist/index.global.js

@@ -36,10 +36,1528 @@ var GameUrbanThree = (() => {
     loadUrbanTestModule: () => loadUrbanTestModule
   });
 
+  // ../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, tube2 = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) {
+    const parameters = { radius, tube: tube2, radialSegments, tubularSegments, arc };
+    radialSegments = Math.floor(radialSegments);
+    tubularSegments = Math.floor(tubularSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let j = 0; j <= radialSegments; j++) {
+      for (let i = 0; i <= tubularSegments; i++) {
+        const u = i / tubularSegments * arc;
+        const v = j / radialSegments * Math.PI * 2;
+        const x = (radius + tube2 * Math.cos(v)) * Math.cos(u);
+        const y = (radius + tube2 * Math.cos(v)) * Math.sin(u);
+        const z = tube2 * Math.sin(v);
+        vertices.push(x, y, z);
+        const cx = radius * Math.cos(u);
+        const cy = radius * Math.sin(u);
+        const n = normalize3(x - cx, y - cy, z - 0);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(i / tubularSegments);
+        uvs.push(j / radialSegments);
+      }
+    }
+    for (let j = 1; j <= radialSegments; j++) {
+      for (let i = 1; i <= tubularSegments; i++) {
+        const a = (tubularSegments + 1) * j + i - 1;
+        const b = (tubularSegments + 1) * (j - 1) + i - 1;
+        const c = (tubularSegments + 1) * (j - 1) + i;
+        const d = (tubularSegments + 1) * j + i;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("TorusGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function difference(size, subtract) {
+    const [w, h, d] = size;
+    const hw = w / 2;
+    const hh = h / 2;
+    const hd = d / 2;
+    const holes = subtract.map((hole) => ({ x0: Math.max(-hw, Math.min(hole.min[0], hole.max[0])), x1: Math.min(hw, Math.max(hole.min[0], hole.max[0])), y0: Math.max(-hh, Math.min(hole.min[1], hole.max[1])), y1: Math.min(hh, Math.max(hole.min[1], hole.max[1])) })).filter((hole) => hole.x1 > hole.x0 && hole.y1 > hole.y0);
+    const cuts = (lo, hi, values) => [.../* @__PURE__ */ new Set([lo, hi, ...values.filter((v) => v > lo && v < hi)])].sort((a, b) => a - b);
+    const xs = cuts(-hw, hw, holes.flatMap((hole) => [hole.x0, hole.x1]));
+    const ys = cuts(-hh, hh, holes.flatMap((hole) => [hole.y0, hole.y1]));
+    const nx = xs.length - 1;
+    const ny = ys.length - 1;
+    const solid = (i, j) => {
+      if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+      const cx = (xs[i] + xs[i + 1]) / 2;
+      const cy = (ys[j] + ys[j + 1]) / 2;
+      return !holes.some((hole) => cx > hole.x0 && cx < hole.x1 && cy > hole.y0 && cy < hole.y1);
+    };
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    const quad = (corners, normal, uv) => {
+      const base = positions.length / 3;
+      for (let k = 0; k < 4; k++) {
+        positions.push(...corners[k]);
+        normals.push(...normal);
+        uvs.push(...uv[k]);
+      }
+      indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    };
+    const fu = (x) => (x + hw) / w;
+    const fv = (y) => (y + hh) / h;
+    for (let j = 0; j < ny; j++) {
+      for (let i = 0; i < nx; i++) {
+        if (!solid(i, j)) continue;
+        const x0 = xs[i];
+        const x1 = xs[i + 1];
+        const y0 = ys[j];
+        const y1 = ys[j + 1];
+        quad([[x0, y0, hd], [x1, y0, hd], [x1, y1, hd], [x0, y1, hd]], [0, 0, 1], [[fu(x0), fv(y0)], [fu(x1), fv(y0)], [fu(x1), fv(y1)], [fu(x0), fv(y1)]]);
+        quad([[x1, y0, -hd], [x0, y0, -hd], [x0, y1, -hd], [x1, y1, -hd]], [0, 0, -1], [[1 - fu(x1), fv(y0)], [1 - fu(x0), fv(y0)], [1 - fu(x0), fv(y1)], [1 - fu(x1), fv(y1)]]);
+        const zu = (z) => (z + hd) / d;
+        if (!solid(i - 1, j)) quad([[x0, y0, -hd], [x0, y0, hd], [x0, y1, hd], [x0, y1, -hd]], [-1, 0, 0], [[zu(-hd), fv(y0)], [zu(hd), fv(y0)], [zu(hd), fv(y1)], [zu(-hd), fv(y1)]]);
+        if (!solid(i + 1, j)) quad([[x1, y0, hd], [x1, y0, -hd], [x1, y1, -hd], [x1, y1, hd]], [1, 0, 0], [[zu(hd), fv(y0)], [zu(-hd), fv(y0)], [zu(-hd), fv(y1)], [zu(hd), fv(y1)]]);
+        if (!solid(i, j - 1)) quad([[x0, y0, -hd], [x1, y0, -hd], [x1, y0, hd], [x0, y0, hd]], [0, -1, 0], [[fu(x0), zu(-hd)], [fu(x1), zu(-hd)], [fu(x1), zu(hd)], [fu(x0), zu(hd)]]);
+        if (!solid(i, j + 1)) quad([[x0, y1, hd], [x1, y1, hd], [x1, y1, -hd], [x0, y1, -hd]], [0, 1, 0], [[fu(x0), zu(hd)], [fu(x1), zu(hd)], [fu(x1), zu(-hd)], [fu(x0), zu(-hd)]]);
+      }
+    }
+    return {
+      type: "BufferGeometry",
+      parameters: { size: [w, h, d], subtract: holes.map((hole) => ({ min: [hole.x0, hole.y0], max: [hole.x1, hole.y1] })) },
+      positions: new Float32Array(positions),
+      normals: new Float32Array(normals),
+      uvs: new Float32Array(uvs),
+      indices: indexArray(indices),
+      groups: []
+    };
+  }
+  var Earcut = {
+    triangulate: function(data, holeIndices, dim = 2) {
+      const hasHoles = holeIndices && holeIndices.length;
+      const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+      let outerNode = linkedList(data, 0, outerLen, dim, true);
+      const triangles = [];
+      if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+      let minX, minY, maxX, maxY, x, y, invSize;
+      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+      if (data.length > 80 * dim) {
+        minX = maxX = data[0];
+        minY = maxY = data[1];
+        for (let i = dim; i < outerLen; i += dim) {
+          x = data[i];
+          y = data[i + 1];
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+        }
+        invSize = Math.max(maxX - minX, maxY - minY);
+        invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+      return triangles;
+    }
+  };
+  function linkedList(data, start, end, dim, clockwise) {
+    let i, last;
+    if (clockwise === signedArea(data, start, end, dim) > 0) {
+      for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+    } else {
+      for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start) return start;
+    if (!end) end = start;
+    let p = start, again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next) break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear) return;
+    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+    let stop = ear, prev, next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+    let p = ear.prevZ, n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev, b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+    const queue = [];
+    let i, len2, start, end, list2;
+    for (i = 0, len2 = holeIndices.length; i < len2; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len2 - 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 sum2 = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      sum2 += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+      j = i;
+    }
+    return sum2;
+  }
+  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 cache2 = options.cache !== false;
+    const key = cache2 ? "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) => cache2 ? buildPrimitive(node) : direct();
+    const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+    const constructors = {
+      BoxGeometry: (width, height, depth, ws = 1, hs = 1, ds = 1) => made(viaCache({ kind: "box", size: [width ?? 1, height ?? 1, depth ?? 1], segments: [ws, hs, ds] }, () => box(width, height, depth, ws, hs, ds))),
+      CylinderGeometry: (radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cylinder", ...defined({ radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cylinder(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      ConeGeometry: (radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) => made(viaCache({ kind: "cone", ...defined({ radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength }) }, () => cone(radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))),
+      SphereGeometry: (radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) => made(viaCache({ kind: "sphere", ...defined({ radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength }) }, () => sphere(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength))),
+      PlaneGeometry: (width, height, widthSegments, heightSegments) => made(viaCache({ kind: "plane", ...defined({ width, height, widthSegments, heightSegments }) }, () => plane(width, height, widthSegments, heightSegments))),
+      CircleGeometry: (radius, segments, thetaStart, thetaLength) => made(viaCache({ kind: "circle", ...defined({ radius, segments, thetaStart, thetaLength }) }, () => circle(radius, segments, thetaStart, thetaLength))),
+      RingGeometry: (innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength) => made(viaCache({ kind: "ring", ...defined({ innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength }) }, () => ring(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength))),
+      LatheGeometry: (points, segments, phiStart, phiLength) => {
+        if (!points) return new THREE.LatheGeometry(void 0, segments, phiStart, phiLength);
+        const profile = points.map((p) => [p.x, p.y]);
+        return made(viaCache({ kind: "lathe", points: profile, ...defined({ segments, phiStart, phiLength }) }, () => lathe(profile, segments, phiStart, phiLength)));
+      },
+      TorusGeometry: (radius, tube2, radialSegments, tubularSegments, arc) => made(viaCache({ kind: "torus", ...defined({ radius, tube: tube2, radialSegments, tubularSegments, arc }) }, () => torus(radius, tube2, radialSegments, tubularSegments, arc))),
+      ExtrudeGeometry: (shapes, extrudeOptions) => {
+        const buffers = shapes === void 0 ? null : extrudeOf(shapes, extrudeOptions);
+        if (!buffers) return new THREE.ExtrudeGeometry(shapes, extrudeOptions);
+        const geometry = toGeometry(THREE, buffers);
+        geometry.parameters = { shapes, options: extrudeOptions ?? {} };
+        return geometry;
+      }
+    };
+    const namespace = { ...THREE };
+    for (const type of SHAPE_GEOMETRY_TYPES) {
+      const make2 = constructors[type];
+      const Constructor = function(...args) {
+        return make2(...args);
+      };
+      Constructor.prototype = THREE[type].prototype;
+      Object.defineProperty(Constructor, "name", { value: type });
+      namespace[type] = Constructor;
+    }
+    const result = namespace;
+    byKey.set(key, result);
+    shims.add(result);
+    return result;
+  }
+
   // src/rounded-box.ts
   function createRoundedBox(THREE, width, height, depth, radius) {
-    if (radius === 0) return new THREE.BoxGeometry(width, height, depth);
-    const geometry = new THREE.BoxGeometry(2, 2, 2, 4, 4, 4);
+    const T = shapeGeometries(THREE);
+    if (radius === 0) return new T.BoxGeometry(width, height, depth);
+    const geometry = new T.BoxGeometry(2, 2, 2, 4, 4, 4);
     const position = geometry.attributes.position;
     const normal = geometry.attributes.normal;
     const half = [width / 2, height / 2, depth / 2];
@@ -76,7 +1594,7 @@ var GameUrbanThree = (() => {
     shape.lineTo(width / 2, 0);
     shape.lineTo(0, height);
     shape.lineTo(-width / 2, 0);
-    const geometry = new THREE.ExtrudeGeometry(shape, { depth, bevelEnabled: false });
+    const geometry = new (shapeGeometries(THREE)).ExtrudeGeometry(shape, { depth, bevelEnabled: false });
     geometry.translate(0, 0, -depth / 2);
     return geometry;
   }
@@ -95,11 +1613,11 @@ var GameUrbanThree = (() => {
     g.textAlign = "center";
     g.textBaseline = "middle";
     const base = g.font;
-    lines.forEach((text, index) => {
+    lines.forEach((text2, index) => {
       g.font = base;
-      const measured = g.measureText(text).width;
+      const measured = g.measureText(text2).width;
       if (measured > o.width * FIT) g.font = base.replace(/(\d+(?:\.\d+)?)px/, (_match, size) => (Number(size) * o.width * FIT / measured).toFixed(1) + "px");
-      g.fillText(text, o.width / 2, o.height / 2 + (index - (lines.length - 1) / 2) * (o.height / lines.length));
+      g.fillText(text2, o.width / 2, o.height / 2 + (index - (lines.length - 1) / 2) * (o.height / lines.length));
     });
     const texture = new THREE.CanvasTexture(canvas);
     texture.anisotropy = 4;
@@ -115,25 +1633,26 @@ var GameUrbanThree = (() => {
   var SIGN_FONT = '700 56px "Arial Narrow", Arial, sans-serif';
   var SIGN_CANVAS = { width: 512, height: 128 };
   function createUrbanThree(THREE, options = {}) {
+    const T = shapeGeometries(THREE);
     const geometries = /* @__PURE__ */ new Map();
     const materials = /* @__PURE__ */ new Map();
     const disposables = [];
-    const standard = (color, style, flat = false) => {
+    const standard = (color2, style, flat = false) => {
       const roughness = style?.roughness ?? DEFAULT_ROUGHNESS;
       const metalness = style?.metalness ?? DEFAULT_METALNESS;
-      const key = `s|${color}|${roughness}|${metalness}|${flat ? 1 : 0}`;
+      const key = `s|${color2}|${roughness}|${metalness}|${flat ? 1 : 0}`;
       let material = materials.get(key);
       if (!material) {
-        material = new THREE.MeshStandardMaterial({ color, roughness, metalness, flatShading: flat });
+        material = new THREE.MeshStandardMaterial({ color: color2, roughness, metalness, flatShading: flat });
         materials.set(key, material);
       }
       return material;
     };
-    const glowing = (color) => {
-      const key = `b|${color}`;
+    const glowing = (color2) => {
+      const key = `b|${color2}`;
       let material = materials.get(key);
       if (!material) {
-        material = new THREE.MeshBasicMaterial({ color });
+        material = new THREE.MeshBasicMaterial({ color: color2 });
         materials.set(key, material);
       }
       return material;
@@ -147,9 +1666,9 @@ var GameUrbanThree = (() => {
       }
       return geometry;
     };
-    const shadows = (mesh, style, cast, receive) => {
-      mesh.castShadow = style?.castShadow ?? cast;
-      mesh.receiveShadow = style?.receiveShadow ?? receive;
+    const shadows = (mesh2, style, cast, receive) => {
+      mesh2.castShadow = style?.castShadow ?? cast;
+      mesh2.receiveShadow = style?.receiveShadow ?? receive;
     };
     const texture = (lines, width, height, background, foreground, font) => {
       if (!options.document) throw new Error("createUrbanThree needs a document (option) to draw signs and labels");
@@ -158,12 +1677,12 @@ var GameUrbanThree = (() => {
       return map;
     };
     const textPlane = (part, map) => {
-      const mesh = new THREE.Mesh(new THREE.PlaneGeometry(part.width, part.height), new THREE.MeshBasicMaterial({ map, transparent: true }));
-      mesh.userData.own = true;
-      mesh.position.set(part.x, part.y, part.z);
-      if (part.ry) mesh.rotation.y = part.ry;
-      disposables.push(mesh.geometry, mesh.material);
-      return mesh;
+      const mesh2 = new THREE.Mesh(new T.PlaneGeometry(part.width, part.height), new THREE.MeshBasicMaterial({ map, transparent: true }));
+      mesh2.userData.own = true;
+      mesh2.position.set(part.x, part.y, part.z);
+      if (part.ry) mesh2.rotation.y = part.ry;
+      disposables.push(mesh2.geometry, mesh2.material);
+      return mesh2;
     };
     const drawPart = (part, animators, lights) => {
       switch (part.shape) {
@@ -174,94 +1693,94 @@ var GameUrbanThree = (() => {
           return [group];
         }
         case "box": {
-          const mesh = new THREE.Mesh(roundedBox(part.width, part.height, part.depth, part.radius), part.emissive ? glowing(part.color) : standard(part.color, part.style));
-          mesh.position.set(part.x, part.y, part.z);
-          if (part.ry) mesh.rotation.y = part.ry;
-          if (part.rz) mesh.rotation.z = part.rz;
-          shadows(mesh, part.style, true, true);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(roundedBox(part.width, part.height, part.depth, part.radius), part.emissive ? glowing(part.color) : standard(part.color, part.style));
+          mesh2.position.set(part.x, part.y, part.z);
+          if (part.ry) mesh2.rotation.y = part.ry;
+          if (part.rz) mesh2.rotation.z = part.rz;
+          shadows(mesh2, part.style, true, true);
+          return [mesh2];
         }
         case "prism": {
           const geometry = createPrism(THREE, part.width, part.height, part.depth);
           disposables.push(geometry);
-          const mesh = new THREE.Mesh(geometry, standard(part.color, part.style, true));
-          mesh.position.set(part.x, part.y, part.z);
-          if (part.ry) mesh.rotation.y = part.ry;
-          shadows(mesh, part.style, true, true);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(geometry, standard(part.color, part.style, true));
+          mesh2.position.set(part.x, part.y, part.z);
+          if (part.ry) mesh2.rotation.y = part.ry;
+          shadows(mesh2, part.style, true, true);
+          return [mesh2];
         }
         case "cylinder": {
-          const geometry = new THREE.CylinderGeometry(part.radiusTop, part.radiusBottom, part.height, part.segments);
+          const geometry = new T.CylinderGeometry(part.radiusTop, part.radiusBottom, part.height, part.segments);
           disposables.push(geometry);
-          const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
-          mesh.position.set(part.x, part.y, part.z);
-          shadows(mesh, part.style, true, true);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(geometry, standard(part.color, part.style));
+          mesh2.position.set(part.x, part.y, part.z);
+          shadows(mesh2, part.style, true, true);
+          return [mesh2];
         }
         case "cone": {
-          const geometry = new THREE.ConeGeometry(part.radius, part.height, part.segments);
+          const geometry = new T.ConeGeometry(part.radius, part.height, part.segments);
           disposables.push(geometry);
-          const mesh = new THREE.Mesh(geometry, standard(part.color, part.style, true));
-          mesh.position.set(part.x, part.y, part.z);
-          shadows(mesh, part.style, true, true);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(geometry, standard(part.color, part.style, true));
+          mesh2.position.set(part.x, part.y, part.z);
+          shadows(mesh2, part.style, true, true);
+          return [mesh2];
         }
         case "crown": {
           const geometry = new THREE.DodecahedronGeometry(part.radius, 0);
           disposables.push(geometry);
-          const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
-          mesh.position.set(part.x, part.y, part.z);
-          shadows(mesh, part.style, true, false);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(geometry, standard(part.color, part.style));
+          mesh2.position.set(part.x, part.y, part.z);
+          shadows(mesh2, part.style, true, false);
+          return [mesh2];
         }
         case "terrain": {
           const { grid } = part;
-          const geometry = new THREE.PlaneGeometry(grid.size, grid.size, grid.segments, grid.segments);
+          const geometry = new T.PlaneGeometry(grid.size, grid.size, grid.segments, grid.segments);
           geometry.rotateX(-Math.PI / 2);
           const position = geometry.attributes.position;
           const colors2 = new Float32Array(position.count * 3);
-          const color = new THREE.Color();
+          const color2 = new THREE.Color();
           for (let index = 0; index < position.count; index++) {
             position.setXYZ(index, grid.x[index], grid.heights[index], grid.z[index]);
-            color.setHex(grid.colors[index]);
-            colors2[index * 3] = color.r;
-            colors2[index * 3 + 1] = color.g;
-            colors2[index * 3 + 2] = color.b;
+            color2.setHex(grid.colors[index]);
+            colors2[index * 3] = color2.r;
+            colors2[index * 3 + 1] = color2.g;
+            colors2[index * 3 + 2] = color2.b;
           }
           geometry.setAttribute("color", new THREE.BufferAttribute(colors2, 3));
           geometry.computeVertexNormals();
           disposables.push(geometry);
           const material = new THREE.MeshStandardMaterial({ vertexColors: true, flatShading: true, roughness: 1 });
           disposables.push(material);
-          const mesh = new THREE.Mesh(geometry, material);
-          mesh.userData.own = true;
-          shadows(mesh, part.style, true, true);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(geometry, material);
+          mesh2.userData.own = true;
+          shadows(mesh2, part.style, true, true);
+          return [mesh2];
         }
         case "vault": {
-          const geometry = new THREE.CylinderGeometry(part.radius, part.radius, part.length, part.segments, 1, false, 0, part.arc);
+          const geometry = new T.CylinderGeometry(part.radius, part.radius, part.length, part.segments, 1, false, 0, part.arc);
           disposables.push(geometry);
-          const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
-          mesh.rotation.set(part.rotation.x, part.rotation.y, part.rotation.z);
-          mesh.position.set(part.x, part.y, part.z);
-          mesh.scale.set(part.scale.x, part.scale.y, part.scale.z);
-          shadows(mesh, part.style, true, false);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(geometry, standard(part.color, part.style));
+          mesh2.rotation.set(part.rotation.x, part.rotation.y, part.rotation.z);
+          mesh2.position.set(part.x, part.y, part.z);
+          mesh2.scale.set(part.scale.x, part.scale.y, part.scale.z);
+          shadows(mesh2, part.style, true, false);
+          return [mesh2];
         }
         case "plane": {
-          const geometry = new THREE.PlaneGeometry(part.width, part.depth).rotateX(-Math.PI / 2);
+          const geometry = new T.PlaneGeometry(part.width, part.depth).rotateX(-Math.PI / 2);
           disposables.push(geometry);
-          const mesh = new THREE.Mesh(geometry, standard(part.color, part.style));
-          mesh.position.set(part.x, part.y, part.z);
-          shadows(mesh, part.style, false, true);
-          return [mesh];
+          const mesh2 = new THREE.Mesh(geometry, standard(part.color, part.style));
+          mesh2.position.set(part.x, part.y, part.z);
+          shadows(mesh2, part.style, false, true);
+          return [mesh2];
         }
         case "line": {
           const geometry = new THREE.BufferGeometry().setFromPoints(part.points.map(([x, y, z]) => new THREE.Vector3(x, y, z)));
-          const mesh = new THREE.Line(geometry, new THREE.LineBasicMaterial({ color: part.color }));
-          mesh.userData.own = true;
-          disposables.push(geometry, mesh.material);
-          return [mesh];
+          const mesh2 = new THREE.Line(geometry, new THREE.LineBasicMaterial({ color: part.color }));
+          mesh2.userData.own = true;
+          disposables.push(geometry, mesh2.material);
+          return [mesh2];
         }
         case "sign":
           return [textPlane(part, texture([part.text], SIGN_CANVAS.width, SIGN_CANVAS.height, part.background, part.foreground, SIGN_FONT))];
@@ -272,8 +1791,8 @@ var GameUrbanThree = (() => {
           holder.position.set(part.x, part.y, part.z);
           if (part.ry) holder.rotation.y = part.ry;
           if (part.scale !== 1) holder.scale.setScalar(part.scale);
-          const object = options.resolvers?.[part.kind]?.(part);
-          if (object) holder.add(object);
+          const object2 = options.resolvers?.[part.kind]?.(part);
+          if (object2) holder.add(object2);
           holder.userData.placement = { kind: part.kind, id: part.id };
           return [holder];
         }
@@ -305,39 +1824,39 @@ var GameUrbanThree = (() => {
         }
       }
     };
-    const instancedItems = (list) => {
-      const mesh = new THREE.InstancedMesh(roundedBox(1, 1, 1, ITEM_ROUNDNESS), standard(16777215), list.length);
+    const instancedItems = (list2) => {
+      const mesh2 = new THREE.InstancedMesh(roundedBox(1, 1, 1, ITEM_ROUNDNESS), standard(16777215), list2.length);
       const matrix = new THREE.Matrix4();
       const quaternion = new THREE.Quaternion();
       const euler = new THREE.Euler();
       const position = new THREE.Vector3();
       const scale = new THREE.Vector3();
-      const color = new THREE.Color();
-      list.forEach((entry, index) => {
+      const color2 = new THREE.Color();
+      list2.forEach((entry, index) => {
         euler.set(entry.rx, entry.ry, entry.rz);
         quaternion.setFromEuler(euler);
         matrix.compose(position.set(entry.x, entry.y + entry.height / 2, entry.z), quaternion, scale.set(entry.width, entry.height, entry.depth));
-        mesh.setMatrixAt(index, matrix);
-        mesh.setColorAt(index, color.set(entry.color));
+        mesh2.setMatrixAt(index, matrix);
+        mesh2.setColorAt(index, color2.set(entry.color));
       });
-      mesh.castShadow = true;
-      mesh.receiveShadow = true;
-      return mesh;
+      mesh2.castShadow = true;
+      mesh2.receiveShadow = true;
+      return mesh2;
     };
-    const instancedWindows = (list, material) => {
-      const geometry = new THREE.PlaneGeometry(1, 1);
+    const instancedWindows = (list2, material) => {
+      const geometry = new T.PlaneGeometry(1, 1);
       disposables.push(geometry);
-      const mesh = new THREE.InstancedMesh(geometry, material, list.length);
+      const mesh2 = new THREE.InstancedMesh(geometry, material, list2.length);
       const matrix = new THREE.Matrix4();
       const quaternion = new THREE.Quaternion();
       const axis = new THREE.Vector3(0, 1, 0);
       const scale = new THREE.Vector3();
-      list.forEach((entry, index) => {
+      list2.forEach((entry, index) => {
         quaternion.setFromAxisAngle(axis, entry.ry);
         matrix.compose(new THREE.Vector3(entry.x, entry.y, entry.z), quaternion, scale.set(entry.width, entry.height, 1));
-        mesh.setMatrixAt(index, matrix);
+        mesh2.setMatrixAt(index, matrix);
       });
-      return mesh;
+      return mesh2;
     };
     function draw(scene, drawOptions = {}) {
       const root = drawOptions.root ?? new THREE.Group();
@@ -590,7 +2109,7 @@ var GameUrbanThree = (() => {
     const [h, s, v] = toHsv(c);
     return fromHsv(h - amt * 0.03, clamp(s - amt * 0.12, 0, 1), clamp(v + amt * 0.35, 0, 1));
   }
-  function srgbToLinear(v) {
+  function srgbToLinear2(v) {
     return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
   }
   function linearToSrgb(v) {
@@ -772,7 +2291,7 @@ var GameUrbanThree = (() => {
       this.groupTriangles();
       const n = this.pos.length / 3;
       const colors2 = new Float32Array(n * 3);
-      for (let i = 0; i < n * 3; i++) colors2[i] = srgbToLinear(this.col[i]);
+      for (let i = 0; i < n * 3; i++) colors2[i] = srgbToLinear2(this.col[i]);
       return {
         positions: new Float32Array(this.pos),
         normals: new Float32Array(this.nor),
@@ -973,16 +2492,16 @@ var GameUrbanThree = (() => {
       const f = frames[k];
       const r = o.radii[k];
       const t = k / (n - 1);
-      const ring = [];
+      const ring2 = [];
       for (let i = 0; i < S; i++) {
         const a = i / S * TAU;
         const ca = Math.cos(a);
         const sa = Math.sin(a);
         const dir = [f.n[0] * ca + f.b[0] * sa, f.n[1] * ca + f.b[1] * sa, f.n[2] * ca + f.b[2] * sa];
         const rr = r * (1 + (o.rough ? o.rough(k, i) : 0));
-        ring.push({ p: add(path[k], mul(dir, rr)), nr: dir, c: o.color(t, i / S) });
+        ring2.push({ p: add(path[k], mul(dir, rr)), nr: dir, c: o.color(t, i / S) });
       }
-      rings.push(ring);
+      rings.push(ring2);
     }
     const sw = (k) => o.sway(k / (n - 1));
     if (smooth2) {
@@ -1066,7 +2585,7 @@ var GameUrbanThree = (() => {
     const swayAt = (k) => o.sway(k / (N - 1));
     for (let k = 0; k < N; k++) {
       const f = fr[k];
-      const ring = [];
+      const ring2 = [];
       for (let i = 0; i < S; i++) {
         const ridge = i % 2 === 0;
         const rib = i >> 1;
@@ -1076,10 +2595,10 @@ var GameUrbanThree = (() => {
         const rr = radii[k] * (ridge ? 1 + wob : o.valley);
         const p = add(pts[k], mul(dir, rr));
         const c = o.color(Math.min(1, k / (path.length - 1)), ridge, rib);
-        ring.push({ p, nr: dir, c });
+        ring2.push({ p, nr: dir, c });
         if (ridge && k < path.length) info.ridges.push({ p, n: dir, t: k / (path.length - 1), rib, ring: k });
       }
-      rings.push(ring);
+      rings.push(ring2);
     }
     for (let k = 0; k < N - 1; k++) {
       for (let i = 0; i < S; i++) {
@@ -1401,7 +2920,7 @@ var GameUrbanThree = (() => {
       return { p, r, members: g.members };
     });
   }
-  function octa(b, center, radii, color, sway) {
+  function octa(b, center, radii, color2, sway) {
     const pts = [
       [radii[0], 0, 0],
       [0, 0, radii[2]],
@@ -1414,11 +2933,11 @@ var GameUrbanThree = (() => {
       const a = pts[i];
       const c = pts[(i + 1) % 4];
       const out = sub(add(a, c), mul(center, 2));
-      b.flatTri(a, c, top, color(0.5), color(0.5), color(1), sway, sway, sway, add(out, [0, 1, 0]));
-      b.flatTri(c, a, bot, color(0.5), color(0.5), color(0), sway, sway, sway, add(out, [0, -1, 0]));
+      b.flatTri(a, c, top, color2(0.5), color2(0.5), color2(1), sway, sway, sway, add(out, [0, 1, 0]));
+      b.flatTri(c, a, bot, color2(0.5), color2(0.5), color2(0), sway, sway, sway, add(out, [0, -1, 0]));
     }
   }
-  function blossom(b, center, normal, size, color, heart, sway, petals = 5, twist = 0) {
+  function blossom(b, center, normal, size, color2, heart, sway, petals = 5, twist = 0) {
     const f = frameFromAxis(center, normal, twist);
     const peak = toWorld(f, [0, size * 0.3, 0]);
     for (let i = 0; i < petals; i++) {
@@ -1428,7 +2947,7 @@ var GameUrbanThree = (() => {
       const p0 = toWorld(f, [Math.cos(a0) * size * 0.75, 0, Math.sin(a0) * size * 0.75]);
       const p1 = toWorld(f, [Math.cos(a1) * size * 0.75, 0, Math.sin(a1) * size * 0.75]);
       const pm = toWorld(f, [Math.cos(am) * size * 1.1, size * 0.08, Math.sin(am) * size * 1.1]);
-      const c = i % 2 ? shade(color, 0.93) : color;
+      const c = i % 2 ? shade(color2, 0.93) : color2;
       b.flatTri(peak, p0, pm, heart, c, lighten(c, 0.4), sway, sway, sway, normal);
       b.flatTri(peak, pm, p1, heart, lighten(c, 0.4), c, sway, sway, sway, normal);
     }
@@ -2318,8 +3837,8 @@ var GameUrbanThree = (() => {
         const nb = ctx.pick(6, 5, 4);
         for (let i = 0; i < nb; i++) {
           const a = i * 2.2 + 0.4;
-          const ring = i === 0 ? 0 : moundR * 0.5;
-          blobs.push({ c: [Math.cos(a) * ring, moundH * (i === 0 ? 0.55 : 0.28 + 0.07 * (i % 3)), Math.sin(a) * ring], r: moundR * (i === 0 ? 0.62 : 0.52), sq: 0.95 });
+          const ring2 = i === 0 ? 0 : moundR * 0.5;
+          blobs.push({ c: [Math.cos(a) * ring2, moundH * (i === 0 ? 0.55 : 0.28 + 0.07 * (i % 3)), Math.sin(a) * ring2], r: moundR * (i === 0 ? 0.62 : 0.52), sq: 0.95 });
         }
       }
       for (const bl of blobs) clump(ctx.foliage, { center: bl.c, radius: bl.r, squash: bl.sq, detail: ctx.pick(1, 1, 0), seed: rng.seed(), base: dead ? mix(leafBase, [0.42, 0.32, 0.2], 0.7) : dry ? mix(leafBase, [0.55, 0.48, 0.22], 0.45) : mix(leafBase, [0.25, 0.55, 0.22], 0.25), swayK: 0.3, noise: 0.16, flatBottom: 0.8, ao: 0.5 });
@@ -2686,7 +4205,7 @@ var GameUrbanThree = (() => {
       }
     }
     if (o.teeth && o.teeth.count > 0) {
-      const { count, color, size } = o.teeth;
+      const { count, color: color2, size } = o.teeth;
       for (let k = 0; k < count; k++) {
         const t0 = 0.12 + 0.7 * k / count;
         const t1 = t0 + 0.05;
@@ -2697,7 +4216,7 @@ var GameUrbanThree = (() => {
           const e1 = sd < 0 ? rows[i1].L : rows[i1].R;
           const out = mul(right, sd * width * size);
           const tip = add(add(mul(add(e0, e1), 0.5), out), mul(d, length * 0.02));
-          b.flatTri(e0, tip, e1, color, shade(color, 1.3), color, rows[i0].s, rows[i0].s, rows[i1].s, add(out, n2));
+          b.flatTri(e0, tip, e1, color2, shade(color2, 1.3), color2, rows[i0].s, rows[i0].s, rows[i1].s, add(out, n2));
         }
       }
     }
@@ -2726,8 +4245,8 @@ var GameUrbanThree = (() => {
           const az = i / n * TAU * 1 + rng.range(-0.3, 0.3);
           const el = rng.range(1.2, 1.5);
           const len2 = h * rng.range(0.55, 1) * (ctx.condition === "dead" ? 0.6 : 1);
-          const ring = rng.range(0, 0.08);
-          const base0 = [Math.cos(az) * ring, 0, Math.sin(az) * ring];
+          const ring2 = rng.range(0, 0.08);
+          const base0 = [Math.cos(az) * ring2, 0, Math.sin(az) * ring2];
           const band = rng.range(0, TAU);
           fleshyLeaf(ctx.foliage, base0, dirFromAngles(az, el), dirFromAngles(az + Math.PI, 0.2), len2, h * 0.16 * rng.range(0.85, 1.15), {
             rows: ctx.pick(7, 4, 2),
@@ -2749,10 +4268,10 @@ var GameUrbanThree = (() => {
         const base = tintFlesh(rgb(spec.color ?? 7315306), ctx.condition);
         const edge = rgb(spec.edgeColor ?? 15261896);
         for (let i = 0; i < n; i++) {
-          const ring = i < n * 0.4 ? 0 : i < n * 0.75 ? 1 : 2;
+          const ring2 = i < n * 0.4 ? 0 : i < n * 0.75 ? 1 : 2;
           const az = i * 2.4 + rng.range(-0.2, 0.2);
-          const el = [1.15, 0.85, 0.55][ring] + rng.range(-0.1, 0.1);
-          const len2 = h * [0.75, 0.95, 0.85][ring] * rng.range(0.9, 1.1);
+          const el = [1.15, 0.85, 0.55][ring2] + rng.range(-0.1, 0.1);
+          const len2 = h * [0.75, 0.95, 0.85][ring2] * rng.range(0.9, 1.1);
           const c = jitter(base, rng, 0.01, 0.06, 0.04);
           fleshyLeaf(ctx.foliage, [0, 0.02, 0], dirFromAngles(az, el), [0, 1, 0], len2, h * 0.26, {
             rows: ctx.pick(3, 2, 2),
@@ -2839,7 +4358,7 @@ var GameUrbanThree = (() => {
     }
     return { collider: null, bendable: true };
   }
-  function spineTuft(b, p, n, count, length, color, rng, sway = 0) {
+  function spineTuft(b, p, n, count, length, color2, rng, sway = 0) {
     const nn = norm(n);
     const t1 = perp(nn);
     const t2 = norm(cross(nn, t1));
@@ -2852,15 +4371,15 @@ var GameUrbanThree = (() => {
       const side = mul(norm(cross(dir, nn)), w);
       const left = add(p, side);
       const right = add(p, mul(side, -1));
-      b.flatTri(left, right, tip, shade(color, 0.8), shade(color, 0.8), color, sway, sway, sway, nn);
+      b.flatTri(left, right, tip, shade(color2, 0.8), shade(color2, 0.8), color2, sway, sway, sway, nn);
     }
   }
-  function areole(b, p, n, size, color, sway = 0) {
+  function areole(b, p, n, size, color2, sway = 0) {
     const nn = norm(n);
     const t1 = mul(perp(nn), size);
     const t2 = mul(norm(cross(nn, perp(nn))), size);
     const c = add(p, mul(nn, size * 0.1));
-    b.flatTri(add(c, t1), add(c, add(mul(t1, -0.5), t2)), add(c, add(mul(t1, -0.5), mul(t2, -1))), color, color, color, sway, sway, sway, nn);
+    b.flatTri(add(c, t1), add(c, add(mul(t1, -0.5), t2)), add(c, add(mul(t1, -0.5), mul(t2, -1))), color2, color2, color2, sway, sway, sway, nn);
   }
   function generateColumnarCactus(spec, ctx) {
     const rng = ctx.rng;
@@ -2897,7 +4416,7 @@ var GameUrbanThree = (() => {
         dome: domeSteps,
         color: (t, ridge, rib) => bodyColor(t, ridge, rib + seedK),
         sway: () => 0,
-        rough: (ring, rib) => Math.sin(ring * 1.7 + rib * 2.3 + seedK) * 0.03
+        rough: (ring2, rib) => Math.sin(ring2 * 1.7 + rib * 2.3 + seedK) * 0.03
       });
       const last = path[path.length - 1];
       const prev = path[path.length - 2];
@@ -3109,7 +4628,7 @@ var GameUrbanThree = (() => {
         return shade(base, k);
       },
       sway: () => 0,
-      rough: (ring, rib) => Math.sin(ring * 2.1 + rib * 1.3) * 0.02
+      rough: (ring2, rib) => Math.sin(ring2 * 2.1 + rib * 1.3) * 0.02
     });
     if (ctx.lod === 0) {
       for (const rd of res.ridges) {
@@ -3264,9 +4783,9 @@ var GameUrbanThree = (() => {
         sides,
         radii,
         color: (t, a) => {
-          const ring = 0.84 + 0.16 * Math.cos(t * stemH * scars * TAU);
+          const ring2 = 0.84 + 0.16 * Math.cos(t * stemH * scars * TAU);
           const stripe = 0.94 + 0.06 * Math.cos(a * TAU * 3 + t * 4);
-          let c = shade(trunkC, ring * stripe * (0.78 + 0.22 * Math.min(1, t * 6)));
+          let c = shade(trunkC, ring2 * stripe * (0.78 + 0.22 * Math.min(1, t * 6)));
           if (variant === "royal") c = mix(c, [0.62, 0.62, 0.55], 0.25);
           if (dead) c = mix(c, [0.4, 0.37, 0.32], 0.5);
           return c;
@@ -3291,34 +4810,34 @@ var GameUrbanThree = (() => {
       for (let i = 0; i < n; i++) {
         if (ctx.lod === 2 && variant === "fan" && i % 2 === 1) continue;
         const f = srng.fork(i);
-        const ring = i % 3;
+        const ring2 = i % 3;
         const az2 = i / n * TAU * 1 + f.range(-0.2, 0.2) + si;
         let elev;
         let droop;
         if (variant === "royal") {
-          elev = [1.1, 0.65, 0.2][ring] + f.range(-0.1, 0.1);
-          droop = [0.35, 0.65, 1][ring];
+          elev = [1.1, 0.65, 0.2][ring2] + f.range(-0.1, 0.1);
+          droop = [0.35, 0.65, 1][ring2];
         } else if (variant === "date") {
-          elev = [1.15, 0.8, 0.45][ring] + f.range(-0.08, 0.08);
-          droop = [0.3, 0.5, 0.75][ring];
+          elev = [1.15, 0.8, 0.45][ring2] + f.range(-0.08, 0.08);
+          droop = [0.3, 0.5, 0.75][ring2];
         } else if (variant === "areca") {
-          elev = [1.1, 0.8, 0.5][ring] + f.range(-0.1, 0.1);
-          droop = [0.45, 0.8, 1.1][ring];
+          elev = [1.1, 0.8, 0.5][ring2] + f.range(-0.1, 0.1);
+          droop = [0.45, 0.8, 1.1][ring2];
         } else if (variant === "fan") {
-          elev = [1.3, 0.95, 0.6][ring] + f.range(-0.1, 0.1);
-          droop = [0.25, 0.35, 0.5][ring];
+          elev = [1.3, 0.95, 0.6][ring2] + f.range(-0.1, 0.1);
+          droop = [0.25, 0.35, 0.5][ring2];
         } else {
-          elev = [1.15, 0.75, 0.38][ring] + f.range(-0.1, 0.1);
-          droop = [0.45, 0.78, 1.1][ring];
+          elev = [1.15, 0.75, 0.38][ring2] + f.range(-0.1, 0.1);
+          droop = [0.45, 0.78, 1.1][ring2];
         }
         if (dead) {
           elev = elev * 0.4 - 0.3;
           droop *= 1.4;
         }
         if (dry) droop *= 1.15;
-        const len2 = frondL * f.range(0.85, 1.1) * (ring === 2 ? 0.92 : 1);
+        const len2 = frondL * f.range(0.85, 1.1) * (ring2 === 2 ? 0.92 : 1);
         const colA = dead ? mix(c0, deadC, 0.8) : c0;
-        const colB = dead ? mix(c1, deadC, 0.7) : ring === 2 && dry ? mix(c1, deadC, 0.4) : c1;
+        const colB = dead ? mix(c1, deadC, 0.7) : ring2 === 2 && dry ? mix(c1, deadC, 0.4) : c1;
         if (variant === "fan") {
           fanFrond(ctx, f, crownTop, az2, elev, len2, droop, colA, colB);
         } else {
@@ -3429,10 +4948,10 @@ var GameUrbanThree = (() => {
     const rows = ctx.pick(9, 6, 3);
     for (let i = 0; i < nLeaves; i++) {
       const f = rng.fork(i);
-      const ring = i % 3;
+      const ring2 = i % 3;
       const az = i / nLeaves * TAU * 1 + f.range(-0.25, 0.25);
-      const L = H * f.range(0.55, 0.72) * (ring === 2 ? 0.85 : 1);
-      const el = [1.15, 0.8, 0.45][ring] + f.range(-0.12, 0.12);
+      const L = H * f.range(0.55, 0.72) * (ring2 === 2 ? 0.85 : 1);
+      const el = [1.15, 0.8, 0.45][ring2] + f.range(-0.12, 0.12);
       const horiz = dirFromAngles(az, 0);
       const petL = L * 0.18;
       const pEnd = [top[0] + horiz[0] * petL * Math.cos(el), top[1] + petL * Math.sin(el), top[2] + horiz[2] * petL * Math.cos(el)];
@@ -3443,7 +4962,7 @@ var GameUrbanThree = (() => {
       const tearSeed = f.range(0, 10);
       leaf(ctx.foliage, pEnd, norm([horiz[0] * Math.cos(el), Math.sin(el), horiz[2] * Math.cos(el)]), [0, 1, 0], L, L * 0.34, c0, c1, {
         rows,
-        curl: [0.55, 0.7, 0.8][ring] * (dry ? 1.2 : 1),
+        curl: [0.55, 0.7, 0.8][ring2] * (dry ? 1.2 : 1),
         fold: 0.35,
         swayBase: 0.25,
         swayTip: 1,
@@ -3543,8 +5062,8 @@ var GameUrbanThree = (() => {
       if (hit) return hit;
       const m = Math.max(Math.abs(c[0]), Math.abs(c[1]), Math.abs(c[2]));
       const s = norm(c);
-      const sphere = [s[0] * m, s[1] * m, s[2] * m];
-      const q = [lerp(c[0], sphere[0], o.round), lerp(c[1], sphere[1], o.round), lerp(c[2], sphere[2], o.round)];
+      const sphere2 = [s[0] * m, s[1] * m, s[2] * m];
+      const q = [lerp(c[0], sphere2[0], o.round), lerp(c[1], sphere2[1], o.round), lerp(c[2], sphere2[2], o.round)];
       const base = [o.center[0] + q[0] * hx, o.center[1] + q[1] * hy, o.center[2] + q[2] * hz];
       const nz = valueNoise3(base[0] * freq, base[1] * freq, base[2] * freq, seed) * 0.75 + valueNoise3(base[0] * freq * 2.3, base[1] * freq * 2.3, base[2] * freq * 2.3, seed + 7) * 0.25;
       const out = norm([q[0] / Math.max(hx, 1e-6), q[1] / Math.max(hy, 1e-6), q[2] / Math.max(hz, 1e-6)]);
@@ -3750,14 +5269,14 @@ var GameUrbanThree = (() => {
         const dark = shade(col, 0.62);
         const apex = [lean * (y / H) ** 2, y + tierH * 0.55, 0];
         const innerR = r * 0.32;
-        const ring = (rad, yy, k, ph) => [apex[0] + Math.cos(k / K * TAU + ph) * rad, yy, Math.sin(k / K * TAU + ph) * rad];
+        const ring2 = (rad, yy, k, ph) => [apex[0] + Math.cos(k / K * TAU + ph) * rad, yy, Math.sin(k / K * TAU + ph) * rad];
         const tphase = i * 0.7;
         for (let k = 0; k < K; k++) {
           const jag = k % 2 === 0 ? 1 : 0.78;
-          const a0 = ring(innerR, y + tierH * 0.12, k, tphase);
-          const a1 = ring(innerR, y + tierH * 0.12, k + 1, tphase);
-          const o0 = ring(r * jag, y - tierH * 0.42, k, tphase);
-          const o1 = ring(r * (k % 2 === 0 ? 0.78 : 1), y - tierH * 0.42, k + 1, tphase);
+          const a0 = ring2(innerR, y + tierH * 0.12, k, tphase);
+          const a1 = ring2(innerR, y + tierH * 0.12, k + 1, tphase);
+          const o0 = ring2(r * jag, y - tierH * 0.42, k, tphase);
+          const o1 = ring2(r * (k % 2 === 0 ? 0.78 : 1), y - tierH * 0.42, k + 1, tphase);
           const sw = 0.25 + 0.35 * (1 - f);
           foliage.flat(apex, a1, a0, shade(lightTop, 0.85), 0.2, [0, 1, 0]);
           foliage.flatTri(a0, a1, o1, mix(col, lightTop, 0.2), mix(col, lightTop, 0.2), lightTop, 0.2, 0.2, sw, [0, 1, 0]);
@@ -3946,12 +5465,12 @@ var GameUrbanThree = (() => {
       const a1 = (i + 1) / sides * TAU;
       ctx.wood.flatTri([0, soilY, 0], [Math.cos(a1) * rim, soilY, Math.sin(a1) * rim], [Math.cos(a0) * rim, soilY, Math.sin(a0) * rim], shade(soil, 0.9), soil, soil, 0, 0, 0, [0, 1, 0]);
     }
-    const inner = generate(spec.plant, { seed: ctx.rng.fork("plant").seed(), lod: ctx.lod, condition: ctx.condition, season: ctx.season });
+    const inner = generate2(spec.plant, { seed: ctx.rng.fork("plant").seed(), lod: ctx.lod, condition: ctx.condition, season: ctx.season });
     const yOff = soilY - 0.02;
     const tagsOf = (part) => {
-      const mesh = inner.parts[part];
-      if (!mesh) return void 0;
-      const tags = new Array(mesh.triangleCount).fill("");
+      const mesh2 = inner.parts[part];
+      if (!mesh2) return void 0;
+      const tags = new Array(mesh2.triangleCount).fill("");
       for (const pc of inner.pieces) {
         if (pc.part !== part) continue;
         if (!ctx.pieceMeta.has(pc.id)) ctx.pieceMeta.set(pc.id, { kind: pc.kind, parent: pc.parent, pivot: [pc.pivot[0], pc.pivot[1] + yOff, pc.pivot[2]], ...pc.radius === void 0 || pc.length === void 0 || !pc.axis || !pc.base ? {} : { geom: { radius: pc.radius, length: pc.length, axis: pc.axis, base: [pc.base[0], pc.base[1] + yOff, pc.base[2]] } } });
@@ -3988,7 +5507,7 @@ var GameUrbanThree = (() => {
     vine: generateVine,
     potted: generatePotted
   };
-  function generate(spec, opts = {}) {
+  function generate2(spec, opts = {}) {
     const gen = GENERATORS[spec.archetype];
     if (!gen) throw new Error(`game-vegetation: unknown archetype "${spec.archetype}"`);
     const seed = toSeed(opts.seed);
@@ -4197,29 +5716,29 @@ var GameUrbanThree = (() => {
     }
     const tagBox = /* @__PURE__ */ new Map();
     for (const part of PART_ORDER) {
-      const mesh = parts[part];
-      if (!mesh) continue;
+      const mesh2 = parts[part];
+      if (!mesh2) continue;
       for (const r of builders[part].ranges) {
         const tag = r.tag || rootId;
-        let box = tagBox.get(tag);
-        if (!box) tagBox.set(tag, box = { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] });
+        let box2 = tagBox.get(tag);
+        if (!box2) tagBox.set(tag, box2 = { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] });
         for (let i = r.indexStart; i < r.indexStart + r.indexCount; i++) {
-          const v = mesh.indices[i] * 3;
+          const v = mesh2.indices[i] * 3;
           for (let a = 0; a < 3; a++) {
-            const c = mesh.positions[v + a];
-            if (c < box.min[a]) box.min[a] = c;
-            if (c > box.max[a]) box.max[a] = c;
+            const c = mesh2.positions[v + a];
+            if (c < box2.min[a]) box2.min[a] = c;
+            if (c > box2.max[a]) box2.max[a] = c;
           }
         }
       }
     }
     const fruitHang = /* @__PURE__ */ new Map();
     const PRIORITY = { branch: 0, pad: 0, arm: 0, stem: 1, trunk: 1, crown: 2 };
-    for (const [tag, box] of tagBox) {
+    for (const [tag, box2] of tagBox) {
       if (meta.get(tag)?.kind !== "fruit") continue;
-      const cx = (box.min[0] + box.max[0]) / 2;
-      const cy = (box.min[1] + box.max[1]) / 2;
-      const cz = (box.min[2] + box.max[2]) / 2;
+      const cx = (box2.min[0] + box2.max[0]) / 2;
+      const cy = (box2.min[1] + box2.max[1]) / 2;
+      const cz = (box2.min[2] + box2.max[2]) / 2;
       let parent;
       let pbox;
       let bd = Infinity;
@@ -4241,24 +5760,24 @@ var GameUrbanThree = (() => {
           pbox = pb;
         }
       }
-      const pc = pbox ? [(pbox.min[0] + pbox.max[0]) / 2, (pbox.min[1] + pbox.max[1]) / 2, (pbox.min[2] + pbox.max[2]) / 2] : [cx, box.max[1], cz];
-      const pivot = [Math.min(box.max[0], Math.max(box.min[0], pc[0])), Math.min(box.max[1], Math.max(box.min[1], pc[1])), Math.min(box.max[2], Math.max(box.min[2], pc[2]))];
+      const pc = pbox ? [(pbox.min[0] + pbox.max[0]) / 2, (pbox.min[1] + pbox.max[1]) / 2, (pbox.min[2] + pbox.max[2]) / 2] : [cx, box2.max[1], cz];
+      const pivot = [Math.min(box2.max[0], Math.max(box2.min[0], pc[0])), Math.min(box2.max[1], Math.max(box2.min[1], pc[1])), Math.min(box2.max[2], Math.max(box2.min[2], pc[2]))];
       fruitHang.set(tag, { parent, pivot });
     }
     const idOf = (tag, part) => primary.get(tag) === part ? tag : `${tag}:${part}`;
     const out = [];
     for (const part of PART_ORDER) {
-      const mesh = parts[part];
-      if (!mesh) continue;
+      const mesh2 = parts[part];
+      if (!mesh2) continue;
       for (const r of builders[part].ranges) {
         const tag = r.tag || rootId;
         const m = meta.get(tag) ?? { kind: "stem" };
         const min = [Infinity, Infinity, Infinity];
         const max = [-Infinity, -Infinity, -Infinity];
         for (let i = r.indexStart; i < r.indexStart + r.indexCount; i++) {
-          const v = mesh.indices[i] * 3;
+          const v = mesh2.indices[i] * 3;
           for (let a = 0; a < 3; a++) {
-            const c = mesh.positions[v + a];
+            const c = mesh2.positions[v + a];
             if (c < min[a]) min[a] = c;
             if (c > max[a]) max[a] = c;
           }
@@ -4270,7 +5789,7 @@ var GameUrbanThree = (() => {
         else if (m.kind === "crown" || m.kind === "fruit") pivot = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
         else pivot = [(min[0] + max[0]) / 2, min[1], (min[2] + max[2]) / 2];
         if (m.kind === "trunk" || m.kind === "stem" || m.kind === "pot" || m.kind === "soil") pivot = [0, min[1], 0];
-        let material = materialKeyForPart(part, mesh.material, condition);
+        let material = materialKeyForPart(part, mesh2.material, condition);
         if (m.kind === "pot") material = "pot";
         else if (m.kind === "soil") material = "soil";
         const parentTag = hang ? hang.parent : m.parent;
@@ -4295,7 +5814,7 @@ var GameUrbanThree = (() => {
 
   // ../game-vegetation/dist/three.js
   var MAX_ACTORS = 4;
-  var COMMON = (
+  var COMMON2 = (
     /* glsl */
     `
 #include <common>
@@ -4356,13 +5875,13 @@ gl_Position = projectionMatrix * mvPosition;
     const patch = (m) => {
       m.onBeforeCompile = (shader) => {
         Object.assign(shader.uniforms, uniforms);
-        shader.vertexShader = shader.vertexShader.replace("#include <common>", COMMON).replace("#include <project_vertex>", PROJECT);
+        shader.vertexShader = shader.vertexShader.replace("#include <common>", COMMON2).replace("#include <project_vertex>", PROJECT);
       };
       m.customProgramCacheKey = () => "vegetation-sway-v1";
     };
     const flat = opts.flatShading !== false;
     const rough = typeof opts.roughness === "number" ? opts.roughness : 0.85;
-    const make = (flatShading, double, roughness) => {
+    const make2 = (flatShading, double, roughness) => {
       const m = new THREE.MeshStandardMaterial({
         vertexColors: true,
         flatShading,
@@ -4373,11 +5892,11 @@ gl_Position = projectionMatrix * mvPosition;
       patch(m);
       return m;
     };
-    const wood = make(false, false, 0.95);
-    const foliage = make(flat, true, rough);
-    const flowers = make(flat, true, 0.7);
-    const fruit = make(flat, false, 0.55);
-    const spines = make(true, true, 0.8);
+    const wood = make2(false, false, 0.95);
+    const foliage = make2(flat, true, rough);
+    const flowers = make2(flat, true, 0.7);
+    const fruit = make2(flat, false, 0.55);
+    const spines = make2(true, true, 0.8);
     const dir = uniforms.uWindDir.value;
     return {
       materialIds: resolveMaterialIds(opts.materialIds),
@@ -4415,13 +5934,13 @@ gl_Position = projectionMatrix * mvPosition;
     };
   }
   var PART_ORDER2 = ["wood", "foliage", "flowers", "fruit", "spines"];
-  function toBufferGeometry(THREE, mesh) {
+  function toBufferGeometry(THREE, mesh2) {
     const g = new THREE.BufferGeometry();
-    g.setAttribute("position", new THREE.BufferAttribute(mesh.positions, 3));
-    g.setAttribute("normal", new THREE.BufferAttribute(mesh.normals, 3));
-    g.setAttribute("color", new THREE.BufferAttribute(mesh.colors, 3));
-    g.setAttribute("sway", new THREE.BufferAttribute(mesh.sway, 1));
-    g.setIndex(new THREE.BufferAttribute(mesh.indices, 1));
+    g.setAttribute("position", new THREE.BufferAttribute(mesh2.positions, 3));
+    g.setAttribute("normal", new THREE.BufferAttribute(mesh2.normals, 3));
+    g.setAttribute("color", new THREE.BufferAttribute(mesh2.colors, 3));
+    g.setAttribute("sway", new THREE.BufferAttribute(mesh2.sway, 1));
+    g.setIndex(new THREE.BufferAttribute(mesh2.indices, 1));
     g.computeBoundingSphere();
     g.computeBoundingBox();
     return g;
@@ -4435,18 +5954,18 @@ gl_Position = projectionMatrix * mvPosition;
   function meshFor(THREE, data, material, ids, condition) {
     const geo = toBufferGeometry(THREE, data);
     inflate(geo, 0.4);
-    const mesh = new THREE.Mesh(geo, material);
-    mesh.name = data.kind;
-    mesh.userData.damageable = { material: data.material };
-    if (ids) mesh.userData.destructionMaterial = ids[materialKeyForPart(data.kind, data.material, condition)];
-    return mesh;
+    const mesh2 = new THREE.Mesh(geo, material);
+    mesh2.name = data.kind;
+    mesh2.userData.damageable = { material: data.material };
+    if (ids) mesh2.userData.destructionMaterial = ids[materialKeyForPart(data.kind, data.material, condition)];
+    return mesh2;
   }
-  function slicePiece(mesh, indexStart, indexCount, origin) {
+  function slicePiece(mesh2, indexStart, indexCount, origin) {
     const remap = /* @__PURE__ */ new Map();
     const order = [];
     const indices = new Uint32Array(indexCount);
     for (let i = 0; i < indexCount; i++) {
-      const v = mesh.indices[indexStart + i];
+      const v = mesh2.indices[indexStart + i];
       let n = remap.get(v);
       if (n === void 0) {
         n = order.length;
@@ -4461,14 +5980,14 @@ gl_Position = projectionMatrix * mvPosition;
     const sway = new Float32Array(order.length);
     for (let i = 0; i < order.length; i++) {
       const v = order[i];
-      positions[i * 3] = mesh.positions[v * 3] - origin[0];
-      positions[i * 3 + 1] = mesh.positions[v * 3 + 1] - origin[1];
-      positions[i * 3 + 2] = mesh.positions[v * 3 + 2] - origin[2];
-      normals.set(mesh.normals.subarray(v * 3, v * 3 + 3), i * 3);
-      colors2.set(mesh.colors.subarray(v * 3, v * 3 + 3), i * 3);
-      sway[i] = mesh.sway[v];
-    }
-    return { positions, normals, colors: colors2, sway, indices, triangleCount: indexCount / 3, kind: mesh.kind, material: mesh.material };
+      positions[i * 3] = mesh2.positions[v * 3] - origin[0];
+      positions[i * 3 + 1] = mesh2.positions[v * 3 + 1] - origin[1];
+      positions[i * 3 + 2] = mesh2.positions[v * 3 + 2] - origin[2];
+      normals.set(mesh2.normals.subarray(v * 3, v * 3 + 3), i * 3);
+      colors2.set(mesh2.colors.subarray(v * 3, v * 3 + 3), i * 3);
+      sway[i] = mesh2.sway[v];
+    }
+    return { positions, normals, colors: colors2, sway, indices, triangleCount: indexCount / 3, kind: mesh2.kind, material: mesh2.material };
   }
   function createPlantObject(THREE, plant, materials, options = {}) {
     const mats = materials ?? createVegetationMaterials(THREE);
@@ -4480,13 +5999,13 @@ gl_Position = projectionMatrix * mvPosition;
         const src = plant.parts[pc.part];
         if (!src) continue;
         const data = slicePiece(src, pc.indexStart, pc.indexCount, pc.pivot);
-        const mesh = meshFor(THREE, data, mats[pc.part]);
-        mesh.name = pc.id;
-        mesh.position.set(pc.pivot[0], pc.pivot[1], pc.pivot[2]);
+        const mesh2 = meshFor(THREE, data, mats[pc.part]);
+        mesh2.name = pc.id;
+        mesh2.position.set(pc.pivot[0], pc.pivot[1], pc.pivot[2]);
         const id = ids[pc.material];
-        mesh.userData.destructionMaterial = id;
-        mesh.userData.destructionPart = { id: pc.id, kind: pc.kind, parent: pc.parent, material: id, materialKey: pc.material, ...pc.radius === void 0 ? {} : { radius: pc.radius, length: pc.length, axis: pc.axis, base: pc.base } };
-        g.add(mesh);
+        mesh2.userData.destructionMaterial = id;
+        mesh2.userData.destructionPart = { id: pc.id, kind: pc.kind, parent: pc.parent, material: id, materialKey: pc.material, ...pc.radius === void 0 ? {} : { radius: pc.radius, length: pc.length, axis: pc.axis, base: pc.base } };
+        g.add(mesh2);
       }
       g.userData = { collider: plant.collider, bendable: plant.bendable, thorny: plant.thorny, species: plant.species, bounds: plant.bounds, pieces: plant.pieces, separable: true };
       return g;
@@ -7066,16 +8585,16 @@ gl_Position = projectionMatrix * mvPosition;
     };
   }
   function pickForContext(region, context, rng) {
-    const list = region.contexts[context];
-    if (!list || list.length === 0) throw new Error(`game-vegetation-species: region "${region.id}" has no context "${context}"`);
+    const list2 = region.contexts[context];
+    if (!list2 || list2.length === 0) throw new Error(`game-vegetation-species: region "${region.id}" has no context "${context}"`);
     const next = toNext(rng);
-    const total = list.reduce((a, b) => a + b.weight, 0);
+    const total = list2.reduce((a, b) => a + b.weight, 0);
     let r = next() * total;
-    for (const it of list) {
+    for (const it of list2) {
       r -= it.weight;
       if (r <= 0) return it.species;
     }
-    return list[list.length - 1].species;
+    return list2[list2.length - 1].species;
   }
 
   // src/resolvers.ts
@@ -7107,8 +8626,8 @@ gl_Position = projectionMatrix * mvPosition;
       const key = `${part.id}|${part.seed}`;
       if (!made.has(key)) {
         try {
-          const mesh = generate(toSpec(part.id), { seed: part.seed, lod: options.lod ?? 1, condition: options.condition ?? "healthy", season: options.season ?? "spring", species: part.id });
-          made.set(key, createPlantObject(THREE, mesh, materials));
+          const mesh2 = generate2(toSpec(part.id), { seed: part.seed, lod: options.lod ?? 1, condition: options.condition ?? "healthy", season: options.season ?? "spring", species: part.id });
+          made.set(key, createPlantObject(THREE, mesh2, materials));
         } catch {
           made.set(key, null);
         }
@@ -7116,8 +8635,8 @@ gl_Position = projectionMatrix * mvPosition;
       return made.get(key)?.clone() ?? null;
     };
     resolve.dispose = () => {
-      for (const object of made.values()) {
-        object?.traverse((o) => o.geometry?.dispose?.());
+      for (const object2 of made.values()) {
+        object2?.traverse((o) => o.geometry?.dispose?.());
       }
       made.clear();
     };
@@ -7134,8 +8653,8 @@ gl_Position = projectionMatrix * mvPosition;
     CATALOG[def.type] = item;
     return item;
   }
-  function registerItems(list) {
-    for (const d of list) registerItem(d);
+  function registerItems(list2) {
+    for (const d of list2) registerItem(d);
   }
   var locales = {};
   function registerLocale(code, table) {
@@ -7371,34 +8890,34 @@ gl_Position = projectionMatrix * mvPosition;
   function createSilhouetteBuilder(random) {
     const parts = [];
     const windows = [];
-    const pick = (list) => list[Math.floor(random() * list.length)];
+    const pick = (list2) => list2[Math.floor(random() * list2.length)];
     const group = (x, y, z, ry = 0, parent = ROOT) => parts.push({ shape: "group", parent, x, y, z, ry }) - 1;
-    const box = (x, y, z, width, height, depth, color, o = {}) => {
-      parts.push({ shape: "box", parent: o.parent ?? ROOT, x, y: y + height / 2, z, width, height, depth, color, emissive: o.emissive ?? false, ry: o.ry ?? 0, rz: o.rz ?? 0, radius: boxRadius(width, height, depth) });
+    const box2 = (x, y, z, width, height, depth, color2, o = {}) => {
+      parts.push({ shape: "box", parent: o.parent ?? ROOT, x, y: y + height / 2, z, width, height, depth, color: color2, emissive: o.emissive ?? false, ry: o.ry ?? 0, rz: o.rz ?? 0, radius: boxRadius(width, height, depth) });
     };
-    const prism = (x, y, z, width, height, depth, color, parent = ROOT) => {
-      parts.push({ shape: "prism", parent, x, y, z, width, height, depth, color, ry: 0 });
+    const prism = (x, y, z, width, height, depth, color2, parent = ROOT) => {
+      parts.push({ shape: "prism", parent, x, y, z, width, height, depth, color: color2, ry: 0 });
     };
-    const cylinder = (x, y, z, radiusTop, radiusBottom, height, color, parent = ROOT, segments = 14) => {
-      parts.push({ shape: "cylinder", parent, x, y: y + height / 2, z, radiusTop, radiusBottom, height, color, segments });
+    const cylinder2 = (x, y, z, radiusTop, radiusBottom, height, color2, parent = ROOT, segments = 14) => {
+      parts.push({ shape: "cylinder", parent, x, y: y + height / 2, z, radiusTop, radiusBottom, height, color: color2, segments });
     };
-    const line = (points, color, parent = ROOT) => {
-      parts.push({ shape: "line", parent, points, color });
+    const line = (points, color2, parent = ROOT) => {
+      parts.push({ shape: "line", parent, points, color: color2 });
     };
-    const sign = (text, x, y, z, width, height, ry, colors2, parent = ROOT) => {
-      parts.push({ shape: "sign", parent, x, y, z, width, height, ry, text, ...colors2 });
+    const sign2 = (text2, x, y, z, width, height, ry, colors2, parent = ROOT) => {
+      parts.push({ shape: "sign", parent, x, y, z, width, height, ry, text: text2, ...colors2 });
     };
-    const fence = (x0, z0, x1, z1, height, color, parent = ROOT) => {
+    const fence = (x0, z0, x1, z1, height, color2, parent = ROOT) => {
       const length = Math.hypot(x1 - x0, z1 - z0);
       const count = Math.ceil(length / 3);
       for (let index = 0; index <= count; index++) {
         const t = index / count;
-        cylinder(x0 + (x1 - x0) * t, 0, z0 + (z1 - z0) * t, 0.05, 0.05, height, color, parent, 5);
+        cylinder2(x0 + (x1 - x0) * t, 0, z0 + (z1 - z0) * t, 0.05, 0.05, height, color2, parent, 5);
       }
       for (const level of [height * 0.35, height * 0.65, height * 0.98]) line([[x0, level, z0], [x1, level, z1]], 9079950, parent);
     };
     const finish = (footprint) => ({ parts, windows, footprint });
-    return { random, pick, group, box, prism, cylinder, line, sign, fence, windows, finish };
+    return { random, pick, group, box: box2, prism, cylinder: cylinder2, line, sign: sign2, fence, windows, finish };
   }
   var STOREY_HEIGHT = 3;
   var SHOP_AWNING_HEIGHT = 4.5;
@@ -7419,8 +8938,8 @@ gl_Position = projectionMatrix * mvPosition;
         const zFace = z + face * (d / 2);
         b.box(x, SHOP_AWNING_HEIGHT, zFace + face * 0.8, w, 0.2, 1.6, 2763308);
         b.box(x, 0, zFace + face * 0.03, w * 0.6, 3.5, 0.05, 4869198);
-        const text = b.pick(SHOP_SIGNS);
-        b.sign(text, x, 5.3, zFace + face * 0.12, Math.min(w * 0.7, 8), 1, face > 0 ? 0 : Math.PI, { background: "#1a1a1c", foreground: b.pick(SIGN_COLORS) });
+        const text2 = b.pick(SHOP_SIGNS);
+        b.sign(text2, x, 5.3, zFace + face * 0.12, Math.min(w * 0.7, 8), 1, face > 0 ? 0 : Math.PI, { background: "#1a1a1c", foreground: b.pick(SIGN_COLORS) });
       }
     }
     addWindows(b, p, hasShop ? SHOP_AWNING_HEIGHT : 0);
@@ -7455,8 +8974,8 @@ gl_Position = projectionMatrix * mvPosition;
     b.box(0, 3.1, d / 2 + 0.5, w * 0.6, 0.15, 1, 6974054, { parent: g });
     for (const floor of [0, 1]) {
       for (const side of [-1, 1]) {
-        const { color, emissive } = pane(b.random() < 0.12);
-        b.box(side * w * 0.26, 1.1 + floor * 3, d / 2 + 0.03, 1.1, 1.2, 0.04, color, { parent: g, emissive });
+        const { color: color2, emissive } = pane(b.random() < 0.12);
+        b.box(side * w * 0.26, 1.1 + floor * 3, d / 2 + 0.03, 1.1, 1.2, 0.04, color2, { parent: g, emissive });
       }
     }
     b.box(0, 0, d / 2 + 0.02, 1, 2.1, 0.05, 2759956, { parent: g });
@@ -7469,8 +8988,8 @@ gl_Position = projectionMatrix * mvPosition;
     for (let floor = 0; floor < floors; floor++) {
       const isTop = floor === floors - 1;
       b.box(0, floor * 2.9, 0, w, 2.9, d, isTop && b.random() < 0.5 ? 10119760 : p.color, { parent: g });
-      const { color, emissive } = pane(b.random() < 0.1);
-      b.box(0, floor * 2.9 + 1.1, d / 2 + 0.03, 1, 1, 0.04, color, { parent: g, emissive });
+      const { color: color2, emissive } = pane(b.random() < 0.1);
+      b.box(0, floor * 2.9 + 1.1, d / 2 + 0.03, 1, 1, 0.04, color2, { parent: g, emissive });
     }
     b.cylinder(w * 0.25, floors * 2.9, -d * 0.2, 0.55, 0.55, 0.9, 2775712, g, 10);
     for (let level = 0; level < floors; level++) b.box(w / 2 + 0.4, level * 2.9, 0, 0.8, 0.18, 1.2, 8026740, { parent: g });
@@ -7489,8 +9008,8 @@ gl_Position = projectionMatrix * mvPosition;
       const u = (index - (count - 1) / 2) * 2.2;
       const isDoor = index === 0 && p.hasDoor;
       const lit = isDoor ? false : b.random() < 0.15;
-      const color = isDoor ? 3810326 : lit ? LIT_WINDOW2 : 2767434;
-      b.box(u, 1, 5.02, 0.9, 2, 0.05, color, { parent: g, emissive: lit });
+      const color2 = isDoor ? 3810326 : lit ? LIT_WINDOW2 : 2767434;
+      b.box(u, 1, 5.02, 0.9, 2, 0.05, color2, { parent: g, emissive: lit });
     }
     return b.finish({ x: p.x, z: p.z, width: w, depth: 10, height: 6 });
   }
@@ -7501,8 +9020,8 @@ gl_Position = projectionMatrix * mvPosition;
     b.box(0, 0.8, 0, 7, 4.2, 9, p.color ?? 7031344, { parent: g });
     b.prism(0, 5, 0, 7.6, 4, 9.6, 2894376, g);
     b.box(2.2, 5, -1, 0.8, 4.2, 0.8, 5920336, { parent: g });
-    const { color, emissive } = pane(b.random() < 0.3);
-    b.box(0, 1.6, 4.52, 1.3, 1.3, 0.04, color, { parent: g, emissive });
+    const { color: color2, emissive } = pane(b.random() < 0.3);
+    b.box(0, 1.6, 4.52, 1.3, 1.3, 0.04, color2, { parent: g, emissive });
     b.box(0, 6.2, 4.6, 1, 1, 0.04, DARK_WINDOW2, { parent: g });
     return b.finish({ x: p.x, z: p.z, width: 7.6, depth: 9.6, height: 9 });
   }
@@ -7544,8 +9063,8 @@ gl_Position = projectionMatrix * mvPosition;
     b.prism(0, 3, 0, w + 0.5, 1.6, d + 0.5, p.roofColor ?? DEFAULT_ROOF, g);
     b.box(0, 0, d / 2 + 0.02, 1, 2.1, 0.05, 2759956, { parent: g });
     for (const side of [-1, 1]) {
-      const { color, emissive } = pane(b.random() < 0.15);
-      b.box(side * w * 0.28, 1.1, d / 2 + 0.03, 1.1, 1.1, 0.04, color, { parent: g, emissive });
+      const { color: color2, emissive } = pane(b.random() < 0.15);
+      b.box(side * w * 0.28, 1.1, d / 2 + 0.03, 1.1, 1.1, 0.04, color2, { parent: g, emissive });
       if (p.isBoarded || b.random() < 0.3) for (const k of [-1, 1]) b.box(side * w * 0.28, 1.5 + k * 0.25, d / 2 + 0.08, 1.3, 0.14, 0.04, 7031338, { parent: g, rz: k * 0.15 });
     }
     return b.finish({ x: p.x, z: p.z, width: w + 0.5, depth: d + 0.5, height: 4.6 });
@@ -12691,8 +14210,8 @@ gl_Position = projectionMatrix * mvPosition;
         });
       return GRM[kind];
     }
-    function mkSurf(mesh, W) {
-      const geo = mesh.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
+    function mkSurf(mesh2, W) {
+      const geo = mesh2.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
       geo.computeBoundingBox();
       const bb = geo.boundingBox.clone();
       const T = [], BY = {}, BX = {}, Q = 0.02;
@@ -12709,11 +14228,11 @@ gl_Position = projectionMatrix * mvPosition;
       S.hit = function(o, dd) {
         const d = dd.clone().normalize();
         ray.set(o, d);
-        const list = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
-        if (!list) return null;
+        const list2 = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
+        if (!list2) return null;
         let best = 1e9, bt = null;
-        for (let k = 0; k < list.length; k++) {
-          const t = T[list[k]];
+        for (let k = 0; k < list2.length; k++) {
+          const t = T[list2[k]];
           if (!ray.intersectTriangle(t[0], t[1], t[2], false, tmp)) continue;
           const dist2 = tmp.distanceTo(o);
           if (dist2 < best) {
@@ -12888,8 +14407,8 @@ gl_Position = projectionMatrix * mvPosition;
       t.castShadow = false;
       return t;
     }
-    function lineOn(c, Gd, list, r, mat, off) {
-      const pts = list.map(function(q) {
+    function lineOn(c, Gd, list2, r, mat, off) {
+      const pts = list2.map(function(q) {
         const s = Gd.at(q[0], q[1]);
         return s.p.addScaledVector(s.n, off || 3e-3);
       });
@@ -12960,8 +14479,8 @@ gl_Position = projectionMatrix * mvPosition;
           const r = sh(q[0]), y = (r[0] + r[1]) / 2 + (q[1] || 0), s = Gd.at(q[0], y), rad = q[2] || Math.min(0.034, (r[1] - r[0]) * 0.4);
           const cup = onSurf(c.cylinder(rad * 1.35, rad * 1.2, 0.012, LH, 0, 0, 0), s, 8e-3);
           cup.castShadow = false;
-          const ring = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
-          ring.castShadow = false;
+          const ring2 = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
+          ring2.castShadow = false;
           const b = onSurf(c.sphere(rad, MT.head, 0, 0, 0, 1, 0.55, 1), s, 0.01);
           b.castShadow = false;
           inner.push(b);
@@ -13578,9 +15097,9 @@ gl_Position = projectionMatrix * mvPosition;
       });
     })();
     const REFLB = CM("#d3d7da", { metalness: 0.35, roughness: 0.28 });
-    function dlo(list) {
+    function dlo(list2) {
       return function(def) {
-        return list.concat([def[def.length - 1]]);
+        return list2.concat([def[def.length - 1]]);
       };
     }
     function cabTaper(belt, top, x0, L, a) {
@@ -15938,7 +17457,7 @@ gl_Position = projectionMatrix * mvPosition;
           guards: [-1.1, 2],
           lightsY: 0.62
         });
-        const box = boxBody(c, { x0: f - len2 - 0.1, x1: -3.72, y0: 0.98, y1: 3.38, W: 2.42, col: "#f1f1ec" });
+        const box2 = boxBody(c, { x0: f - len2 - 0.1, x1: -3.72, y0: 0.98, y1: 3.38, W: 2.42, col: "#f1f1ec" });
         [1, -1].forEach(function(s) {
           c.roundBox(4.6, 0.32, 0.01, 0.01, CM("#1f4fa3", { roughness: 0.5 }), -1, 1.35, s * 1.217);
           c.roundBox(4.6, 0.06, 0.01, 0.01, CM("#e0a21c", { roughness: 0.5 }), -1, 1.56, s * 1.217);
@@ -15969,7 +17488,7 @@ gl_Position = projectionMatrix * mvPosition;
             c2.rod(new V3(-3.86, 0.6, z), new V3(-3.86, 3.5, z), 0.022, kit.steelMaterial);
           });
         });
-        void box;
+        void box2;
       }
     );
     fx.register(
@@ -17146,9 +18665,9 @@ gl_Position = projectionMatrix * mvPosition;
       return m;
     }
     function fenestron(c, x, y, R, w, n, mat, bladeMat) {
-      const ring = c.add(new THREE.TorusGeometry(R + 0.06, 0.07, 10, 36), mat, x, y, 0);
-      ring.scale.z = w / 0.14;
-      c.deform.push(ring);
+      const ring2 = c.add(new THREE.TorusGeometry(R + 0.06, 0.07, 10, 36), mat, x, y, 0);
+      ring2.scale.z = w / 0.14;
+      c.deform.push(ring2);
       const duct = c.cylinder(R + 0.01, R + 0.01, w, MT.dark, x, y, 0, "z", { seg: 36, open: true });
       duct.material = CM("#141516", { roughness: 0.8, side: THREE.DoubleSide });
       const g = new THREE.Group();
@@ -17176,7 +18695,7 @@ gl_Position = projectionMatrix * mvPosition;
         );
       }
       c.spin.push({ o: g, axis: "z", v: 22 });
-      return { ring, fan: g, duct };
+      return { ring: ring2, fan: g, duct };
     }
     function xRotor(c, x, y, z, R, ch, mat, tip) {
       const g = new THREE.Group();
@@ -18893,16 +20412,16 @@ gl_Position = projectionMatrix * mvPosition;
     function settle(c, tilt, riseOnly) {
       if (tilt) c.vehicle.rotation.z += tilt;
       c.root.updateMatrixWorld(true);
-      const inv = new THREE.Matrix4().copy(c.root.matrixWorld).invert(), box = new THREE.Box3(), tmp = new THREE.Box3();
+      const inv = new THREE.Matrix4().copy(c.root.matrixWorld).invert(), box2 = new THREE.Box3(), tmp = new THREE.Box3();
       c.vehicle.traverse(function(ob) {
         if (!ob.isMesh) return;
         for (let q = ob; q && q !== c.vehicle; q = q.parent)
           if (!q.visible || q.userData.decal || q.userData.ghost || q.userData.antena) return;
         if (!ob.geometry.boundingBox) ob.geometry.computeBoundingBox();
         tmp.copy(ob.geometry.boundingBox).applyMatrix4(ob.matrixWorld).applyMatrix4(inv);
-        box.union(tmp);
+        box2.union(tmp);
       });
-      if (!box.isEmpty() && (!riseOnly || box.min.y < -5e-3)) c.vehicle.position.y -= box.min.y;
+      if (!box2.isEmpty() && (!riseOnly || box2.min.y < -5e-3)) c.vehicle.position.y -= box2.min.y;
     }
     function rollover(c, o) {
       o = o || {};
@@ -19179,10 +20698,10 @@ gl_Position = projectionMatrix * mvPosition;
     function periscope(c, x, y, z, w, label, o) {
       o = o || {};
       const rot = o.rot || 0;
-      const box = c.roundBox(0.14, 0.12, w + 0.06, 0.02, o.mat || OLIVE_STEEL, x, y, z, { rot: [0, rot, 0] });
+      const box2 = c.roundBox(0.14, 0.12, w + 0.06, 0.02, o.mat || OLIVE_STEEL, x, y, z, { rot: [0, rot, 0] });
       const gl = c.roundBox(0.02, 0.07, w, 0.01, MT.armorGlass, x + Math.cos(rot) * 0.07, y, z - Math.sin(rot) * 0.07, { rot: [0, rot, 0] });
       if (label) kit.asGlass(c, gl, label, "laminated");
-      return box;
+      return box2;
     }
     function sideSeat(c, x0, x1, fl, z, dir, o) {
       o = o || {};
@@ -21510,7 +23029,7 @@ gl_Position = projectionMatrix * mvPosition;
       o = o || {};
       if (kit.lod.on) o = Object.assign({}, o, { seg: Math.max(kit.lod.minLoftSegments, Math.round((o.seg || 24) * kit.lod.loftSegmentFraction)) });
       if (o.smooth) st = resample(st, o.smooth);
-      const seg = o.seg || 24, pos = [], idx = [], ring = seg + 1, axisY = o.axis === "y";
+      const seg = o.seg || 24, pos = [], idx = [], ring2 = seg + 1, axisY = o.axis === "y";
       st.forEach(function(s) {
         const a0 = s[1], b0 = s[2], cc = (a0 + b0) / 2, hh = Math.abs(a0 - b0) / 2, w = s[3] / 2, e = 2 / (s[4] || o.p || 2.4), zc = s[5] || 0;
         for (let j = 0; j <= seg; j++) {
@@ -21522,7 +23041,7 @@ gl_Position = projectionMatrix * mvPosition;
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const A = i * ring + k, B = A + ring;
+          const A = i * ring2 + k, 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);
         }
@@ -21534,7 +23053,7 @@ gl_Position = projectionMatrix * mvPosition;
         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, flip = e === 0 !== axisY;
+          const a = si * ring2 + k, flip = e === 0 !== axisY;
           if (flip) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
         }
@@ -21721,8 +23240,8 @@ gl_Position = projectionMatrix * mvPosition;
         });
       return GRM[kind];
     }
-    function mkSurf(mesh, W) {
-      const geo = mesh.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
+    function mkSurf(mesh2, W) {
+      const geo = mesh2.geometry, pos = geo.attributes.position, ix = geo.index, n = ix ? ix.count : pos.count;
       geo.computeBoundingBox();
       const bb = geo.boundingBox.clone();
       const T = [], BY = {}, BX = {}, Q = 0.02;
@@ -21739,11 +23258,11 @@ gl_Position = projectionMatrix * mvPosition;
       S.hit = function(o, dd) {
         const d = dd.clone().normalize();
         ray.set(o, d);
-        const list = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
-        if (!list) return null;
+        const list2 = Math.abs(d.y) < 0.5 ? BY[Math.floor(o.y / Q)] : BX[Math.floor(o.x / Q)];
+        if (!list2) return null;
         let best = 1e9, bt = null;
-        for (let k = 0; k < list.length; k++) {
-          const t = T[list[k]];
+        for (let k = 0; k < list2.length; k++) {
+          const t = T[list2[k]];
           if (!ray.intersectTriangle(t[0], t[1], t[2], false, tmp)) continue;
           const dist2 = tmp.distanceTo(o);
           if (dist2 < best) {
@@ -21918,8 +23437,8 @@ gl_Position = projectionMatrix * mvPosition;
       t.castShadow = false;
       return t;
     }
-    function lineOn(c, Gd, list, r, mat, off) {
-      const pts = list.map(function(q) {
+    function lineOn(c, Gd, list2, r, mat, off) {
+      const pts = list2.map(function(q) {
         const s = Gd.at(q[0], q[1]);
         return s.p.addScaledVector(s.n, off || 3e-3);
       });
@@ -21990,8 +23509,8 @@ gl_Position = projectionMatrix * mvPosition;
           const r = sh(q[0]), y = (r[0] + r[1]) / 2 + (q[1] || 0), s = Gd.at(q[0], y), rad = q[2] || Math.min(0.034, (r[1] - r[0]) * 0.4);
           const cup = onSurf(c.cylinder(rad * 1.35, rad * 1.2, 0.012, LH, 0, 0, 0), s, 8e-3);
           cup.castShadow = false;
-          const ring = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
-          ring.castShadow = false;
+          const ring2 = onSurf(c.add(new THREE.TorusGeometry(rad * 1.05, 4e-3, 6, 22), MT.chrome), s, 0.012, new V3(0, 0, 1));
+          ring2.castShadow = false;
           const b = onSurf(c.sphere(rad, MT.head, 0, 0, 0, 1, 0.55, 1), s, 0.01);
           b.castShadow = false;
           inner.push(b);
@@ -24068,9 +25587,9 @@ gl_Position = projectionMatrix * mvPosition;
       L.inner.push(m);
       return m;
     }
-    function bendSet(list, piv, axis, ang) {
+    function bendSet(list2, piv, axis, ang) {
       const q = new THREE.Quaternion().setFromAxisAngle(axis.clone().normalize(), ang);
-      list.forEach(function(m) {
+      list2.forEach(function(m) {
         if (!m.parent) return;
         m.position.sub(piv).applyQuaternion(q).add(piv);
         m.quaternion.premultiply(q);
@@ -25117,7 +26636,7 @@ gl_Position = projectionMatrix * mvPosition;
       );
       [1, -1].forEach(function(s) {
         const z = s * (s > 0 ? 0.44 : 0.4);
-        const box = c.roundBox(0.5, 0.38, 0.2, 0.03, aluBox, -0.7, 0.8, z, { def: true }), luggageCase = [box, c.roundBox(0.52, 0.04, 0.21, 0.015, blk, -0.7, 0.98, z)];
+        const box2 = c.roundBox(0.5, 0.38, 0.2, 0.03, aluBox, -0.7, 0.8, z, { def: true }), luggageCase = [box2, c.roundBox(0.52, 0.04, 0.21, 0.015, blk, -0.7, 0.98, z)];
         [-0.88, -0.52].forEach(function(x) {
           luggageCase.push(c.roundBox(0.04, 0.06, 0.03, 0.01, blk, x, 0.95, z + s * 0.1));
         });
@@ -25131,7 +26650,7 @@ gl_Position = projectionMatrix * mvPosition;
           blk,
           { seg: 12 }
         );
-        c.part("cargo", s > 0 ? trl("labels.right_pannier") : trl("labels.left_pannier"), box, new V3(-0.7, 0.8, z), 0.6);
+        c.part("cargo", s > 0 ? trl("labels.right_pannier") : trl("labels.left_pannier"), box2, new V3(-0.7, 0.8, z), 0.6);
         c.zone(
           s > 0 ? "case_right" : "case_left",
           s > 0 ? trl("labels.right_pannier") : trl("labels.left_pannier"),
@@ -25779,7 +27298,7 @@ gl_Position = projectionMatrix * mvPosition;
     function sloft(st, o) {
       o = o || {};
       if (kit.lod.on) o = Object.assign({}, o, { seg: Math.max(kit.lod.minLoftSegments, Math.round((o.seg || 24) * kit.lod.loftSegmentFraction)) });
-      const seg = o.seg || 24, pos = [], idx = [], ring = seg + 1, axisY = o.axis === "y";
+      const seg = o.seg || 24, pos = [], idx = [], ring2 = seg + 1, axisY = o.axis === "y";
       st.forEach(function(s) {
         const a0 = s[1], b0 = s[2], cc = (a0 + b0) / 2, hh = Math.abs(a0 - b0) / 2, w = s[3] / 2, e = 2 / (s[4] || o.p || 2.4), zc = s[5] || 0;
         for (let j = 0; j <= seg; j++) {
@@ -25791,7 +27310,7 @@ gl_Position = projectionMatrix * mvPosition;
       });
       for (let i = 0; i < st.length - 1; i++)
         for (let k = 0; k < seg; k++) {
-          const A = i * ring + k, B = A + ring;
+          const A = i * ring2 + k, 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);
         }
@@ -25803,7 +27322,7 @@ gl_Position = projectionMatrix * mvPosition;
         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, flip = e === 0 !== axisY;
+          const a = si * ring2 + k, flip = e === 0 !== axisY;
           if (flip) idx.push(ci, a + 1, a);
           else idx.push(ci, a, a + 1);
         }
@@ -27034,12 +28553,12 @@ gl_Position = projectionMatrix * mvPosition;
         });
         Z.fairing = grab(c, n0).concat([fendF]);
         const HL = lamp(c, { style: "round", x: 0.72, y: 0.84, z: 0, w: 0.19, h: 0.19, d: 0.1, side: 1, label: trl("labels.headlight") });
-        const ring = new THREE.Mesh(new THREE.TorusGeometry(0.075, 7e-3, 6, 32), DRL);
-        ring.rotation.y = PI / 2;
-        ring.position.set(0.052, 0, 0);
-        ring.castShadow = false;
-        HL.group.add(ring);
-        HL.inner.push(ring);
+        const ring2 = new THREE.Mesh(new THREE.TorusGeometry(0.075, 7e-3, 6, 32), DRL);
+        ring2.rotation.y = PI / 2;
+        ring2.position.set(0.052, 0, 0);
+        ring2.castShadow = false;
+        HL.group.add(ring2);
+        HL.inner.push(ring2);
         n0 = c.vehicle.children.length;
         const TK = [
           [0.46, 0.89, 0.76, 0.18, 2.2],
@@ -30088,7 +31607,7 @@ gl_Position = projectionMatrix * mvPosition;
       });
     }
     function roofLining(c, extra) {
-      const m = c.meta, yb = (m.glasshouse ? m.glasshouse.belt : m.belt) + 0.25, bb = new THREE.Box3(), sz = new V3(), ce = new V3(), gl = new Set(c.glass), list = [];
+      const m = c.meta, yb = (m.glasshouse ? m.glasshouse.belt : m.belt) + 0.25, bb = new THREE.Box3(), sz = new V3(), ce = new V3(), gl = new Set(c.glass), list2 = [];
       const cols = [m.color, m.roofCol].filter(Boolean).map(function(h) {
         return new THREE.Color(h).getHex();
       });
@@ -30100,14 +31619,14 @@ gl_Position = projectionMatrix * mvPosition;
         bb.copy(o.geometry.boundingBox).applyMatrix4(o.matrix);
         bb.getSize(sz);
         bb.getCenter(ce);
-        if (sz.x > 0.5 && sz.z > 0.6 && sz.y < 0.08 && ce.y > yb) list.push(o);
+        if (sz.x > 0.5 && sz.z > 0.6 && sz.y < 0.08 && ce.y > yb) list2.push(o);
       });
       extra = extra || [];
-      if (list.length || extra.length)
+      if (list2.length || extra.length)
         c.zone("roof", null, null, null, {
           onBand: function(c2, b) {
             if (b >= 4)
-              list.concat(extra).forEach(function(o) {
+              list2.concat(extra).forEach(function(o) {
                 o.visible = false;
               });
           }
@@ -31892,7 +33411,7 @@ gl_Position = projectionMatrix * mvPosition;
         }
         return pts;
       }
-      const ring = 2 * (m1 + m2) + 1;
+      const ring2 = 2 * (m1 + m2) + 1;
       for (let i = 0; i <= n; i++) {
         const t = i / n, x = o.x0 + t * o.L, P = sec(t), row = [];
         for (let k = P.length - 1; k >= 1; k--) row.push([-P[k][0], P[k][1]]);
@@ -31908,8 +33427,8 @@ gl_Position = projectionMatrix * mvPosition;
         });
       }
       for (let a = 0; a < n; a++)
-        for (let k2 = 0; k2 < ring - 1; k2++) {
-          const p0 = a * ring + k2, p1 = p0 + ring;
+        for (let k2 = 0; k2 < ring2 - 1; k2++) {
+          const p0 = a * ring2 + k2, p1 = p0 + ring2;
           idx.push(p0, p0 + 1, p1, p0 + 1, p1 + 1, p1);
         }
       const ci = pos.length / 3, sh0 = o.sheer(0), ky0 = o.keel(0);
@@ -31918,7 +33437,7 @@ gl_Position = projectionMatrix * mvPosition;
         const c0 = o.col(o.x0, (sh0[1] + ky0) / 2, 0);
         col.push(c0.r, c0.g, c0.b);
       }
-      for (let r = 0; r < ring - 1; r++) idx.push(ci, r + 1, r);
+      for (let r = 0; r < ring2 - 1; r++) idx.push(ci, r + 1, r);
       let g = new THREE.BufferGeometry();
       g.setAttribute("position", new THREE.Float32BufferAttribute(pos, 3));
       if (o.col) g.setAttribute("color", new THREE.Float32BufferAttribute(col, 3));
@@ -31991,7 +33510,7 @@ gl_Position = projectionMatrix * mvPosition;
     function foilGeo(sts, o) {
       o = o || {};
       const n = o.n || 12, up = o.up || "y", pos = [], idx = [];
-      let ring;
+      let ring2;
       const cnt = 0;
       function prof(st) {
         const out = [], cam = st.cam || 0;
@@ -32011,14 +33530,14 @@ gl_Position = projectionMatrix * mvPosition;
       }
       sts.forEach(function(st) {
         const P = prof(st);
-        ring = P.length;
+        ring2 = P.length;
         P.forEach(function(p) {
           pos.push(p[0], p[1], p[2]);
         });
       });
       for (let a = 0; a < sts.length - 1; a++)
-        for (let k = 0; k < ring; k++) {
-          const k1 = (k + 1) % ring, p0 = a * ring + k, p1 = (a + 1) * ring + k, q0 = a * ring + k1, q1 = (a + 1) * ring + k1;
+        for (let k = 0; k < ring2; k++) {
+          const k1 = (k + 1) % ring2, p0 = a * ring2 + k, p1 = (a + 1) * ring2 + k, q0 = a * ring2 + k1, q1 = (a + 1) * ring2 + k1;
           idx.push(p0, q0, p1, q0, q1, p1);
         }
       ;
@@ -32026,8 +33545,8 @@ gl_Position = projectionMatrix * mvPosition;
         if (sts[si].noCap) return;
         const ci = pos.length / 3, st = sts[si];
         pos.push(st.p[0] - st.c * 0.35, st.p[1], st.p[2]);
-        for (let k = 0; k < ring; k++) {
-          const a0 = si * ring + k, a1 = si * ring + (k + 1) % ring;
+        for (let k = 0; k < ring2; k++) {
+          const a0 = si * ring2 + k, a1 = si * ring2 + (k + 1) % ring2;
           if (e === 0) idx.push(ci, a1, a0);
           else idx.push(ci, a0, a1);
         }
@@ -32255,7 +33774,7 @@ gl_Position = projectionMatrix * mvPosition;
       blue: CM("#1d4f9a", { emissive: new THREE.Color("#3a7cff"), emissiveIntensity: 1.4, roughness: 0.3 })
     };
     const HALO = { red: "#ff3a2a", green: "#3aff7a", white: "#fff1d0", amber: "#ffb040", blue: "#4a8cff" };
-    function navLight(c, x, y, z, color, label, o) {
+    function navLight(c, x, y, z, color2, label, o) {
       o = o || {};
       const r = o.r || 0.045, g = new THREE.Group();
       g.position.set(x, y, z);
@@ -32265,11 +33784,11 @@ gl_Position = projectionMatrix * mvPosition;
       base.position.y = -r * 0.4;
       if (o.rot) base.rotation.set(o.rot[0], o.rot[1], o.rot[2]);
       g.add(base);
-      const bulb = new THREE.Mesh(new THREE.SphereGeometry(r * 0.55, 10, 8), NAV[color] || NAV.white);
+      const bulb = new THREE.Mesh(new THREE.SphereGeometry(r * 0.55, 10, 8), NAV[color2] || NAV.white);
       g.add(bulb);
       const lens = new THREE.Mesh(
         new THREE.SphereGeometry(r, 12, 8),
-        color === "red" ? MT.lensRed : color === "amber" ? MT.lensAmber : MT.lens
+        color2 === "red" ? MT.lensRed : color2 === "amber" ? MT.lensAmber : MT.lens
       );
       lens.renderOrder = 3;
       g.add(lens);
@@ -32278,10 +33797,10 @@ gl_Position = projectionMatrix * mvPosition;
         inner: [bulb],
         lens: [lens],
         kind: o.front ? "headlight" : "taillight",
-        tint: color === "red" ? "red" : "clear",
+        tint: color2 === "red" ? "red" : "clear",
         broken: false
       };
-      if (o.halo !== false) L.halo = [kit.halo(g, 0, 0, 0, o.hs || 0.35, HALO[color] || "#ffffff", 0.5)];
+      if (o.halo !== false) L.halo = [kit.halo(g, 0, 0, 0, o.hs || 0.35, HALO[color2] || "#ffffff", 0.5)];
       c.lights.push(L);
       const pt = c.part(o.front ? "headlight" : "taillight", label, g, new V3(x, y, z), o.reach || 0.5);
       pt.light = L;
@@ -32403,15 +33922,15 @@ gl_Position = projectionMatrix * mvPosition;
       c.roundBox(0.16 * r, 0.03, 0.04, 0.012, MT.chrome, x, y + 0.04, z);
       c.roundBox(0.04, 0.04, 0.03, 0.01, MT.chrome, x, y + 0.02, z);
     }
-    function skinOf(c, mesh, keep, mat, o) {
+    function skinOf(c, mesh2, keep, mat, o) {
       o = o || {};
-      const g = mesh.geometry.clone(), p = g.attributes.position, sz = o.sz || 1.006, dy = o.dy || 0;
+      const g = mesh2.geometry.clone(), p = g.attributes.position, sz = o.sz || 1.006, dy = o.dy || 0;
       for (let i = 0; i < p.count; i++) {
         p.setZ(i, p.getZ(i) * sz);
         p.setY(i, p.getY(i) + dy * Math.sign(p.getY(i)));
       }
       if (g.attributes.color) g.deleteAttribute("color");
-      const m = c.add(g, mat, mesh.position.x, mesh.position.y, mesh.position.z);
+      const m = c.add(g, mat, mesh2.position.x, mesh2.position.y, mesh2.position.z);
       m.castShadow = false;
       kit.cutMesh(m, [keep], 40, o.sub ? { sub: o.sub } : void 0);
       c.deform.push(m);
@@ -34796,26 +36315,26 @@ gl_Position = projectionMatrix * mvPosition;
     const items = [];
     const windows = { lit: [], dark: [] };
     const lights = options.budget ?? createLightBudget(Number.POSITIVE_INFINITY);
-    const pick = (list) => list[Math.floor(random() * list.length)];
+    const pick = (list2) => list2[Math.floor(random() * list2.length)];
     const group = (x, y, z, ry = 0, parent = ROOT2) => parts.push({ shape: "group", parent, x, y, z, ry }) - 1;
-    const box = (x, y, z, width, height, depth, color, o = {}) => {
-      const part = { shape: "box", parent: o.parent ?? ROOT2, x, y: y + height / 2, z, width, height, depth, color, emissive: o.emissive ?? false, ry: o.ry ?? 0, rz: o.rz ?? 0, radius: boxRadius(width, height, depth) };
+    const box2 = (x, y, z, width, height, depth, color2, o = {}) => {
+      const part = { shape: "box", parent: o.parent ?? ROOT2, x, y: y + height / 2, z, width, height, depth, color: color2, emissive: o.emissive ?? false, ry: o.ry ?? 0, rz: o.rz ?? 0, radius: boxRadius(width, height, depth) };
       if (o.style) part.style = o.style;
       parts.push(part);
     };
-    const cylinder = (x, y, z, radiusTop, radiusBottom, height, color, parent = ROOT2, segments = DEFAULT_CYLINDER_SEGMENTS, style) => {
-      const part = { shape: "cylinder", parent, x, y: y + height / 2, z, radiusTop, radiusBottom, height, color, segments };
+    const cylinder2 = (x, y, z, radiusTop, radiusBottom, height, color2, parent = ROOT2, segments = DEFAULT_CYLINDER_SEGMENTS, style) => {
+      const part = { shape: "cylinder", parent, x, y: y + height / 2, z, radiusTop, radiusBottom, height, color: color2, segments };
       if (style) part.style = style;
       parts.push(part);
     };
-    const cone = (x, y, z, radius, height, color, parent = ROOT2, segments = DEFAULT_CONE_SEGMENTS) => {
-      parts.push({ shape: "cone", parent, x, y: y + height / 2, z, radius, height, color, segments });
+    const cone2 = (x, y, z, radius, height, color2, parent = ROOT2, segments = DEFAULT_CONE_SEGMENTS) => {
+      parts.push({ shape: "cone", parent, x, y: y + height / 2, z, radius, height, color: color2, segments });
     };
-    const prism = (x, y, z, width, height, depth, color, parent = ROOT2, ry = 0) => {
-      parts.push({ shape: "prism", parent, x, y, z, width, height, depth, color, ry });
+    const prism = (x, y, z, width, height, depth, color2, parent = ROOT2, ry = 0) => {
+      parts.push({ shape: "prism", parent, x, y, z, width, height, depth, color: color2, ry });
     };
-    const plane = (x, y, z, width, depth, color, style, parent = ROOT2) => {
-      const part = { shape: "plane", parent, x, y, z, width, depth, color };
+    const plane2 = (x, y, z, width, depth, color2, style, parent = ROOT2) => {
+      const part = { shape: "plane", parent, x, y, z, width, depth, color: color2 };
       if (style) part.style = style;
       parts.push(part);
     };
@@ -34825,11 +36344,11 @@ gl_Position = projectionMatrix * mvPosition;
     const terrain = (grid, parent = ROOT2) => {
       parts.push({ shape: "terrain", parent, grid });
     };
-    const crown = (x, y, z, radius, color, parent = ROOT2) => {
-      parts.push({ shape: "crown", parent, x, y, z, radius, color });
+    const crown = (x, y, z, radius, color2, parent = ROOT2) => {
+      parts.push({ shape: "crown", parent, x, y, z, radius, color: color2 });
     };
-    const line = (points, color, parent = ROOT2) => {
-      parts.push({ shape: "line", parent, points, color });
+    const line = (points, color2, parent = ROOT2) => {
+      parts.push({ shape: "line", parent, points, color: color2 });
     };
     const label = (lines, x, y, z, width, height, ry, o, parent = ROOT2) => {
       parts.push({ shape: "label", parent, x, y, z, width, height, ry, lines, background: o.background, foreground: o.foreground, font: o.font ?? DEFAULT_LABEL_FONT, canvas: o.canvas ?? { width: 512, height: 128 } });
@@ -34845,14 +36364,14 @@ gl_Position = projectionMatrix * mvPosition;
       if (o.color !== void 0) part.color = o.color;
       parts.push(part);
     };
-    const item = (x, y, z, width, height, depth, color, ry = 0, rx = 0, rz = 0) => {
-      items.push({ x, y, z, width, height, depth, color, rx, ry, rz });
+    const item = (x, y, z, width, height, depth, color2, ry = 0, rx = 0, rz = 0) => {
+      items.push({ x, y, z, width, height, depth, color: color2, rx, ry, rz });
     };
-    const fence = (x0, z0, x1, z1, height, color = DEFAULT_FENCE_POST) => {
+    const fence = (x0, z0, x1, z1, height, color2 = DEFAULT_FENCE_POST) => {
       const count = Math.ceil(Math.hypot(x1 - x0, z1 - z0) / 3);
       for (let index = 0; index <= count; index++) {
         const t = index / count;
-        cylinder(x0 + (x1 - x0) * t, 0, z0 + (z1 - z0) * t, 0.05, 0.05, height, color, ROOT2, 5);
+        cylinder2(x0 + (x1 - x0) * t, 0, z0 + (z1 - z0) * t, 0.05, 0.05, height, color2, ROOT2, 5);
       }
       for (const level of [height * 0.35, height * 0.65, height * 0.98]) line([[x0, level, z0], [x1, level, z1]], DEFAULT_FENCE_WIRE);
     };
@@ -34862,7 +36381,7 @@ gl_Position = projectionMatrix * mvPosition;
       for (const window of silhouette.windows) (window.isLit ? windows.lit : windows.dark).push(window);
     };
     const scene = () => ({ parts, items, windows });
-    return { random, pick, lights, parts, items, windows, group, box, cylinder, cone, prism, plane, vault, terrain, crown, line, label, light, spot, place, item, fence, add: add2, scene };
+    return { random, pick, lights, parts, items, windows, group, box: box2, cylinder: cylinder2, cone: cone2, prism, plane: plane2, vault, terrain, crown, line, label, light, spot, place, item, fence, add: add2, scene };
   }
   var on = (o) => o.on ?? true;
   function drawMast(b, mast, x, z, parent = -1) {
@@ -34972,8 +36491,8 @@ gl_Position = projectionMatrix * mvPosition;
     const style = walkStyle(options);
     b.box(x, 0, z, w, style.height, d, style.color, { style: { castShadow: style.castShadow } });
   }
-  function drawGround(b, color = DEFAULT_GROUND_COLOR, size = DEFAULT_GROUND_SIZE) {
-    b.plane(0, 0, 0, size, size, color);
+  function drawGround(b, color2 = DEFAULT_GROUND_COLOR, size = DEFAULT_GROUND_SIZE) {
+    b.plane(0, 0, 0, size, size, color2);
   }
   function drawStreetGrid(b, block, count, width, options) {
     for (let k = -count; k <= count; k++) {
@@ -34982,6 +36501,85 @@ gl_Position = projectionMatrix * mvPosition;
     }
     for (let i = -count; i < count; i++) for (let j = -count; j < count; j++) drawWalk(b, i * block + block / 2, j * block + block / 2, block - width, block - width, options);
   }
+  var DEFAULT_TOWER_PRESETS = [
+    { id: "office", weight: 0.6, storeyHeight: 4, mechanicalEvery: 20, glass: true, color: 3955315 },
+    { id: "residential", weight: 0.4, storeyHeight: 3.1, mechanicalEvery: 25, glass: false }
+  ];
+  var TOWER_DEFAULTS = { minHeight: 60, maxStoreys: 60, mast: 0.06, lit: 0.12 };
+  var PODIUM = 1.5;
+  var PLANT = 2895667;
+  var PODIUM_COLOR = 2764081;
+  var PARAPET = 2763308;
+  var MAST = 10133670;
+  var MAX_MAST = 25;
+  var GLASS_COLUMN = 1.6;
+  var MASONRY_COLUMN = 3;
+  function pickTowerPreset(b, presets) {
+    const total = presets.reduce((sum2, p) => sum2 + p.weight, 0);
+    let r = b.random() * total;
+    for (const preset of presets) {
+      r -= preset.weight;
+      if (r < 0) return preset;
+    }
+    return presets[presets.length - 1];
+  }
+  var towerStoreys = (height, preset) => Math.max(3, Math.round(height / preset.storeyHeight));
+  function drawTower(b, request, options = {}) {
+    const { x, z, width: w, depth: d, preset } = request;
+    const storeys = towerStoreys(request.height, preset);
+    const h = preset.storeyHeight;
+    const podium = h * PODIUM;
+    const skin = preset.color ?? request.color;
+    const mechanical = /* @__PURE__ */ new Set();
+    if (preset.mechanicalEvery) {
+      for (let k = preset.mechanicalEvery; k < storeys - 1; k += preset.mechanicalEvery) if (storeys - 1 - k >= preset.mechanicalEvery / 2) mechanical.add(k);
+    }
+    mechanical.add(storeys - 1);
+    b.box(x, 0, z, w + 0.6, podium, d + 0.6, PODIUM_COLOR);
+    const shaftTop = (storeys - 1) * h;
+    b.box(x, podium, z, w, shaftTop - podium + (podium - h), d, skin);
+    for (const k of mechanical) {
+      if (k === storeys - 1) b.box(x, k * h + (podium - h), z, w * 0.82, h, d * 0.82, PLANT);
+      else b.box(x, k * h + (podium - h), z, w + 0.4, h, d + 0.4, PLANT);
+    }
+    const top = storeys * h + (podium - h);
+    b.box(x, top, z, w * 0.82 + 0.3, 0.35, d * 0.82 + 0.3, PARAPET);
+    const mast = Math.min(MAX_MAST, top * (options.mast ?? TOWER_DEFAULTS.mast));
+    if (mast > 0.5) b.cylinder(x, top + 0.35, z, 0.12, 0.2, mast, MAST, -1, 6);
+    const column = preset.glass ? GLASS_COLUMN : MASONRY_COLUMN;
+    const winHeight = preset.glass ? h * 0.62 : 1.5;
+    const winWidth = preset.glass ? column * 0.86 : 1.3;
+    const faces = [[0, d / 2 + 0.03, w, 0], [0, -d / 2 - 0.03, w, Math.PI], [w / 2 + 0.03, 0, d, Math.PI / 2], [-w / 2 - 0.03, 0, d, -Math.PI / 2]];
+    for (const [ox, oz, faceWidth, ry] of faces) {
+      const columns = Math.max(1, Math.floor(faceWidth / column));
+      for (let storey = 1; storey < storeys; storey++) {
+        if (mechanical.has(storey)) continue;
+        const y = storey * h + (podium - h) + h * (preset.glass ? 0.2 : 0.35);
+        for (let c = 0; c < columns; c++) {
+          const u = (c - (columns - 1) / 2) * column;
+          const lit = b.random() < request.lit;
+          (lit ? b.windows.lit : b.windows.dark).push({ x: ox ? x + ox : x + u, y, z: ox ? z + u : z + oz, ry, width: winWidth, height: winHeight, isLit: lit });
+        }
+      }
+    }
+    return { x, z, width: w, depth: d, height: top + 0.35 + (mast > 0.5 ? mast : 0), color: request.color };
+  }
+  function createTowerDrawer(towers, plain) {
+    const minHeight = towers.minHeight ?? TOWER_DEFAULTS.minHeight;
+    const presets = towers.presets ?? DEFAULT_TOWER_PRESETS;
+    return (b, x, z, width, depth, height, color2, o = {}) => {
+      if (height < minHeight || presets.length === 0) return plain(b, x, z, width, depth, height, color2, o);
+      const preset = (o.preset ? presets.find((p) => p.id === o.preset) : void 0) ?? pickTowerPreset(b, presets);
+      const top = (preset.maxStoreys ?? towers.maxStoreys ?? TOWER_DEFAULTS.maxStoreys) * preset.storeyHeight;
+      const bottom = (preset.minStoreys ?? 0) * preset.storeyHeight;
+      const request = { x, z, width, depth, height: Math.min(Math.max(height, bottom), top), color: color2, preset, lit: o.lit ?? towers.lit ?? TOWER_DEFAULTS.lit, ...o.use ? { use: o.use } : {}, ...o.storeys ? { storeys: o.storeys } : {} };
+      if (towers.provider) {
+        towers.provider(request, b);
+        return { x, z, width, depth, height: request.height, color: color2 };
+      }
+      return drawTower(b, request, towers);
+    };
+  }
   var DEFAULT_FACADES = [3882821, 4866104, 3489853, 4602426, 4143924, 3093561, 5327167, 5920334];
   var DEFAULT_PARTITIONS = 2;
   var DEFAULT_GAP = 0.08;
@@ -34989,9 +36587,21 @@ gl_Position = projectionMatrix * mvPosition;
   var FOOTPRINT_TRIM = 1.2;
   var FOOTPRINT_JITTER = 1.5;
   var HEIGHT_CURVE = 1.6;
-  function drawBuilding(b, x, z, width, depth, height, color, options = {}) {
-    b.add(createCityBuilding({ x, z, width, depth, height, color, random: b.random, shopChance: options.shop, litChance: options.lit }));
-    return { x, z, width, depth, height, color };
+  var DEFAULT_STOREY_PRESETS = { commercial: "office", residential: "residential" };
+  function drawBuilding(b, x, z, width, depth, height, color2, options = {}) {
+    b.add(createCityBuilding({ x, z, width, depth, height, color: color2, random: b.random, shopChance: options.shop, litChance: options.lit }));
+    return { x, z, width, depth, height, color: color2 };
+  }
+  function pickUse(b, uses) {
+    const entries = Object.entries(uses).filter(([, w]) => w > 0);
+    const total = entries.reduce((sum2, [, w]) => sum2 + w, 0);
+    if (total <= 0) return void 0;
+    let r = b.random() * total;
+    for (const [use, w] of entries) {
+      r -= w;
+      if (r < 0) return use;
+    }
+    return entries[entries.length - 1][0];
   }
   var lerp2 = (a, b, t) => a + (b - a) * t;
   function fillBlock(b, cx, cz, size, minHeight, maxHeight, options = {}) {
@@ -35005,11 +36615,25 @@ gl_Position = projectionMatrix * mvPosition;
         if (b.random() < (options.gap || DEFAULT_GAP)) continue;
         const width = lot - FOOTPRINT_TRIM - b.random() * FOOTPRINT_JITTER;
         const depth = lot - FOOTPRINT_TRIM - b.random() * FOOTPRINT_JITTER;
-        const height = lerp2(minHeight, maxHeight, Math.pow(b.random(), HEIGHT_CURVE));
+        const t = Math.pow(b.random(), HEIGHT_CURVE);
+        let height = lerp2(minHeight, maxHeight, t);
+        let extra = null;
+        if (options.floors !== void 0 || options.uses) {
+          const use = options.uses ? pickUse(b, options.uses) : void 0;
+          const presetId = use ? (options.storeyPresets ?? DEFAULT_STOREY_PRESETS)[use] : void 0;
+          const preset = presetId ? (options.presets ?? DEFAULT_TOWER_PRESETS).find((p) => p.id === presetId) : void 0;
+          extra = { use, preset: preset?.id };
+          if (options.floors !== void 0) {
+            const [lo, hi] = typeof options.floors === "number" ? [options.floors, options.floors] : options.floors;
+            const storeys = Math.max(1, Math.round(lerp2(lo, hi, t)));
+            height = storeys * (preset?.storeyHeight ?? options.storeyHeight ?? DEFAULT_TOWER_PRESETS[DEFAULT_TOWER_PRESETS.length - 1].storeyHeight);
+            extra.storeys = storeys;
+          }
+        }
         const x = cx - half + lot * (i + 0.5);
         const z = cz - half + lot * (j + 0.5);
-        const color = b.pick(palette);
-        placed.push(drawBuilding(b, x, z, width, depth, height, color, options));
+        const color2 = b.pick(palette);
+        placed.push((options.draw ?? drawBuilding)(b, x, z, width, depth, height, color2, extra ? { ...options, ...extra } : options));
       }
     }
     return placed;
@@ -35029,11 +36653,11 @@ gl_Position = projectionMatrix * mvPosition;
   var LABEL_CANVAS = { width: 1024, height: 200 };
   var SANDBAG_LENGTH = 0.56;
   var colors = (c) => ({ ...DEFAULT_PROP_COLORS, ...c });
-  function drawFence(b, x0, z0, x1, z1, height, color) {
-    b.fence(x0, z0, x1, z1, height, color);
+  function drawFence(b, x0, z0, x1, z1, height, color2) {
+    b.fence(x0, z0, x1, z1, height, color2);
   }
-  function drawTent(b, x, z, ry, w, d, color, c) {
-    b.prism(x, 0, z, w, w * 0.7, d, color ?? colors(c).tent, -1, ry);
+  function drawTent(b, x, z, ry, w, d, color2, c) {
+    b.prism(x, 0, z, w, w * 0.7, d, color2 ?? colors(c).tent, -1, ry);
   }
   function drawPine(b, x, z, scale = 1, y = 0, c) {
     const palette = colors(c);
@@ -35047,9 +36671,9 @@ gl_Position = projectionMatrix * mvPosition;
     b.cylinder(x, 0, z, 0.12 * scale, 0.18 * scale, 1.8 * scale, palette.trunk);
     b.crown(x, 2.6 * scale, z, 1.3 * scale, b.pick(palette.crowns));
   }
-  function drawContainer(b, x, y, z, ry, color) {
+  function drawContainer(b, x, y, z, ry, color2) {
     const group = b.group(x, y, z, ry);
-    b.box(0, 0, 0, 2.44, 2.6, 6.06, color, { parent: group, style: { roughness: 0.7, metalness: 0.3 } });
+    b.box(0, 0, 0, 2.44, 2.6, 6.06, color2, { parent: group, style: { roughness: 0.7, metalness: 0.3 } });
     for (let k = -2; k <= 2; k++) b.box(k * 0.5, 0, 3.04, 0.06, 2.6, 0.04, 1710618, { parent: group });
   }
   function drawWatchtower(b, x, z, searchlight = false, c) {
@@ -35061,11 +36685,11 @@ gl_Position = projectionMatrix * mvPosition;
     if (searchlight) b.spot({ x, y: 9, z, color: 15134463, intensity: 2.4, distance: 70, decay: 1.2, angle: 0.35, penumbra: 0.5, target: { x: x + 20, y: 0, z: z + 20 }, sweep: { speed: 0.5, radius: 25 } });
   }
   function drawSandbags(b, x, z, length, along, rows = 3, c) {
-    const color = colors(c).sandbags;
+    const color2 = colors(c).sandbags;
     for (let r = 0; r < rows; r++) {
       for (let i = 0; i < length / SANDBAG_LENGTH; i++) {
         const u = -length / 2 + 0.28 + i * SANDBAG_LENGTH + r % 2 * 0.28;
-        b.item(along === "x" ? x + u : x, r * 0.21, along === "x" ? z : z + u, along === "x" ? 0.55 : 0.32, 0.22, along === "x" ? 0.32 : 0.55, color);
+        b.item(along === "x" ? x + u : x, r * 0.21, along === "x" ? z : z + u, along === "x" ? 0.55 : 0.32, 0.22, along === "x" ? 0.32 : 0.55, color2);
       }
     }
   }
@@ -35073,8 +36697,8 @@ gl_Position = projectionMatrix * mvPosition;
     const { background, foreground } = colors(c).label;
     b.label([title, subtitle], x, 2.4, z, 22, 4.4, 0, { background, foreground, font: LABEL_FONT, canvas: LABEL_CANVAS });
   }
-  function drawWires(b, points, y, color, c) {
-    b.line(points.map(([px, pz]) => [px, y, pz]), color ?? colors(c).wire);
+  function drawWires(b, points, y, color2, c) {
+    b.line(points.map(([px, pz]) => [px, y, pz]), color2 ?? colors(c).wire);
   }
   var DEFAULT_WIDTH = 8;
   var DEFAULT_DEPTH = 10;
@@ -35136,18 +36760,18 @@ gl_Position = projectionMatrix * mvPosition;
         else kit.props.tree(b, request.x, request.z, request.scale);
         plan.plants.push(request);
       },
-      building: (x, z, width, depth, height, color, o) => {
-        plan.buildings.push(kit.block.building(b, x, z, width, depth, height, color, o));
+      building: (x, z, width, depth, height, color2, o) => {
+        plan.buildings.push(kit.block.building(b, x, z, width, depth, height, color2, o));
       }
     };
     composer(context);
-    const text = pattern.text[locale] ?? pattern.text[DEFAULT_LOCALE];
-    kit.props.label(b, origin.x, origin.z + LABEL_OFFSET_Z, text.title, text.caption);
+    const text2 = pattern.text[locale] ?? pattern.text[DEFAULT_LOCALE];
+    kit.props.label(b, origin.x, origin.z + LABEL_OFFSET_Z, text2.title, text2.caption);
     return plan;
   }
   function patternMarker(pattern, origin, locale = DEFAULT_LOCALE) {
-    const text = pattern.text[locale] ?? pattern.text[DEFAULT_LOCALE];
-    return { x: origin.x, y: pattern.marker.height, z: origin.z + (pattern.marker.dz ?? 0), label: text.label, detail: text.detail };
+    const text2 = pattern.text[locale] ?? pattern.text[DEFAULT_LOCALE];
+    return { x: origin.x, y: pattern.marker.height, z: origin.z + (pattern.marker.dz ?? 0), label: text2.label, detail: text2.detail };
   }
   var composeDowntown = ({ b, kit, pattern, params, x0, z0, pole, building, vehicle }) => {
     b.plane(x0, 0.02, z0, params.roadLength, pattern.streetWidth, params.roadColor);
@@ -35543,6 +37167,359 @@ gl_Position = projectionMatrix * mvPosition;
     rural: { x: 80, z: 56 },
     military: { x: 160, z: 0 }
   };
+  var DEFAULT_DISTRICT_KINDS = [
+    { id: "downtown", color: "#3b4f7a", zone: "zt", pattern: "financial_district", floors: [20, 60], uses: { commercial: 0.7, residential: 0.3 }, block: 90, text: { "pt-BR": { name: "Centro financeiro", description: "Arranha-c\xE9us de escrit\xF3rio e torres residenciais, de 20 a 60 andares." }, en: { name: "Downtown core", description: "Office and residential towers, 20 to 60 storeys." } } },
+    { id: "commercial_center", color: "#5b6fa3", zone: "zc", pattern: "downtown", floors: [4, 15], uses: { commercial: 0.6, residential: 0.4 }, block: 70, text: { "pt-BR": { name: "Centro comercial", description: "Loja no t\xE9rreo e escrit\xF3rios ou apartamentos em cima, de 4 a 15 andares." }, en: { name: "Commercial centre", description: "Shops on the ground floor, offices or flats above, 4 to 15 storeys." } } },
+    { id: "residential_high", color: "#7a68a6", zone: "zt", pattern: "downtown", floors: [8, 25], uses: { residential: 0.9, commercial: 0.1 }, block: 80, text: { "pt-BR": { name: "Bairro de pr\xE9dios", description: "Condom\xEDnios de pr\xE9dios de 8 a 25 andares com \xE1rea de lazer." }, en: { name: "High-rise residential", description: "Apartment blocks, 8 to 25 storeys." } } },
+    { id: "mixed", color: "#9c7fb8", zone: "zr3_zm", pattern: "downtown", floors: [2, 8], uses: { residential: 0.6, commercial: 0.4 }, block: 60, text: { "pt-BR": { name: "Uso misto", description: "Sobrados, pr\xE9dios baixos e com\xE9rcio de rua, de 2 a 8 andares." }, en: { name: "Mixed use", description: "Townhouses, low blocks and street shops, 2 to 8 storeys." } } },
+    { id: "residential_mid", color: "#d9a35b", zone: "zr2", pattern: "suburb", floors: [1, 4], uses: { residential: 0.95, commercial: 0.05 }, block: 60, text: { "pt-BR": { name: "Residencial m\xE9dio", description: "Casas, sobrados e pr\xE9dios pequenos de at\xE9 4 andares." }, en: { name: "Mid-density residential", description: "Houses and small blocks up to 4 storeys." } } },
+    { id: "residential_low", color: "#e8c477", zone: "zr1", pattern: "suburb", floors: [1, 2], uses: { residential: 1 }, block: 70, text: { "pt-BR": { name: "Residencial de casas", description: "Casas t\xE9rreas e sobrados com quintal e recuo." }, en: { name: "Low-density residential", description: "Houses with yards and setbacks." } } },
+    { id: "residential_gated", color: "#c9d27a", zone: "zr_ap", pattern: "suburb", floors: [1, 3], uses: { residential: 1 }, block: 110, text: { "pt-BR": { name: "Condom\xEDnio fechado", description: "Casas grandes em lotes amplos, muro e portaria." }, en: { name: "Gated community", description: "Large houses on big lots behind a wall and gate." } } },
+    { id: "residential_popular", color: "#d97a5b", zone: "zr2", pattern: "working_class", floors: [1, 3], uses: { residential: 0.9, commercial: 0.1 }, block: 45, text: { "pt-BR": { name: "Bairro popular", description: "Casas geminadas de laje, sem recuo, ruas estreitas." }, en: { name: "Working-class housing", description: "Terraced self-built houses, narrow streets." } } },
+    { id: "historic", color: "#b5835a", zone: "zr3_zm", pattern: "historic_street", floors: [1, 3], uses: { residential: 0.6, commercial: 0.4 }, block: 50, text: { "pt-BR": { name: "Centro hist\xF3rico", description: "Casario colonial colado, rua de pedra, igreja e pra\xE7a." }, en: { name: "Historic quarter", description: "Colonial row houses, cobbled streets, church and square." } } },
+    { id: "institutional", color: "#5aa3a0", zone: "zc", pattern: "downtown", floors: [2, 8], uses: { institutional: 1 }, block: 120, text: { "pt-BR": { name: "Institucional", description: "Hospital, escola, campus, prefeitura, delegacia e quartel de bombeiros." }, en: { name: "Institutional", description: "Hospital, schools, campus, city hall, police and fire stations." } } },
+    { id: "industrial", color: "#7d7d74", zone: "zi", pattern: "industrial_port", floors: [1, 1], uses: { industrial: 1 }, block: 140, text: { "pt-BR": { name: "Distrito industrial", description: "Galp\xF5es de 8 a 12 m, p\xE1tios e chamin\xE9s." }, en: { name: "Industrial district", description: "Sheds 8 to 12 m tall, yards and stacks." } } },
+    { id: "logistics", color: "#96968a", zone: "zi", pattern: "industrial_port", floors: [1, 1], uses: { industrial: 0.8, commercial: 0.2 }, block: 160, text: { "pt-BR": { name: "Distrito log\xEDstico", description: "Centros de distribui\xE7\xE3o, posto de caminhoneiro, p\xE1tio de carretas." }, en: { name: "Logistics", description: "Distribution centres, truck stop, trailer yards." } } },
+    { id: "port", color: "#5f7f8f", zone: "zi", pattern: "industrial_port", floors: [1, 1], uses: { industrial: 1 }, block: 150, text: { "pt-BR": { name: "Porto", description: "Cais, guindastes, cont\xEAineres empilhados e armaz\xE9ns." }, en: { name: "Port", description: "Quays, cranes, stacked containers and warehouses." } } },
+    { id: "rail_yard", color: "#6e6158", zone: "zi", pattern: "railway_village", floors: [1, 1], uses: { industrial: 1 }, block: 150, text: { "pt-BR": { name: "P\xE1tio ferrovi\xE1rio", description: "Linhas, rotunda, oficina e vag\xF5es parados." }, en: { name: "Rail yard", description: "Tracks, roundhouse, workshop and parked wagons." } } },
+    { id: "company_housing", color: "#cfae86", zone: "zr1", pattern: "railway_village", floors: [1, 1], uses: { residential: 1 }, block: 50, text: { "pt-BR": { name: "Vila oper\xE1ria", description: "Casas iguais em fila, da ferrovia ou da f\xE1brica." }, en: { name: "Company housing", description: "Identical row houses of the railway or the mill." } } },
+    { id: "hillside_resort", color: "#a3b58a", zone: "zr1", pattern: "mountain_resort", floors: [1, 2], uses: { residential: 0.7, commercial: 0.3 }, block: 60, text: { "pt-BR": { name: "Serra e pousadas", description: "Chal\xE9s e pousadas na encosta, ruas em curva." }, en: { name: "Hillside resort", description: "Chalets and inns on the slope." } } },
+    { id: "stilt", color: "#7fa3b5", zone: "zr1", pattern: "stilt_village", floors: [1, 1], uses: { residential: 1 }, block: 40, text: { "pt-BR": { name: "Palafitas", description: "Casas sobre estacas na beira da \xE1gua, trapiches." }, en: { name: "Stilt village", description: "Houses on stilts by the water, jetties." } } },
+    { id: "park", color: "#6f9a5e", zone: null, pattern: null, floors: [0, 0], uses: {}, block: 0, text: { "pt-BR": { name: "Parque e pra\xE7a", description: "\xC1rea verde, pra\xE7a, campo de futebol." }, en: { name: "Park", description: "Green space, square, football pitch." } } },
+    { id: "rural", color: "#a7b86d", zone: "za", pattern: "rural", floors: [1, 2], uses: { residential: 0.8, agricultural: 0.2 }, block: 250, text: { "pt-BR": { name: "Ch\xE1caras e s\xEDtios", description: "S\xEDtios com casa sede, horta e pomar." }, en: { name: "Smallholdings", description: "Smallholdings with a farmhouse, garden and orchard." } } },
+    { id: "farmland", color: "#c8c67e", zone: "za", pattern: "rural", floors: [0, 1], uses: { agricultural: 1 }, block: 400, text: { "pt-BR": { name: "Lavoura", description: "Planta\xE7\xE3o, silos e estradas de terra." }, en: { name: "Farmland", description: "Crops, silos and dirt roads." } } },
+    { id: "airfield", color: "#b8b8a8", zone: "za", pattern: "rural", floors: [1, 1], uses: { industrial: 1 }, block: 300, text: { "pt-BR": { name: "Aer\xF3dromo", description: "Pista, hangares e torre." }, en: { name: "Airfield", description: "Runway, hangars and tower." } } },
+    { id: "wild", color: "#4f7a4a", zone: null, pattern: null, floors: [0, 0], uses: {}, block: 0, text: { "pt-BR": { name: "Mata e morro", description: "Mata, morro, \xE1rea sem constru\xE7\xE3o." }, en: { name: "Woods and hills", description: "Woods and hills, unbuilt." } } }
+  ];
+  var DEFAULT_CITY_PLANS = [
+    {
+      id: "metropolis",
+      scale: "metropolis",
+      size: [6e3, 6e3],
+      text: { "pt-BR": { name: "Metr\xF3pole", description: "Centro financeiro de arranha-c\xE9us cercado de com\xE9rcio, bairros de pr\xE9dios, casas, periferia e ind\xFAstria na ferrovia." }, en: { name: "Metropolis", description: "Tower downtown ringed by commerce, high-rise and low-rise neighbourhoods, outskirts and industry on the railway." } },
+      districts: [
+        { id: "outskirts", kind: "rural", rect: [-3e3, -3e3, 3e3, 3e3] },
+        { id: "suburbs_w", kind: "residential_low", rect: [-2600, -2600, -600, 2600] },
+        { id: "suburbs_e", kind: "residential_mid", rect: [600, -2600, 2600, 1e3] },
+        { id: "periphery", kind: "residential_popular", rect: [-3e3, 1200, -800, 3e3] },
+        { id: "gated", kind: "residential_gated", rect: [1400, -3e3, 3e3, -1800] },
+        { id: "industry", kind: "industrial", rect: [600, 1600, 3e3, 3e3] },
+        { id: "logistics", kind: "logistics", rect: [2200, 400, 3e3, 1600] },
+        { id: "mixed", kind: "mixed", rect: [-1600, -1600, 1600, 1400] },
+        { id: "high", kind: "residential_high", rect: [-1400, -1500, -300, -300] },
+        { id: "high2", kind: "residential_high", rect: [300, -1500, 1400, -600] },
+        { id: "center", kind: "commercial_center", rect: [-900, -700, 1100, 800] },
+        { id: "downtown", kind: "downtown", rect: [-400, -400, 600, 400] },
+        { id: "hospital", kind: "institutional", rect: [-1600, 500, -1e3, 1100] },
+        { id: "campus", kind: "institutional", rect: [1300, -500, 2e3, 300] },
+        { id: "park", kind: "park", rect: [-300, 500, 500, 1100] },
+        { id: "hills", kind: "wild", rect: [-3e3, -3e3, -1800, -1800] }
+      ],
+      lines: [
+        { id: "ring", kind: "avenue", width: 30, points: [[-1700, -1700], [1700, -1700], [1700, 1500], [-1700, 1500], [-1700, -1700]] },
+        { id: "main_ns", kind: "avenue", width: 30, points: [[100, -3e3], [100, 3e3]] },
+        { id: "main_ew", kind: "avenue", width: 30, points: [[-3e3, 0], [3e3, 0]] },
+        { id: "rail", kind: "rail", width: 12, points: [[-3e3, 1500], [0, 1500], [3e3, 1300]] },
+        { id: "highway", kind: "highway", width: 24, points: [[-3e3, -2200], [3e3, -2400]] }
+      ],
+      landmarks: [
+        { kind: "station", at: [0, 1500] },
+        { kind: "hospital", at: [-1300, 800] },
+        { kind: "stadium", at: [1700, -100] },
+        { kind: "cathedral", at: [100, 100] },
+        { kind: "mall", at: [800, 600] },
+        { kind: "police", at: [300, -300] },
+        { kind: "fire", at: [-500, 600] },
+        { kind: "gas_station", at: [2400, -2300] }
+      ]
+    },
+    {
+      id: "regional_city",
+      scale: "city",
+      size: [4e3, 4e3],
+      text: { "pt-BR": { name: "Cidade m\xE9dia", description: "Centro comercial com poucos pr\xE9dios altos, bairros de casas e um distrito industrial." }, en: { name: "Regional city", description: "Commercial centre with a few tall buildings, house neighbourhoods and an industrial district." } },
+      districts: [
+        { id: "outskirts", kind: "rural", rect: [-2e3, -2e3, 2e3, 2e3] },
+        { id: "res_w", kind: "residential_low", rect: [-1800, -1600, -300, 1600] },
+        { id: "res_e", kind: "residential_mid", rect: [300, -1600, 1800, 600] },
+        { id: "popular", kind: "residential_popular", rect: [-1800, 800, -500, 1800] },
+        { id: "industry", kind: "industrial", rect: [500, 900, 2e3, 2e3] },
+        { id: "mixed", kind: "mixed", rect: [-800, -800, 900, 700] },
+        { id: "center", kind: "commercial_center", rect: [-400, -400, 500, 350] },
+        { id: "square", kind: "park", rect: [-100, -100, 150, 100] },
+        { id: "hospital", kind: "institutional", rect: [600, -900, 1e3, -500] }
+      ],
+      lines: [
+        { id: "main_ns", kind: "avenue", width: 24, points: [[0, -2e3], [0, 2e3]] },
+        { id: "main_ew", kind: "avenue", width: 24, points: [[-2e3, 0], [2e3, 0]] },
+        { id: "highway", kind: "highway", width: 24, points: [[-2e3, 1600], [2e3, 1500]] }
+      ],
+      landmarks: [
+        { kind: "church", at: [0, 0] },
+        { kind: "hospital", at: [800, -700] },
+        { kind: "school", at: [-600, 300] },
+        { kind: "police", at: [200, -200] },
+        { kind: "market", at: [300, 200] },
+        { kind: "gas_station", at: [1500, 1550] }
+      ]
+    },
+    {
+      id: "port_city",
+      scale: "city",
+      size: [4e3, 3e3],
+      text: { "pt-BR": { name: "Cidade portu\xE1ria", description: "Cais e armaz\xE9ns na margem, centro hist\xF3rico atr\xE1s do porto e bairros subindo o morro." }, en: { name: "Port city", description: "Quays and warehouses on the shore, old town behind the port and neighbourhoods up the hill." } },
+      districts: [
+        { id: "outskirts", kind: "rural", rect: [-2e3, -1500, 2e3, 1500] },
+        { id: "hill", kind: "residential_low", rect: [500, -1500, 2e3, -200] },
+        { id: "res", kind: "residential_mid", rect: [-300, -500, 1300, 900] },
+        { id: "industry", kind: "industrial", rect: [800, 500, 2e3, 1500] },
+        { id: "port", kind: "port", rect: [-2e3, -1300, -900, 1100] },
+        { id: "old_town", kind: "historic", rect: [-900, -800, 200, 400] },
+        { id: "center", kind: "commercial_center", rect: [-500, -400, 200, 100] },
+        { id: "stilts", kind: "stilt", rect: [-2e3, 1e3, -1200, 1500] }
+      ],
+      lines: [
+        { id: "shore", kind: "river", width: 60, points: [[-2e3, -1500], [-1950, 0], [-1900, 1500]] },
+        { id: "main", kind: "avenue", width: 20, points: [[-900, 0], [2e3, 0]] },
+        { id: "rail", kind: "rail", width: 12, points: [[-1200, -1500], [-1e3, -400]] }
+      ],
+      landmarks: [
+        { kind: "harbour_office", at: [-1200, 0] },
+        { kind: "church", at: [-300, -200] },
+        { kind: "market", at: [-600, 200] },
+        { kind: "lighthouse", at: [1600, -1300] },
+        { kind: "hospital", at: [700, 200] }
+      ]
+    },
+    {
+      id: "rail_town",
+      scale: "town",
+      size: [3e3, 3e3],
+      text: { "pt-BR": { name: "Cidade ferrovi\xE1ria", description: "Cidade que cresceu em volta da esta\xE7\xE3o: p\xE1tio, centro velho, vila da companhia." }, en: { name: "Rail town", description: "A town grown around its station: rail yard, old centre, company village." } },
+      districts: [
+        { id: "outskirts", kind: "rural", rect: [-1500, -1500, 1500, 1500] },
+        { id: "res", kind: "residential_low", rect: [500, 500, 1500, 1500] },
+        { id: "logistics", kind: "logistics", rect: [500, -700, 1500, 500] },
+        { id: "popular", kind: "residential_popular", rect: [-1500, 600, -300, 1500] },
+        { id: "company", kind: "company_housing", rect: [-1500, -800, -700, 500] },
+        { id: "yard", kind: "rail_yard", rect: [-700, 0, 500, 500] },
+        { id: "old_center", kind: "historic", rect: [-500, -700, 500, 0] }
+      ],
+      lines: [
+        { id: "rail", kind: "rail", width: 12, points: [[-1500, 250], [1500, 250]] },
+        { id: "highway", kind: "highway", width: 24, points: [[-1500, -100], [1500, -200]] }
+      ],
+      landmarks: [
+        { kind: "station", at: [0, 100] },
+        { kind: "church", at: [0, -400] },
+        { kind: "gas_station", at: [1e3, -150] }
+      ]
+    },
+    {
+      id: "country_town",
+      scale: "town",
+      size: [2400, 2400],
+      text: { "pt-BR": { name: "Cidade do interior", description: "Pra\xE7a da matriz no meio, com\xE9rcio t\xE9rreo em volta, casas, cooperativa e s\xEDtios em volta." }, en: { name: "Country town", description: "Main square with the church, ground-floor shops around, houses, a co-op and smallholdings." } },
+      districts: [
+        { id: "farms", kind: "farmland", rect: [-1200, -1200, 1200, 1200] },
+        { id: "chacaras", kind: "rural", rect: [-900, -900, 900, 900] },
+        { id: "houses", kind: "residential_low", rect: [-600, -600, 600, 500] },
+        { id: "company", kind: "company_housing", rect: [-700, 350, -250, 700] },
+        { id: "coop", kind: "farmland", rect: [350, 500, 900, 900], floors: [1, 1], uses: { agricultural: 0.5, industrial: 0.5 } },
+        { id: "center", kind: "historic", rect: [-250, -250, 250, 250] },
+        { id: "square", kind: "park", rect: [-60, -60, 60, 60] }
+      ],
+      lines: [
+        { id: "main", kind: "street", width: 12, points: [[-1200, 0], [1200, 0]] },
+        { id: "road", kind: "street", width: 8, points: [[0, -1200], [0, 1200]] }
+      ],
+      landmarks: [
+        { kind: "church", at: [0, -70] },
+        { kind: "market", at: [120, 80] },
+        { kind: "school", at: [-300, -200] },
+        { kind: "gas_station", at: [700, 0] },
+        { kind: "silo", at: [600, 700] }
+      ]
+    },
+    {
+      id: "mountain_village",
+      scale: "village",
+      size: [1600, 1200],
+      text: { "pt-BR": { name: "Vila serrana", description: "Largo da igreja, rua das pousadas subindo a serra e chal\xE9s espalhados na encosta." }, en: { name: "Mountain village", description: "Church square, a street of inns up the slope and chalets scattered on the hill." } },
+      districts: [
+        { id: "wild", kind: "wild", rect: [-800, -600, 800, 600] },
+        { id: "slope", kind: "rural", rect: [-700, -500, 700, 500] },
+        { id: "resort", kind: "hillside_resort", rect: [-400, -450, 500, 0] },
+        { id: "square", kind: "historic", rect: [-250, 0, 250, 300] },
+        { id: "station", kind: "rail_yard", rect: [300, 150, 700, 450] }
+      ],
+      lines: [
+        { id: "road", kind: "street", width: 7, points: [[-800, 200], [0, 150], [800, 300]] }
+      ],
+      landmarks: [
+        { kind: "church", at: [0, 150] },
+        { kind: "inn", at: [100, -200] },
+        { kind: "station", at: [500, 300] }
+      ]
+    }
+  ];
+  var DEFAULT_MAX_FLOORS = 60;
+  var DEFAULT_STREET = 10;
+  var DEFAULT_LOCALE2 = "pt-BR";
+  var DEFAULT_STOREY_PRESETS2 = { commercial: "office", residential: "residential" };
+  var text = (by, locale) => by[locale] ?? by[DEFAULT_LOCALE2];
+  var named = (name, locale) => typeof name === "string" || name === void 0 ? name : name[locale] ?? name[DEFAULT_LOCALE2];
+  var mergeLists = (parent, own) => {
+    const list2 = [...parent];
+    for (const item of own) {
+      const at = list2.findIndex((p) => p.id === item.id);
+      if (at >= 0) list2[at] = item;
+      else list2.push(item);
+    }
+    return list2;
+  };
+  function createCities(o) {
+    const maxFloors = o.maxFloors ?? DEFAULT_MAX_FLOORS;
+    const kindEntries = mergeById(DEFAULT_DISTRICT_KINDS, o.packs?.kinds);
+    applyPatches(kindEntries, o.patch?.kinds);
+    removeIds(kindEntries, o.remove?.kinds);
+    const planEntries = mergeById(DEFAULT_CITY_PLANS, o.packs?.plans);
+    applyPatches(planEntries, o.patch?.plans);
+    removeIds(planEntries, o.remove?.plans);
+    const registry = (entries, label) => ({
+      ids: () => [...entries.keys()],
+      list: () => [...entries.values()],
+      has: (id) => entries.has(id),
+      get(id) {
+        const entry = entries.get(id);
+        if (!entry) throw new Error(`Unknown ${label} "${id}"`);
+        return entry;
+      }
+    });
+    const kinds = registry(kindEntries, "district kind");
+    const rawPlans = registry(planEntries, "city plan");
+    const resolvePlan = (plan, seen = []) => {
+      if (seen.includes(plan.id)) throw new Error(`City plan "${plan.id}" extends itself (${[...seen, plan.id].join(" > ")})`);
+      const parent = plan.extends ? resolvePlan(rawPlans.get(plan.extends), [...seen, plan.id]) : void 0;
+      const scale = plan.scale ?? parent?.scale;
+      const size = plan.size ?? parent?.size;
+      const planText = plan.text ?? parent?.text;
+      if (!scale || !size || !planText) throw new Error(`City plan "${plan.id}" has no ${!scale ? "scale" : !size ? "size" : "text"}`);
+      return {
+        id: plan.id,
+        scale,
+        size,
+        text: planText,
+        extends: plan.extends,
+        districts: mergeLists(parent?.districts ?? [], plan.districts ?? []),
+        lines: mergeLists(parent?.lines ?? [], plan.lines ?? []),
+        landmarks: [...parent?.landmarks ?? [], ...plan.landmarks ?? []]
+      };
+    };
+    const plans = {
+      ...rawPlans,
+      /** The plan with everything inherited from the plans it extends. */
+      resolve: (id) => resolvePlan(rawPlans.get(id))
+    };
+    const layout = (planOrId, options = {}) => {
+      const plan = typeof planOrId === "string" ? plans.resolve(planOrId) : resolvePlan(planOrId);
+      const locale = options.locale ?? DEFAULT_LOCALE2;
+      const cap = Math.max(0, options.maxFloors ?? maxFloors);
+      const clamp22 = (n) => Math.min(cap, Math.max(0, n));
+      const districts = plan.districts.map((d) => {
+        const kind = kinds.get(d.kind);
+        const kindText = text(kind.text, locale);
+        const [lo, hi] = d.floors ?? kind.floors;
+        return {
+          id: d.id,
+          kind: kind.id,
+          rect: d.rect,
+          name: named(d.name, locale) ?? kindText.name,
+          description: kindText.description,
+          color: kind.color,
+          zone: kind.zone,
+          pattern: kind.pattern,
+          floors: [clamp22(lo), clamp22(hi)],
+          uses: d.uses ?? kind.uses,
+          block: kind.block
+        };
+      });
+      const inside = (d, x, z) => x >= d.rect[0] && x <= d.rect[2] && z >= d.rect[1] && z <= d.rect[3];
+      const districtAt = (x, z) => {
+        for (let i = districts.length - 1; i >= 0; i--) if (inside(districts[i], x, z)) return districts[i];
+        return void 0;
+      };
+      const blocks = (districtId, bo = {}) => {
+        const d = districts.find((x) => x.id === districtId);
+        if (!d) throw new Error(`City plan "${plan.id}" has no district "${districtId}"`);
+        const street = bo.street ?? DEFAULT_STREET;
+        const cell = d.block;
+        const side = cell - street;
+        if (cell <= 0 || side <= 0) return [];
+        const [x0, z0, x1, z1] = d.rect;
+        const cols = Math.floor((x1 - x0) / cell);
+        const rows = Math.floor((z1 - z0) / cell);
+        const ox = x0 + (x1 - x0 - cols * cell) / 2;
+        const oz = z0 + (z1 - z0 - rows * cell) / 2;
+        const found = [];
+        for (let i = 0; i < cols; i++) {
+          for (let j = 0; j < rows; j++) {
+            const x = ox + cell * (i + 0.5);
+            const z = oz + cell * (j + 0.5);
+            if (districtAt(x, z)?.id !== d.id) continue;
+            found.push({ x, z, size: [side, side], district: d.id, building: { floors: d.floors, uses: d.uses, zone: d.zone, pattern: d.pattern } });
+          }
+        }
+        return found;
+      };
+      const landmarks = plan.landmarks.map((l) => {
+        const { name, ...rest } = l;
+        const label = named(name, locale);
+        return label === void 0 ? rest : { ...rest, name: label };
+      });
+      const planText = text(plan.text, locale);
+      return { id: plan.id, scale: plan.scale, size: plan.size, name: planText.name, description: planText.description, districts, lines: [...plan.lines], landmarks, districtAt, blocks };
+    };
+    const stats2 = (l) => {
+      const xs = [...new Set(l.districts.flatMap((d) => [d.rect[0], d.rect[2]]))].sort((a, b) => a - b);
+      const zs = [...new Set(l.districts.flatMap((d) => [d.rect[1], d.rect[3]]))].sort((a, b) => a - b);
+      const area3 = /* @__PURE__ */ new Map();
+      let total = 0;
+      for (let i = 0; i + 1 < xs.length; i++) {
+        for (let j = 0; j + 1 < zs.length; j++) {
+          const x0 = xs[i];
+          const z0 = zs[j];
+          const w = xs[i + 1] - x0;
+          const d = zs[j + 1] - z0;
+          const owner = l.districtAt(x0 + w / 2, z0 + d / 2);
+          if (!owner) continue;
+          area3.set(owner.kind, (area3.get(owner.kind) ?? 0) + w * d);
+          total += w * d;
+        }
+      }
+      const count = /* @__PURE__ */ new Map();
+      for (const d of l.districts) count.set(d.kind, (count.get(d.kind) ?? 0) + 1);
+      return [...count.keys()].map((kind) => ({ kind, area: area3.get(kind) ?? 0, share: total > 0 ? (area3.get(kind) ?? 0) / total : 0, districts: count.get(kind) ?? 0 })).sort((a, b) => b.area - a.area);
+    };
+    const fillBlock2 = (b, block, options = {}) => {
+      const { floors, uses, pattern } = block.building;
+      if (floors[1] <= 0 || pattern === null) return [];
+      const { shop, ...rest } = options;
+      const storey = options.storeyHeight ?? o.presets.find((p) => p.id === DEFAULT_STOREY_PRESETS2.residential)?.storeyHeight ?? o.presets[0]?.storeyHeight;
+      return o.fill(b, {
+        cx: block.x,
+        cz: block.z,
+        size: Math.min(block.size[0], block.size[1]),
+        minHeight: floors[0] * storey,
+        maxHeight: floors[1] * storey,
+        floors: [floors[0], floors[1]],
+        uses,
+        shop: shop ?? uses.commercial ?? 0,
+        ...rest
+      });
+    };
+    return { maxFloors, kinds, plans, layout, stats: stats2, fillBlock: fillBlock2 };
+  }
   var clamp3 = (v, a, b) => v < a ? a : v > b ? b : v;
   var lerp22 = (a, b, t) => a + (b - a) * t;
   var smoothstep = (a, b, x) => {
@@ -35679,6 +37656,9 @@ gl_Position = projectionMatrix * mvPosition;
     const lightBudget = options.lights?.budget ?? DEFAULT_LIGHT_BUDGET;
     const facades = options.facades ?? DEFAULT_FACADES;
     const propColors = { ...DEFAULT_PROP_COLORS, ...options.props };
+    const towers = options.towers ? options.towers === true ? {} : options.towers : null;
+    const building = (b, x, z, width, depth, height, color2, o) => drawBuilding(b, x, z, width, depth, height, color2, o);
+    const drawBlockBuilding = towers ? createTowerDrawer(towers, building) : building;
     const poles = {
       ids: () => [...entries.keys()],
       list: () => [...entries.values()],
@@ -35700,19 +37680,19 @@ gl_Position = projectionMatrix * mvPosition;
       },
       block: {
         facades,
-        building: (b, x, z, width, depth, height, color, o) => drawBuilding(b, x, z, width, depth, height, color, o),
-        fill: (b, g) => fillBlock(b, g.cx, g.cz, g.size, g.minHeight, g.maxHeight, { palette: facades, ...g })
+        building: drawBlockBuilding,
+        fill: (b, g) => fillBlock(b, g.cx, g.cz, g.size, g.minHeight, g.maxHeight, { palette: facades, draw: drawBlockBuilding, ...towers?.presets ? { presets: towers.presets } : {}, ...g })
       },
       props: {
         fence: drawFence,
-        tent: (b, x, z, ry, w, d, color) => drawTent(b, x, z, ry, w, d, color, propColors),
+        tent: (b, x, z, ry, w, d, color2) => drawTent(b, x, z, ry, w, d, color2, propColors),
         pine: (b, x, z, scale, y) => drawPine(b, x, z, scale, y, propColors),
         tree: (b, x, z, scale) => drawTree(b, x, z, scale, propColors),
         container: drawContainer,
         watchtower: (b, x, z, searchlight) => drawWatchtower(b, x, z, searchlight, propColors),
         sandbags: (b, x, z, length, along, rows) => drawSandbags(b, x, z, length, along, rows, propColors),
         label: (b, x, z, title, subtitle) => drawStripLabel(b, x, z, title, subtitle, propColors),
-        wires: (b, points, y, color) => drawWires(b, points, y, color, propColors)
+        wires: (b, points, y, color2) => drawWires(b, points, y, color2, propColors)
       }
     };
     const builder = (o = {}) => createUrbanBuilder(o.random ?? createSilhouetteRandom(o.seed ?? DEFAULT_URBAN_SEED), { budget: createLightBudget(o.budget ?? lightBudget) });
@@ -35744,7 +37724,15 @@ gl_Position = projectionMatrix * mvPosition;
       }
     };
     const terrain = (o) => createTerrain(o);
-    return { ...core, poles, builder, neighbourhoods, terrain, drawTerrain };
+    const cities = createCities({
+      maxFloors: options.cities?.maxFloors,
+      packs: { kinds: options.packs?.districtKinds, plans: options.packs?.cityPlans },
+      patch: { kinds: options.patch?.districtKinds, plans: options.patch?.cityPlans },
+      remove: { kinds: options.remove?.districtKinds, plans: options.remove?.cityPlans },
+      presets: towers?.presets ?? DEFAULT_TOWER_PRESETS,
+      fill: core.block.fill
+    });
+    return { ...core, poles, cities, builder, neighbourhoods, terrain, drawTerrain, towers: { enabled: towers !== null, options: towers } };
   }
   var PARKED_VEHICLE_IDS = [...cars, ...suvs, ...pickups.filter((id) => id !== "monster_truck"), ...vans];
   var hashSpot = (x, z, ry) => {
@@ -35762,8 +37750,8 @@ gl_Position = projectionMatrix * mvPosition;
     if (ids.length === 0) throw new Error("The vehicle provider needs at least one vehicle id");
     return (request, b) => {
       const id = options.pick ? options.pick(request, ids) : ids[hashSpot(request.x, request.z, request.ry) % ids.length];
-      const color = options.paint ? options.paint(request) : request.color;
-      b.place("vehicle", id, request.x, request.z, { ry: request.ry, ...color === void 0 ? {} : { color }, seed: `${id}:${request.x}:${request.z}` });
+      const color2 = options.paint ? options.paint(request) : request.color;
+      b.place("vehicle", id, request.x, request.z, { ry: request.ry, ...color2 === void 0 ? {} : { color: color2 }, seed: `${id}:${request.x}:${request.z}` });
     };
   }
   var DEFAULT_PLANT_CONTEXTS = { tree: "sidewalk_tree", pine: "square" };
@@ -35923,9 +37911,9 @@ gl_Position = projectionMatrix * mvPosition;
   var placements = (parts, kind) => parts.filter((part) => part.shape === "placement" && part.kind === kind);
   var round = (value, digits = 3) => Math.round(value * 10 ** digits) / 10 ** digits;
   var createScenarios2 = (deps) => {
-    const { text } = deps;
-    const say = (id, ...values) => fill(text.checks[id], ...values);
-    const scenario = (id, run) => ({ id, name: text.scenarios[id] ?? id, run });
+    const { text: text2 } = deps;
+    const say = (id, ...values) => fill(text2.checks[id], ...values);
+    const scenario = (id, run) => ({ id, name: text2.scenarios[id] ?? id, run });
     const kit = () => createUrban(deps.urban);
     return [
       scenario("urban_pole_heights", ({ expect }) => {
@@ -36047,7 +38035,7 @@ gl_Position = projectionMatrix * mvPosition;
   var LAMP_SHARES = { pattern: void 0, all: 1, half: 0.5, none: 0 };
   function createUrbanTestModule(options = {}) {
     const locale = (options.locale ?? "pt-BR").toLowerCase().startsWith("en") ? "en" : "pt-BR";
-    const text = TEXT[locale];
+    const text2 = TEXT[locale];
     const terrain = options.terrain ?? DEFAULT_TEST_TERRAIN;
     const seed = options.seed ?? 7;
     const benchOrigin = options.benchOrigin ?? [0, -60];
@@ -36105,7 +38093,7 @@ gl_Position = projectionMatrix * mvPosition;
     };
     const item = (id) => ({
       id,
-      name: text.items[id] ?? id,
+      name: text2.items[id] ?? id,
       movable: false,
       build: (THREE) => {
         three = THREE;
@@ -36116,9 +38104,9 @@ gl_Position = projectionMatrix * mvPosition;
       },
       spec: (root) => {
         const THREE_ = three;
-        const box = new THREE_.Box3().setFromObject(root);
-        const size = box.getSize(new THREE_.Vector3());
-        const centre = box.getCenter(new THREE_.Vector3());
+        const box2 = new THREE_.Box3().setFromObject(root);
+        const size = box2.getSize(new THREE_.Vector3());
+        const centre = box2.getCenter(new THREE_.Vector3());
         return { name: id, tags: ["structure"], parts: [{ id: "ground", material: "concrete", shape: { kind: "box", size: [Math.max(size.x, 0.1), Math.max(size.y, 0.1), Math.max(size.z, 0.1)] }, position: [centre.x, centre.y, centre.z], anchored: true }] };
       }
     });
@@ -36136,7 +38124,7 @@ gl_Position = projectionMatrix * mvPosition;
       if (!host || !three) return;
       clearBench();
       const kit = kitWith({ lamps: settings.lamps, budget: settings.budget });
-      if ((settings.providers === "vehicles" || settings.providers === "both") && !options.vehicles) host.log(text.log.no_vehicles);
+      if ((settings.providers === "vehicles" || settings.providers === "both") && !options.vehicles) host.log(text2.log.no_vehicles);
       const b = kit.builder({ seed: settings.seed });
       const made = kit.neighbourhoods.get(settings.pattern).compose(b, { x: 0, z: 0 }, { locale, providers: providersOf(settings.providers) });
       const document = options.document ?? globalThis.document;
@@ -36145,7 +38133,7 @@ gl_Position = projectionMatrix * mvPosition;
       host.scene.add(drawn.root);
       bench = { root: drawn.root, drawn, plan: made };
       lightsLeft = b.lights.left;
-      host.log(fill(text.log.composed, settings.pattern, settings.seed, countObjects(drawn.root), drawn.lights.length), { pattern: settings.pattern, seed: settings.seed });
+      host.log(fill(text2.log.composed, settings.pattern, settings.seed, countObjects(drawn.root), drawn.lights.length), { pattern: settings.pattern, seed: settings.seed });
       helpersShown = "";
     };
     let lightsLeft = settings.budget;
@@ -36155,7 +38143,7 @@ gl_Position = projectionMatrix * mvPosition;
         if (change.id === "compose") composeBench();
         else if (change.id === "clear") {
           clearBench();
-          host?.log(text.log.cleared);
+          host?.log(text2.log.cleared);
         }
         return;
       }
@@ -36203,15 +38191,15 @@ gl_Position = projectionMatrix * mvPosition;
         if (!entry.root.parent) continue;
         entry.root.updateMatrixWorld(true);
         if (host.bench.layer("bounds")) {
-          const box = new three.Box3().setFromObject(entry.root);
+          const box2 = new three.Box3().setFromObject(entry.root);
           const inverse = new three.Matrix4().copy(entry.root.matrixWorld).invert();
-          box.applyMatrix4(inverse);
-          mark(entry.root, new three.Box3Helper(box, 6737151));
+          box2.applyMatrix4(inverse);
+          mark(entry.root, new three.Box3Helper(box2, 6737151));
         }
         if (host.bench.layer("light_radius")) {
           for (const light of entry.drawn.lights) {
             if (!light.isPointLight && !light.isSpotLight) continue;
-            const reach = new three.Mesh(new three.SphereGeometry(Math.min(light.distance || 10, 60), 14, 8), new three.MeshBasicMaterial({ color: light.color ?? 16764006, wireframe: true, transparent: true, opacity: 0.25 }));
+            const reach = new three.Mesh(new (shapeGeometries(three)).SphereGeometry(Math.min(light.distance || 10, 60), 14, 8), new three.MeshBasicMaterial({ color: light.color ?? 16764006, wireframe: true, transparent: true, opacity: 0.25 }));
             reach.position.copy(light.position);
             mark(light.parent ?? entry.root, reach);
           }
@@ -36244,7 +38232,7 @@ gl_Position = projectionMatrix * mvPosition;
       }
       return { drawCalls, triangles: Math.round(triangles), lights, instances };
     };
-    const area = () => {
+    const area3 = () => {
       const placements2 = [];
       poleIds.forEach((id, index) => placements2.push({ item: `pole_${id}`, position: [(index - (poleIds.length - 1) / 2) * POLE_GAP, 0, POLE_ROW_Z], rotationY: 0 }));
       placements2.push({ item: "street_grid", position: [-230, 0, -200], rotationY: 0 });
@@ -36259,8 +38247,8 @@ gl_Position = projectionMatrix * mvPosition;
     };
     return {
       id: URBAN_AREA_ID,
-      name: text.name,
-      group: text.group,
+      name: text2.name,
+      group: text2.group,
       get placed() {
         return placed;
       },
@@ -36270,25 +38258,25 @@ gl_Position = projectionMatrix * mvPosition;
       },
       items: () => itemIds.map(item),
       scenarios: () => createScenarios2({ text: TEXT[locale], urban: options.urban, terrain }),
-      area,
+      area: area3,
       controls: () => [
-        { kind: "choice", id: "pattern", name: text.controls.pattern, hint: text.hints.pattern, options: patternIds.map((id) => ({ id, name: text.items[id] ?? id })), default: patternIds.includes("downtown") ? "downtown" : patternIds[0] },
-        { kind: "number", id: "seed", name: text.controls.seed, hint: text.hints.seed, min: 0, max: 99999, step: 1, default: seed },
-        { kind: "choice", id: "lamps", name: text.controls.lamps, hint: text.hints.lamps, options: Object.keys(LAMP_SHARES).map((id) => ({ id, name: text.options.lamps[id] })), default: "pattern" },
-        { kind: "number", id: "budget", name: text.controls.budget, hint: text.hints.budget, min: 0, max: 64, step: 1, default: 16 },
-        { kind: "choice", id: "providers", name: text.controls.providers, hint: text.hints.providers, options: ["none", "plants", "vehicles", "both"].map((id) => ({ id, name: text.options.providers[id] })), default: "none" },
-        { kind: "action", id: "compose", name: text.actions.compose },
-        { kind: "action", id: "clear", name: text.actions.clear }
+        { kind: "choice", id: "pattern", name: text2.controls.pattern, hint: text2.hints.pattern, options: patternIds.map((id) => ({ id, name: text2.items[id] ?? id })), default: patternIds.includes("downtown") ? "downtown" : patternIds[0] },
+        { kind: "number", id: "seed", name: text2.controls.seed, hint: text2.hints.seed, min: 0, max: 99999, step: 1, default: seed },
+        { kind: "choice", id: "lamps", name: text2.controls.lamps, hint: text2.hints.lamps, options: Object.keys(LAMP_SHARES).map((id) => ({ id, name: text2.options.lamps[id] })), default: "pattern" },
+        { kind: "number", id: "budget", name: text2.controls.budget, hint: text2.hints.budget, min: 0, max: 64, step: 1, default: 16 },
+        { kind: "choice", id: "providers", name: text2.controls.providers, hint: text2.hints.providers, options: ["none", "plants", "vehicles", "both"].map((id) => ({ id, name: text2.options.providers[id] })), default: "none" },
+        { kind: "action", id: "compose", name: text2.actions.compose },
+        { kind: "action", id: "clear", name: text2.actions.clear }
       ],
-      layers: () => ["light_radius", "bounds"].map((id) => ({ id, name: text.layers[id], default: false })),
+      layers: () => ["light_radius", "bounds"].map((id) => ({ id, name: text2.layers[id], default: false })),
       metrics: () => [
-        { id: "samples", name: text.metrics.samples, read: () => [...placed.values()].filter((entry) => entry.root.parent).length },
-        { id: "draw_calls", name: text.metrics.draw_calls, read: () => count().drawCalls },
-        { id: "triangles", name: text.metrics.triangles, read: () => count().triangles },
-        { id: "real_lights", name: text.metrics.real_lights, read: () => count().lights },
-        { id: "instances", name: text.metrics.instances, read: () => count().instances },
-        { id: "bench_objects", name: text.metrics.bench_objects, read: () => bench ? countObjects(bench.root) : 0 },
-        { id: "light_budget_left", name: text.metrics.light_budget_left, read: () => bench ? lightsLeft : settings.budget }
+        { id: "samples", name: text2.metrics.samples, read: () => [...placed.values()].filter((entry) => entry.root.parent).length },
+        { id: "draw_calls", name: text2.metrics.draw_calls, read: () => count().drawCalls },
+        { id: "triangles", name: text2.metrics.triangles, read: () => count().triangles },
+        { id: "real_lights", name: text2.metrics.real_lights, read: () => count().lights },
+        { id: "instances", name: text2.metrics.instances, read: () => count().instances },
+        { id: "bench_objects", name: text2.metrics.bench_objects, read: () => bench ? countObjects(bench.root) : 0 },
+        { id: "light_budget_left", name: text2.metrics.light_budget_left, read: () => bench ? lightsLeft : settings.budget }
       ],
       attach(lent) {
         host = lent;