@adatechnology/game-interactables-three 0.1.6 → 0.1.8

package/dist/index.global.js

@@ -376,15 +376,15 @@ void main() {
       const uv = new Float32Array(n * 2);
       geo.setAttribute("uv", new THREE.BufferAttribute(uv, 2).setUsage(THREE.DynamicDrawUsage));
       geo.setIndex(streamIndex);
-      const mesh = new THREE.Mesh(geo, streamMat);
-      mesh.frustumCulled = false;
-      mesh.visible = false;
-      mesh.name = `effects:stream${i}`;
-      group.add(mesh);
-      streams.push(mesh);
-    }
-    const writeStream = (mesh, k) => {
-      const geo = mesh.geometry;
+      const mesh2 = new THREE.Mesh(geo, streamMat);
+      mesh2.frustumCulled = false;
+      mesh2.visible = false;
+      mesh2.name = `effects:stream${i}`;
+      group.add(mesh2);
+      streams.push(mesh2);
+    }
+    const writeStream = (mesh2, k) => {
+      const geo = mesh2.geometry;
       const pos = geo.getAttribute("position").array;
       const col = geo.getAttribute("color").array;
       const uv = geo.getAttribute("uv").array;
@@ -435,7 +435,7 @@ void main() {
       geo.getAttribute("position").needsUpdate = true;
       geo.getAttribute("color").needsUpdate = true;
       geo.getAttribute("uv").needsUpdate = true;
-      mesh.visible = true;
+      mesh2.visible = true;
     };
     const CONES = 16;
     const maxFlames = Math.max(0, Math.floor(options.maxFlames ?? 16));
@@ -733,10 +733,2237 @@ void main() {
     if (points.length < 2) throw new Error("createCord needs at least two points");
     const curve = new THREE.CatmullRomCurve3(points.map((p) => new THREE.Vector3(p[0], p[1], p[2])), false, "centripetal");
     const segments = Math.max(4, (points.length - 1) * 4);
-    const mesh = new THREE.Mesh(new THREE.TubeGeometry(curve, segments, radius, radialSegments, false), material);
-    mesh.name = "cord";
-    mesh.castShadow = true;
-    return mesh;
+    const mesh2 = new THREE.Mesh(new THREE.TubeGeometry(curve, segments, radius, radialSegments, false), material);
+    mesh2.name = "cord";
+    mesh2.castShadow = true;
+    return mesh2;
+  }
+
+  // ../game-shapes/dist/chunk-R4RY23RH.js
+  var __defProp2 = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  function colorHex(color2, fallback = 16777215) {
+    if (color2 === void 0) return fallback;
+    if (typeof color2 === "number") return Math.floor(color2);
+    const match = /^#([0-9a-fA-F]{6})$/.exec(color2);
+    if (!match) throw new Error(`game-shapes: colour "${color2}" is not 0xRRGGBB or #rrggbb`);
+    return parseInt(match[1], 16);
+  }
+  var srgbToLinear = (c) => c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+  function colorChannels(hex, space) {
+    const r = (hex >> 16 & 255) / 255;
+    const g = (hex >> 8 & 255) / 255;
+    const b = (hex & 255) / 255;
+    return space === "linear" ? [srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)] : [r, g, b];
+  }
+  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";
+  }
+  var lane = (text, offset, prime) => {
+    let hash = offset;
+    for (let index = 0; index < text.length; index++) {
+      hash ^= text.charCodeAt(index);
+      hash = Math.imul(hash, prime);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  };
+  var hash64 = (text) => lane(text, 2166136261, 16777619) + lane(text, 84696351, 1540483477);
+  var hashValue = (value) => hash64(canonicalJson(value));
+  var identity4 = () => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+  function quaternionFromEuler(x, y, z, order = "XYZ") {
+    const cos = Math.cos;
+    const sin = Math.sin;
+    const c1 = cos(x / 2);
+    const c2 = cos(y / 2);
+    const c3 = cos(z / 2);
+    const s1 = sin(x / 2);
+    const s2 = sin(y / 2);
+    const s3 = sin(z / 2);
+    switch (order) {
+      case "XYZ":
+        return [s1 * c2 * c3 + c1 * s2 * s3, c1 * s2 * c3 - s1 * c2 * s3, c1 * c2 * s3 + s1 * s2 * c3, c1 * c2 * c3 - s1 * s2 * s3];
+      case "YXZ":
+        return [s1 * c2 * c3 + c1 * s2 * s3, c1 * s2 * c3 - s1 * c2 * s3, c1 * c2 * s3 - s1 * s2 * c3, c1 * c2 * c3 + s1 * s2 * s3];
+      case "ZXY":
+        return [s1 * c2 * c3 - c1 * s2 * s3, c1 * s2 * c3 + s1 * c2 * s3, c1 * c2 * s3 + s1 * s2 * c3, c1 * c2 * c3 - s1 * s2 * s3];
+      case "ZYX":
+        return [s1 * c2 * c3 - c1 * s2 * s3, c1 * s2 * c3 + s1 * c2 * s3, c1 * c2 * s3 - s1 * s2 * c3, c1 * c2 * c3 + s1 * s2 * s3];
+      case "YZX":
+        return [s1 * c2 * c3 + c1 * s2 * s3, c1 * s2 * c3 + s1 * c2 * s3, c1 * c2 * s3 - s1 * s2 * c3, c1 * c2 * c3 - s1 * s2 * s3];
+      case "XZY":
+        return [s1 * c2 * c3 - c1 * s2 * s3, c1 * s2 * c3 - s1 * c2 * s3, c1 * c2 * s3 + s1 * s2 * c3, c1 * c2 * c3 + s1 * s2 * s3];
+      default:
+        throw new Error(`game-shapes: unknown rotation order "${String(order)}"`);
+    }
+  }
+  function compose(px, py, pz, q, sx, sy, sz) {
+    const [x, y, z, w] = q;
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+    const xx = x * x2;
+    const xy = x * y2;
+    const xz = x * z2;
+    const yy = y * y2;
+    const yz = y * z2;
+    const zz = z * z2;
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+    return [
+      (1 - (yy + zz)) * sx,
+      (xy + wz) * sx,
+      (xz - wy) * sx,
+      0,
+      (xy - wz) * sy,
+      (1 - (xx + zz)) * sy,
+      (yz + wx) * sy,
+      0,
+      (xz + wy) * sz,
+      (yz - wx) * sz,
+      (1 - (xx + yy)) * sz,
+      0,
+      px,
+      py,
+      pz,
+      1
+    ];
+  }
+  function headingMatrix(theta, x = 0, y = 0, z = 0) {
+    const c = Math.cos(theta);
+    const s = Math.sin(theta);
+    return [c, 0, -s, 0, 0, 1, 0, 0, s, 0, c, 0, x, y, z, 1];
+  }
+  function multiply(ae, be) {
+    const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
+    const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
+    const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
+    const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
+    const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
+    const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
+    const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
+    const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
+    return [
+      a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41,
+      a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41,
+      a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41,
+      a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41,
+      a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42,
+      a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42,
+      a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42,
+      a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42,
+      a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43,
+      a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43,
+      a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43,
+      a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43,
+      a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44,
+      a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44,
+      a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44,
+      a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44
+    ];
+  }
+  function normalMatrix(me) {
+    const n11 = me[0], n21 = me[1], n31 = me[2];
+    const n12 = me[4], n22 = me[5], n32 = me[6];
+    const n13 = me[8], n23 = me[9], n33 = me[10];
+    const t11 = n33 * n22 - n32 * n23;
+    const t12 = n32 * n13 - n33 * n12;
+    const t13 = n23 * n12 - n22 * n13;
+    const det = n11 * t11 + n21 * t12 + n31 * t13;
+    if (det === 0) return [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const detInv = 1 / det;
+    const te = [
+      t11 * detInv,
+      (n31 * n23 - n33 * n21) * detInv,
+      (n32 * n21 - n31 * n22) * detInv,
+      t12 * detInv,
+      (n33 * n11 - n31 * n13) * detInv,
+      (n31 * n12 - n32 * n11) * detInv,
+      t13 * detInv,
+      (n21 * n13 - n23 * n11) * detInv,
+      (n22 * n11 - n21 * n12) * detInv
+    ];
+    let tmp = te[1];
+    te[1] = te[3];
+    te[3] = tmp;
+    tmp = te[2];
+    te[2] = te[6];
+    te[6] = tmp;
+    tmp = te[5];
+    te[5] = te[7];
+    te[7] = tmp;
+    return te;
+  }
+  var isAffine = (e) => e[3] === 0 && e[7] === 0 && e[11] === 0 && e[15] === 1;
+  function transformPoint(e, x, y, z) {
+    const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+    return [(e[0] * x + e[4] * y + e[8] * z + e[12]) * w, (e[1] * x + e[5] * y + e[9] * z + e[13]) * w, (e[2] * x + e[6] * y + e[10] * z + e[14]) * w];
+  }
+  var toVec3 = (scale) => scale === void 0 ? [1, 1, 1] : typeof scale === "number" ? [scale, scale, scale] : scale;
+  function matrixOf(t) {
+    if (t.matrix !== void 0) return [...t.matrix];
+    if (t.heading !== void 0) {
+      const p2 = t.position ?? [0, 0, 0];
+      return headingMatrix(t.heading, p2[0], p2[1], p2[2]);
+    }
+    if (t.position === void 0 && t.rotation === void 0 && t.scale === void 0) return null;
+    const p = t.position ?? [0, 0, 0];
+    const r = t.rotation ?? [0, 0, 0];
+    const s = toVec3(t.scale);
+    return compose(p[0], p[1], p[2], quaternionFromEuler(r[0], r[1], r[2], t.rotationOrder ?? "XYZ"), s[0], s[1], s[2]);
+  }
+  var asMat4 = (m) => m ? [...m] : identity4();
+  function needsUint32(array) {
+    for (let i = array.length - 1; i >= 0; --i) if (array[i] >= 65535) return true;
+    return false;
+  }
+  var indexArray = (indices) => needsUint32(indices) ? new Uint32Array(indices) : new Uint16Array(indices);
+  function pack(type, parameters, a) {
+    return {
+      type,
+      parameters,
+      positions: new Float32Array(a.vertices),
+      normals: new Float32Array(a.normals),
+      uvs: new Float32Array(a.uvs),
+      ...a.indices ? { indices: indexArray(a.indices) } : {},
+      groups: a.groups
+    };
+  }
+  var normalize3 = (x, y, z) => {
+    const length = Math.sqrt(x * x + y * y + z * z);
+    const s = 1 / (length || 1);
+    return [x * s, y * s, z * s];
+  };
+  function box(width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1) {
+    const parameters = { width, height, depth, widthSegments, heightSegments, depthSegments };
+    widthSegments = Math.floor(widthSegments);
+    heightSegments = Math.floor(heightSegments);
+    depthSegments = Math.floor(depthSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let numberOfVertices = 0;
+    let groupStart = 0;
+    const buildPlane = (u, v, w, udir, vdir, width2, height2, depth2, gridX, gridY, materialIndex) => {
+      const segmentWidth = width2 / gridX;
+      const segmentHeight = height2 / gridY;
+      const widthHalf = width2 / 2;
+      const heightHalf = height2 / 2;
+      const depthHalf = depth2 / 2;
+      const gridX1 = gridX + 1;
+      const gridY1 = gridY + 1;
+      let vertexCounter = 0;
+      let groupCount = 0;
+      const vector = { x: 0, y: 0, z: 0 };
+      for (let iy = 0; iy < gridY1; iy++) {
+        const y = iy * segmentHeight - heightHalf;
+        for (let ix = 0; ix < gridX1; ix++) {
+          const x = ix * segmentWidth - widthHalf;
+          vector[u] = x * udir;
+          vector[v] = y * vdir;
+          vector[w] = depthHalf;
+          vertices.push(vector.x, vector.y, vector.z);
+          vector[u] = 0;
+          vector[v] = 0;
+          vector[w] = depth2 > 0 ? 1 : -1;
+          normals.push(vector.x, vector.y, vector.z);
+          uvs.push(ix / gridX);
+          uvs.push(1 - iy / gridY);
+          vertexCounter += 1;
+        }
+      }
+      for (let iy = 0; iy < gridY; iy++) {
+        for (let ix = 0; ix < gridX; ix++) {
+          const a = numberOfVertices + ix + gridX1 * iy;
+          const b = numberOfVertices + ix + gridX1 * (iy + 1);
+          const c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1);
+          const d = numberOfVertices + (ix + 1) + gridX1 * iy;
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex });
+      groupStart += groupCount;
+      numberOfVertices += vertexCounter;
+    };
+    buildPlane("z", "y", "x", -1, -1, depth, height, width, depthSegments, heightSegments, 0);
+    buildPlane("z", "y", "x", 1, -1, depth, height, -width, depthSegments, heightSegments, 1);
+    buildPlane("x", "z", "y", 1, 1, width, depth, height, widthSegments, depthSegments, 2);
+    buildPlane("x", "z", "y", 1, -1, width, depth, -height, widthSegments, depthSegments, 3);
+    buildPlane("x", "y", "z", 1, -1, width, height, depth, widthSegments, heightSegments, 4);
+    buildPlane("x", "y", "z", -1, -1, width, height, -depth, widthSegments, heightSegments, 5);
+    return pack("BoxGeometry", parameters, { vertices, normals, uvs, indices, groups });
+  }
+  function cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
+    radialSegments = Math.floor(radialSegments);
+    heightSegments = Math.floor(heightSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    const groups = [];
+    let index = 0;
+    const indexArray2 = [];
+    const halfHeight = height / 2;
+    let groupStart = 0;
+    const generateTorso = () => {
+      let groupCount = 0;
+      const slope = (radiusBottom - radiusTop) / height;
+      for (let y = 0; y <= heightSegments; y++) {
+        const indexRow = [];
+        const v = y / heightSegments;
+        const radius = v * (radiusBottom - radiusTop) + radiusTop;
+        for (let x = 0; x <= radialSegments; x++) {
+          const u = x / radialSegments;
+          const theta = u * thetaLength + thetaStart;
+          const sinTheta = Math.sin(theta);
+          const cosTheta = Math.cos(theta);
+          vertices.push(radius * sinTheta, -v * height + halfHeight, radius * cosTheta);
+          const n = normalize3(sinTheta, slope, cosTheta);
+          normals.push(n[0], n[1], n[2]);
+          uvs.push(u, 1 - v);
+          indexRow.push(index++);
+        }
+        indexArray2.push(indexRow);
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        for (let y = 0; y < heightSegments; y++) {
+          const a = indexArray2[y][x];
+          const b = indexArray2[y + 1][x];
+          const c = indexArray2[y + 1][x + 1];
+          const d = indexArray2[y][x + 1];
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+          groupCount += 6;
+        }
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: 0 });
+      groupStart += groupCount;
+    };
+    const generateCap = (top) => {
+      const centerIndexStart = index;
+      let groupCount = 0;
+      const radius = top === true ? radiusTop : radiusBottom;
+      const sign2 = top === true ? 1 : -1;
+      for (let x = 1; x <= radialSegments; x++) {
+        vertices.push(0, halfHeight * sign2, 0);
+        normals.push(0, sign2, 0);
+        uvs.push(0.5, 0.5);
+        index++;
+      }
+      const centerIndexEnd = index;
+      for (let x = 0; x <= radialSegments; x++) {
+        const u = x / radialSegments;
+        const theta = u * thetaLength + thetaStart;
+        const cosTheta = Math.cos(theta);
+        const sinTheta = Math.sin(theta);
+        vertices.push(radius * sinTheta, halfHeight * sign2, radius * cosTheta);
+        normals.push(0, sign2, 0);
+        uvs.push(cosTheta * 0.5 + 0.5, sinTheta * 0.5 * sign2 + 0.5);
+        index++;
+      }
+      for (let x = 0; x < radialSegments; x++) {
+        const c = centerIndexStart + x;
+        const i = centerIndexEnd + x;
+        if (top === true) indices.push(i, i + 1, c);
+        else indices.push(i + 1, i, c);
+        groupCount += 3;
+      }
+      groups.push({ start: groupStart, count: groupCount, materialIndex: top === true ? 1 : 2 });
+      groupStart += groupCount;
+    };
+    generateTorso();
+    if (openEnded === false) {
+      if (radiusTop > 0) generateCap(true);
+      if (radiusBottom > 0) generateCap(false);
+    }
+    return { vertices, normals, uvs, indices, groups };
+  }
+  function cylinder(radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("CylinderGeometry", parameters, cylinderArrays(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function cone(radius = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength };
+    return pack("ConeGeometry", parameters, cylinderArrays(0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength));
+  }
+  function sphere(radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI) {
+    const parameters = { radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength };
+    widthSegments = Math.max(3, Math.floor(widthSegments));
+    heightSegments = Math.max(2, Math.floor(heightSegments));
+    const thetaEnd = Math.min(thetaStart + thetaLength, Math.PI);
+    let index = 0;
+    const grid = [];
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy <= heightSegments; iy++) {
+      const verticesRow = [];
+      const v = iy / heightSegments;
+      let uOffset = 0;
+      if (iy === 0 && thetaStart === 0) uOffset = 0.5 / widthSegments;
+      else if (iy === heightSegments && thetaEnd === Math.PI) uOffset = -0.5 / widthSegments;
+      for (let ix = 0; ix <= widthSegments; ix++) {
+        const u = ix / widthSegments;
+        const x = -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        const y = radius * Math.cos(thetaStart + v * thetaLength);
+        const z = radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
+        vertices.push(x, y, z);
+        const n = normalize3(x, y, z);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(u + uOffset, 1 - v);
+        verticesRow.push(index++);
+      }
+      grid.push(verticesRow);
+    }
+    for (let iy = 0; iy < heightSegments; iy++) {
+      for (let ix = 0; ix < widthSegments; ix++) {
+        const a = grid[iy][ix + 1];
+        const b = grid[iy][ix];
+        const c = grid[iy + 1][ix];
+        const d = grid[iy + 1][ix + 1];
+        if (iy !== 0 || thetaStart > 0) indices.push(a, b, d);
+        if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d);
+      }
+    }
+    return pack("SphereGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function plane(width = 1, height = 1, widthSegments = 1, heightSegments = 1) {
+    const parameters = { width, height, widthSegments, heightSegments };
+    const widthHalf = width / 2;
+    const heightHalf = height / 2;
+    const gridX = Math.floor(widthSegments);
+    const gridY = Math.floor(heightSegments);
+    const gridX1 = gridX + 1;
+    const gridY1 = gridY + 1;
+    const segmentWidth = width / gridX;
+    const segmentHeight = height / gridY;
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let iy = 0; iy < gridY1; iy++) {
+      const y = iy * segmentHeight - heightHalf;
+      for (let ix = 0; ix < gridX1; ix++) {
+        const x = ix * segmentWidth - widthHalf;
+        vertices.push(x, -y, 0);
+        normals.push(0, 0, 1);
+        uvs.push(ix / gridX);
+        uvs.push(1 - iy / gridY);
+      }
+    }
+    for (let iy = 0; iy < gridY; iy++) {
+      for (let ix = 0; ix < gridX; ix++) {
+        const a = ix + gridX1 * iy;
+        const b = ix + gridX1 * (iy + 1);
+        const c = ix + 1 + gridX1 * (iy + 1);
+        const d = ix + 1 + gridX1 * iy;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("PlaneGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function circle(radius = 1, segments = 32, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { radius, segments, thetaStart, thetaLength };
+    segments = Math.max(3, segments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    vertices.push(0, 0, 0);
+    normals.push(0, 0, 1);
+    uvs.push(0.5, 0.5);
+    for (let s = 0, i = 3; s <= segments; s++, i += 3) {
+      const segment = thetaStart + s / segments * thetaLength;
+      vertices.push(radius * Math.cos(segment), radius * Math.sin(segment), 0);
+      normals.push(0, 0, 1);
+      uvs.push((vertices[i] / radius + 1) / 2, (vertices[i + 1] / radius + 1) / 2);
+    }
+    for (let i = 1; i <= segments; i++) indices.push(i, i + 1, 0);
+    return pack("CircleGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function ring(innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2) {
+    const parameters = { innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength };
+    thetaSegments = Math.max(3, thetaSegments);
+    phiSegments = Math.max(1, phiSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    let radius = innerRadius;
+    const radiusStep = (outerRadius - innerRadius) / phiSegments;
+    for (let j = 0; j <= phiSegments; j++) {
+      for (let i = 0; i <= thetaSegments; i++) {
+        const segment = thetaStart + i / thetaSegments * thetaLength;
+        const x = radius * Math.cos(segment);
+        const y = radius * Math.sin(segment);
+        vertices.push(x, y, 0);
+        normals.push(0, 0, 1);
+        uvs.push((x / outerRadius + 1) / 2, (y / outerRadius + 1) / 2);
+      }
+      radius += radiusStep;
+    }
+    for (let j = 0; j < phiSegments; j++) {
+      const thetaSegmentLevel = j * (thetaSegments + 1);
+      for (let i = 0; i < thetaSegments; i++) {
+        const segment = i + thetaSegmentLevel;
+        const a = segment;
+        const b = segment + thetaSegments + 1;
+        const c = segment + thetaSegments + 2;
+        const d = segment + 1;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("RingGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function lathe(points, segments = 12, phiStart = 0, phiLength = Math.PI * 2) {
+    const parameters = { points: points.map(([x, y]) => ({ x, y })), segments, phiStart, phiLength };
+    segments = Math.floor(segments);
+    phiLength = Math.max(0, Math.min(Math.PI * 2, phiLength));
+    const indices = [];
+    const vertices = [];
+    const uvs = [];
+    const initNormals = [];
+    const normals = [];
+    const inverseSegments = 1 / segments;
+    const normal = { x: 0, y: 0, z: 0 };
+    const curNormal = { x: 0, y: 0, z: 0 };
+    const prevNormal = { x: 0, y: 0, z: 0 };
+    let dx = 0;
+    let dy = 0;
+    const last = points.length - 1;
+    const px = (j) => points[j][0];
+    const py = (j) => points[j][1];
+    const setNormalized = () => {
+      const n = normalize3(normal.x, normal.y, normal.z);
+      normal.x = n[0];
+      normal.y = n[1];
+      normal.z = n[2];
+    };
+    for (let j = 0; j <= last; j++) {
+      if (j === 0) {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        prevNormal.x = normal.x;
+        prevNormal.y = normal.y;
+        prevNormal.z = normal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+      } else if (j === last) {
+        initNormals.push(prevNormal.x, prevNormal.y, prevNormal.z);
+      } else {
+        dx = px(j + 1) - px(j);
+        dy = py(j + 1) - py(j);
+        normal.x = dy * 1;
+        normal.y = -dx;
+        normal.z = dy * 0;
+        curNormal.x = normal.x;
+        curNormal.y = normal.y;
+        curNormal.z = normal.z;
+        normal.x += prevNormal.x;
+        normal.y += prevNormal.y;
+        normal.z += prevNormal.z;
+        setNormalized();
+        initNormals.push(normal.x, normal.y, normal.z);
+        prevNormal.x = curNormal.x;
+        prevNormal.y = curNormal.y;
+        prevNormal.z = curNormal.z;
+      }
+    }
+    for (let i = 0; i <= segments; i++) {
+      const phi = phiStart + i * inverseSegments * phiLength;
+      const sin = Math.sin(phi);
+      const cos = Math.cos(phi);
+      for (let j = 0; j <= last; j++) {
+        vertices.push(px(j) * sin, py(j), px(j) * cos);
+        uvs.push(i / segments, j / (points.length - 1));
+        const x = initNormals[3 * j + 0] * sin;
+        const y = initNormals[3 * j + 1];
+        const z = initNormals[3 * j + 0] * cos;
+        normals.push(x, y, z);
+      }
+    }
+    for (let i = 0; i < segments; i++) {
+      for (let j = 0; j < points.length - 1; j++) {
+        const base = j + i * points.length;
+        const a = base;
+        const b = base + points.length;
+        const c = base + points.length + 1;
+        const d = base + 1;
+        indices.push(a, b, d);
+        indices.push(c, d, b);
+      }
+    }
+    return pack("LatheGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function torus(radius = 1, tube = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2) {
+    const parameters = { radius, tube, radialSegments, tubularSegments, arc };
+    radialSegments = Math.floor(radialSegments);
+    tubularSegments = Math.floor(tubularSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    for (let j = 0; j <= radialSegments; j++) {
+      for (let i = 0; i <= tubularSegments; i++) {
+        const u = i / tubularSegments * arc;
+        const v = j / radialSegments * Math.PI * 2;
+        const x = (radius + tube * Math.cos(v)) * Math.cos(u);
+        const y = (radius + tube * Math.cos(v)) * Math.sin(u);
+        const z = tube * Math.sin(v);
+        vertices.push(x, y, z);
+        const cx = radius * Math.cos(u);
+        const cy = radius * Math.sin(u);
+        const n = normalize3(x - cx, y - cy, z - 0);
+        normals.push(n[0], n[1], n[2]);
+        uvs.push(i / tubularSegments);
+        uvs.push(j / radialSegments);
+      }
+    }
+    for (let j = 1; j <= radialSegments; j++) {
+      for (let i = 1; i <= tubularSegments; i++) {
+        const a = (tubularSegments + 1) * j + i - 1;
+        const b = (tubularSegments + 1) * (j - 1) + i - 1;
+        const c = (tubularSegments + 1) * (j - 1) + i;
+        const d = (tubularSegments + 1) * j + i;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    return pack("TorusGeometry", parameters, { vertices, normals, uvs, indices, groups: [] });
+  }
+  function difference(size, subtract) {
+    const [w, h, d] = size;
+    const hw = w / 2;
+    const hh = h / 2;
+    const hd = d / 2;
+    const holes = subtract.map((hole) => ({ x0: Math.max(-hw, Math.min(hole.min[0], hole.max[0])), x1: Math.min(hw, Math.max(hole.min[0], hole.max[0])), y0: Math.max(-hh, Math.min(hole.min[1], hole.max[1])), y1: Math.min(hh, Math.max(hole.min[1], hole.max[1])) })).filter((hole) => hole.x1 > hole.x0 && hole.y1 > hole.y0);
+    const cuts = (lo, hi, values) => [.../* @__PURE__ */ new Set([lo, hi, ...values.filter((v) => v > lo && v < hi)])].sort((a, b) => a - b);
+    const xs = cuts(-hw, hw, holes.flatMap((hole) => [hole.x0, hole.x1]));
+    const ys = cuts(-hh, hh, holes.flatMap((hole) => [hole.y0, hole.y1]));
+    const nx = xs.length - 1;
+    const ny = ys.length - 1;
+    const solid = (i, j) => {
+      if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+      const cx = (xs[i] + xs[i + 1]) / 2;
+      const cy = (ys[j] + ys[j + 1]) / 2;
+      return !holes.some((hole) => cx > hole.x0 && cx < hole.x1 && cy > hole.y0 && cy < hole.y1);
+    };
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    const quad = (corners, normal, uv) => {
+      const base = positions.length / 3;
+      for (let k = 0; k < 4; k++) {
+        positions.push(...corners[k]);
+        normals.push(...normal);
+        uvs.push(...uv[k]);
+      }
+      indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    };
+    const fu = (x) => (x + hw) / w;
+    const fv = (y) => (y + hh) / h;
+    for (let j = 0; j < ny; j++) {
+      for (let i = 0; i < nx; i++) {
+        if (!solid(i, j)) continue;
+        const x0 = xs[i];
+        const x1 = xs[i + 1];
+        const y0 = ys[j];
+        const y1 = ys[j + 1];
+        quad([[x0, y0, hd], [x1, y0, hd], [x1, y1, hd], [x0, y1, hd]], [0, 0, 1], [[fu(x0), fv(y0)], [fu(x1), fv(y0)], [fu(x1), fv(y1)], [fu(x0), fv(y1)]]);
+        quad([[x1, y0, -hd], [x0, y0, -hd], [x0, y1, -hd], [x1, y1, -hd]], [0, 0, -1], [[1 - fu(x1), fv(y0)], [1 - fu(x0), fv(y0)], [1 - fu(x0), fv(y1)], [1 - fu(x1), fv(y1)]]);
+        const zu = (z) => (z + hd) / d;
+        if (!solid(i - 1, j)) quad([[x0, y0, -hd], [x0, y0, hd], [x0, y1, hd], [x0, y1, -hd]], [-1, 0, 0], [[zu(-hd), fv(y0)], [zu(hd), fv(y0)], [zu(hd), fv(y1)], [zu(-hd), fv(y1)]]);
+        if (!solid(i + 1, j)) quad([[x1, y0, hd], [x1, y0, -hd], [x1, y1, -hd], [x1, y1, hd]], [1, 0, 0], [[zu(hd), fv(y0)], [zu(-hd), fv(y0)], [zu(-hd), fv(y1)], [zu(hd), fv(y1)]]);
+        if (!solid(i, j - 1)) quad([[x0, y0, -hd], [x1, y0, -hd], [x1, y0, hd], [x0, y0, hd]], [0, -1, 0], [[fu(x0), zu(-hd)], [fu(x1), zu(-hd)], [fu(x1), zu(hd)], [fu(x0), zu(hd)]]);
+        if (!solid(i, j + 1)) quad([[x0, y1, hd], [x1, y1, hd], [x1, y1, -hd], [x0, y1, -hd]], [0, 1, 0], [[fu(x0), zu(hd)], [fu(x1), zu(hd)], [fu(x1), zu(-hd)], [fu(x0), zu(-hd)]]);
+      }
+    }
+    return {
+      type: "BufferGeometry",
+      parameters: { size: [w, h, d], subtract: holes.map((hole) => ({ min: [hole.x0, hole.y0], max: [hole.x1, hole.y1] })) },
+      positions: new Float32Array(positions),
+      normals: new Float32Array(normals),
+      uvs: new Float32Array(uvs),
+      indices: indexArray(indices),
+      groups: []
+    };
+  }
+  var Earcut = {
+    triangulate: function(data, holeIndices, dim = 2) {
+      const hasHoles = holeIndices && holeIndices.length;
+      const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+      let outerNode = linkedList(data, 0, outerLen, dim, true);
+      const triangles = [];
+      if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+      let minX, minY, maxX, maxY, x, y, invSize;
+      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+      if (data.length > 80 * dim) {
+        minX = maxX = data[0];
+        minY = maxY = data[1];
+        for (let i = dim; i < outerLen; i += dim) {
+          x = data[i];
+          y = data[i + 1];
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+        }
+        invSize = Math.max(maxX - minX, maxY - minY);
+        invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+      return triangles;
+    }
+  };
+  function linkedList(data, start, end, dim, clockwise) {
+    let i, last;
+    if (clockwise === signedArea(data, start, end, dim) > 0) {
+      for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+    } else {
+      for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start) return start;
+    if (!end) end = start;
+    let p = start, again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next) break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear) return;
+    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+    let stop = ear, prev, next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev, b = ear, c = ear.next;
+    if (area(a, b, c) >= 0) return false;
+    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+    let p = ear.prevZ, n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev, b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+    const queue = [];
+    let i, len, start, end, list2;
+    for (i = 0, len = holeIndices.length; i < len; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+      list2 = linkedList(data, start, end, dim, false);
+      if (list2 === list2.next) list2.steiner = true;
+      queue.push(getLeftmost(list2));
+    }
+    queue.sort(compareX);
+    for (i = 0; i < queue.length; i++) {
+      outerNode = eliminateHole(queue[i], outerNode);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+      return outerNode;
+    }
+    const bridgeReverse = splitPolygon(bridge, hole);
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode, qx = -Infinity, m;
+    const hx = hole.x, hy = hole.y;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x <= hx && x > qx) {
+          qx = x;
+          m = p.x < p.next.x ? p : p.next;
+          if (x === hx) return m;
+        }
+      }
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m) return null;
+    const stop = m, mx = m.x, my = m.y;
+    let tanMin = Infinity, tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list2) {
+    let i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+    do {
+      p = list2;
+      list2 = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i = 0; i < inSize; i++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q) break;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail) tail.nextZ = e;
+          else list2 = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list2;
+  }
+  function zOrder(x, y, minX, minY, invSize) {
+    x = (x - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
+    x = (x | x << 8) & 16711935;
+    x = (x | x << 4) & 252645135;
+    x = (x | x << 2) & 858993459;
+    x = (x | x << 1) & 1431655765;
+    y = (y | y << 8) & 16711935;
+    y = (y | y << 4) & 252645135;
+    y = (y | y << 2) & 858993459;
+    y = (y | y << 1) & 1431655765;
+    return x | y << 1;
+  }
+  function getLeftmost(start) {
+    let p = start, leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+    (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+    (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+    equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4) return true;
+    if (o1 === 0 && onSegment(p1, p2, q1)) return true;
+    if (o2 === 0 && onSegment(p1, q2, q1)) return true;
+    if (o3 === 0 && onSegment(p2, p1, q2)) return true;
+    if (o4 === 0 && onSegment(p2, q1, q2)) return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num2) {
+    return num2 > 0 ? 1 : num2 < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a, inside = false;
+    const px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i, x, y, last) {
+    const p = new Node(i, x, y);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+  }
+  function Node(i, x, y) {
+    this.i = i;
+    this.x = x;
+    this.y = y;
+    this.prev = null;
+    this.next = null;
+    this.z = 0;
+    this.prevZ = null;
+    this.nextZ = null;
+    this.steiner = false;
+  }
+  function signedArea(data, start, end, dim) {
+    let sum = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+      j = i;
+    }
+    return sum;
+  }
+  var equals2 = (a, b) => a.x === b.x && a.y === b.y;
+  var linePoint = (v1, v2, t) => t === 1 ? { x: v2.x, y: v2.y } : { x: (v2.x - v1.x) * t + v1.x, y: (v2.y - v1.y) * t + v1.y };
+  function pathPoints(points) {
+    const out = [];
+    let last;
+    for (let i = 1; i < points.length; i++) {
+      const v1 = { x: points[i - 1][0], y: points[i - 1][1] };
+      const v2 = { x: points[i][0], y: points[i][1] };
+      for (let d = 0; d <= 1; d++) {
+        const point = linePoint(v1, v2, d / 1);
+        if (last && equals2(last, point)) continue;
+        out.push(point);
+        last = point;
+      }
+    }
+    return out;
+  }
+  function area2(contour) {
+    const n = contour.length;
+    let a = 0;
+    for (let p = n - 1, q = 0; q < n; p = q++) a += contour[p].x * contour[q].y - contour[q].x * contour[p].y;
+    return a * 0.5;
+  }
+  var isClockWise = (pts) => area2(pts) < 0;
+  function removeDupEndPts(points) {
+    const l = points.length;
+    if (l > 2 && equals2(points[l - 1], points[0])) points.pop();
+  }
+  function triangulateShape(contour, holes) {
+    const vertices = [];
+    const holeIndices = [];
+    const faces = [];
+    removeDupEndPts(contour);
+    for (const p of contour) vertices.push(p.x, p.y);
+    let holeIndex = contour.length;
+    holes.forEach(removeDupEndPts);
+    for (let i = 0; i < holes.length; i++) {
+      holeIndices.push(holeIndex);
+      holeIndex += holes[i].length;
+      for (const p of holes[i]) vertices.push(p.x, p.y);
+    }
+    const triangles = Earcut.triangulate(vertices, holeIndices);
+    for (let i = 0; i < triangles.length; i += 3) faces.push(triangles.slice(i, i + 3));
+    return faces;
+  }
+  function computeVertexNormals(positions, indices) {
+    const normals = new Float32Array(positions.length);
+    const get = (array, i) => [array[i * 3], array[i * 3 + 1], array[i * 3 + 2]];
+    const face = (vA, vB, vC) => {
+      const pA = get(positions, vA);
+      const pB = get(positions, vB);
+      const pC = get(positions, vC);
+      const cb = [pC[0] - pB[0], pC[1] - pB[1], pC[2] - pB[2]];
+      const ab = [pA[0] - pB[0], pA[1] - pB[1], pA[2] - pB[2]];
+      return [cb[1] * ab[2] - cb[2] * ab[1], cb[2] * ab[0] - cb[0] * ab[2], cb[0] * ab[1] - cb[1] * ab[0]];
+    };
+    const set = (i, x, y, z) => {
+      normals[i * 3] = x;
+      normals[i * 3 + 1] = y;
+      normals[i * 3 + 2] = z;
+    };
+    if (indices) {
+      for (let i = 0; i < indices.length; i += 3) {
+        const vA = indices[i];
+        const vB = indices[i + 1];
+        const vC = indices[i + 2];
+        const cb = face(vA, vB, vC);
+        for (const v of [vA, vB, vC]) {
+          const n = get(normals, v);
+          set(v, n[0] + cb[0], n[1] + cb[1], n[2] + cb[2]);
+        }
+      }
+    } else {
+      for (let i = 0; i < positions.length / 3; i += 3) {
+        const cb = face(i, i + 1, i + 2);
+        set(i, cb[0], cb[1], cb[2]);
+        set(i + 1, cb[0], cb[1], cb[2]);
+        set(i + 2, cb[0], cb[1], cb[2]);
+      }
+    }
+    for (let i = 0; i < normals.length / 3; i++) {
+      const [x, y, z] = get(normals, i);
+      const s = 1 / (Math.sqrt(x * x + y * y + z * z) || 1);
+      set(i, x * s, y * s, z * s);
+    }
+    return normals;
+  }
+  function extrude(outline, depth = 1, steps = 1, bevel = void 0) {
+    const parameters = { shape: outline, depth, steps, bevel: bevel ?? {} };
+    const verticesArray = [];
+    const uvArray = [];
+    const groups = [];
+    const placeholder = [];
+    const bevelEnabled = bevel !== false;
+    const spec = bevel === false || bevel === void 0 ? {} : bevel;
+    let bevelThickness = spec.thickness !== void 0 ? spec.thickness : 0.2;
+    let bevelSize = spec.size !== void 0 ? spec.size : bevelThickness - 0.1;
+    let bevelOffset = spec.offset !== void 0 ? spec.offset : 0;
+    let bevelSegments = spec.segments !== void 0 ? spec.segments : 3;
+    if (!bevelEnabled) {
+      bevelSegments = 0;
+      bevelThickness = 0;
+      bevelSize = 0;
+      bevelOffset = 0;
+    }
+    let vertices = pathPoints(outline.outer);
+    const holes = (outline.holes ?? []).map(pathPoints);
+    const reverse = !isClockWise(vertices);
+    if (reverse) {
+      vertices = vertices.reverse();
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        if (isClockWise(ahole)) holes[h] = ahole.reverse();
+      }
+    }
+    const faces = triangulateShape(vertices, holes);
+    const contour = vertices;
+    for (const ahole of holes) vertices = vertices.concat(ahole);
+    const scalePt2 = (pt, vec, size) => ({ x: pt.x + vec.x * size, y: pt.y + vec.y * size });
+    const vlen = vertices.length;
+    const flen = faces.length;
+    const getBevelVec = (inPt, inPrev, inNext) => {
+      let vTransX;
+      let vTransY;
+      let shrinkBy;
+      const vPrevX = inPt.x - inPrev.x;
+      const vPrevY = inPt.y - inPrev.y;
+      const vNextX = inNext.x - inPt.x;
+      const vNextY = inNext.y - inPt.y;
+      const vPrevLensq = vPrevX * vPrevX + vPrevY * vPrevY;
+      const collinear0 = vPrevX * vNextY - vPrevY * vNextX;
+      if (Math.abs(collinear0) > Number.EPSILON) {
+        const vPrevLen = Math.sqrt(vPrevLensq);
+        const vNextLen = Math.sqrt(vNextX * vNextX + vNextY * vNextY);
+        const ptPrevShiftX = inPrev.x - vPrevY / vPrevLen;
+        const ptPrevShiftY = inPrev.y + vPrevX / vPrevLen;
+        const ptNextShiftX = inNext.x - vNextY / vNextLen;
+        const ptNextShiftY = inNext.y + vNextX / vNextLen;
+        const sf = ((ptNextShiftX - ptPrevShiftX) * vNextY - (ptNextShiftY - ptPrevShiftY) * vNextX) / (vPrevX * vNextY - vPrevY * vNextX);
+        vTransX = ptPrevShiftX + vPrevX * sf - inPt.x;
+        vTransY = ptPrevShiftY + vPrevY * sf - inPt.y;
+        const vTransLensq = vTransX * vTransX + vTransY * vTransY;
+        if (vTransLensq <= 2) return { x: vTransX, y: vTransY };
+        shrinkBy = Math.sqrt(vTransLensq / 2);
+      } else {
+        let directionEq = false;
+        if (vPrevX > Number.EPSILON) {
+          if (vNextX > Number.EPSILON) directionEq = true;
+        } else if (vPrevX < -Number.EPSILON) {
+          if (vNextX < -Number.EPSILON) directionEq = true;
+        } else if (Math.sign(vPrevY) === Math.sign(vNextY)) {
+          directionEq = true;
+        }
+        if (directionEq) {
+          vTransX = -vPrevY;
+          vTransY = vPrevX;
+          shrinkBy = Math.sqrt(vPrevLensq);
+        } else {
+          vTransX = vPrevX;
+          vTransY = vPrevY;
+          shrinkBy = Math.sqrt(vPrevLensq / 2);
+        }
+      }
+      return { x: vTransX / shrinkBy, y: vTransY / shrinkBy };
+    };
+    const movements = (ring2) => {
+      const out = [];
+      for (let i = 0, il = ring2.length, j = il - 1, k = i + 1; i < il; i++, j++, k++) {
+        if (j === il) j = 0;
+        if (k === il) k = 0;
+        out[i] = getBevelVec(ring2[i], ring2[j], ring2[k]);
+      }
+      return out;
+    };
+    const contourMovements = movements(contour);
+    const holesMovements = [];
+    let verticesMovements = contourMovements.concat();
+    for (const ahole of holes) {
+      const oneHoleMovements = movements(ahole);
+      holesMovements.push(oneHoleMovements);
+      verticesMovements = verticesMovements.concat(oneHoleMovements);
+    }
+    const v = (x, y, z) => {
+      placeholder.push(x);
+      placeholder.push(y);
+      placeholder.push(z);
+    };
+    const bevelLayer = (b, zOf) => {
+      const t = b / bevelSegments;
+      const z = bevelThickness * Math.cos(t * Math.PI / 2);
+      const bs2 = bevelSize * Math.sin(t * Math.PI / 2) + bevelOffset;
+      for (let i = 0; i < contour.length; i++) {
+        const vert = scalePt2(contour[i], contourMovements[i], bs2);
+        v(vert.x, vert.y, zOf(z));
+      }
+      for (let h = 0; h < holes.length; h++) {
+        const ahole = holes[h];
+        const oneHoleMovements = holesMovements[h];
+        for (let i = 0; i < ahole.length; i++) {
+          const vert = scalePt2(ahole[i], oneHoleMovements[i], bs2);
+          v(vert.x, vert.y, zOf(z));
+        }
+      }
+    };
+    for (let b = 0; b < bevelSegments; b++) bevelLayer(b, (z) => -z);
+    const bs = bevelSize + bevelOffset;
+    for (let i = 0; i < vlen; i++) {
+      const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+      v(vert.x, vert.y, 0);
+    }
+    for (let s = 1; s <= steps; s++) {
+      for (let i = 0; i < vlen; i++) {
+        const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
+        v(vert.x, vert.y, depth / steps * s);
+      }
+    }
+    for (let b = bevelSegments - 1; b >= 0; b--) bevelLayer(b, (z) => depth + z);
+    const addVertex = (index) => {
+      verticesArray.push(placeholder[index * 3 + 0]);
+      verticesArray.push(placeholder[index * 3 + 1]);
+      verticesArray.push(placeholder[index * 3 + 2]);
+    };
+    const addUV = (x, y) => {
+      uvArray.push(x);
+      uvArray.push(y);
+    };
+    const at = (index, axis) => verticesArray[index * 3 + axis];
+    const f3 = (a, b, c) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(c);
+      const nextIndex = verticesArray.length / 3;
+      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at(index, 0), at(index, 1));
+    };
+    const f4 = (a, b, c, d) => {
+      addVertex(a);
+      addVertex(b);
+      addVertex(d);
+      addVertex(b);
+      addVertex(c);
+      addVertex(d);
+      const nextIndex = verticesArray.length / 3;
+      const iA = nextIndex - 6;
+      const iB = nextIndex - 3;
+      const iC = nextIndex - 2;
+      const iD = nextIndex - 1;
+      const byX = Math.abs(at(iA, 1) - at(iB, 1)) < Math.abs(at(iA, 0) - at(iB, 0));
+      const uv = (index) => [byX ? at(index, 0) : at(index, 1), 1 - at(index, 2)];
+      const uvs = [uv(iA), uv(iB), uv(iC), uv(iD)];
+      for (const k of [0, 1, 3, 1, 2, 3]) addUV(...uvs[k]);
+    };
+    let start = verticesArray.length / 3;
+    if (bevelEnabled) {
+      let offset = 0;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2] + offset, face[1] + offset, face[0] + offset);
+      }
+      const layer = steps + bevelSegments * 2;
+      offset = vlen * layer;
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + offset, face[1] + offset, face[2] + offset);
+      }
+    } else {
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[2], face[1], face[0]);
+      }
+      for (let i = 0; i < flen; i++) {
+        const face = faces[i];
+        f3(face[0] + vlen * steps, face[1] + vlen * steps, face[2] + vlen * steps);
+      }
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 0 });
+    start = verticesArray.length / 3;
+    const sidewalls = (ring2, layeroffset2) => {
+      let i = ring2.length;
+      while (--i >= 0) {
+        const j = i;
+        let k = i - 1;
+        if (k < 0) k = ring2.length - 1;
+        for (let s = 0, sl = steps + bevelSegments * 2; s < sl; s++) {
+          const slen1 = vlen * s;
+          const slen2 = vlen * (s + 1);
+          f4(layeroffset2 + j + slen1, layeroffset2 + k + slen1, layeroffset2 + k + slen2, layeroffset2 + j + slen2);
+        }
+      }
+    };
+    let layeroffset = 0;
+    sidewalls(contour, layeroffset);
+    layeroffset += contour.length;
+    for (const ahole of holes) {
+      sidewalls(ahole, layeroffset);
+      layeroffset += ahole.length;
+    }
+    groups.push({ start, count: verticesArray.length / 3 - start, materialIndex: 1 });
+    const positions = new Float32Array(verticesArray);
+    return { type: "ExtrudeGeometry", parameters, positions, normals: computeVertexNormals(positions), uvs: new Float32Array(uvArray), groups };
+  }
+  var PARAMETER_KEYS = {
+    box: ["size", "segments"],
+    cylinder: ["radiusTop", "radiusBottom", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    cone: ["radius", "height", "radialSegments", "heightSegments", "openEnded", "thetaStart", "thetaLength"],
+    sphere: ["radius", "widthSegments", "heightSegments", "phiStart", "phiLength", "thetaStart", "thetaLength"],
+    plane: ["width", "height", "widthSegments", "heightSegments"],
+    circle: ["radius", "segments", "thetaStart", "thetaLength"],
+    ring: ["innerRadius", "outerRadius", "thetaSegments", "phiSegments", "thetaStart", "thetaLength"],
+    lathe: ["points", "segments", "phiStart", "phiLength"],
+    torus: ["radius", "tube", "radialSegments", "tubularSegments", "arc"],
+    extrude: ["shape", "depth", "steps", "bevel"],
+    difference: ["size", "subtract"],
+    mesh: ["positions", "normals", "uvs", "indices"]
+  };
+  var SEGMENT_KEYS = {
+    cylinder: ["radialSegments"],
+    cone: ["radialSegments"],
+    sphere: ["widthSegments", "heightSegments"],
+    circle: ["segments"],
+    ring: ["thetaSegments"],
+    lathe: ["segments"],
+    torus: ["radialSegments", "tubularSegments"]
+  };
+  var SEGMENT_DEFAULTS = { radialSegments: 32, widthSegments: 32, heightSegments: 16, segments: 12, thetaSegments: 32, tubularSegments: 48 };
+  var segmentDefault = (kind, key) => kind === "circle" && key === "segments" ? 32 : kind === "torus" && key === "radialSegments" ? 12 : SEGMENT_DEFAULTS[key];
+  function primitiveParameters(node, options = {}) {
+    const out = {};
+    const source = node;
+    for (const key of PARAMETER_KEYS[node.kind]) if (source[key] !== void 0) out[key] = source[key];
+    const detail = options.detail ?? 1;
+    if (detail !== 1) {
+      const floor = options.minSegments ?? 3;
+      for (const key of SEGMENT_KEYS[node.kind] ?? []) {
+        const given = out[key] ?? segmentDefault(node.kind, key);
+        out[key] = Math.max(floor, Math.round(given * detail));
+      }
+    }
+    return out;
+  }
+  function mesh(p) {
+    const positions = new Float32Array(p.positions);
+    const indices = p.indices ? indexArray(p.indices) : void 0;
+    return {
+      type: "BufferGeometry",
+      parameters: {},
+      positions,
+      normals: p.normals ? new Float32Array(p.normals) : computeVertexNormals(positions, indices),
+      uvs: p.uvs ? new Float32Array(p.uvs) : new Float32Array(positions.length / 3 * 2),
+      ...indices ? { indices } : {},
+      groups: []
+    };
+  }
+  function make(kind, p) {
+    switch (kind) {
+      case "box": {
+        const size = p.size ?? [1, 1, 1];
+        const segments = p.segments ?? [1, 1, 1];
+        return box(size[0], size[1], size[2], segments[0], segments[1], segments[2]);
+      }
+      case "cylinder":
+        return cylinder(p.radiusTop, p.radiusBottom, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "cone":
+        return cone(p.radius, p.height, p.radialSegments, p.heightSegments, p.openEnded, p.thetaStart, p.thetaLength);
+      case "sphere":
+        return sphere(p.radius, p.widthSegments, p.heightSegments, p.phiStart, p.phiLength, p.thetaStart, p.thetaLength);
+      case "plane":
+        return plane(p.width, p.height, p.widthSegments, p.heightSegments);
+      case "circle":
+        return circle(p.radius, p.segments, p.thetaStart, p.thetaLength);
+      case "ring":
+        return ring(p.innerRadius, p.outerRadius, p.thetaSegments, p.phiSegments, p.thetaStart, p.thetaLength);
+      case "lathe":
+        return lathe(p.points, p.segments, p.phiStart, p.phiLength);
+      case "torus":
+        return torus(p.radius, p.tube, p.radialSegments, p.tubularSegments, p.arc);
+      case "extrude":
+        return extrude(p.shape, p.depth, p.steps, p.bevel);
+      case "difference":
+        return difference(p.size, p.subtract ?? []);
+      case "mesh":
+        return mesh(p);
+      default:
+        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+    }
+  }
+  var templates = /* @__PURE__ */ new Map();
+  var templateLimit = 4096;
+  var stats = { hits: 0, misses: 0 };
+  function buildPrimitive(node, options = {}) {
+    const parameters = primitiveParameters(node, options);
+    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    const key = `${node.kind}:${canonicalJson(parameters)}`;
+    const cached = templates.get(key);
+    if (cached) {
+      stats.hits++;
+      templates.delete(key);
+      templates.set(key, cached);
+      return cached;
+    }
+    stats.misses++;
+    const built = make(node.kind, parameters);
+    templates.set(key, built);
+    if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
+    return built;
+  }
+  function mulberry32(seed) {
+    let state = seed >>> 0;
+    return () => {
+      state = state + 1831565813 >>> 0;
+      let t = state;
+      t = Math.imul(t ^ t >>> 15, t | 1);
+      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  var streamFor = (seed, generator, path) => mulberry32(parseInt(hash64(`${String(seed)}\0${generator}\0${path}`).slice(0, 8), 16));
+  var generators = /* @__PURE__ */ new Map();
+  var getGenerator = (name) => generators.get(name);
+  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"] }
+  };
+  function validateNode(node, path, errors) {
+    if (!node || typeof node !== "object" || Array.isArray(node)) {
+      errors.push(`${path}: expected a node object`);
+      return;
+    }
+    const record = node;
+    const spec = typeof record.kind === "string" ? KINDS[record.kind] : void 0;
+    if (!spec) {
+      errors.push(`${path}.kind: expected one of ${Object.keys(KINDS).join(", ")}`);
+      return;
+    }
+    for (const key of spec.required ?? []) if (record[key] === void 0) errors.push(`${path}.${key}: required`);
+    for (const key of Object.keys(record)) {
+      if (record[key] === void 0 || key === "children") continue;
+      const check = spec.fields[key] ?? COMMON[key];
+      if (!check) {
+        errors.push(`${path}.${key}: unknown field for a ${String(record.kind)}`);
+        continue;
+      }
+      const e = check(record[key]);
+      if (e) errors.push(`${path}.${key}: ${e}`);
+    }
+    const exclusive = ["matrix", "heading"].filter((key) => record[key] !== void 0);
+    if (record.matrix !== void 0 && (record.position !== void 0 || record.rotation !== void 0 || record.scale !== void 0 || record.heading !== void 0))
+      errors.push(`${path}.matrix: cannot be combined with position, rotation, scale or heading`);
+    else if (exclusive.includes("heading") && (record.rotation !== void 0 || record.scale !== void 0)) errors.push(`${path}.heading: cannot be combined with rotation or scale`);
+    if (record.children !== void 0) {
+      if (record.kind !== "group") errors.push(`${path}.children: only a group has children`);
+      else if (!Array.isArray(record.children)) errors.push(`${path}.children: expected an array`);
+      else record.children.forEach((child, index) => validateNode(child, `${path}.children[${index}]`, errors));
+    }
+  }
+  function validateShape(schema) {
+    const errors = [];
+    if (!schema || typeof schema !== "object" || Array.isArray(schema)) return ["expected a shape object"];
+    const record = schema;
+    for (const key of Object.keys(record)) if (!["version", "name", "materials", "root", "lod", "cullDistance"].includes(key) && record[key] !== void 0) errors.push(`${key}: unknown field`);
+    if (record.version !== 1) errors.push("version: expected 1");
+    if (record.name !== void 0 && typeof record.name !== "string") errors.push("name: expected a string");
+    if (record.materials !== void 0) {
+      if (!record.materials || typeof record.materials !== "object" || Array.isArray(record.materials)) errors.push("materials: expected an object");
+      else {
+        const material = object({
+          color,
+          roughness: range(0, 1),
+          metalness: range(0, 1),
+          opacity: range(0, 1),
+          transparent: bool,
+          emissive: color,
+          emissiveIntensity: (v) => typeof v === "number" && v >= 0 ? null : "expected a number >= 0",
+          side: oneOf(["front", "back", "double"]),
+          flatShading: bool,
+          vertexColors: bool,
+          depthWrite: bool
+        });
+        for (const [id, hint] of Object.entries(record.materials)) {
+          const e = material(hint);
+          if (e) errors.push(`materials.${id}: ${e}`);
+        }
+      }
+    }
+    if (record.lod !== void 0) {
+      const e = list(object({ distance: (v) => typeof v === "number" && v >= 0 ? null : "expected a number >= 0", detail: range(0, 1, true), minSize: (v) => typeof v === "number" && v >= 0 ? null : "expected a number >= 0", minSegments: int(3) }, ["distance", "detail"]))(record.lod);
+      if (e) errors.push(`lod${e.startsWith("[") ? "" : ": "}${e}`);
+    }
+    if (record.cullDistance !== void 0 && !(typeof record.cullDistance === "number" && record.cullDistance > 0)) errors.push("cullDistance: expected a number > 0");
+    if (record.root === void 0) errors.push("root: required");
+    else validateNode(record.root, "root", errors);
+    return errors;
+  }
+  function assertValidShape(schema) {
+    const errors = validateShape(schema);
+    if (errors.length) throw new Error(`game-shapes: invalid shape
+  ${errors.slice(0, 20).join("\n  ")}${errors.length > 20 ? `
+  ... ${errors.length - 20} more` : ""}`);
+  }
+  var PRIMITIVE_KINDS = /* @__PURE__ */ new Set(["box", "cylinder", "cone", "sphere", "plane", "circle", "ring", "lathe", "torus", "extrude", "difference", "mesh"]);
+  var isPrimitiveNode = (node) => PRIMITIVE_KINDS.has(node.kind);
+  function keyOptions(options = {}) {
+    return {
+      seed: options.seed ?? 0,
+      colors: options.colors ?? "linear",
+      indexed: options.indexed ?? true,
+      materials: options.materials,
+      fallbackMaterial: options.fallbackMaterial,
+      materialAlias: options.materialAlias,
+      instancing: options.instancing,
+      levels: options.levels
+    };
+  }
+  var shapeKey = (schema, options = {}) => hashValue({ schema, options: keyOptions(options) });
+  var IDENTITY_UV = { u0: 0, v0: 0, u1: 1, v1: 1 };
+  var FloatList = class {
+    constructor(capacity = 256) {
+      __publicField(this, "array");
+      __publicField(this, "length", 0);
+      this.array = new Float32Array(capacity);
+    }
+    reserve(extra) {
+      if (this.length + extra <= this.array.length) return;
+      let capacity = this.array.length * 2;
+      while (capacity < this.length + extra) capacity *= 2;
+      const next = new Float32Array(capacity);
+      next.set(this.array.subarray(0, this.length));
+      this.array = next;
+    }
+    done() {
+      return this.array.slice(0, this.length);
+    }
+  };
+  var IndexList = class {
+    constructor(capacity = 256) {
+      __publicField(this, "array");
+      __publicField(this, "length", 0);
+      this.array = new Uint32Array(capacity);
+    }
+    reserve(extra) {
+      if (this.length + extra <= this.array.length) return;
+      let capacity = this.array.length * 2;
+      while (capacity < this.length + extra) capacity *= 2;
+      const next = new Uint32Array(capacity);
+      next.set(this.array.subarray(0, this.length));
+      this.array = next;
+    }
+  };
+  var Accumulator = class {
+    constructor(material, part) {
+      __publicField(this, "material", material);
+      __publicField(this, "part", part);
+      __publicField(this, "positions", new FloatList());
+      __publicField(this, "normals", new FloatList());
+      __publicField(this, "uvs", new FloatList(170));
+      __publicField(this, "colors", new FloatList());
+      __publicField(this, "indices", new IndexList());
+      __publicField(this, "ranges", []);
+      __publicField(this, "vertices", 0);
+    }
+  };
+  function bake(acc, t, world, rgb, u, indexed) {
+    const e = world;
+    const nm = normalMatrix(world);
+    const affine = isAffine(world);
+    const source = t.positions;
+    const count = source.length / 3;
+    const order = indexed ? null : t.indices ?? null;
+    const emitted = order ? order.length : count;
+    acc.positions.reserve(emitted * 3);
+    acc.normals.reserve(emitted * 3);
+    acc.uvs.reserve(emitted * 2);
+    if (rgb) acc.colors.reserve(emitted * 3);
+    const P = acc.positions.array;
+    const N = acc.normals.array;
+    const U = acc.uvs.array;
+    const C = acc.colors.array;
+    let pi = acc.positions.length;
+    let ni = acc.normals.length;
+    let ui = acc.uvs.length;
+    let ci = acc.colors.length;
+    const du = u.u1 - u.u0;
+    const dv = u.v1 - u.v0;
+    const tn = t.normals;
+    const tu = t.uvs;
+    for (let k = 0; k < emitted; k++) {
+      const i = order ? order[k] : k;
+      const x = source[i * 3];
+      const y = source[i * 3 + 1];
+      const z = source[i * 3 + 2];
+      if (affine) {
+        P[pi++] = e[0] * x + e[4] * y + e[8] * z + e[12];
+        P[pi++] = e[1] * x + e[5] * y + e[9] * z + e[13];
+        P[pi++] = e[2] * x + e[6] * y + e[10] * z + e[14];
+      } else {
+        const p = transformPoint(e, x, y, z);
+        P[pi++] = p[0];
+        P[pi++] = p[1];
+        P[pi++] = p[2];
+      }
+      const nx = tn[i * 3];
+      const ny = tn[i * 3 + 1];
+      const nz = tn[i * 3 + 2];
+      const vx = nm[0] * nx + nm[3] * ny + nm[6] * nz;
+      const vy = nm[1] * nx + nm[4] * ny + nm[7] * nz;
+      const vz = nm[2] * nx + nm[5] * ny + nm[8] * nz;
+      const s = 1 / (Math.sqrt(vx * vx + vy * vy + vz * vz) || 1);
+      N[ni++] = vx * s;
+      N[ni++] = vy * s;
+      N[ni++] = vz * s;
+      U[ui++] = u.u0 + tu[i * 2] * du;
+      U[ui++] = u.v0 + tu[i * 2 + 1] * dv;
+      if (rgb) {
+        C[ci++] = rgb[0];
+        C[ci++] = rgb[1];
+        C[ci++] = rgb[2];
+      }
+    }
+    acc.positions.length = pi;
+    acc.normals.length = ni;
+    acc.uvs.length = ui;
+    acc.colors.length = ci;
+    if (indexed) {
+      const base = acc.vertices;
+      const idx = t.indices;
+      const n = idx ? idx.length : count;
+      acc.indices.reserve(n);
+      const I = acc.indices.array;
+      let ii = acc.indices.length;
+      for (let k = 0; k < n; k++) I[ii++] = base + (idx ? idx[k] : k);
+      acc.indices.length = ii;
+    }
+    acc.vertices += emitted;
+  }
+  function boundsOf(positions) {
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < positions.length; i += 3) {
+      for (let axis = 0; axis < 3; axis++) {
+        const v = positions[i + axis];
+        if (v < min[axis]) min[axis] = v;
+        if (v > max[axis]) max[axis] = v;
+      }
+    }
+    return { min, max };
+  }
+  function finish(acc, indexed, withColors) {
+    const positions = acc.positions.done();
+    const indices = indexed ? acc.vertices > 65535 ? acc.indices.array.slice(0, acc.indices.length) : Uint16Array.from(acc.indices.array.subarray(0, acc.indices.length)) : void 0;
+    return {
+      material: acc.material,
+      part: acc.part,
+      positions,
+      normals: acc.normals.done(),
+      uvs: acc.uvs.done(),
+      ...withColors ? { colors: acc.colors.done() } : {},
+      ...indices ? { indices } : {},
+      ranges: acc.ranges,
+      bounds: boundsOf(positions)
+    };
+  }
+  var radiusOf = (t, world) => {
+    let r = 0;
+    const p = t.positions;
+    for (let i = 0; i < p.length; i += 3) r = Math.max(r, Math.hypot(p[i], p[i + 1], p[i + 2]));
+    const sx = Math.hypot(world[0], world[1], world[2]);
+    const sy = Math.hypot(world[4], world[5], world[6]);
+    const sz = Math.hypot(world[8], world[9], world[10]);
+    return r * Math.max(sx, sy, sz);
+  };
+  function expandCustom(node, settings, detail, path) {
+    const generator = settings.generators?.[node.generator] ?? getGenerator(node.generator);
+    if (!generator) throw new Error(`game-shapes: no generator "${node.generator}" (register it with registerGenerator, in the worker too) at ${path}`);
+    const generated = generator(node.params, { random: streamFor(settings.seed, node.generator, path), seed: settings.seed, detail, path });
+    const { kind: _kind, generator: _generator, params: _params, ...common } = node;
+    return { ...common, kind: "group", children: [generated] };
+  }
+  var leafKey = (node, material, color2, uv, level) => `${node.kind}|${canonicalJson(primitiveParameters(node, level))}|${material}|${color2}|${uv.u0},${uv.v0},${uv.u1},${uv.v1}`;
+  function runLevel(schema, settings, level) {
+    const bakeParts = level.index > 0;
+    const root = { part: null, accs: /* @__PURE__ */ new Map() };
+    const targets = [root];
+    const partTargets = /* @__PURE__ */ new Map();
+    const parts = [];
+    const points = [];
+    const instanced = [];
+    let primitives = 0;
+    const space = settings.colors === "none" ? null : settings.colors;
+    const channels = /* @__PURE__ */ new Map();
+    const rgbOf = (hex) => {
+      if (!space) return null;
+      let c = channels.get(hex);
+      if (!c) {
+        c = colorChannels(hex, space);
+        channels.set(hex, c);
+      }
+      return c;
+    };
+    const resolveMaterial = (id) => {
+      let out = id;
+      if (settings.materials && !settings.materials.has(out)) out = settings.fallback ?? out;
+      return settings.alias?.[out] ?? out;
+    };
+    const accOf = (target, material) => {
+      let acc = target.accs.get(material);
+      if (!acc) {
+        acc = new Accumulator(material, target.part);
+        target.accs.set(material, acc);
+      }
+      return acc;
+    };
+    const autoCounts = /* @__PURE__ */ new Map();
+    const autoGroups = /* @__PURE__ */ new Map();
+    const count = (node, inherited, path) => {
+      if (node.minDetail !== void 0 && level.detail < node.minDetail) return;
+      if (node.kind === "custom") return count(expandCustom(node, settings, level.detail, path), inherited, path);
+      const next = {
+        material: node.material !== void 0 ? resolveMaterial(node.material) : inherited.material,
+        color: node.color !== void 0 ? colorHex(node.color) : inherited.color,
+        uv: node.uv ?? inherited.uv,
+        inPart: inherited.inPart || node.part !== void 0 && !bakeParts
+      };
+      if (node.instances) return;
+      if (node.kind === "group") {
+        node.children?.forEach((child, index) => count(child, next, `${path}/${index}`));
+        return;
+      }
+      if (isPrimitiveNode(node) && node.name === void 0 && !next.inPart) {
+        const key = leafKey(node, next.material, next.color, next.uv, level);
+        autoCounts.set(key, (autoCounts.get(key) ?? 0) + 1);
+      }
+    };
+    const rootMaterial = resolveMaterial("default");
+    if (settings.autoMin !== void 0) count(schema.root, { material: rootMaterial, color: 16777215, uv: IDENTITY_UV, inPart: false }, "root");
+    const visit = (node, parent, inherited, path) => {
+      if (node.minDetail !== void 0 && level.detail < node.minDetail) return;
+      if (node.kind === "custom") return visit(expandCustom(node, settings, level.detail, path), parent, inherited, path);
+      let target = inherited.target;
+      let parentWorld = parent;
+      if (node.part !== void 0) {
+        if (bakeParts) {
+          parentWorld = null;
+        } else {
+          let partTarget = partTargets.get(node.part);
+          if (!partTarget) {
+            partTarget = { part: node.part, accs: /* @__PURE__ */ new Map() };
+            partTargets.set(node.part, partTarget);
+            targets.push(partTarget);
+            const { position, rotation, rotationOrder, scale, heading, matrix } = node;
+            parts.push({
+              id: node.part,
+              ...position ? { position } : {},
+              ...rotation ? { rotation } : {},
+              ...rotationOrder ? { rotationOrder } : {},
+              ...scale !== void 0 ? { scale } : {},
+              ...heading !== void 0 ? { heading } : {},
+              ...matrix ? { matrix } : { matrix: asMat4(matrixOf(node)) }
+            });
+          }
+          target = partTarget;
+        }
+      }
+      const isPart = node.part !== void 0 && !bakeParts;
+      const local = isPart ? null : matrixOf(node);
+      const world = isPart ? null : local ? parentWorld ? multiply(parentWorld, local) : local : parentWorld;
+      const next = {
+        material: node.material !== void 0 ? resolveMaterial(node.material) : inherited.material,
+        color: node.color !== void 0 ? colorHex(node.color) : inherited.color,
+        uv: node.uv ?? inherited.uv,
+        target
+      };
+      if (node.instances) {
+        drawInstanced(node, parentWorld, next, path);
+        return;
+      }
+      const snapshot = node.name !== void 0 ? new Map([...target.accs].map(([m, a]) => [m, { v: a.vertices, i: a.indices.length }])) : null;
+      if (node.kind === "group") {
+        node.children?.forEach((child, index) => visit(child, world, next, `${path}/${index}`));
+      } else if (node.kind === "point") {
+        const p = node.position ?? [0, 0, 0];
+        points.push({
+          ...node.name !== void 0 ? { name: node.name } : {},
+          part: target.part,
+          position: parent ? transformPoint(parent, p[0], p[1], p[2]) : [p[0], p[1], p[2]],
+          ...node.data !== void 0 ? { data: node.data } : {},
+          ...node.tags ? { tags: node.tags } : {}
+        });
+      } else if (isPrimitiveNode(node)) {
+        const template = buildPrimitive(node, level);
+        const m = world ?? identity4();
+        if (level.minSize !== void 0 && radiusOf(template, m) < level.minSize) return;
+        primitives++;
+        if (settings.autoMin !== void 0 && node.name === void 0 && target.part === null) {
+          const key = leafKey(node, next.material, next.color, next.uv, level);
+          if ((autoCounts.get(key) ?? 0) >= settings.autoMin) {
+            let group = autoGroups.get(key);
+            if (!group) {
+              group = { node, material: next.material, color: next.color, part: null, matrices: [] };
+              autoGroups.set(key, group);
+            }
+            group.matrices.push(...m);
+            return;
+          }
+        }
+        bake(accOf(target, next.material), template, m, rgbOf(next.color), next.uv, settings.indexed);
+      }
+      if (snapshot) {
+        for (const [material, acc] of target.accs) {
+          const before = snapshot.get(material) ?? { v: 0, i: 0 };
+          if (acc.vertices === before.v) continue;
+          acc.ranges.push({
+            name: node.name,
+            ...node.tags ? { tags: node.tags } : {},
+            vertexStart: before.v,
+            vertexCount: acc.vertices - before.v,
+            indexStart: before.i,
+            indexCount: acc.indices.length - before.i
+          });
+        }
+      }
+    };
+    const drawInstanced = (node, parentWorld, inherited, path) => {
+      const collector = { part: inherited.target.part, accs: /* @__PURE__ */ new Map() };
+      const { instances, ...single } = node;
+      const before = parts.length;
+      visit(single, null, { ...inherited, target: collector }, path);
+      if (parts.length !== before) throw new Error(`game-shapes: an instanced node cannot hold parts (${path})`);
+      const matrices = new Float32Array(instances.length * 16);
+      const hasColors = instances.some((instance) => instance.color !== void 0);
+      const colors = hasColors ? new Float32Array(instances.length * 3) : void 0;
+      instances.forEach((instance, index) => {
+        const local = matrixOf(instance);
+        const m = local ? parentWorld ? multiply(parentWorld, local) : local : parentWorld ?? identity4();
+        matrices.set(m, index * 16);
+        if (colors) colors.set(colorChannels(colorHex(instance.color), space ?? "srgb"), index * 3);
+      });
+      for (const acc of collector.accs.values()) {
+        const batch = finish(acc, settings.indexed, false);
+        instanced.push({
+          material: acc.material,
+          part: collector.part,
+          ...node.name !== void 0 ? { name: node.name } : {},
+          geometry: { type: "BufferGeometry", parameters: {}, positions: batch.positions, normals: batch.normals, uvs: batch.uvs, ...batch.indices ? { indices: batch.indices } : {}, groups: [] },
+          matrices: matrices.slice(),
+          ...colors ? { colors: colors.slice() } : {},
+          count: instances.length
+        });
+      }
+    };
+    visit(schema.root, null, { material: rootMaterial, color: 16777215, uv: IDENTITY_UV, target: root }, "root");
+    for (const group of autoGroups.values()) {
+      const template = buildPrimitive(group.node, level);
+      const n = group.matrices.length / 16;
+      const rgb = colorChannels(group.color, space ?? "srgb");
+      const colors = new Float32Array(n * 3);
+      for (let i = 0; i < n; i++) colors.set(rgb, i * 3);
+      instanced.push({
+        material: group.material,
+        part: null,
+        geometry: { type: template.type, parameters: template.parameters, positions: template.positions.slice(), normals: template.normals.slice(), uvs: template.uvs.slice(), ...template.indices ? { indices: template.indices.slice() } : {}, groups: template.groups.map((g) => ({ ...g })) },
+        matrices: new Float32Array(group.matrices),
+        ...space ? { colors } : {},
+        count: n
+      });
+    }
+    const batches = [];
+    for (const target of targets) for (const acc of target.accs.values()) if (acc.vertices > 0 && (!settings.indexed || acc.indices.length > 0)) batches.push(finish(acc, settings.indexed, space !== null));
+    return { level: { distance: level.distance, detail: level.detail, batches, instanced }, parts, points, primitives };
+  }
+  function generate(schema, options = {}) {
+    if (options.validate !== false) assertValidShape(schema);
+    const settings = {
+      colors: options.colors ?? "linear",
+      indexed: options.indexed ?? true,
+      ...options.materials ? { materials: new Set(options.materials) } : {},
+      ...options.fallbackMaterial !== void 0 ? { fallback: options.fallbackMaterial } : {},
+      ...options.materialAlias ? { alias: options.materialAlias } : {},
+      seed: options.seed ?? 0,
+      ...options.generators ? { generators: options.generators } : {},
+      ...options.instancing ? { autoMin: Math.max(2, options.instancing.minCount) } : {}
+    };
+    const specs = [{ distance: 0, detail: 1, index: 0 }, ...(schema.lod ?? []).map((rule, index) => ({ ...rule, index: index + 1 }))];
+    const wanted = options.levels ? specs.filter((spec) => options.levels.includes(spec.index)) : specs;
+    let parts = [];
+    let points = [];
+    let primitives = 0;
+    const levels = [];
+    for (const spec of wanted) {
+      const result = runLevel(schema, settings, spec);
+      if (spec.index === 0 || levels.length === 0) {
+        parts = result.parts;
+        points = result.points;
+        primitives = result.primitives;
+      }
+      levels.push(result.level);
+    }
+    const first = levels[0];
+    const vertices = first ? first.batches.reduce((sum, batch) => sum + batch.positions.length / 3, 0) : 0;
+    const triangles = first ? first.batches.reduce((sum, batch) => sum + (batch.indices ? batch.indices.length : batch.positions.length / 3) / 3, 0) + first.instanced.reduce((sum, batch) => sum + (batch.geometry.indices ? batch.geometry.indices.length : batch.geometry.positions.length / 3) / 3 * batch.count, 0) : 0;
+    return {
+      key: options.key === false ? "" : options.key ?? shapeKey(schema, options),
+      ...schema.name !== void 0 ? { name: schema.name } : {},
+      levels,
+      parts,
+      points,
+      ...schema.materials ? { materials: schema.materials } : {},
+      ...schema.cullDistance !== void 0 ? { cullDistance: schema.cullDistance } : {},
+      stats: { vertices, triangles, batches: first ? first.batches.length : 0, instances: first ? first.instanced.reduce((sum, batch) => sum + batch.count, 0) : 0, primitives }
+    };
+  }
+
+  // ../game-props3d/dist/index.js
+  var T = (id, interior, w, d, h, y, solid, group) => ({ id, interior, w, d, h, y, solid, group });
+  var TYPE_DEFS = [
+    T("ceiling_light", true, 0.4, 0.4, 0.07, 0, false, "ceiling"),
+    T("pendant", true, 0.34, 0.34, 1, 0, false, "ceiling"),
+    T("track_spot", true, 1.2, 0.1, 0.2, 0, false, "ceiling"),
+    T("chandelier", true, 0.7, 0.7, 0.7, 0, false, "ceiling"),
+    T("wall_ac", true, 0.9, 0.2, 0.28, 2.15, false, "wall"),
+    T("picture_small", true, 0.35, 0.03, 0.45, 1.3, false, "wall"),
+    T("picture_large", true, 1, 0.04, 0.7, 1.2, false, "wall"),
+    T("mirror", true, 0.6, 0.03, 1.2, 0.9, false, "wall"),
+    T("curtain", true, 1.6, 0.12, 2.3, 0.1, false, "wall"),
+    T("blinds", true, 1.2, 0.08, 1.3, 1, false, "wall"),
+    T("flat_tv", true, 1.2, 0.06, 0.7, 1, false, "wall"),
+    T("floor_plant", true, 0.5, 0.5, 1.1, 0, true, "plants"),
+    T("table_plant", true, 0.2, 0.2, 0.3, 0, false, "plants"),
+    T("hanging_plant", true, 0.5, 0.5, 1, 0, false, "plants"),
+    T("tv_stand", true, 1.6, 0.42, 1.05, 0, true, "furniture"),
+    T("breakfast_bar", true, 2, 1.6, 0.95, 0, true, "furniture"),
+    T("sofa_l", true, 2.8, 1.7, 0.85, 0, true, "furniture"),
+    T("double_bed_modern", true, 1.6, 2.1, 1.2, 0, true, "furniture"),
+    T("home_office", true, 1.4, 0.75, 1.2, 0, true, "furniture"),
+    T("closet", true, 2.2, 0.6, 2.3, 0, true, "furniture"),
+    T("vanity", true, 0.6, 0.45, 1.5, 0, true, "furniture"),
+    T("ac_condenser", false, 0.8, 0.3, 0.55, 0.5, true, "yard"),
+    T("lawn", false, 4, 4, 0.02, 0, false, "floor"),
+    T("tile_floor", false, 4, 3, 0.03, 0, false, "floor"),
+    T("concrete", false, 4, 4, 0.03, 0, false, "floor"),
+    T("deck_floor", false, 4, 3, 0.04, 0, false, "floor"),
+    T("dirt", false, 4, 4, 0.02, 0, false, "floor"),
+    T("gourmet_counter", false, 4.2, 3, 2.9, 0, true, "yard"),
+    T("sauna", false, 2, 1.8, 2.1, 0, true, "yard"),
+    T("soaking_tub", false, 1.3, 1.3, 0.8, 0, true, "yard"),
+    T("pool", false, 4.5, 2.8, 0.1, 0, true, "yard"),
+    T("deck", false, 3.5, 3, 0.22, 0, true, "yard"),
+    T("sun_lounger", false, 0.62, 1.9, 0.5, 0, true, "yard"),
+    T("garden_bed", false, 2, 1, 0.9, 0, true, "yard"),
+    T("fruit_tree", false, 2.4, 2.4, 3.2, 0, true, "yard"),
+    T("palm_tree", false, 2, 2, 4.5, 0, true, "yard"),
+    T("pergola", false, 3.5, 3, 2.4, 0, true, "yard"),
+    T("slide", false, 0.8, 2.6, 1.5, 0, true, "yard"),
+    T("swing", false, 2.2, 1.7, 2.2, 0, true, "yard"),
+    T("bbq_simple", false, 0.9, 0.6, 1, 0, true, "yard"),
+    T("garage_car", false, 1.8, 4.2, 1.45, 0, true, "yard"),
+    T("window_boards", true, 1.2, 0.06, 1.15, 1, false, "house_state"),
+    T("barricade", true, 1.5, 0.7, 1.8, 0, true, "house_state"),
+    T("sandbags", false, 1.6, 0.5, 0.6, 0, true, "house_state"),
+    T("barbed_wire", false, 4, 0.2, 0.6, 0, false, "house_state"),
+    T("razor_wire", false, 4, 0.6, 0.6, 0, false, "house_state"),
+    T("water_bottle_crates", true, 0.9, 0.6, 0.65, 0, true, "house_state"),
+    T("canned_food", true, 0.4, 0.3, 0.3, 0, false, "house_state"),
+    T("water_jug", true, 0.3, 0.3, 0.5, 0, true, "house_state"),
+    T("floor_mattress", true, 0.9, 1.9, 0.3, 0, false, "house_state"),
+    T("lantern", true, 0.16, 0.16, 0.3, 0, false, "house_state"),
+    T("candles", true, 0.25, 0.25, 0.2, 0, false, "house_state"),
+    T("open_suitcases", true, 1.5, 0.7, 0.6, 0, false, "house_state"),
+    T("clothes_on_floor", true, 1.2, 1, 0.05, 0, false, "house_state"),
+    T("fallen_chair", true, 0.5, 0.5, 0.5, 0, false, "house_state"),
+    T("blood_stains", true, 1.2, 1.2, 0.01, 0, false, "house_state"),
+    T("open_door", true, 0.9, 0.15, 2.15, 0, false, "house_state")
+  ];
+  var DEFS = Object.fromEntries(TYPE_DEFS.map((t) => [t.id, t]));
+  var LEAF = (() => {
+    const f = [0, 0, 0, -0.5, 0.4, 0, 0.5, 0.4, 0, 0, 1, 0];
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const indices = [];
+    for (const side of [1, -1]) {
+      const base = positions.length / 3;
+      for (let i = 0; i < 4; i++) {
+        positions.push(f[i * 3], f[i * 3 + 1], f[i * 3 + 2]);
+        normals.push(0, 0, side);
+        uvs.push(f[i * 3] + 0.5, f[i * 3 + 1]);
+      }
+      if (side === 1) indices.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
+      else indices.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
+    }
+    return { positions, normals, uvs, indices };
+  })();
+  function createShapeRecorder(options = {}) {
+    const cyl = options.cylinderSegments ?? 12;
+    const hex2 = options.hexSegments ?? 6;
+    const [sphereW, sphereH] = options.sphereSegments ?? [12, 8];
+    const root = [];
+    const parts = [];
+    const partChildren = /* @__PURE__ */ new Map();
+    let current = root;
+    let lastFrame = null;
+    const into = (M) => {
+      const x = M?.x ?? 0;
+      const z = M?.z ?? 0;
+      const ry = M?.ry ?? 0;
+      const last = lastFrame;
+      if (last && last.list === current && current[current.length - 1] === last.group && Object.is(last.x, x) && Object.is(last.z, z) && Object.is(last.ry, ry)) return last.group.children;
+      const group = { kind: "group", position: [x, 0, z], heading: ry, children: [] };
+      current.push(group);
+      lastFrame = { list: current, group, x, z, ry };
+      return group.children;
+    };
+    const api = {
+      box(M, material, x, y, z, w, h, d, color2, ry, rx, rz) {
+        into(M).push({ kind: "box", material, color: color2, position: [x, y + h / 2, z], rotation: [rx, ry, rz], rotationOrder: "YXZ", scale: [w, h, d] });
+      },
+      cylinder(M, material, x, y, z, r, h, color2, rx, rz, shape) {
+        const tilted = rx !== 0 || rz !== 0;
+        const cy = shape === "sphere" ? y + h / 2 : tilted ? y : y + h / 2;
+        const sy = shape === "sphere" ? h / 2 : h;
+        const place = { material, color: color2, position: [x, cy, z], rotation: [rx, 0, rz], rotationOrder: "YXZ", scale: [r, sy, r] };
+        const list2 = into(M);
+        switch (shape) {
+          case "cyl6":
+            list2.push({ kind: "cylinder", radiusTop: 1, radiusBottom: 1, height: 1, radialSegments: hex2, ...place });
+            break;
+          case "cone":
+            list2.push({ kind: "cylinder", radiusTop: 0, radiusBottom: 1, height: 1, radialSegments: cyl, ...place });
+            break;
+          case "sphere":
+            list2.push({ kind: "sphere", radius: 1, widthSegments: sphereW, heightSegments: sphereH, ...place });
+            break;
+          default:
+            list2.push({ kind: "cylinder", radiusTop: 1, radiusBottom: 1, height: 1, radialSegments: cyl, ...place });
+        }
+      },
+      leaf(M, x, y, z, w, h, color2, ry, rx) {
+        into(M).push({ kind: "mesh", ...LEAF, material: "plant", color: color2, position: [x, y, z], rotation: [rx, ry, 0], rotationOrder: "YXZ", scale: [w, h, 1] });
+      },
+      plane(M, material, x, y, z, w, h, color2, ry, rx, rz, uv) {
+        into(M).push({
+          kind: "plane",
+          width: 1,
+          height: 1,
+          material,
+          color: color2,
+          position: [x, y, z],
+          rotation: [rx, ry, rz],
+          rotationOrder: "YXZ",
+          scale: [w, h, 1],
+          ...uv ? { uv: { u0: uv.u0, v0: uv.v0, u1: uv.u1, v1: uv.v1 } } : {}
+        });
+      },
+      light(M, x, y, z, color2, range2, kind) {
+        into(M).push({ kind: "point", position: [x, y, z], data: { light: true, color: color2, range: range2, kind } });
+      },
+      part(id, pivot, ry, draw) {
+        let children = partChildren.get(id);
+        if (!children) {
+          children = [];
+          partChildren.set(id, children);
+          parts.push({ id, pivot: [pivot[0], pivot[1], pivot[2]], ry });
+          current.push({ kind: "group", part: id, position: [pivot[0], pivot[1], pivot[2]], rotation: [0, ry, 0], children });
+        }
+        const outer = current;
+        current = children;
+        try {
+          draw();
+        } finally {
+          current = outer;
+        }
+      }
+    };
+    return {
+      api,
+      parts,
+      schema: () => ({ version: 1, ...options.name !== void 0 ? { name: options.name } : {}, root: { kind: "group", children: root } })
+    };
   }
 
   // src/types.ts
@@ -954,27 +3181,27 @@ vec3 batchRotate(vec4 q, vec3 v) { return v + 2.0 * cross(q.xyz, cross(q.xyz, v)
       const map = /* @__PURE__ */ new Map();
       for (const g of groups) {
         g.updateMatrix();
-        for (const mesh of meshesOf(g)) {
-          const key = `${String(mesh.userData.material)}|${mesh.material.uuid}`;
+        for (const mesh2 of meshesOf(g)) {
+          const key = `${String(mesh2.userData.material)}|${mesh2.material.uuid}`;
           let e = map.get(key);
           if (!e) {
-            e = { base: mesh.material, pieces: [], mesh };
+            e = { base: mesh2.material, pieces: [], mesh: mesh2 };
             map.set(key, e);
           }
-          e.pieces.push({ geometry: mesh.geometry, matrix: g.matrix, extra: extra(g, mesh.geometry.getAttribute("position").count) });
+          e.pieces.push({ geometry: mesh2.geometry, matrix: g.matrix, extra: extra(g, mesh2.geometry.getAttribute("position").count) });
         }
       }
       return map;
     };
     const finishMesh = (name, key, geometry, template, set, group) => {
-      const mesh = new THREE.Mesh(geometry, set.material);
-      mesh.name = `${name}:${key}`;
-      mesh.userData.material = key;
-      mesh.castShadow = template.castShadow;
-      mesh.receiveShadow = template.receiveShadow;
-      mesh.customDepthMaterial = set.depth;
-      mesh.customDistanceMaterial = set.distance;
-      group.add(mesh);
+      const mesh2 = new THREE.Mesh(geometry, set.material);
+      mesh2.name = `${name}:${key}`;
+      mesh2.userData.material = key;
+      mesh2.castShadow = template.castShadow;
+      mesh2.receiveShadow = template.receiveShadow;
+      mesh2.customDepthMaterial = set.depth;
+      mesh2.customDistanceMaterial = set.distance;
+      group.add(mesh2);
     };
     const cloths = (spec.soft ?? []).filter((s) => s.kind === "cloth" && parts[s.part ?? s.id] && !skip.has(s.part ?? s.id));
     const clothPart = (s) => s.part ?? s.id;
@@ -1043,8 +3270,8 @@ uniform vec2 swayAxz[${n}];
     for (const p of spec.parts ?? []) {
       if (!p.group || !parts[p.id] || skip.has(p.id)) continue;
       const sig = `${p.group}|${JSON.stringify(p.motion)}`;
-      const list = bySignature.get(sig);
-      if (list) list.push(p.id);
+      const list2 = bySignature.get(sig);
+      if (list2) list2.push(p.id);
       else bySignature.set(sig, [p.id]);
     }
     for (const [sig, ids] of bySignature) {
@@ -1122,214 +3349,99 @@ ${QROT}${shader.vertexShader}`;
       atlas_floor: std({ roughness: 1 })
     };
   }
-  var IDENT_UV = { u0: 0, v0: 0, u1: 1, v1: 1 };
+  var colorSpaces = /* @__PURE__ */ new WeakMap();
+  function colorSpaceOf(THREE) {
+    const known = colorSpaces.get(THREE.Color);
+    if (known) return known;
+    const space = detectColorSpace(THREE);
+    colorSpaces.set(THREE.Color, space);
+    return space;
+  }
+  function detectColorSpace(THREE) {
+    const color2 = new THREE.Color();
+    for (let c = 0; c < 256; c++) {
+      color2.setHex(c * 65793);
+      if (color2.r !== colorChannels(c * 65793, "linear")[0]) {
+        if (color2.r !== c / 255) throw new Error("createMeshApi: this three.js stores colours in a space game-shapes does not know");
+        return "srgb";
+      }
+    }
+    return "linear";
+  }
   function createMeshApi(THREE, options = {}) {
     const quality = options.quality ?? "high";
     const shadows = options.shadows !== false;
     const materials = { ...createDefaultMaterials(THREE, quality), ...stripUndefined(options.materials) };
     if (options.doubleSidedPlanes) for (const k of MATERIAL_KEYS) materials[k].side = THREE.DoubleSide;
-    const root = { id: null, pivot: [0, 0, 0], ry: 0, acc: /* @__PURE__ */ new Map(), lights: [] };
-    const partTargets = /* @__PURE__ */ new Map();
-    const stack = [];
-    let current = root;
     let finished = false;
-    const templates = /* @__PURE__ */ new Map();
-    const template = (key, make) => {
-      let t = templates.get(key);
-      if (!t) {
-        const g = make();
-        t = {
-          pos: g.getAttribute("position").array,
-          nor: g.getAttribute("normal").array,
-          uv: g.getAttribute("uv").array,
-          idx: g.index ? g.index.array : Array.from({ length: g.getAttribute("position").count }, (_, i) => i)
-        };
-        templates.set(key, t);
-      }
-      return t;
-    };
-    const segs = quality === "high" ? { cyl: 12, sphereW: 12, sphereH: 8 } : { cyl: 8, sphereW: 8, sphereH: 6 };
-    const tBox = () => template("box", () => new THREE.BoxGeometry(1, 1, 1));
-    const tCyl = (shape) => {
-      switch (shape) {
-        case "cyl6":
-          return template("cyl6", () => new THREE.CylinderGeometry(1, 1, 1, 6));
-        case "cone":
-          return template("cone", () => new THREE.CylinderGeometry(0, 1, 1, segs.cyl));
-        case "sphere":
-          return template("sphere", () => new THREE.SphereGeometry(1, segs.sphereW, segs.sphereH));
-        default:
-          return template("cyl", () => new THREE.CylinderGeometry(1, 1, 1, segs.cyl));
-      }
-    };
-    const tPlane = () => template("plane", () => new THREE.PlaneGeometry(1, 1));
-    const tLeaf = () => {
-      let t = templates.get("leaf");
-      if (!t) {
-        const f = [0, 0, 0, -0.5, 0.4, 0, 0.5, 0.4, 0, 0, 1, 0];
-        const pos = [];
-        const nor = [];
-        const uv = [];
-        const idx = [];
-        for (const side of [1, -1]) {
-          const base = pos.length / 3;
-          for (let i = 0; i < 4; i++) {
-            pos.push(f[i * 3], f[i * 3 + 1], f[i * 3 + 2]);
-            nor.push(0, 0, side);
-            uv.push(f[i * 3] + 0.5, f[i * 3 + 1]);
-          }
-          if (side === 1) idx.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
-          else idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
-        }
-        t = { pos: new Float32Array(pos), nor: new Float32Array(nor), uv: new Float32Array(uv), idx };
-        templates.set("leaf", t);
-      }
-      return t;
-    };
-    const m4 = new THREE.Matrix4();
-    const mItem = new THREE.Matrix4();
-    const mTotal = new THREE.Matrix4();
-    const n3 = new THREE.Matrix3();
-    const v = new THREE.Vector3();
-    const quat = new THREE.Quaternion();
-    const euler = new THREE.Euler();
-    const scl = new THREE.Vector3();
-    const color = new THREE.Color();
-    const canonical = /* @__PURE__ */ new Map();
+    const recorder = quality === "high" ? createShapeRecorder({ cylinderSegments: 12, sphereSegments: [12, 8] }) : createShapeRecorder({ cylinderSegments: 8, sphereSegments: [8, 6] });
+    const materialAlias = {};
     for (const k of MATERIAL_KEYS) {
       const first = MATERIAL_KEYS.find((o) => materials[o] === materials[k]) ?? k;
-      canonical.set(k, first);
-    }
-    const accOf = (requested) => {
-      const key = canonical.get(requested) ?? requested;
-      let a = current.acc.get(key);
-      if (!a) {
-        a = { pos: [], nor: [], col: [], uv: [], idx: [] };
-        current.acc.set(key, a);
-      }
-      return a;
-    };
-    const frame = (M) => {
-      mItem.makeRotationY(M?.ry ?? 0);
-      mItem.setPosition(M?.x ?? 0, 0, M?.z ?? 0);
-      return mItem;
-    };
-    const emit = (requested, M, local, t, hexColor, uv) => {
-      const key = requested in materials ? requested : "plain";
-      const a = accOf(key);
-      const total = mTotal.copy(frame(M)).multiply(local);
-      n3.getNormalMatrix(total);
-      const base = a.pos.length / 3;
-      color.setHex(hexColor);
-      const count = t.pos.length / 3;
-      const e = total.elements;
-      const nm = n3.elements;
-      const u = uv ?? IDENT_UV;
-      for (let i = 0; i < count; i++) {
-        const x = t.pos[i * 3];
-        const y = t.pos[i * 3 + 1];
-        const z = t.pos[i * 3 + 2];
-        a.pos.push(e[0] * x + e[4] * y + e[8] * z + e[12], e[1] * x + e[5] * y + e[9] * z + e[13], e[2] * x + e[6] * y + e[10] * z + e[14]);
-        const nx = t.nor[i * 3];
-        const ny = t.nor[i * 3 + 1];
-        const nz = t.nor[i * 3 + 2];
-        v.set(nm[0] * nx + nm[3] * ny + nm[6] * nz, nm[1] * nx + nm[4] * ny + nm[7] * nz, nm[2] * nx + nm[5] * ny + nm[8] * nz).normalize();
-        a.nor.push(v.x, v.y, v.z);
-        a.col.push(color.r, color.g, color.b);
-        a.uv.push(u.u0 + t.uv[i * 2] * (u.u1 - u.u0), u.v0 + t.uv[i * 2 + 1] * (u.v1 - u.v0));
-      }
-      for (let i = 0; i < t.idx.length; i++) a.idx.push(base + t.idx[i]);
-    };
-    const compose = (x, y, z, rx, ry, rz, sx, sy, sz) => {
-      euler.set(rx, ry, rz, "YXZ");
-      quat.setFromEuler(euler);
-      return m4.compose(v.set(x, y, z), quat, scl.set(sx, sy, sz));
-    };
-    const api = {
-      box(M, material, x, y, z, w, h, d, col, ry, rx, rz) {
-        emit(material, M, compose(x, y + h / 2, z, rx, ry, rz, w, h, d), tBox(), col);
-      },
-      cylinder(M, material, x, y, z, r, h, col, rx, rz, shape) {
-        const tilted = rx !== 0 || rz !== 0;
-        const cy = shape === "sphere" ? y + h / 2 : tilted ? y : y + h / 2;
-        const sy = shape === "sphere" ? h / 2 : h;
-        emit(material, M, compose(x, cy, z, rx, 0, rz, r, sy, r), tCyl(shape), col);
-      },
-      leaf(M, x, y, z, w, h, col, ry, rx) {
-        emit("plant", M, compose(x, y, z, rx, ry, 0, w, h, 1), tLeaf(), col);
-      },
-      plane(M, material, x, y, z, w, h, col, ry, rx, rz, uv) {
-        emit(material, M, compose(x, y, z, rx, ry, rz, w, h, 1), tPlane(), col, uv);
-      },
-      light(M, x, y, z, col, range) {
-        const fr = frame(M);
-        v.set(x, y, z).applyMatrix4(fr);
-        current.lights.push({ x: v.x, y: v.y, z: v.z, color: col, range });
-      },
-      part(id, pivot, ry, draw) {
-        let target = partTargets.get(id);
-        if (!target) {
-          target = { id, pivot: [pivot[0], pivot[1], pivot[2]], ry, acc: /* @__PURE__ */ new Map(), lights: [] };
-          partTargets.set(id, target);
-        }
-        stack.push(current);
-        current = target;
-        try {
-          draw();
-        } finally {
-          current = stack.pop() ?? root;
-        }
-      }
-    };
-    const build = (target, into, materialFor) => {
-      for (const [key, a] of target.acc) {
-        if (!a.idx.length) continue;
+      if (first !== k) materialAlias[k] = first;
+    }
+    const lightsOut = [];
+    const build = (batches, points, id, into, materialFor) => {
+      for (const batch of batches) {
         const g = new THREE.BufferGeometry();
-        g.setAttribute("position", new THREE.Float32BufferAttribute(a.pos, 3));
-        g.setAttribute("normal", new THREE.Float32BufferAttribute(a.nor, 3));
-        g.setAttribute("color", new THREE.Float32BufferAttribute(a.col, 3));
-        g.setAttribute("uv", new THREE.Float32BufferAttribute(a.uv, 2));
-        g.setIndex(a.pos.length / 3 > 65535 ? new THREE.Uint32BufferAttribute(a.idx, 1) : new THREE.Uint16BufferAttribute(a.idx, 1));
+        g.setAttribute("position", new THREE.BufferAttribute(batch.positions, 3));
+        g.setAttribute("normal", new THREE.BufferAttribute(batch.normals, 3));
+        g.setAttribute("color", new THREE.BufferAttribute(batch.colors, 3));
+        g.setAttribute("uv", new THREE.BufferAttribute(batch.uvs, 2));
+        g.setIndex(new THREE.BufferAttribute(batch.indices, 1));
         g.computeBoundingSphere();
         g.computeBoundingBox();
-        const mesh = new THREE.Mesh(g, materialFor?.(key, target.id) ?? materials[key]);
-        mesh.name = target.id === null ? `static:${key}` : `part:${target.id}`;
-        if (target.id !== null) mesh.userData.part = target.id;
-        mesh.userData.material = key;
-        mesh.castShadow = shadows;
-        mesh.receiveShadow = shadows;
-        into.add(mesh);
-      }
-      for (const l of target.lights) {
+        const key = batch.material;
+        const mesh2 = new THREE.Mesh(g, materialFor?.(key, id) ?? materials[key]);
+        mesh2.name = id === null ? `static:${key}` : `part:${id}`;
+        if (id !== null) mesh2.userData.part = id;
+        mesh2.userData.material = key;
+        mesh2.castShadow = shadows;
+        mesh2.receiveShadow = shadows;
+        into.add(mesh2);
+      }
+      for (const point of points) {
+        const l = point.data;
         const light = new THREE.PointLight(l.color, 1, l.range);
-        light.position.set(l.x, l.y, l.z);
+        light.position.set(point.position[0], point.position[1], point.position[2]);
         into.add(light);
         lightsOut.push(light);
       }
     };
-    const lightsOut = [];
     return {
-      api,
+      api: recorder.api,
       materials,
       finish(spec, finishOptions) {
         const materialFor = finishOptions?.materialFor ?? options.materialFor;
         if (finished) throw new Error("createMeshApi: finish() was already called");
         finished = true;
+        const buffers = generate(recorder.schema(), {
+          colors: colorSpaceOf(THREE),
+          materials: MATERIAL_KEYS,
+          fallbackMaterial: "plain",
+          materialAlias,
+          validate: false,
+          key: false
+        });
+        const batches = buffers.levels[0]?.batches ?? [];
+        const of = (id) => ({ batches: batches.filter((b) => b.part === id), points: buffers.points.filter((p) => p.part === id) });
         const group = new THREE.Group();
         group.name = "interactable";
         const parts = {};
-        build(root, group, materialFor);
-        for (const [id, target] of partTargets) {
+        const body = of(null);
+        build(body.batches, body.points, null, group, materialFor);
+        for (const part of recorder.parts) {
           const g = new THREE.Group();
-          g.name = `part:${id}`;
-          g.userData.part = id;
-          g.position.set(target.pivot[0], target.pivot[1], target.pivot[2]);
-          g.rotation.y = target.ry;
+          g.name = `part:${part.id}`;
+          g.userData.part = part.id;
+          g.position.set(part.pivot[0], part.pivot[1], part.pivot[2]);
+          g.rotation.y = part.ry;
           g.updateMatrix();
-          build(target, g, materialFor);
+          const drawn = of(part.id);
+          build(drawn.batches, drawn.points, part.id, g, materialFor);
           rememberRest(g);
           group.add(g);
-          parts[id] = g;
+          parts[part.id] = g;
         }
         if (spec && (options.mergeParts ?? quality === "game")) mergeParts(THREE, group, parts, spec, { swayAmplitude: options.swayAmplitude });
         if (spec) tagDestruction(group, parts, spec);
@@ -1418,16 +3530,16 @@ ${QROT}${shader.vertexShader}`;
     const scl = new THREE.Vector3();
     const n = new THREE.Vector3();
     const toEye = new THREE.Vector3();
-    const box = new THREE.Box3();
+    const box2 = new THREE.Box3();
     const size = new THREE.Vector3();
     const facing = new THREE.Vector3();
     const flip = new THREE.Quaternion(0, 1, 0, 0);
     return {
       envMaterial,
-      register(id, mesh, normal) {
+      register(id, mesh2, normal) {
         const previous = entries.get(id);
-        entries.set(id, { mesh, normal: normal ?? null, original: previous ? previous.original : mesh.material });
-        mesh.material = envMaterial;
+        entries.set(id, { mesh: mesh2, normal: normal ?? null, original: previous ? previous.original : mesh2.material });
+        mesh2.material = envMaterial;
       },
       unregister(id) {
         const e = entries.get(id);
@@ -1460,8 +3572,8 @@ ${QROT}${shader.vertexShader}`;
           e.mesh.updateWorldMatrix(true, false);
           e.mesh.matrixWorld.decompose(pos, quat, scl);
           if (!e.mesh.geometry.boundingBox) e.mesh.geometry.computeBoundingBox();
-          box.copy(e.mesh.geometry.boundingBox);
-          box.getSize(size);
+          box2.copy(e.mesh.geometry.boundingBox);
+          box2.getSize(size);
           worldNormal(e, n);
           s.reflector.position.copy(pos).addScaledVector(n, offset);
           s.reflector.quaternion.copy(quat);
@@ -1672,19 +3784,19 @@ uniform float swayAmplitude;
     material.userData.distanceMaterial = distance;
     return material;
   }
-  function attachSway(THREE, mesh, options = {}) {
+  function attachSway(THREE, mesh2, options = {}) {
     let anchorY = options.anchorY;
     if (anchorY === void 0) {
-      if (!mesh.geometry.boundingBox) mesh.geometry.computeBoundingBox();
-      anchorY = mesh.geometry.boundingBox ? mesh.geometry.boundingBox.max.y : 0;
+      if (!mesh2.geometry.boundingBox) mesh2.geometry.computeBoundingBox();
+      anchorY = mesh2.geometry.boundingBox ? mesh2.geometry.boundingBox.max.y : 0;
     }
-    const base = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+    const base = Array.isArray(mesh2.material) ? mesh2.material[0] : mesh2.material;
     const m = swayMaterial(THREE, base, { ...options, anchorY });
     m.userData.sway.uniforms.anchorY.value = anchorY;
-    mesh.material = m;
-    mesh.customDepthMaterial = m.userData.depthMaterial;
-    mesh.customDistanceMaterial = m.userData.distanceMaterial;
-    mesh.userData.sway = m.userData.sway;
+    mesh2.material = m;
+    mesh2.customDepthMaterial = m.userData.depthMaterial;
+    mesh2.customDistanceMaterial = m.userData.distanceMaterial;
+    mesh2.userData.sway = m.userData.sway;
     return m.userData.sway;
   }
 
@@ -1696,12 +3808,12 @@ uniform float swayAmplitude;
       applyPose: (group, motion, t) => applyPose(THREE, group, motion, t),
       syncObject: (world, objectId, parts, o) => syncObject(THREE, world, objectId, parts, o),
       swayMaterial: (base, o) => swayMaterial(THREE, base, o),
-      attachSway: (mesh, o) => attachSway(THREE, mesh, o),
+      attachSway: (mesh2, o) => attachSway(THREE, mesh2, o),
       createEffects: ((a, o = {}) => a.isObject3D ? createEffects(THREE, a, { document: options.document, ...o }) : createEffects(THREE, { document: options.document, ...a })),
       createScreen: (o = {}) => {
-        const document = o.document ?? options.document;
-        if (!document) throw new Error("createScreen needs a document (option of createThreeAdapter or of the call)");
-        return createScreen(THREE, { ...o, document });
+        const document2 = o.document ?? options.document;
+        if (!document2) throw new Error("createScreen needs a document (option of createThreeAdapter or of the call)");
+        return createScreen(THREE, { ...o, document: document2 });
       },
       createMirrors: (o = {}) => createMirrors(THREE, { Reflector: options.Reflector, envMap: options.envMap, ...o }),
       createCord: (points, radius, material) => createCord(THREE, points, radius, material),