printbench 0.7.1 → 0.8.0

package/dist/assets/manifold.worker-C1p2Y56M.js

@@ -0,0 +1,2944 @@
+async function Yr(o = {}) {
+  var r, n = o, i = !!globalThis.window, c = !!globalThis.WorkerGlobalScope, a = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+  if (a) {
+    const { createRequire: t } = await Promise.resolve().then(function() {
+      return Io;
+    });
+    var f = t(import.meta.url);
+  }
+  var d = !1;
+  n.setup = function() {
+    if (d) return;
+    d = !0, n.initTBB();
+    function t(u, h, C = ((W) => W)) {
+      if (h)
+        for (let W of h)
+          u.push_back(C(W));
+      return u;
+    }
+    function e(u, h = ((C) => C)) {
+      const C = [], W = u.size();
+      for (let K = 0; K < W; K++) C.push(h(u.get(K)));
+      return C;
+    }
+    function s(u, h = ((C) => C)) {
+      const C = [], W = u.size();
+      for (let K = 0; K < W; K++) {
+        const Z = u.get(K), ot = Z.size(), yt = [];
+        for (let ct = 0; ct < ot; ct++)
+          yt.push(h(Z.get(ct)));
+        C.push(yt);
+      }
+      return C;
+    }
+    function l(u) {
+      return u[0].length < 3 && (u = [u]), t(new n.Vector2_vec2(), u, (h) => t(new n.Vector_vec2(), h, (C) => C instanceof Array ? { x: C[0], y: C[1] } : C));
+    }
+    function p(u) {
+      for (let h = 0; h < u.size(); h++) u.get(h).delete();
+      u.delete();
+    }
+    function _(u) {
+      return u[0] instanceof Array ? { x: u[0][0], y: u[0][1] } : typeof u[0] == "number" ? { x: u[0] || 0, y: u[1] || 0 } : u[0];
+    }
+    function $(u) {
+      return u[0] instanceof Array ? { x: u[0][0], y: u[0][1], z: u[0][2] } : typeof u[0] == "number" ? { x: u[0] || 0, y: u[1] || 0, z: u[2] || 0 } : u[0];
+    }
+    function A(u) {
+      return u == "EvenOdd" ? 0 : u == "NonZero" ? 1 : u == "Negative" ? 3 : 2;
+    }
+    function V(u) {
+      return u == "Round" ? 1 : u == "Miter" ? 2 : 0;
+    }
+    const N = n.CrossSection;
+    function q(u, h = "Positive") {
+      if (u instanceof N)
+        return u;
+      {
+        const C = l(u), W = new N(C, A(h));
+        return p(C), W;
+      }
+    }
+    n.CrossSection.prototype.translate = function(...u) {
+      return this._Translate(_(u));
+    }, n.CrossSection.prototype.scale = function(u) {
+      return typeof u == "number" ? this._Scale({ x: u, y: u }) : this._Scale(_([u]));
+    }, n.CrossSection.prototype.mirror = function(u) {
+      return this._Mirror(_([u]));
+    }, n.CrossSection.prototype.warp = function(u) {
+      const h = Vt(function(W) {
+        const K = dt(W, "double"), Z = dt(W + 8, "double"), ot = [K, Z];
+        u(ot), Dt(W, ot[0], "double"), Dt(W + 8, ot[1], "double");
+      }, "vi"), C = this._Warp(h);
+      return Bt(h), C;
+    }, n.CrossSection.prototype.decompose = function() {
+      const u = this._Decompose(), h = e(u);
+      return u.delete(), h;
+    }, n.CrossSection.prototype.bounds = function() {
+      const u = this._Bounds();
+      return { min: ["x", "y"].map((h) => u.min[h]), max: ["x", "y"].map((h) => u.max[h]) };
+    }, n.CrossSection.prototype.offset = function(u, h = "Round", C = 2, W = 0) {
+      return this._Offset(u, V(h), C, W);
+    }, n.CrossSection.prototype.simplify = function(u = 1e-6) {
+      return this._Simplify(u);
+    }, n.CrossSection.prototype.extrude = function(u, h = 0, C = 0, W = [1, 1], K = !1) {
+      W = _([W]);
+      const Z = n._Extrude(this._ToPolygons(), u, h, C, W);
+      return K ? Z.translate([0, 0, -u / 2]) : Z;
+    }, n.CrossSection.prototype.revolve = function(u = 0, h = 360) {
+      return n._Revolve(this._ToPolygons(), u, h);
+    }, n.CrossSection.prototype.add = function(u) {
+      return this._add(q(u));
+    }, n.CrossSection.prototype.subtract = function(u) {
+      return this._subtract(q(u));
+    }, n.CrossSection.prototype.intersect = function(u) {
+      return this._intersect(q(u));
+    }, n.CrossSection.prototype.toPolygons = function() {
+      const u = this._ToPolygons(), h = s(u, (C) => [C.x, C.y]);
+      return u.delete(), h;
+    }, n.Manifold.prototype.smoothOut = function(u = 52.5, h = 0) {
+      return this._SmoothOut(u, h);
+    }, n.Manifold.prototype.warp = function(u) {
+      const h = Vt(function(K) {
+        const Z = dt(K, "double"), ot = dt(K + 8, "double"), yt = dt(K + 16, "double"), ct = [Z, ot, yt];
+        u(ct), Dt(K, ct[0], "double"), Dt(K + 8, ct[1], "double"), Dt(K + 16, ct[2], "double");
+      }, "vi"), C = this._Warp(h);
+      Bt(h);
+      const W = C.status();
+      if (W !== "NoError")
+        throw new n.ManifoldError(W);
+      return C;
+    }, n.Manifold.prototype.warpBatch = function(u) {
+      const h = Vt(function(K, Z) {
+        const ot = n.HEAPF64 ?? O;
+        if (!ot)
+          throw new Error("WASM heap is not initialized (HEAPF64 unavailable)");
+        const yt = new Float64Array(ot.buffer, K, Z * 3);
+        u(yt, Z);
+      }, "vii"), C = this._WarpBatch(h);
+      Bt(h);
+      const W = C.status();
+      if (W !== "NoError")
+        throw new n.ManifoldError(W);
+      return C;
+    }, n.Manifold.prototype.calculateNormals = function(u = 0, h = 52.5) {
+      return this._CalculateNormals(u, h);
+    }, n.Manifold.prototype.smoothByNormals = function(u = 0) {
+      return this._SmoothByNormals(u);
+    }, n.Manifold.prototype.setProperties = function(u, h) {
+      const C = this.numProp(), W = Vt(function(Z, ot, yt) {
+        const ct = [];
+        for (let it = 0; it < u; ++it)
+          ct[it] = dt(Z + 8 * it, "double");
+        const kt = [];
+        for (let it = 0; it < 3; ++it)
+          kt[it] = dt(ot + 8 * it, "double");
+        const Et = [];
+        for (let it = 0; it < C; ++it)
+          Et[it] = dt(yt + 8 * it, "double");
+        h(ct, kt, Et);
+        for (let it = 0; it < u; ++it)
+          Dt(Z + 8 * it, ct[it], "double");
+      }, "viii"), K = this._SetProperties(u, W);
+      return Bt(W), K;
+    }, n.Manifold.prototype.translate = function(...u) {
+      return this._Translate($(u));
+    }, n.Manifold.prototype.rotate = function(u, h, C) {
+      return Array.isArray(u) ? this._Rotate(...u) : this._Rotate(u, h || 0, C || 0);
+    }, n.Manifold.prototype.scale = function(u) {
+      return typeof u == "number" ? this._Scale({ x: u, y: u, z: u }) : this._Scale($([u]));
+    }, n.Manifold.prototype.mirror = function(u) {
+      return this._Mirror($([u]));
+    }, n.Manifold.prototype.trimByPlane = function(u, h = 0) {
+      return this._TrimByPlane($([u]), h);
+    }, n.Manifold.prototype.slice = function(u = 0) {
+      const h = this._Slice(u), C = new N(h, A("Positive"));
+      return p(h), C;
+    }, n.Manifold.prototype.project = function() {
+      const u = this._Project(), h = new N(u, A("Positive"));
+      return p(u), h;
+    }, n.Manifold.prototype.rayCast = function(u, h) {
+      const C = this._RayCast($([u]), $([h])), W = e(C, (K) => ({ faceID: K.faceID, distance: K.distance, position: ["x", "y", "z"].map((Z) => K.position[Z]), normal: ["x", "y", "z"].map((Z) => K.normal[Z]) }));
+      return C.delete(), W;
+    }, n.Manifold.prototype.split = function(u) {
+      const h = this._Split(u), C = e(h);
+      return h.delete(), C;
+    }, n.Manifold.prototype.splitByPlane = function(u, h = 0) {
+      const C = this._SplitByPlane($([u]), h), W = e(C);
+      return C.delete(), W;
+    }, n.Manifold.prototype.decompose = function() {
+      const u = this._Decompose(), h = e(u);
+      return u.delete(), h;
+    }, n.Manifold.prototype.boundingBox = function() {
+      const u = this._boundingBox();
+      return { min: ["x", "y", "z"].map((h) => u.min[h]), max: ["x", "y", "z"].map((h) => u.max[h]) };
+    }, n.Manifold.prototype.simplify = function(u = 0) {
+      return this._Simplify(u);
+    };
+    class Q {
+      constructor({ numProp: h = 3, triVerts: C = new Uint32Array(), vertProperties: W = new Float32Array(), mergeFromVert: K, mergeToVert: Z, runIndex: ot, runOriginalID: yt, faceID: ct, halfedgeTangent: kt, runTransform: Et, runFlags: it, tolerance: Ce = 0 } = {}) {
+        this.numProp = h, this.triVerts = C, this.vertProperties = W, this.mergeFromVert = K, this.mergeToVert = Z, this.runIndex = ot, this.runOriginalID = yt, this.faceID = ct, this.halfedgeTangent = kt, this.runTransform = Et, this.runFlags = it, this.tolerance = Ce;
+      }
+      get numTri() {
+        return this.triVerts.length / 3;
+      }
+      get numVert() {
+        return this.vertProperties.length / this.numProp;
+      }
+      get numRun() {
+        return this.runOriginalID.length;
+      }
+      merge() {
+        const { changed: h, mesh: C } = n._Merge(this);
+        return Object.assign(this, { ...C }), h;
+      }
+      verts(h) {
+        return this.triVerts.subarray(3 * h, 3 * (h + 1));
+      }
+      position(h) {
+        return this.vertProperties.subarray(this.numProp * h, this.numProp * h + 3);
+      }
+      extras(h) {
+        return this.vertProperties.subarray(this.numProp * h + 3, this.numProp * (h + 1));
+      }
+      tangent(h) {
+        return this.halfedgeTangent.subarray(4 * h, 4 * (h + 1));
+      }
+      transform(h) {
+        const C = new Array(16);
+        for (const W of [0, 1, 2, 3])
+          for (const K of [0, 1, 2])
+            C[4 * W + K] = this.runTransform[12 * h + 3 * W + K];
+        return C[15] = 1, C;
+      }
+      backside(h) {
+        return this.runFlags != null && h < this.runFlags.length && (this.runFlags[h] & 1) !== 0;
+      }
+      hasNormals(h) {
+        return this.runFlags != null && h < this.runFlags.length && (this.runFlags[h] & 2) !== 0;
+      }
+    }
+    n.Mesh = Q, n.Manifold.prototype.getMesh = function(u = -1) {
+      return new Q(this._GetMeshJS(u));
+    }, n.ManifoldError = function(h, ...C) {
+      let W = "Unknown error";
+      switch (h) {
+        case "NonFiniteVertex":
+          W = "Non-finite vertex";
+          break;
+        case "NotManifold":
+          W = "Not manifold";
+          break;
+        case "VertexOutOfBounds":
+          W = "Vertex index out of bounds";
+          break;
+        case "PropertiesWrongLength":
+          W = "Properties have wrong length";
+          break;
+        case "MissingPositionProperties":
+          W = "Less than three properties";
+          break;
+        case "MergeVectorsDifferentLengths":
+          W = "Merge vectors have different lengths";
+          break;
+        case "MergeIndexOutOfBounds":
+          W = "Merge index out of bounds";
+          break;
+        case "TransformWrongLength":
+          W = "Transform vector has wrong length";
+          break;
+        case "RunIndexWrongLength":
+          W = "Run index vector has wrong length";
+          break;
+        case "FaceIDWrongLength":
+          W = "Face ID vector has wrong length";
+          break;
+        case "InvalidConstruction":
+          W = "Manifold constructed with invalid parameters";
+          break;
+        case "ResultTooLarge":
+          W = "Result exceeds maximum size";
+          break;
+        case "InvalidTangents":
+          W = "Invalid halfedge tangents";
+          break;
+      }
+      const K = Error.apply(this, [W, ...C]);
+      K.name = this.name = "ManifoldError", this.message = K.message, this.stack = K.stack, this.code = h;
+    }, n.ManifoldError.prototype = Object.create(Error.prototype, { constructor: { value: n.ManifoldError, writable: !0, configurable: !0 } }), n.CrossSection = function(u, h = "Positive") {
+      const C = l(u), W = new N(C, A(h));
+      return p(C), W;
+    }, n.CrossSection.ofPolygons = function(u, h = "Positive") {
+      return new n.CrossSection(u, h);
+    }, n.CrossSection.square = function(...u) {
+      let h;
+      u.length == 0 ? h = { x: 1, y: 1 } : typeof u[0] == "number" ? h = { x: u[0], y: u[0] } : h = _(u);
+      const C = u[1] || !1;
+      return n._Square(h, C);
+    }, n.CrossSection.circle = function(u, h = 0) {
+      return n._Circle(u, h);
+    };
+    function et(u) {
+      return function(...h) {
+        h.length == 1 && (h = h[0]);
+        const C = new n.Vector_crossSection();
+        for (const K of h) C.push_back(q(K));
+        const W = n["_crossSection" + u](C);
+        return C.delete(), W;
+      };
+    }
+    n.CrossSection.compose = et("Compose"), n.CrossSection.union = et("UnionN"), n.CrossSection.difference = et("DifferenceN"), n.CrossSection.intersection = et("IntersectionN");
+    function tt(u, h) {
+      t(u, h, (C) => C instanceof Array ? { x: C[0], y: C[1] } : C);
+    }
+    n.CrossSection.hull = function(...u) {
+      u.length == 1 && (u = u[0]);
+      let h = new n.Vector_vec2();
+      for (const W of u)
+        if (W instanceof N)
+          n._crossSectionCollectVertices(h, W);
+        else if (W instanceof Array && W.length == 2 && typeof W[0] == "number")
+          h.push_back({ x: W[0], y: W[1] });
+        else if (W.x)
+          h.push_back(W);
+        else {
+          const Z = W[0].length == 2 && typeof W[0][0] == "number" || W[0].x ? [W] : W;
+          for (const ot of Z) tt(h, ot);
+        }
+      const C = n._crossSectionHullPoints(h);
+      return h.delete(), C;
+    }, n.CrossSection.prototype = Object.create(N.prototype), Object.defineProperty(n.CrossSection, Symbol.hasInstance, { get: () => (u) => u instanceof N });
+    const st = n.Manifold;
+    n.Manifold = function(u) {
+      const h = new st(u), C = h.status();
+      if (C !== "NoError")
+        throw new n.ManifoldError(C);
+      return h;
+    }, n.Manifold.ofMesh = function(u) {
+      return new n.Manifold(u);
+    }, n.Manifold.tetrahedron = function() {
+      return n._Tetrahedron();
+    }, n.Manifold.cube = function(...u) {
+      let h;
+      u.length == 0 ? h = { x: 1, y: 1, z: 1 } : typeof u[0] == "number" ? h = { x: u[0], y: u[0], z: u[0] } : h = $(u);
+      const C = u[1] || !1;
+      return n._Cube(h, C);
+    }, n.Manifold.cylinder = function(u, h, C = -1, W = 0, K = !1) {
+      return n._Cylinder(u, h, C, W, K);
+    }, n.Manifold.sphere = function(u, h = 0) {
+      return n._Sphere(u, h);
+    }, n.Manifold.smooth = function(u, h = []) {
+      const C = new n.Vector_smoothness();
+      t(C, h);
+      const W = n._Smooth(u, C);
+      return C.delete(), W;
+    }, n.Manifold.extrude = function(u, h, C = 0, W = 0, K = [1, 1], Z = !1) {
+      return (u instanceof N ? u : n.CrossSection(u, "Positive")).extrude(h, C, W, K, Z);
+    }, n.Manifold.revolve = function(u, h = 0, C = 360) {
+      return (u instanceof N ? u : n.CrossSection(u, "Positive")).revolve(h, C);
+    }, n.Manifold.reserveIDs = function(u) {
+      return n._ReserveIDs(u);
+    };
+    function pt(u) {
+      return function(...h) {
+        h.length == 1 && (h = h[0]);
+        const C = new n.Vector_manifold();
+        for (const K of h) C.push_back(K);
+        const W = n["_manifold" + u + "N"](C);
+        return C.delete(), W;
+      };
+    }
+    n.Manifold.union = pt("Union"), n.Manifold.compose = n.Manifold.union, n.Manifold.difference = pt("Difference"), n.Manifold.intersection = pt("Intersection"), n.Manifold.levelSet = function(u, h, C, W = 0, K = -1) {
+      const Z = { min: { x: h.min[0], y: h.min[1], z: h.min[2] }, max: { x: h.max[0], y: h.max[1], z: h.max[2] } }, ot = Vt(function(ct) {
+        const kt = dt(ct, "double"), Et = dt(ct + 8, "double"), it = dt(ct + 16, "double");
+        return u([kt, Et, it]);
+      }, "di"), yt = n._LevelSet(ot, Z, C, W, K);
+      return Bt(ot), yt;
+    }, n.ExecutionContext.prototype.fromMesh = function(u) {
+      return this._FromMesh(u);
+    }, n.ExecutionContext.prototype.smooth = function(u, h = []) {
+      const C = new n.Vector_smoothness();
+      t(C, h);
+      const W = this._Smooth(u, C);
+      return C.delete(), W;
+    }, n.ExecutionContext.prototype.levelSet = function(u, h, C, W = 0, K = -1) {
+      const Z = { min: { x: h.min[0], y: h.min[1], z: h.min[2] }, max: { x: h.max[0], y: h.max[1], z: h.max[2] } }, ot = Vt(function(ct) {
+        const kt = dt(ct, "double"), Et = dt(ct + 8, "double"), it = dt(ct + 16, "double");
+        return u([kt, Et, it]);
+      }, "di"), yt = this._LevelSet(ot, Z, C, W, K);
+      return Bt(ot), yt;
+    };
+    function gt(u, h) {
+      t(u, h, (C) => C instanceof Array ? { x: C[0], y: C[1], z: C[2] } : C);
+    }
+    n.Manifold.hull = function(...u) {
+      u.length == 1 && (u = u[0]);
+      let h = new n.Vector_vec3();
+      for (const W of u)
+        W instanceof st ? n._manifoldCollectVertices(h, W) : W instanceof Array && W.length == 3 && typeof W[0] == "number" ? h.push_back({ x: W[0], y: W[1], z: W[2] }) : W.x ? h.push_back(W) : gt(h, W);
+      const C = n._manifoldHullPoints(h);
+      return h.delete(), C;
+    }, n.Manifold.prototype = Object.create(st.prototype), Object.defineProperty(n.Manifold, Symbol.hasInstance, { get: () => (u) => u instanceof st }), n.triangulate = function(u, h = -1, C = !0) {
+      const W = l(u), K = e(n._Triangulate(W, h, C), (Z) => [Z[0], Z[1], Z[2]]);
+      return p(W), K;
+    };
+  };
+  var v = import.meta.url, y = "";
+  function m(t) {
+    return n.locateFile ? n.locateFile(t, y) : y + t;
+  }
+  var k, b;
+  if (a) {
+    var x = f("node:fs");
+    v.startsWith("file:") && (y = f("node:path").dirname(f("node:url").fileURLToPath(v)) + "/"), b = (t) => {
+      t = M(t) ? new URL(t) : t;
+      var e = x.readFileSync(t);
+      return e;
+    }, k = async (t, e = !0) => {
+      t = M(t) ? new URL(t) : t;
+      var s = x.readFileSync(t, e ? void 0 : "utf8");
+      return s;
+    }, process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2);
+  } else if (i || c) {
+    try {
+      y = new URL(".", v).href;
+    } catch {
+    }
+    c && (b = (t) => {
+      var e = new XMLHttpRequest();
+      return e.open("GET", t, !1), e.responseType = "arraybuffer", e.send(null), new Uint8Array(e.response);
+    }), k = async (t) => {
+      if (M(t))
+        return new Promise((s, l) => {
+          var p = new XMLHttpRequest();
+          p.open("GET", t, !0), p.responseType = "arraybuffer", p.onload = () => {
+            if (p.status == 200 || p.status == 0 && p.response) {
+              s(p.response);
+              return;
+            }
+            l(p.status);
+          }, p.onerror = l, p.send(null);
+        });
+      var e = await fetch(t, { credentials: "same-origin" });
+      if (e.ok)
+        return e.arrayBuffer();
+      throw new Error(e.status + " : " + e.url);
+    };
+  }
+  console.log.bind(console);
+  var E = console.error.bind(console), g, P = !1, M = (t) => t.startsWith("file://"), F, I, z, T, S, w, B, R, j, O, D, L, U = !1;
+  function J() {
+    var t = ce.buffer;
+    z = new Int8Array(t), S = new Int16Array(t), T = new Uint8Array(t), w = new Uint16Array(t), B = new Int32Array(t), R = new Uint32Array(t), j = new Float32Array(t), O = new Float64Array(t), D = new BigInt64Array(t), L = new BigUint64Array(t);
+  }
+  function X() {
+    if (n.preRun)
+      for (typeof n.preRun == "function" && (n.preRun = [n.preRun]); n.preRun.length; )
+        qt(n.preRun.shift());
+    Mt(jt);
+  }
+  function rt() {
+    U = !0, Ot.J();
+  }
+  function H() {
+    if (n.postRun)
+      for (typeof n.postRun == "function" && (n.postRun = [n.postRun]); n.postRun.length; )
+        Lt(n.postRun.shift());
+    Mt(xt);
+  }
+  function G(t) {
+    n.onAbort?.(t), t = "Aborted(" + t + ")", E(t), P = !0, t += ". Build with -sASSERTIONS for more info.";
+    var e = new WebAssembly.RuntimeError(t);
+    throw I?.(e), e;
+  }
+  var Y;
+  function mt() {
+    return n.locateFile ? m("manifold.wasm") : "".href;
+  }
+  function ft(t) {
+    if (t == Y && g)
+      return new Uint8Array(g);
+    if (b)
+      return b(t);
+    throw "both async and sync fetching of the wasm failed";
+  }
+  async function ut(t) {
+    if (!g)
+      try {
+        var e = await k(t);
+        return new Uint8Array(e);
+      } catch {
+      }
+    return ft(t);
+  }
+  async function Pt(t, e) {
+    try {
+      var s = await ut(t), l = await WebAssembly.instantiate(s, e);
+      return l;
+    } catch (p) {
+      E(`failed to asynchronously prepare wasm: ${p}`), G(p);
+    }
+  }
+  async function Ct(t, e, s) {
+    if (!t && !M(e) && !a)
+      try {
+        var l = fetch(e, { credentials: "same-origin" }), p = await WebAssembly.instantiateStreaming(l, s);
+        return p;
+      } catch (_) {
+        E(`wasm streaming compile failed: ${_}`), E("falling back to ArrayBuffer instantiation");
+      }
+    return Pt(e, s);
+  }
+  function _t() {
+    var t = { a: Gr };
+    return t;
+  }
+  async function Ft() {
+    function t(_, $) {
+      return Ot = _.exports, Ot = Kr(Ot), Jr(Ot), J(), Ot;
+    }
+    function e(_) {
+      return t(_.instance);
+    }
+    var s = _t();
+    if (n.instantiateWasm)
+      return new Promise((_, $) => {
+        n.instantiateWasm(s, (A, V) => {
+          _(t(A));
+        });
+      });
+    Y ??= mt();
+    var l = await Ct(g, Y, s), p = e(l);
+    return p;
+  }
+  var Mt = (t) => {
+    for (; t.length > 0; )
+      t.shift()(n);
+  }, xt = [], Lt = (t) => xt.push(t), jt = [], qt = (t) => jt.push(t);
+  function dt(t, e = "i8") {
+    switch (e.endsWith("*") && (e = "*"), e) {
+      case "i1":
+        return z[t >>> 0];
+      case "i8":
+        return z[t >>> 0];
+      case "i16":
+        return S[t >>> 1 >>> 0];
+      case "i32":
+        return B[t >>> 2 >>> 0];
+      case "i64":
+        return D[t >>> 3 >>> 0];
+      case "float":
+        return j[t >>> 2 >>> 0];
+      case "double":
+        return O[t >>> 3 >>> 0];
+      case "*":
+        return R[t >>> 2 >>> 0];
+      default:
+        G(`invalid type for getValue: ${e}`);
+    }
+  }
+  function Dt(t, e, s = "i8") {
+    switch (s.endsWith("*") && (s = "*"), s) {
+      case "i1":
+        z[t >>> 0] = e;
+        break;
+      case "i8":
+        z[t >>> 0] = e;
+        break;
+      case "i16":
+        S[t >>> 1 >>> 0] = e;
+        break;
+      case "i32":
+        B[t >>> 2 >>> 0] = e;
+        break;
+      case "i64":
+        D[t >>> 3 >>> 0] = BigInt(e);
+        break;
+      case "float":
+        j[t >>> 2 >>> 0] = e;
+        break;
+      case "double":
+        O[t >>> 3 >>> 0] = e;
+        break;
+      case "*":
+        R[t >>> 2 >>> 0] = e;
+        break;
+      default:
+        G(`invalid type for setValue: ${s}`);
+    }
+  }
+  class bn {
+    constructor(e) {
+      this.excPtr = e, this.ptr = e - 24;
+    }
+    set_type(e) {
+      R[this.ptr + 4 >>> 2 >>> 0] = e;
+    }
+    get_type() {
+      return R[this.ptr + 4 >>> 2 >>> 0];
+    }
+    set_destructor(e) {
+      R[this.ptr + 8 >>> 2 >>> 0] = e;
+    }
+    get_destructor() {
+      return R[this.ptr + 8 >>> 2 >>> 0];
+    }
+    set_caught(e) {
+      e = e ? 1 : 0, z[this.ptr + 12 >>> 0] = e;
+    }
+    get_caught() {
+      return z[this.ptr + 12 >>> 0] != 0;
+    }
+    set_rethrown(e) {
+      e = e ? 1 : 0, z[this.ptr + 13 >>> 0] = e;
+    }
+    get_rethrown() {
+      return z[this.ptr + 13 >>> 0] != 0;
+    }
+    init(e, s) {
+      this.set_adjusted_ptr(0), this.set_type(e), this.set_destructor(s);
+    }
+    set_adjusted_ptr(e) {
+      R[this.ptr + 16 >>> 2 >>> 0] = e;
+    }
+    get_adjusted_ptr() {
+      return R[this.ptr + 16 >>> 2 >>> 0];
+    }
+  }
+  var ke = 0;
+  function xn(t, e, s) {
+    t >>>= 0, e >>>= 0, s >>>= 0;
+    var l = new bn(t);
+    throw l.init(e, s), ke = t, ke;
+  }
+  var _n = () => G(""), Qt = {}, he = (t) => {
+    for (; t.length; ) {
+      var e = t.pop(), s = t.pop();
+      s(e);
+    }
+  };
+  function Jt(t) {
+    return this.fromWireType(R[t >>> 2 >>> 0]);
+  }
+  var Ut = {}, Rt = {}, te = {}, Mn = class extends Error {
+    constructor(e) {
+      super(e), this.name = "InternalError";
+    }
+  }, ee = (t) => {
+    throw new Mn(t);
+  }, It = (t, e, s) => {
+    t.forEach((A) => te[A] = e);
+    function l(A) {
+      var V = s(A);
+      V.length !== t.length && ee("Mismatched type converter count");
+      for (var N = 0; N < t.length; ++N)
+        vt(t[N], V[N]);
+    }
+    var p = new Array(e.length), _ = [], $ = 0;
+    for (let [A, V] of e.entries())
+      Rt.hasOwnProperty(V) ? p[A] = Rt[V] : (_.push(V), Ut.hasOwnProperty(V) || (Ut[V] = []), Ut[V].push(() => {
+        p[A] = Rt[V], ++$, $ === _.length && l(p);
+      }));
+    _.length === 0 && l(p);
+  }, wn = function(t) {
+    t >>>= 0;
+    var e = Qt[t];
+    delete Qt[t];
+    var s = e.rawConstructor, l = e.rawDestructor, p = e.fields, _ = p.map(($) => $.getterReturnType).concat(p.map(($) => $.setterArgumentType));
+    It([t], _, ($) => {
+      var A = {};
+      for (var [V, N] of p.entries()) {
+        const q = $[V], Q = N.getter, et = N.getterContext, tt = $[V + p.length], st = N.setter, pt = N.setterContext;
+        A[N.fieldName] = { read: (gt) => q.fromWireType(Q(et, gt)), write: (gt, u) => {
+          var h = [];
+          st(pt, gt, tt.toWireType(h, u)), he(h);
+        }, optional: q.optional };
+      }
+      return [{ name: e.name, fromWireType: (q) => {
+        var Q = {};
+        for (var et in A)
+          Q[et] = A[et].read(q);
+        return l(q), Q;
+      }, toWireType: (q, Q) => {
+        for (var et in A)
+          if (!(et in Q) && !A[et].optional)
+            throw new TypeError(`Missing field: "${et}"`);
+        var tt = s();
+        for (et in A)
+          A[et].write(tt, Q[et]);
+        return q !== null && q.push(l, tt), tt;
+      }, readValueFromPointer: Jt, destructorFunction: l }];
+    });
+  }, lt = (t) => {
+    t >>>= 0;
+    for (var e = ""; ; ) {
+      var s = T[t++ >>> 0];
+      if (!s) return e;
+      e += String.fromCharCode(s);
+    }
+  }, Gt = class extends Error {
+    constructor(e) {
+      super(e), this.name = "BindingError";
+    }
+  }, nt = (t) => {
+    throw new Gt(t);
+  };
+  function $n(t, e, s = {}) {
+    var l = e.name;
+    if (t || nt(`type "${l}" must have a positive integer typeid pointer`), Rt.hasOwnProperty(t)) {
+      if (s.ignoreDuplicateRegistrations)
+        return;
+      nt(`Cannot register type '${l}' twice`);
+    }
+    if (Rt[t] = e, delete te[t], Ut.hasOwnProperty(t)) {
+      var p = Ut[t];
+      delete Ut[t], p.forEach((_) => _());
+    }
+  }
+  function vt(t, e, s = {}) {
+    return $n(t, e, s);
+  }
+  var Ee = (t, e, s) => {
+    switch (e) {
+      case 1:
+        return s ? (l) => z[l >>> 0] : (l) => T[l >>> 0];
+      case 2:
+        return s ? (l) => S[l >>> 1 >>> 0] : (l) => w[l >>> 1 >>> 0];
+      case 4:
+        return s ? (l) => B[l >>> 2 >>> 0] : (l) => R[l >>> 2 >>> 0];
+      case 8:
+        return s ? (l) => D[l >>> 3 >>> 0] : (l) => L[l >>> 3 >>> 0];
+      default:
+        throw new TypeError(`invalid integer width (${e}): ${t}`);
+    }
+  }, Pn = function(t, e, s, l, p) {
+    t >>>= 0, e >>>= 0, s >>>= 0, e = lt(e);
+    const _ = l === 0n;
+    let $ = (A) => A;
+    if (_) {
+      const A = s * 8;
+      $ = (V) => BigInt.asUintN(A, V), p = $(p);
+    }
+    vt(t, { name: e, fromWireType: $, toWireType: (A, V) => (typeof V == "number" && (V = BigInt(V)), V), readValueFromPointer: Ee(e, s, !_), destructorFunction: null });
+  };
+  function Cn(t, e, s, l) {
+    t >>>= 0, e >>>= 0, e = lt(e), vt(t, { name: e, fromWireType: function(p) {
+      return !!p;
+    }, toWireType: function(p, _) {
+      return _ ? s : l;
+    }, readValueFromPointer: function(p) {
+      return this.fromWireType(T[p >>> 0]);
+    }, destructorFunction: null });
+  }
+  var Tn = (t) => ({ count: t.count, deleteScheduled: t.deleteScheduled, preservePointerOnDelete: t.preservePointerOnDelete, ptr: t.ptr, ptrType: t.ptrType, smartPtr: t.smartPtr, smartPtrType: t.smartPtrType }), pe = (t) => {
+    function e(s) {
+      return s.$$.ptrType.registeredClass.name;
+    }
+    nt(e(t) + " instance already deleted");
+  }, ye = !1, Re = (t) => {
+  }, Sn = (t) => {
+    t.smartPtr ? t.smartPtrType.rawDestructor(t.smartPtr) : t.ptrType.registeredClass.rawDestructor(t.ptr);
+  }, We = (t) => {
+    t.count.value -= 1;
+    var e = t.count.value === 0;
+    e && Sn(t);
+  }, Kt = (t) => globalThis.FinalizationRegistry ? (ye = new FinalizationRegistry((e) => {
+    We(e.$$);
+  }), Kt = (e) => {
+    var s = e.$$, l = !!s.smartPtr;
+    if (l) {
+      var p = { $$: s };
+      ye.register(e, p, e);
+    }
+    return e;
+  }, Re = (e) => ye.unregister(e), Kt(t)) : (Kt = (e) => e, t), Fn = () => {
+    let t = ne.prototype;
+    Object.assign(t, { isAliasOf(s) {
+      if (!(this instanceof ne) || !(s instanceof ne))
+        return !1;
+      var l = this.$$.ptrType.registeredClass, p = this.$$.ptr;
+      s.$$ = s.$$;
+      for (var _ = s.$$.ptrType.registeredClass, $ = s.$$.ptr; l.baseClass; )
+        p = l.upcast(p), l = l.baseClass;
+      for (; _.baseClass; )
+        $ = _.upcast($), _ = _.baseClass;
+      return l === _ && p === $;
+    }, clone() {
+      if (this.$$.ptr || pe(this), this.$$.preservePointerOnDelete)
+        return this.$$.count.value += 1, this;
+      var s = Kt(Object.create(Object.getPrototypeOf(this), { $$: { value: Tn(this.$$) } }));
+      return s.$$.count.value += 1, s.$$.deleteScheduled = !1, s;
+    }, delete() {
+      this.$$.ptr || pe(this), this.$$.deleteScheduled && !this.$$.preservePointerOnDelete && nt("Object already scheduled for deletion"), Re(this), We(this.$$), this.$$.preservePointerOnDelete || (this.$$.smartPtr = void 0, this.$$.ptr = void 0);
+    }, isDeleted() {
+      return !this.$$.ptr;
+    }, deleteLater() {
+      return this.$$.ptr || pe(this), this.$$.deleteScheduled && !this.$$.preservePointerOnDelete && nt("Object already scheduled for deletion"), this.$$.deleteScheduled = !0, this;
+    } });
+    const e = Symbol.dispose;
+    e && (t[e] = t.delete);
+  };
+  function ne() {
+  }
+  var re = (t, e) => Object.defineProperty(e, "name", { value: t }), ze = {}, Ve = (t, e, s) => {
+    if (t[e].overloadTable === void 0) {
+      var l = t[e];
+      t[e] = function(...p) {
+        return t[e].overloadTable.hasOwnProperty(p.length) || nt(`Function '${s}' called with an invalid number of arguments (${p.length}) - expects one of (${t[e].overloadTable})!`), t[e].overloadTable[p.length].apply(this, p);
+      }, t[e].overloadTable = [], t[e].overloadTable[l.argCount] = l;
+    }
+  }, Xt = (t, e, s) => {
+    n.hasOwnProperty(t) ? ((s === void 0 || n[t].overloadTable !== void 0 && n[t].overloadTable[s] !== void 0) && nt(`Cannot register public name '${t}' twice`), Ve(n, t, t), n[t].overloadTable.hasOwnProperty(s) && nt(`Cannot register multiple overloads of a function with the same number of arguments (${s})!`), n[t].overloadTable[s] = e) : (n[t] = e, n[t].argCount = s);
+  }, In = 48, An = 57, kn = (t) => {
+    t = t.replace(/[^a-zA-Z0-9_]/g, "$");
+    var e = t.charCodeAt(0);
+    return e >= In && e <= An ? `_${t}` : t;
+  };
+  function En(t, e, s, l, p, _, $, A) {
+    this.name = t, this.constructor = e, this.instancePrototype = s, this.rawDestructor = l, this.baseClass = p, this.getActualType = _, this.upcast = $, this.downcast = A, this.pureVirtualFunctions = [];
+  }
+  var me = (t, e, s) => {
+    for (; e !== s; )
+      e.upcast || nt(`Expected null or instance of ${s.name}, got an instance of ${e.name}`), t = e.upcast(t), e = e.baseClass;
+    return t;
+  }, ve = (t) => {
+    if (t === null)
+      return "null";
+    var e = typeof t;
+    return e === "object" || e === "array" || e === "function" ? t.toString() : "" + t;
+  };
+  function Rn(t, e) {
+    if (e === null)
+      return this.isReference && nt(`null is not a valid ${this.name}`), 0;
+    e.$$ || nt(`Cannot pass "${ve(e)}" as a ${this.name}`), e.$$.ptr || nt(`Cannot pass deleted object as a pointer of type ${this.name}`);
+    var s = e.$$.ptrType.registeredClass, l = me(e.$$.ptr, s, this.registeredClass);
+    return l;
+  }
+  function Wn(t, e) {
+    var s;
+    if (e === null)
+      return this.isReference && nt(`null is not a valid ${this.name}`), this.isSmartPointer ? (s = this.rawConstructor(), t !== null && t.push(this.rawDestructor, s), s) : 0;
+    (!e || !e.$$) && nt(`Cannot pass "${ve(e)}" as a ${this.name}`), e.$$.ptr || nt(`Cannot pass deleted object as a pointer of type ${this.name}`), !this.isConst && e.$$.ptrType.isConst && nt(`Cannot convert argument of type ${e.$$.smartPtrType ? e.$$.smartPtrType.name : e.$$.ptrType.name} to parameter type ${this.name}`);
+    var l = e.$$.ptrType.registeredClass;
+    if (s = me(e.$$.ptr, l, this.registeredClass), this.isSmartPointer)
+      switch (e.$$.smartPtr === void 0 && nt("Passing raw pointer to smart pointer is illegal"), this.sharingPolicy) {
+        case 0:
+          e.$$.smartPtrType === this ? s = e.$$.smartPtr : nt(`Cannot convert argument of type ${e.$$.smartPtrType ? e.$$.smartPtrType.name : e.$$.ptrType.name} to parameter type ${this.name}`);
+          break;
+        case 1:
+          s = e.$$.smartPtr;
+          break;
+        case 2:
+          if (e.$$.smartPtrType === this)
+            s = e.$$.smartPtr;
+          else {
+            var p = e.clone();
+            s = this.rawShare(s, ht.toHandle(() => p.delete())), t !== null && t.push(this.rawDestructor, s);
+          }
+          break;
+        default:
+          nt("Unsupported sharing policy");
+      }
+    return s;
+  }
+  function zn(t, e) {
+    if (e === null)
+      return this.isReference && nt(`null is not a valid ${this.name}`), 0;
+    e.$$ || nt(`Cannot pass "${ve(e)}" as a ${this.name}`), e.$$.ptr || nt(`Cannot pass deleted object as a pointer of type ${this.name}`), e.$$.ptrType.isConst && nt(`Cannot convert argument of type ${e.$$.ptrType.name} to parameter type ${this.name}`);
+    var s = e.$$.ptrType.registeredClass, l = me(e.$$.ptr, s, this.registeredClass);
+    return l;
+  }
+  var Be = (t, e, s) => {
+    if (e === s)
+      return t;
+    if (s.baseClass === void 0)
+      return null;
+    var l = Be(t, e, s.baseClass);
+    return l === null ? null : s.downcast(l);
+  }, Vn = {}, Bn = (t, e) => {
+    for (e === void 0 && nt("ptr should not be undefined"); t.baseClass; )
+      e = t.upcast(e), t = t.baseClass;
+    return e;
+  }, On = (t, e) => (e = Bn(t, e), Vn[e]), oe = (t, e) => {
+    (!e.ptrType || !e.ptr) && ee("makeClassHandle requires ptr and ptrType");
+    var s = !!e.smartPtrType, l = !!e.smartPtr;
+    return s !== l && ee("Both smartPtrType and smartPtr must be specified"), e.count = { value: 1 }, Kt(Object.create(t, { $$: { value: e, writable: !0 } }));
+  };
+  function jn(t) {
+    var e = this.getPointee(t);
+    if (!e)
+      return this.destructor(t), null;
+    var s = On(this.registeredClass, e);
+    if (s !== void 0) {
+      if (s.$$.count.value === 0)
+        return s.$$.ptr = e, s.$$.smartPtr = t, s.clone();
+      var l = s.clone();
+      return this.destructor(t), l;
+    }
+    function p() {
+      return this.isSmartPointer ? oe(this.registeredClass.instancePrototype, { ptrType: this.pointeeType, ptr: e, smartPtrType: this, smartPtr: t }) : oe(this.registeredClass.instancePrototype, { ptrType: this, ptr: t });
+    }
+    var _ = this.registeredClass.getActualType(e), $ = ze[_];
+    if (!$)
+      return p.call(this);
+    var A;
+    this.isConst ? A = $.constPointerType : A = $.pointerType;
+    var V = Be(e, this.registeredClass, A.registeredClass);
+    return V === null ? p.call(this) : this.isSmartPointer ? oe(A.registeredClass.instancePrototype, { ptrType: A, ptr: V, smartPtrType: this, smartPtr: t }) : oe(A.registeredClass.instancePrototype, { ptrType: A, ptr: V });
+  }
+  var Dn = () => {
+    Object.assign(se.prototype, { getPointee(t) {
+      return this.rawGetPointee && (t = this.rawGetPointee(t)), t;
+    }, destructor(t) {
+      this.rawDestructor?.(t);
+    }, readValueFromPointer: Jt, fromWireType: jn });
+  };
+  function se(t, e, s, l, p, _, $, A, V, N, q) {
+    this.name = t, this.registeredClass = e, this.isReference = s, this.isConst = l, this.isSmartPointer = p, this.pointeeType = _, this.sharingPolicy = $, this.rawGetPointee = A, this.rawConstructor = V, this.rawShare = N, this.rawDestructor = q, !p && e.baseClass === void 0 ? l ? (this.toWireType = Rn, this.destructorFunction = null) : (this.toWireType = zn, this.destructorFunction = null) : this.toWireType = Wn;
+  }
+  var Oe = (t, e, s) => {
+    n.hasOwnProperty(t) || ee("Replacing nonexistent public symbol"), n[t].overloadTable !== void 0 && s !== void 0 ? n[t].overloadTable[s] = e : (n[t] = e, n[t].argCount = s);
+  }, ie = (t) => Yt.get(t), Un = (t, e, s = [], l = !1) => {
+    var p = ie(e), _ = p(...s);
+    function $(A) {
+      return t[0] == "p" ? A >>> 0 : A;
+    }
+    return $(_);
+  }, Nn = (t, e, s = !1) => (...l) => Un(t, e, l, s), wt = (t, e, s = !1) => {
+    t = lt(t);
+    function l() {
+      if (t.includes("p"))
+        return Nn(t, e, s);
+      var _ = ie(e);
+      return _;
+    }
+    var p = l();
+    return typeof p != "function" && nt(`unknown function pointer with signature ${t}: ${e}`), p;
+  };
+  class Hn extends Error {
+  }
+  var je = (t) => {
+    var e = Ze(t), s = lt(e);
+    return At(e), s;
+  }, ae = (t, e) => {
+    var s = [], l = {};
+    function p(_) {
+      if (!l[_] && !Rt[_]) {
+        if (te[_]) {
+          te[_].forEach(p);
+          return;
+        }
+        s.push(_), l[_] = !0;
+      }
+    }
+    throw e.forEach(p), new Hn(`${t}: ` + s.map(je).join([", "]));
+  };
+  function Ln(t, e, s, l, p, _, $, A, V, N, q, Q, et) {
+    t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, _ >>>= 0, $ >>>= 0, A >>>= 0, V >>>= 0, N >>>= 0, q >>>= 0, Q >>>= 0, et >>>= 0, q = lt(q), _ = wt(p, _), A &&= wt($, A), N &&= wt(V, N), et = wt(Q, et);
+    var tt = kn(q);
+    Xt(tt, function() {
+      ae(`Cannot construct ${q} due to unbound types`, [l]);
+    }), It([t, e, s], l ? [l] : [], (st) => {
+      st = st[0];
+      var pt, gt;
+      l ? (pt = st.registeredClass, gt = pt.instancePrototype) : gt = ne.prototype;
+      var u = re(q, function(...ot) {
+        if (Object.getPrototypeOf(this) !== h)
+          throw new Gt(`Use 'new' to construct ${q}`);
+        if (C.constructor_body === void 0)
+          throw new Gt(`${q} has no accessible constructor`);
+        var yt = C.constructor_body[ot.length];
+        if (yt === void 0)
+          throw new Gt(`Tried to invoke ctor of ${q} with invalid number of parameters (${ot.length}) - expected (${Object.keys(C.constructor_body).toString()}) parameters instead!`);
+        return yt.apply(this, ot);
+      }), h = Object.create(gt, { constructor: { value: u } });
+      u.prototype = h;
+      var C = new En(q, u, h, et, pt, _, A, N);
+      C.baseClass && (C.baseClass.__derivedClasses ??= [], C.baseClass.__derivedClasses.push(C));
+      var W = new se(q, C, !0, !1, !1), K = new se(q + "*", C, !1, !1, !1), Z = new se(q + " const*", C, !1, !0, !1);
+      return ze[t] = { pointerType: K, constPointerType: Z }, Oe(tt, u), [W, K, Z];
+    });
+  }
+  var ge = (t, e) => {
+    for (var s = [], l = 0; l < t; l++)
+      s.push(R[e + l * 4 >>> 2 >>> 0]);
+    return s;
+  };
+  function De(t) {
+    for (var e = 1; e < t.length; ++e)
+      if (t[e] !== null && t[e].destructorFunction === void 0)
+        return !0;
+    return !1;
+  }
+  function qn(t, e, s, l) {
+    var p = De(t), _ = t.length - 2, $ = [], A = ["fn"];
+    e && A.push("thisWired");
+    for (var V = 0; V < _; ++V)
+      $.push(`arg${V}`), A.push(`arg${V}Wired`);
+    $ = $.join(","), A = A.join(",");
+    var N = `return function (${$}) {
+`;
+    p && (N += `var destructors = [];
+`);
+    var q = p ? "destructors" : "null", Q = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire"];
+    e && (N += `var thisWired = toClassParamWire(${q}, this);
+`);
+    for (var V = 0; V < _; ++V) {
+      var et = `toArg${V}Wire`;
+      N += `var arg${V}Wired = ${et}(${q}, arg${V});
+`, Q.push(et);
+    }
+    if (N += (s || l ? "var rv = " : "") + `invoker(${A});
+`, p)
+      N += `runDestructors(destructors);
+`;
+    else
+      for (var V = e ? 1 : 2; V < t.length; ++V) {
+        var tt = V === 1 ? "thisWired" : "arg" + (V - 2) + "Wired";
+        t[V].destructorFunction !== null && (N += `${tt}_dtor(${tt});
+`, Q.push(`${tt}_dtor`));
+      }
+    return s && (N += `var ret = fromRetWire(rv);
+return ret;
+`), N += `}
+`, new Function(Q, N);
+  }
+  function be(t, e, s, l, p, _) {
+    var $ = e.length;
+    $ < 2 && nt("argTypes array size mismatch! Must at least get return value and 'this' types!");
+    for (var A = e[1] !== null && s !== null, V = De(e), N = !e[0].isVoid, q = e[0], Q = e[1], et = [t, nt, l, p, he, q.fromWireType.bind(q), Q?.toWireType.bind(Q)], tt = 2; tt < $; ++tt) {
+      var st = e[tt];
+      et.push(st.toWireType.bind(st));
+    }
+    if (!V)
+      for (var tt = A ? 1 : 2; tt < e.length; ++tt)
+        e[tt].destructorFunction !== null && et.push(e[tt].destructorFunction);
+    var gt = qn(e, A, N, _)(...et);
+    return re(t, gt);
+  }
+  var Jn = function(t, e, s, l, p, _) {
+    t >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, _ >>>= 0;
+    var $ = ge(e, s);
+    p = wt(l, p), It([], [t], (A) => {
+      A = A[0];
+      var V = `constructor ${A.name}`;
+      if (A.registeredClass.constructor_body === void 0 && (A.registeredClass.constructor_body = []), A.registeredClass.constructor_body[e - 1] !== void 0)
+        throw new Gt(`Cannot register multiple constructors with identical number of parameters (${e - 1}) for class '${A.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
+      return A.registeredClass.constructor_body[e - 1] = () => {
+        ae(`Cannot construct ${A.name} due to unbound types`, $);
+      }, It([], $, (N) => (N.splice(1, 0, null), A.registeredClass.constructor_body[e - 1] = be(V, N, null, p, _), [])), [];
+    });
+  }, Ue = (t) => {
+    t = t.trim();
+    const e = t.indexOf("(");
+    return e === -1 ? t : t.slice(0, e);
+  }, Gn = function(t, e, s, l, p, _, $, A, V, N) {
+    t >>>= 0, e >>>= 0, l >>>= 0, p >>>= 0, _ >>>= 0, $ >>>= 0;
+    var q = ge(s, l);
+    e = lt(e), e = Ue(e), _ = wt(p, _, V), It([], [t], (Q) => {
+      Q = Q[0];
+      var et = `${Q.name}.${e}`;
+      e.startsWith("@@") && (e = Symbol[e.substring(2)]), A && Q.registeredClass.pureVirtualFunctions.push(e);
+      function tt() {
+        ae(`Cannot call ${et} due to unbound types`, q);
+      }
+      var st = Q.registeredClass.instancePrototype, pt = st[e];
+      return pt === void 0 || pt.overloadTable === void 0 && pt.className !== Q.name && pt.argCount === s - 2 ? (tt.argCount = s - 2, tt.className = Q.name, st[e] = tt) : (Ve(st, e, et), st[e].overloadTable[s - 2] = tt), It([], q, (gt) => {
+        var u = be(et, gt, Q, _, $, V);
+        return st[e].overloadTable === void 0 ? (u.argCount = s - 2, st[e] = u) : st[e].overloadTable[s - 2] = u, [];
+      }), [];
+    });
+  }, Ne = [], Wt = [0, 1, , 1, null, 1, !0, 1, !1, 1];
+  function xe(t) {
+    t >>>= 0, t > 9 && --Wt[t + 1] === 0 && (Wt[t] = void 0, Ne.push(t));
+  }
+  var ht = { toValue: (t) => (t || nt(`Cannot use deleted val. handle = ${t}`), Wt[t]), toHandle: (t) => {
+    switch (t) {
+      case void 0:
+        return 2;
+      case null:
+        return 4;
+      case !0:
+        return 6;
+      case !1:
+        return 8;
+      default: {
+        const e = Ne.pop() || Wt.length;
+        return Wt[e] = t, Wt[e + 1] = 1, e;
+      }
+    }
+  } }, He = { name: "emscripten::val", fromWireType: (t) => {
+    var e = ht.toValue(t);
+    return xe(t), e;
+  }, toWireType: (t, e) => ht.toHandle(e), readValueFromPointer: Jt, destructorFunction: null };
+  function Kn(t) {
+    return t >>>= 0, vt(t, He);
+  }
+  var _e = (t, e, s) => {
+    switch (e) {
+      case 1:
+        return s ? function(l) {
+          return this.fromWireType(z[l >>> 0]);
+        } : function(l) {
+          return this.fromWireType(T[l >>> 0]);
+        };
+      case 2:
+        return s ? function(l) {
+          return this.fromWireType(S[l >>> 1 >>> 0]);
+        } : function(l) {
+          return this.fromWireType(w[l >>> 1 >>> 0]);
+        };
+      case 4:
+        return s ? function(l) {
+          return this.fromWireType(B[l >>> 2 >>> 0]);
+        } : function(l) {
+          return this.fromWireType(R[l >>> 2 >>> 0]);
+        };
+      default:
+        throw new TypeError(`invalid integer width (${e}): ${t}`);
+    }
+  };
+  function Xn(t) {
+    return t === 0 ? "object" : t === 1 ? "number" : "string";
+  }
+  function Yn(t, e, s, l, p) {
+    t >>>= 0, e >>>= 0, s >>>= 0, e = lt(e);
+    const _ = Xn(p);
+    switch (_) {
+      case "object": {
+        let N = function() {
+        };
+        N.values = {}, vt(t, { name: e, constructor: N, valueType: _, fromWireType: function(q) {
+          return this.constructor.values[q];
+        }, toWireType: (q, Q) => Q.value, readValueFromPointer: _e(e, s, l), destructorFunction: null }), Xt(e, N);
+        break;
+      }
+      case "number": {
+        var $ = {};
+        vt(t, { name: e, keysMap: $, valueType: _, fromWireType: (N) => N, toWireType: (N, q) => q, readValueFromPointer: _e(e, s, l), destructorFunction: null }), Xt(e, $), delete n[e].argCount;
+        break;
+      }
+      case "string": {
+        var A = {}, V = {}, $ = {};
+        vt(t, { name: e, valuesMap: A, reverseMap: V, keysMap: $, valueType: _, fromWireType: function(q) {
+          return this.reverseMap[q];
+        }, toWireType: function(q, Q) {
+          return this.valuesMap[Q];
+        }, readValueFromPointer: _e(e, s, l), destructorFunction: null }), Xt(e, $), delete n[e].argCount;
+        break;
+      }
+    }
+  }
+  var Le = (t, e) => {
+    var s = Rt[t];
+    return s === void 0 && nt(`${e} has unknown type ${je(t)}`), s;
+  };
+  function Zn(t, e, s) {
+    t >>>= 0, e >>>= 0;
+    var l = Le(t, "enum");
+    switch (e = lt(e), l.valueType) {
+      case "object": {
+        var p = l.constructor, _ = Object.create(l.constructor.prototype, { value: { value: s }, constructor: { value: re(`${l.name}_${e}`, function() {
+        }) } });
+        p.values[s] = _, p[e] = _;
+        break;
+      }
+      case "number": {
+        l.keysMap[e] = s;
+        break;
+      }
+      case "string": {
+        l.valuesMap[e] = s, l.reverseMap[s] = e, l.keysMap[e] = e;
+        break;
+      }
+    }
+  }
+  var Qn = (t, e) => {
+    switch (e) {
+      case 4:
+        return function(s) {
+          return this.fromWireType(j[s >>> 2 >>> 0]);
+        };
+      case 8:
+        return function(s) {
+          return this.fromWireType(O[s >>> 3 >>> 0]);
+        };
+      default:
+        throw new TypeError(`invalid float width (${e}): ${t}`);
+    }
+  }, tr = function(t, e, s) {
+    t >>>= 0, e >>>= 0, s >>>= 0, e = lt(e), vt(t, { name: e, fromWireType: (l) => l, toWireType: (l, p) => p, readValueFromPointer: Qn(e, s), destructorFunction: null });
+  };
+  function er(t, e, s, l, p, _, $, A) {
+    t >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, _ >>>= 0;
+    var V = ge(e, s);
+    t = lt(t), t = Ue(t), p = wt(l, p, $), Xt(t, function() {
+      ae(`Cannot call ${t} due to unbound types`, V);
+    }, e - 1), It([], V, (N) => {
+      var q = [N[0], null].concat(N.slice(1));
+      return Oe(t, be(t, q, null, p, _, $), e - 1), [];
+    });
+  }
+  var nr = function(t, e, s, l, p) {
+    t >>>= 0, e >>>= 0, s >>>= 0, e = lt(e);
+    const _ = l === 0;
+    let $ = (V) => V;
+    if (_) {
+      var A = 32 - 8 * s;
+      $ = (V) => V << A >>> A, p = $(p);
+    }
+    vt(t, { name: e, fromWireType: $, toWireType: (V, N) => N, readValueFromPointer: Ee(e, s, l !== 0), destructorFunction: null });
+  }, rr = (t, e, s) => {
+    const l = (p, _) => {
+      let $ = 0;
+      return { next() {
+        if ($ >= p)
+          return { done: !0 };
+        const A = $;
+        return $++, { value: _(A), done: !1 };
+      }, [Symbol.iterator]() {
+        return this;
+      } };
+    };
+    t[Symbol.iterator] || (t[Symbol.iterator] = function() {
+      const p = this[e]();
+      return l(p, (_) => this[s](_));
+    });
+  }, or = function(t, e, s, l) {
+    t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, s = lt(s), l = lt(l), It([], [t, e], (p) => {
+      const _ = p[0];
+      return rr(_.registeredClass.instancePrototype, s, l), [];
+    });
+  };
+  function sr(t, e, s) {
+    t >>>= 0, s >>>= 0;
+    var l = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array], p = l[e];
+    function _($) {
+      var A = R[$ >>> 2 >>> 0], V = R[$ + 4 >>> 2 >>> 0];
+      return new p(z.buffer, V, A);
+    }
+    s = lt(s), vt(t, { name: s, fromWireType: _, readValueFromPointer: _ }, { ignoreDuplicateRegistrations: !0 });
+  }
+  var ir = Object.assign({ optional: !0 }, He);
+  function ar(t, e) {
+    t >>>= 0, vt(t, ir);
+  }
+  var cr = (t, e, s, l) => {
+    if (s >>>= 0, !(l > 0)) return 0;
+    for (var p = s, _ = s + l - 1, $ = 0; $ < t.length; ++$) {
+      var A = t.codePointAt($);
+      if (A <= 127) {
+        if (s >= _) break;
+        e[s++ >>> 0] = A;
+      } else if (A <= 2047) {
+        if (s + 1 >= _) break;
+        e[s++ >>> 0] = 192 | A >> 6, e[s++ >>> 0] = 128 | A & 63;
+      } else if (A <= 65535) {
+        if (s + 2 >= _) break;
+        e[s++ >>> 0] = 224 | A >> 12, e[s++ >>> 0] = 128 | A >> 6 & 63, e[s++ >>> 0] = 128 | A & 63;
+      } else {
+        if (s + 3 >= _) break;
+        e[s++ >>> 0] = 240 | A >> 18, e[s++ >>> 0] = 128 | A >> 12 & 63, e[s++ >>> 0] = 128 | A >> 6 & 63, e[s++ >>> 0] = 128 | A & 63, $++;
+      }
+    }
+    return e[s >>> 0] = 0, s - p;
+  }, lr = (t, e, s) => cr(t, T, e, s), ur = (t) => {
+    for (var e = 0, s = 0; s < t.length; ++s) {
+      var l = t.charCodeAt(s);
+      l <= 127 ? e++ : l <= 2047 ? e += 2 : l >= 55296 && l <= 57343 ? (e += 4, ++s) : e += 3;
+    }
+    return e;
+  }, qe = globalThis.TextDecoder && new TextDecoder(), Je = (t, e, s, l) => {
+    var p = e + s;
+    if (l) return p;
+    for (; t[e] && !(e >= p); ) ++e;
+    return e;
+  }, fr = (t, e = 0, s, l) => {
+    e >>>= 0;
+    var p = Je(t, e, s, l);
+    if (p - e > 16 && t.buffer && qe)
+      return qe.decode(t.subarray(e, p));
+    for (var _ = ""; e < p; ) {
+      var $ = t[e++];
+      if (!($ & 128)) {
+        _ += String.fromCharCode($);
+        continue;
+      }
+      var A = t[e++] & 63;
+      if (($ & 224) == 192) {
+        _ += String.fromCharCode(($ & 31) << 6 | A);
+        continue;
+      }
+      var V = t[e++] & 63;
+      if (($ & 240) == 224 ? $ = ($ & 15) << 12 | A << 6 | V : $ = ($ & 7) << 18 | A << 12 | V << 6 | t[e++] & 63, $ < 65536)
+        _ += String.fromCharCode($);
+      else {
+        var N = $ - 65536;
+        _ += String.fromCharCode(55296 | N >> 10, 56320 | N & 1023);
+      }
+    }
+    return _;
+  }, dr = (t, e, s) => (t >>>= 0, t ? fr(T, t, e, s) : "");
+  function hr(t, e) {
+    t >>>= 0, e >>>= 0, e = lt(e), vt(t, { name: e, fromWireType(s) {
+      var l = R[s >>> 2 >>> 0], p = s + 4, _;
+      return _ = dr(p, l, !0), At(s), _;
+    }, toWireType(s, l) {
+      l instanceof ArrayBuffer && (l = new Uint8Array(l));
+      var p, _ = typeof l == "string";
+      _ || ArrayBuffer.isView(l) && l.BYTES_PER_ELEMENT == 1 || nt("Cannot pass non-string to std::string"), _ ? p = ur(l) : p = l.length;
+      var $ = Pe(4 + p + 1), A = $ + 4;
+      return R[$ >>> 2 >>> 0] = p, _ ? lr(l, A, p + 1) : T.set(l, A >>> 0), s !== null && s.push(At, $), $;
+    }, readValueFromPointer: Jt, destructorFunction(s) {
+      At(s);
+    } });
+  }
+  var Ge = globalThis.TextDecoder ? new TextDecoder("utf-16le") : void 0, pr = (t, e, s) => {
+    var l = t >>> 1, p = Je(w, l, e / 2, s);
+    if (p - l > 16 && Ge) return Ge.decode(w.subarray(l >>> 0, p >>> 0));
+    for (var _ = "", $ = l; $ < p; ++$) {
+      var A = w[$ >>> 0];
+      _ += String.fromCharCode(A);
+    }
+    return _;
+  }, yr = (t, e, s) => {
+    if (s ??= 2147483647, s < 2) return 0;
+    s -= 2;
+    for (var l = e, p = s < t.length * 2 ? s / 2 : t.length, _ = 0; _ < p; ++_) {
+      var $ = t.charCodeAt(_);
+      S[e >>> 1 >>> 0] = $, e += 2;
+    }
+    return S[e >>> 1 >>> 0] = 0, e - l;
+  }, mr = (t) => t.length * 2, vr = (t, e, s) => {
+    for (var l = "", p = t >>> 2, _ = 0; !(_ >= e / 4); _++) {
+      var $ = R[p + _ >>> 0];
+      if (!$ && !s) break;
+      l += String.fromCodePoint($);
+    }
+    return l;
+  }, gr = (t, e, s) => {
+    if (e >>>= 0, s ??= 2147483647, s < 4) return 0;
+    for (var l = e, p = l + s - 4, _ = 0; _ < t.length; ++_) {
+      var $ = t.codePointAt(_);
+      if ($ > 65535 && _++, B[e >>> 2 >>> 0] = $, e += 4, e + 4 > p) break;
+    }
+    return B[e >>> 2 >>> 0] = 0, e - l;
+  }, br = (t) => {
+    for (var e = 0, s = 0; s < t.length; ++s) {
+      var l = t.codePointAt(s);
+      l > 65535 && s++, e += 4;
+    }
+    return e;
+  };
+  function xr(t, e, s) {
+    t >>>= 0, e >>>= 0, s >>>= 0, s = lt(s);
+    var l, p, _;
+    e === 2 ? (l = pr, p = yr, _ = mr) : (l = vr, p = gr, _ = br), vt(t, { name: s, fromWireType: ($) => {
+      var A = R[$ >>> 2 >>> 0], V = l($ + 4, A * e, !0);
+      return At($), V;
+    }, toWireType: ($, A) => {
+      typeof A != "string" && nt(`Cannot pass non-string to C++ string type ${s}`);
+      var V = _(A), N = Pe(4 + V + e);
+      return R[N >>> 2 >>> 0] = V / e, p(A, N + 4, V + e), $ !== null && $.push(At, N), N;
+    }, readValueFromPointer: Jt, destructorFunction($) {
+      At($);
+    } });
+  }
+  function _r(t, e, s, l, p, _) {
+    t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, _ >>>= 0, Qt[t] = { name: lt(e), rawConstructor: wt(s, l), rawDestructor: wt(p, _), fields: [] };
+  }
+  function Mr(t, e, s, l, p, _, $, A, V, N) {
+    t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, _ >>>= 0, $ >>>= 0, A >>>= 0, V >>>= 0, N >>>= 0, Qt[t].fields.push({ fieldName: lt(e), getterReturnType: s, getter: wt(l, p), getterContext: _, setterArgumentType: $, setter: wt(A, V), setterContext: N });
+  }
+  var wr = function(t, e) {
+    t >>>= 0, e >>>= 0, e = lt(e), vt(t, { isVoid: !0, name: e, fromWireType: () => {
+    }, toWireType: (s, l) => {
+    } });
+  };
+  function $r(t, e) {
+    t >>>= 0, e >>>= 0, t = ht.toValue(t), e = ht.toValue(e), t.set(e);
+  }
+  var Me = [], Pr = (t) => {
+    var e = Me.length;
+    return Me.push(t), e;
+  }, Cr = (t, e) => {
+    for (var s = new Array(t), l = 0; l < t; ++l)
+      s[l] = Le(R[e + l * 4 >>> 2 >>> 0], `parameter ${l}`);
+    return s;
+  }, Tr = (t, e, s) => {
+    var l = [], p = t(l, s);
+    return l.length && (R[e >>> 2 >>> 0] = ht.toHandle(l)), p;
+  }, Sr = {}, Ke = (t) => {
+    var e = Sr[t];
+    return e === void 0 ? lt(t) : e;
+  }, Fr = function(t, e, s) {
+    e >>>= 0;
+    var l = 8, [p, ..._] = Cr(t, e), $ = p.toWireType.bind(p), A = _.map((tt) => tt.readValueFromPointer.bind(tt));
+    t--;
+    var V = { toValue: ht.toValue }, N = A.map((tt, st) => {
+      var pt = `argFromPtr${st}`;
+      return V[pt] = tt, `${pt}(args${st ? "+" + st * l : ""})`;
+    }), q;
+    switch (s) {
+      case 0:
+        q = "toValue(handle)";
+        break;
+      case 2:
+        q = "new (toValue(handle))";
+        break;
+      case 3:
+        q = "";
+        break;
+      case 1:
+        V.getStringOrSymbol = Ke, q = "toValue(handle)[getStringOrSymbol(methodName)]";
+        break;
+    }
+    q += `(${N})`, p.isVoid || (V.toReturnWire = $, V.emval_returnValue = Tr, q = `return emval_returnValue(toReturnWire, destructorsRef, ${q})`), q = `return function (handle, methodName, destructorsRef, args) {
+${q}
+}`;
+    var Q = new Function(Object.keys(V), q)(...Object.values(V)), et = `methodCaller<(${_.map((tt) => tt.name)}) => ${p.name}>`;
+    return Pr(re(et, Q));
+  };
+  function Ir(t, e) {
+    return t >>>= 0, e >>>= 0, t = ht.toValue(t), e = ht.toValue(e), t == e;
+  }
+  function Ar(t, e) {
+    return t >>>= 0, e >>>= 0, t = ht.toValue(t), e = ht.toValue(e), ht.toHandle(t[e]);
+  }
+  function kr(t) {
+    t >>>= 0, t > 9 && (Wt[t + 1] += 1);
+  }
+  function Er(t, e, s, l, p) {
+    return t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, Me[t](e, s, l, p);
+  }
+  function Rr(t) {
+    return t >>>= 0, ht.toHandle(Ke(t));
+  }
+  function Wr() {
+    return ht.toHandle({});
+  }
+  function zr(t) {
+    t >>>= 0;
+    var e = ht.toValue(t);
+    he(e), xe(t);
+  }
+  function Vr(t, e, s) {
+    t >>>= 0, e >>>= 0, s >>>= 0, t = ht.toValue(t), e = ht.toValue(e), s = ht.toValue(s), t[e] = s;
+  }
+  var Br = () => 4294901760, Or = (t, e) => Math.ceil(t / e) * e, jr = (t) => {
+    var e = ce.buffer.byteLength, s = (t - e + 65535) / 65536 | 0;
+    try {
+      return ce.grow(s), J(), 1;
+    } catch {
+    }
+  };
+  function Dr(t) {
+    t >>>= 0;
+    var e = T.length, s = Br();
+    if (t > s)
+      return !1;
+    for (var l = 1; l <= 4; l *= 2) {
+      var p = e * (1 + 0.2 / l);
+      p = Math.min(p, t + 100663296);
+      var _ = Math.min(s, Or(Math.max(t, p), 65536)), $ = jr(_);
+      if ($)
+        return !0;
+    }
+    return !1;
+  }
+  var Ur = (t, e) => {
+    if (zt)
+      for (var s = t; s < t + e; s++) {
+        var l = ie(s);
+        l && zt.set(l, s);
+      }
+  }, zt, Nr = (t) => (zt || (zt = /* @__PURE__ */ new WeakMap(), Ur(0, Yt.length)), zt.get(t) || 0), we = [], Hr = () => we.length ? we.pop() : Yt.grow(1), $e = (t, e) => Yt.set(t, e), Xe = (t) => {
+    const e = t.length;
+    return [e % 128 | 128, e >> 7, ...t];
+  }, Lr = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 }, Ye = (t) => Xe(Array.from(t, (e) => {
+    var s = Lr[e];
+    return s;
+  })), qr = (t, e) => {
+    var s = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...Xe([1, 96, ...Ye(e.slice(1)), ...Ye(e[0] === "v" ? "" : e[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0), l = new WebAssembly.Module(s), p = new WebAssembly.Instance(l, { e: { f: t } }), _ = p.exports.f;
+    return _;
+  }, Vt = (t, e) => {
+    var s = Nr(t);
+    if (s)
+      return s;
+    var l = Hr();
+    try {
+      $e(l, t);
+    } catch (_) {
+      if (!(_ instanceof TypeError))
+        throw _;
+      var p = qr(t, e);
+      $e(l, p);
+    }
+    return zt.set(t, l), l;
+  }, Bt = (t) => {
+    zt.delete(ie(t)), $e(t, null), we.push(t);
+  };
+  if (Fn(), Dn(), n.noExitRuntime && n.noExitRuntime, n.print && n.print, n.printErr && (E = n.printErr), n.wasmBinary && (g = n.wasmBinary), n.arguments && n.arguments, n.thisProgram && n.thisProgram, n.preInit)
+    for (typeof n.preInit == "function" && (n.preInit = [n.preInit]); n.preInit.length > 0; )
+      n.preInit.shift()();
+  n.addFunction = Vt, n.removeFunction = Bt;
+  var Ze, Pe, At, ce, Yt;
+  function Jr(t) {
+    Ze = t.K, Pe = t.M, At = t.N, ce = t.I, Yt = t.L;
+  }
+  var Gr = { l: xn, C: _n, q: wn, z: Pn, G: Cn, j: Ln, i: Jn, a: Gn, E: Kn, x: Yn, d: Zn, y: tr, c: er, p: nr, m: or, h: sr, n: ar, F: hr, w: xr, r: _r, k: Mr, H: wr, u: $r, g: Fr, b: xe, o: Ir, B: Ar, t: kr, f: Er, s: Rr, A: Wr, e: zr, v: Vr, D: Dr };
+  function Kr(t) {
+    t = Object.assign({}, t);
+    var e = (l) => (p) => l(p) >>> 0, s = (l) => () => l() >>> 0;
+    return t.K = e(t.K), t.M = e(t.M), t._emscripten_stack_alloc = e(t._emscripten_stack_alloc), t.emscripten_stack_get_current = s(t.emscripten_stack_get_current), t;
+  }
+  function Xr() {
+    X();
+    function t() {
+      n.calledRun = !0, !P && (rt(), F?.(n), n.onRuntimeInitialized?.(), H());
+    }
+    n.setStatus ? (n.setStatus("Running..."), setTimeout(() => {
+      setTimeout(() => n.setStatus(""), 1), t();
+    }, 1)) : t();
+  }
+  var Ot;
+  return Ot = await Ft(), Xr(), U ? r = n : r = new Promise((t, e) => {
+    F = t, I = e;
+  }), r;
+}
+function Zr(o, r) {
+  return o < r ? `${o}_${r}` : `${r}_${o}`;
+}
+function $t(o, r) {
+  const n = o.length / 3, i = r.length / 3, c = /* @__PURE__ */ new Map();
+  let a = 0, f = 0, d = 0;
+  const v = [1 / 0, 1 / 0, 1 / 0], y = [-1 / 0, -1 / 0, -1 / 0];
+  for (let M = 0; M < n; M++) {
+    const F = o[M * 3], I = o[M * 3 + 1], z = o[M * 3 + 2];
+    F < v[0] && (v[0] = F), I < v[1] && (v[1] = I), z < v[2] && (v[2] = z), F > y[0] && (y[0] = F), I > y[1] && (y[1] = I), z > y[2] && (y[2] = z);
+  }
+  const m = new Int32Array(n);
+  for (let M = 0; M < n; M++) m[M] = M;
+  const k = (M) => {
+    for (; m[M] !== M; )
+      m[M] = m[m[M]], M = m[M];
+    return M;
+  }, b = (M, F) => {
+    const I = k(M), z = k(F);
+    I !== z && (m[I] = z);
+  };
+  for (let M = 0; M < i; M++) {
+    const F = r[M * 3], I = r[M * 3 + 1], z = r[M * 3 + 2], T = o[F * 3], S = o[F * 3 + 1], w = o[F * 3 + 2], B = o[I * 3], R = o[I * 3 + 1], j = o[I * 3 + 2], O = o[z * 3], D = o[z * 3 + 1], L = o[z * 3 + 2], U = B - T, J = R - S, X = j - w, rt = O - T, H = D - S, G = L - w, Y = J * G - X * H, mt = X * rt - U * G, ft = U * H - J * rt, ut = 0.5 * Math.hypot(Y, mt, ft);
+    ut < 1e-12 && d++, f += ut, a += T * Y + S * mt + w * ft;
+    for (const [Pt, Ct] of [[F, I], [I, z], [z, F]]) {
+      const _t = Zr(Pt, Ct);
+      c.set(_t, (c.get(_t) ?? 0) + 1), b(Pt, Ct);
+    }
+  }
+  let x = 0, E = 0;
+  for (const M of c.values())
+    M === 1 ? x++ : M > 2 && E++;
+  const g = /* @__PURE__ */ new Set();
+  for (let M = 0; M < n; M++) g.add(k(M));
+  const P = a / 6;
+  return {
+    triangleCount: i,
+    vertexCount: n,
+    openEdgeCount: x,
+    nonManifoldEdgeCount: E,
+    componentCount: Math.max(1, g.size),
+    volume: P,
+    surfaceArea: f,
+    bbox: {
+      min: v,
+      max: y,
+      size: [y[0] - v[0], y[1] - v[1], y[2] - v[2]]
+    },
+    invertedNormals: P < 0,
+    degenerateCount: d
+  };
+}
+function Qr(o, r, n = 200) {
+  const i = r.length / 3;
+  if (i === 0) return 0;
+  const c = Math.max(1, Math.floor(i / n));
+  let a = 1 / 0;
+  const f = [];
+  for (let d = 0; d < i; d += c) {
+    const v = r[d * 3], y = r[d * 3 + 1], m = r[d * 3 + 2], k = o[v * 3], b = o[v * 3 + 1], x = o[v * 3 + 2], E = o[y * 3], g = o[y * 3 + 1], P = o[y * 3 + 2], M = o[m * 3], F = o[m * 3 + 1], I = o[m * 3 + 2], z = (k + E + M) / 3, T = (b + g + F) / 3, S = (x + P + I) / 3, w = (g - b) * (I - x) - (P - x) * (F - b), B = (P - x) * (M - k) - (E - k) * (I - x), R = (E - k) * (F - b) - (g - b) * (M - k), j = Math.hypot(w, B, R) || 1;
+    f.push([z, T, S, -w / j, -B / j, -R / j]);
+  }
+  for (const [d, v, y, m, k, b] of f) {
+    let x = 1 / 0;
+    for (let E = 0; E < i; E += Math.max(1, Math.floor(c / 2))) {
+      const g = r[E * 3], P = r[E * 3 + 1], M = r[E * 3 + 2], F = Ae(
+        d,
+        v,
+        y,
+        m,
+        k,
+        b,
+        o[g * 3],
+        o[g * 3 + 1],
+        o[g * 3 + 2],
+        o[P * 3],
+        o[P * 3 + 1],
+        o[P * 3 + 2],
+        o[M * 3],
+        o[M * 3 + 1],
+        o[M * 3 + 2]
+      );
+      F > 1e-3 && F < x && (x = F);
+    }
+    x < a && (a = x);
+  }
+  return Number.isFinite(a) ? a : 0;
+}
+function Ae(o, r, n, i, c, a, f, d, v, y, m, k, b, x, E) {
+  const P = y - f, M = m - d, F = k - v, I = b - f, z = x - d, T = E - v, S = c * T - a * z, w = a * I - i * T, B = i * z - c * I, R = P * S + M * w + F * B;
+  if (Math.abs(R) < 1e-8) return 1 / 0;
+  const j = 1 / R, O = o - f, D = r - d, L = n - v, U = (O * S + D * w + L * B) * j;
+  if (U < 0 || U > 1) return 1 / 0;
+  const J = D * F - L * M, X = L * P - O * F, rt = O * M - D * P, H = (i * J + c * X + a * rt) * j;
+  if (H < 0 || U + H > 1) return 1 / 0;
+  const G = (I * J + z * X + T * rt) * j;
+  return G > 0 ? G : 1 / 0;
+}
+function to(o, r, n) {
+  const i = o.length / 3, c = new Float32Array(i * 3), a = r.length / 3, f = Math.min(i, 800), d = Math.max(1, Math.floor(i / f)), v = new Float32Array(i);
+  v.fill(n * 4);
+  for (let y = 0; y < i; y += d) {
+    let m = 0, k = 0, b = 0;
+    for (let I = 0; I < a; I++)
+      if (r[I * 3] === y || r[I * 3 + 1] === y || r[I * 3 + 2] === y) {
+        const z = r[I * 3], T = r[I * 3 + 1], S = r[I * 3 + 2], w = o[z * 3], B = o[z * 3 + 1], R = o[z * 3 + 2], j = o[T * 3], O = o[T * 3 + 1], D = o[T * 3 + 2], L = o[S * 3], U = o[S * 3 + 1], J = o[S * 3 + 2];
+        m += (O - B) * (J - R) - (D - R) * (U - B), k += (D - R) * (L - w) - (j - w) * (J - R), b += (j - w) * (U - B) - (O - B) * (L - w);
+      }
+    const x = Math.hypot(m, k, b) || 1, E = o[y * 3], g = o[y * 3 + 1], P = o[y * 3 + 2];
+    let M = 1 / 0;
+    const F = Math.max(1, Math.floor(a / 120));
+    for (let I = 0; I < a; I += F) {
+      const z = r[I * 3], T = r[I * 3 + 1], S = r[I * 3 + 2], w = Ae(
+        E,
+        g,
+        P,
+        -m / x,
+        -k / x,
+        -b / x,
+        o[z * 3],
+        o[z * 3 + 1],
+        o[z * 3 + 2],
+        o[T * 3],
+        o[T * 3 + 1],
+        o[T * 3 + 2],
+        o[S * 3],
+        o[S * 3 + 1],
+        o[S * 3 + 2]
+      );
+      w > 1e-3 && w < M && (M = w);
+    }
+    v[y] = Number.isFinite(M) ? M : n * 4;
+  }
+  for (let y = 0; y < i; y++) {
+    const m = Math.min(1, v[y] / (n * 3));
+    c[y * 3] = 1 - m, c[y * 3 + 1] = m, c[y * 3 + 2] = 0.15;
+  }
+  return c;
+}
+function Qe(o, r, n, i) {
+  o.push(
+    r[n * 3],
+    r[n * 3 + 1],
+    r[n * 3 + 2],
+    r[i * 3],
+    r[i * 3 + 1],
+    r[i * 3 + 2]
+  );
+}
+function tn(o, r, n) {
+  return [
+    (o[r * 3] + o[n * 3]) / 2,
+    (o[r * 3 + 1] + o[n * 3 + 1]) / 2,
+    (o[r * 3 + 2] + o[n * 3 + 2]) / 2
+  ];
+}
+function eo(o, r, n, i) {
+  const c = o.length / 3, a = r.length / 3, f = /* @__PURE__ */ new Map(), d = new Int32Array(c);
+  for (let w = 0; w < c; w++) d[w] = w;
+  const v = (w) => {
+    for (; d[w] !== w; )
+      d[w] = d[d[w]], w = d[w];
+    return w;
+  }, y = (w, B) => {
+    const R = v(w), j = v(B);
+    R !== j && (d[R] = j);
+  };
+  for (let w = 0; w < a; w++) {
+    const B = r[w * 3], R = r[w * 3 + 1], j = r[w * 3 + 2];
+    for (const [O, D] of [[B, R], [R, j], [j, B]]) {
+      const L = O < D ? `${O}_${D}` : `${D}_${O}`, U = f.get(L);
+      U ? U.count++ : f.set(L, { a: O, b: D, count: 1 }), y(O, D);
+    }
+  }
+  const m = [], k = [];
+  let b, x;
+  for (const w of f.values())
+    w.count === 1 && m.length < 24e3 ? (Qe(m, o, w.a, w.b), b ??= tn(o, w.a, w.b)) : w.count > 2 && k.length < 12e3 && (Qe(k, o, w.a, w.b), x ??= tn(o, w.a, w.b));
+  const E = [];
+  let g;
+  const P = Math.max(1, Math.floor(a / 400));
+  for (let w = 0; w < a && E.length < 9e3; w += P) {
+    const B = r[w * 3], R = r[w * 3 + 1], j = r[w * 3 + 2], O = o[B * 3], D = o[B * 3 + 1], L = o[B * 3 + 2], U = o[R * 3], J = o[R * 3 + 1], X = o[R * 3 + 2], rt = o[j * 3], H = o[j * 3 + 1], G = o[j * 3 + 2], Y = (O + U + rt) / 3, mt = (D + J + H) / 3, ft = (L + X + G) / 3, ut = (J - D) * (G - L) - (X - L) * (H - D), Pt = (X - L) * (rt - O) - (U - O) * (G - L), Ct = (U - O) * (H - D) - (J - D) * (rt - O), _t = Math.hypot(ut, Pt, Ct) || 1;
+    let Ft = 1 / 0;
+    const Mt = Math.max(1, Math.floor(a / 80));
+    for (let xt = 0; xt < a; xt += Mt) {
+      const Lt = r[xt * 3], jt = r[xt * 3 + 1], qt = r[xt * 3 + 2], dt = Ae(
+        Y,
+        mt,
+        ft,
+        -ut / _t,
+        -Pt / _t,
+        -Ct / _t,
+        o[Lt * 3],
+        o[Lt * 3 + 1],
+        o[Lt * 3 + 2],
+        o[jt * 3],
+        o[jt * 3 + 1],
+        o[jt * 3 + 2],
+        o[qt * 3],
+        o[qt * 3 + 1],
+        o[qt * 3 + 2]
+      );
+      dt > 1e-3 && dt < Ft && (Ft = dt);
+    }
+    Ft < n && (E.push(O, D, L, U, J, X, rt, H, G), g ??= [Y, mt, ft]);
+  }
+  const M = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map();
+  for (let w = 0; w < c; w++) {
+    const B = v(w);
+    M.set(B, (M.get(B) ?? 0) + 1), F.has(B) || F.set(B, w);
+  }
+  let I = -1, z = -1;
+  for (const [w, B] of M)
+    B > z && (z = B, I = w);
+  const T = [];
+  let S;
+  if (M.size > 1)
+    for (let w = 0; w < a && T.length < 9e3; w++) {
+      const B = r[w * 3];
+      if (v(B) === I) continue;
+      const R = r[w * 3 + 1], j = r[w * 3 + 2];
+      if (T.push(
+        o[B * 3],
+        o[B * 3 + 1],
+        o[B * 3 + 2],
+        o[R * 3],
+        o[R * 3 + 1],
+        o[R * 3 + 2],
+        o[j * 3],
+        o[j * 3 + 1],
+        o[j * 3 + 2]
+      ), !S) {
+        const O = F.get(v(B)) ?? B;
+        S = [o[O * 3], o[O * 3 + 1], o[O * 3 + 2]];
+      }
+    }
+  return {
+    partIndex: i,
+    openEdgePositions: new Float32Array(m),
+    nonManifoldEdgePositions: new Float32Array(k),
+    thinTriPositions: new Float32Array(E),
+    islandTriPositions: new Float32Array(T),
+    focus: {
+      watertight: b,
+      nonmanifold: x,
+      thinwall: g,
+      islands: S,
+      selfintersect: x ?? b,
+      normals: b
+    }
+  };
+}
+function ue(o, r, n = 1e-5, i, c) {
+  const a = /* @__PURE__ */ new Map(), f = [], d = [], v = [], y = [], m = 1 / n, k = o.length / 3, b = !1, x = !1;
+  for (let g = 0; g < k; g++) {
+    const P = o[g * 3], M = o[g * 3 + 1], F = o[g * 3 + 2];
+    let I = `${Math.round(P * m)}_${Math.round(M * m)}_${Math.round(F * m)}`, z = a.get(I);
+    z === void 0 && (z = f.length / 3, a.set(I, z), f.push(P, M, F)), y[g] = z;
+  }
+  const E = [];
+  for (let g = 0; g < r.length; g += 3) {
+    const P = y[r[g]], M = y[r[g + 1]], F = y[r[g + 2]];
+    P === M || M === F || P === F || E.push(P, M, F);
+  }
+  return {
+    positions: new Float32Array(f),
+    indices: new Uint32Array(E),
+    colors: x ? new Float32Array(d) : void 0,
+    uvs: b ? new Float32Array(v) : void 0
+  };
+}
+function dn(o, r) {
+  const n = /* @__PURE__ */ new Map(), i = (m, k) => {
+    const b = m < k ? `${m}_${k}` : `${k}_${m}`, x = n.get(b) ?? [];
+    x.push(m, k), n.set(b, x);
+  };
+  for (let m = 0; m < r.length; m += 3)
+    i(r[m], r[m + 1]), i(r[m + 1], r[m + 2]), i(r[m + 2], r[m]);
+  const c = /* @__PURE__ */ new Map();
+  for (const [m, k] of n)
+    if (k.length === 2) {
+      const [b, x] = m.split("_").map(Number);
+      n.get(m).length === 2 && c.set(b, x);
+    }
+  const a = [];
+  for (const [, m] of n)
+    m.length === 2 && a.push([m[0], m[1]]);
+  const f = /* @__PURE__ */ new Map();
+  for (const [m, k] of a) {
+    const b = f.get(m) ?? [];
+    b.push(k), f.set(m, b);
+  }
+  const d = /* @__PURE__ */ new Set(), v = [];
+  for (const [m, k] of f)
+    for (const b of k) {
+      const x = `${m}_${b}`;
+      if (d.has(x)) continue;
+      const E = [m];
+      let g = b, P = m;
+      d.add(x);
+      let M = 0;
+      for (; g !== m && M++ < 1e4; ) {
+        E.push(g);
+        const F = f.get(g) ?? [], I = F.find((z) => z !== P) ?? F[0];
+        if (I === void 0) break;
+        d.add(`${g}_${I}`), P = g, g = I;
+      }
+      if (E.length >= 3) {
+        const F = E[0];
+        for (let I = 1; I < E.length - 1; I++)
+          v.push(F, E[I], E[I + 1]);
+      }
+    }
+  if (!v.length) return { positions: o, indices: r };
+  const y = new Uint32Array(r.length + v.length);
+  return y.set(r, 0), y.set(v, r.length), { positions: o, indices: y };
+}
+function en(o, r) {
+  const n = ue(o, r), i = n.indices.length, c = dn(n.positions, n.indices), a = c.indices;
+  if (a !== n.indices && a.length > i)
+    for (let f = i; f < a.length; f += 3) {
+      const d = a[f + 1];
+      a[f + 1] = a[f + 2], a[f + 2] = d;
+    }
+  return ue(c.positions, a, 1e-4);
+}
+function nn(o, r) {
+  const n = new Float32Array(o.length);
+  for (let i = 0; i < o.length; i += 3) {
+    const c = o[i], a = o[i + 1], f = o[i + 2];
+    n[i] = r[0] * c + r[4] * a + r[8] * f + r[12], n[i + 1] = r[1] * c + r[5] * a + r[9] * f + r[13], n[i + 2] = r[2] * c + r[6] * a + r[10] * f + r[14];
+  }
+  return n;
+}
+function bt(o, r) {
+  const n = Math.hypot(o[0], o[1], o[2]);
+  return n < 1e-12 ? { normal: [0, 1, 0], offset: r } : {
+    normal: [o[0] / n, o[1] / n, o[2] / n],
+    offset: r / n
+  };
+}
+function Ht(o) {
+  const { normal: r } = bt(o, 0), n = Math.abs(r[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0], i = n[1] * r[2] - n[2] * r[1], c = n[2] * r[0] - n[0] * r[2], a = n[0] * r[1] - n[1] * r[0], f = Math.hypot(i, c, a) || 1, d = [i / f, c / f, a / f], v = [r[1] * d[2] - r[2] * d[1], r[2] * d[0] - r[0] * d[2], r[0] * d[1] - r[1] * d[0]];
+  return { x: d, y: v, z: r };
+}
+function fe(o, r) {
+  const { x: n, y: i, z: c } = Ht(o);
+  return [n[0], n[1], n[2], 0, i[0], i[1], i[2], 0, c[0], c[1], c[2], 0, r[0], r[1], r[2], 1];
+}
+function no(o, r, n) {
+  const { x: i, y: c } = Ht(n);
+  let a = 1 / 0, f = -1 / 0, d = 1 / 0, v = -1 / 0;
+  for (const m of [o[0], r[0]])
+    for (const k of [o[1], r[1]])
+      for (const b of [o[2], r[2]]) {
+        const x = m * i[0] + k * i[1] + b * i[2], E = m * c[0] + k * c[1] + b * c[2];
+        x < a && (a = x), x > f && (f = x), E < d && (d = E), E > v && (v = E);
+      }
+  const y = Math.min(f - a, v - d);
+  return Number.isFinite(y) && y > 0 ? y : 0;
+}
+const hn = 0.4, ro = 0.3;
+function oo(o) {
+  return Math.max(Math.abs(o) * 0.04, ro);
+}
+function pn(o, r = 0, n = hn) {
+  if (!(o > 0)) return 0;
+  const i = o * Math.max(0, n), c = o * 0.9;
+  return r > 0 ? Math.min(r, c) : Math.min(i, c);
+}
+function yn(o, r, n, i = 0, c = hn) {
+  const a = no(o, r, n);
+  if (!(a > 0)) return 0;
+  const f = a * Math.max(0, c), d = a * 0.9;
+  return i > 0 ? Math.min(i, d) : Math.min(f, d);
+}
+function so(o, r, n) {
+  const { normal: i } = bt(r, 0), c = n * 0.3;
+  return [o[0] + i[0] * c, o[1] + i[1] * c, o[2] + i[2] * c];
+}
+const io = 0.65;
+function ao(o, r, n, i, c = io) {
+  const { normal: a } = bt(r, 0), f = i + n * (c - 0.5);
+  return [o[0] + a[0] * f, o[1] + a[1] * f, o[2] + a[2] * f];
+}
+function co(o, r, n = 0) {
+  return o.min[0] <= r.max[0] + n && o.max[0] >= r.min[0] - n && o.min[1] <= r.max[1] + n && o.max[1] >= r.min[1] - n && o.min[2] <= r.max[2] + n && o.max[2] >= r.min[2] - n;
+}
+function Nt(o) {
+  const r = o.length / 3;
+  if (r < 1) return [0, 0, 0];
+  let n = 0, i = 0, c = 0;
+  for (let a = 0; a < r; a++)
+    n += o[a * 3], i += o[a * 3 + 1], c += o[a * 3 + 2];
+  return [n / r, i / r, c / r];
+}
+function rn(o, r, n) {
+  return (r.x - o.x) * (n.y - o.y) - (r.y - o.y) * (n.x - o.x);
+}
+function on(o, r) {
+  return Math.hypot(o.x - r.x, o.y - r.y);
+}
+function lo(o, r, n) {
+  if (o.length < 3) return 0;
+  const { normal: i } = bt(r, 0), { x: c, y: a } = Ht(i), f = o.map((b) => {
+    const x = b[0] - n[0], E = b[1] - n[1], g = b[2] - n[2];
+    return { x: x * c[0] + E * c[1] + g * c[2], y: x * a[0] + E * a[1] + g * a[2] };
+  });
+  let d = 0;
+  for (let b = 1; b < f.length; b++)
+    (f[b].y < f[d].y || f[b].y === f[d].y && f[b].x < f[d].x) && (d = b);
+  const v = f[d], y = f.map((b, x) => ({ p: b, i: x })).sort((b, x) => {
+    const E = rn(v, b.p, x.p);
+    return Math.abs(E) < 1e-14 ? on(v, b.p) - on(v, x.p) : E > 0 ? -1 : 1;
+  }), m = [];
+  for (const b of y) {
+    const x = b.p;
+    for (; m.length >= 2 && rn(m[m.length - 2], m[m.length - 1], x) <= 0; ) m.pop();
+    m.push(x);
+  }
+  if (m.length < 3) return 0;
+  let k = 0;
+  for (let b = 0; b < m.length; b++) {
+    const x = (b + 1) % m.length;
+    k += m[b].x * m[x].y - m[x].x * m[b].y;
+  }
+  return Math.abs(k) * 0.5;
+}
+function le(o, r) {
+  const [n, i, c, a, f, d] = o;
+  return [n * r[0] + i * r[1] + c * r[2], i * r[0] + a * r[1] + f * r[2], c * r[0] + f * r[1] + d * r[2]];
+}
+function uo(o) {
+  if (o.length < 3) return null;
+  let r = 0, n = 0, i = 0;
+  for (const D of o)
+    r += D[0], n += D[1], i += D[2];
+  const c = o.length;
+  r /= c, n /= c, i /= c;
+  let a = 0, f = 0, d = 0, v = 0, y = 0, m = 0;
+  for (const D of o) {
+    const L = D[0] - r, U = D[1] - n, J = D[2] - i;
+    a += L * L, f += L * U, d += L * J, v += U * U, y += U * J, m += J * J;
+  }
+  const k = [a, f, d, v, y, m], b = (D, L) => {
+    let U = D;
+    for (let J = 0; J < 24; J++) {
+      const X = L(U), rt = Math.hypot(X[0], X[1], X[2]);
+      if (rt < 1e-18) return U;
+      U = [X[0] / rt, X[1] / rt, X[2] / rt];
+    }
+    return U;
+  }, x = b([1, 0.3, 0.2], (D) => le(k, D)), E = le(k, x), g = x[0] * E[0] + x[1] * E[1] + x[2] * E[2], P = (D) => {
+    const L = le(k, D), U = g * (x[0] * D[0] + x[1] * D[1] + x[2] * D[2]);
+    return [L[0] - U * x[0], L[1] - U * x[1], L[2] - U * x[2]];
+  }, M = Math.abs(x[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0], F = [
+    M[1] * x[2] - M[2] * x[1],
+    M[2] * x[0] - M[0] * x[2],
+    M[0] * x[1] - M[1] * x[0]
+  ], I = Math.hypot(F[0], F[1], F[2]) || 1, z = [F[0] / I, F[1] / I, F[2] / I], T = [
+    x[1] * z[2] - x[2] * z[1],
+    x[2] * z[0] - x[0] * z[2],
+    x[0] * z[1] - x[1] * z[0]
+  ], S = (D) => {
+    const L = le(k, D);
+    return D[0] * L[0] + D[1] * L[1] + D[2] * L[2];
+  }, w = b(z, P), B = b(T, P), R = S(w) >= S(B) ? w : B, j = [
+    x[1] * R[2] - x[2] * R[1],
+    x[2] * R[0] - x[0] * R[2],
+    x[0] * R[1] - x[1] * R[0]
+  ], O = Math.hypot(j[0], j[1], j[2]);
+  return O < 1e-12 ? null : [j[0] / O, j[1] / O, j[2] / O];
+}
+function fo(o, r) {
+  if (o.length < 2) return 0;
+  const { x: n, y: i } = Ht(r);
+  let c = 1 / 0, a = -1 / 0, f = 1 / 0, d = -1 / 0;
+  for (const y of o) {
+    const m = y[0] * n[0] + y[1] * n[1] + y[2] * n[2], k = y[0] * i[0] + y[1] * i[1] + y[2] * i[2];
+    m < c && (c = m), m > a && (a = m), k < f && (f = k), k > d && (d = k);
+  }
+  const v = Math.min(a - c, d - f);
+  return Number.isFinite(v) && v > 0 ? v : 0;
+}
+function ho(o, r, n = 0.99) {
+  const { normal: i } = bt(r, 0), c = Math.floor(o.length / 3);
+  if (c < 1) return 0;
+  const a = new Float64Array(c);
+  for (let d = 0; d < c; d++)
+    a[d] = i[0] * o[d * 3] + i[1] * o[d * 3 + 1] + i[2] * o[d * 3 + 2];
+  a.sort();
+  const f = Math.min(c - 1, Math.max(0, Math.floor((c - 1) * n)));
+  return a[f];
+}
+function sn(o, r, n, i, c = 0.99) {
+  if (!(i > 0)) return null;
+  const { normal: a } = bt(n, 0), { x: f, y: d } = Ht(a), v = i * i, y = [], m = Math.floor(o.length / 3);
+  for (let b = 0; b < m; b++) {
+    const x = o[b * 3] - r[0], E = o[b * 3 + 1] - r[1], g = o[b * 3 + 2] - r[2], P = x * f[0] + E * f[1] + g * f[2], M = x * d[0] + E * d[1] + g * d[2];
+    P * P + M * M > v || y.push(a[0] * o[b * 3] + a[1] * o[b * 3 + 1] + a[2] * o[b * 3 + 2]);
+  }
+  if (y.length < 8) return null;
+  y.sort((b, x) => b - x);
+  const k = Math.min(y.length - 1, Math.max(0, Math.floor((y.length - 1) * c)));
+  return y[k];
+}
+function an(o, r, n) {
+  const { positions: i, indices: c } = o, a = c.length / 3;
+  if (a < 1) return null;
+  const f = [0, 0, 0], d = [0, 0, 0];
+  let v = 0, y = 0;
+  const m = [1 / 0, 1 / 0, 1 / 0], k = [-1 / 0, -1 / 0, -1 / 0], b = [];
+  for (let S = 0; S < i.length; S += 3) {
+    const w = [i[S], i[S + 1], i[S + 2]];
+    b.push(w), w[0] < m[0] && (m[0] = w[0]), w[1] < m[1] && (m[1] = w[1]), w[2] < m[2] && (m[2] = w[2]), w[0] > k[0] && (k[0] = w[0]), w[1] > k[1] && (k[1] = w[1]), w[2] > k[2] && (k[2] = w[2]);
+  }
+  for (let S = 0; S < a; S++) {
+    const w = c[S * 3], B = c[S * 3 + 1], R = c[S * 3 + 2], j = i[w * 3], O = i[w * 3 + 1], D = i[w * 3 + 2], L = i[B * 3], U = i[B * 3 + 1], J = i[B * 3 + 2], X = i[R * 3], rt = i[R * 3 + 1], H = i[R * 3 + 2], G = L - j, Y = U - O, mt = J - D, ft = X - j, ut = rt - O, Pt = H - D, Ct = Y * Pt - mt * ut, _t = mt * ft - G * Pt, Ft = G * ut - Y * ft, Mt = 0.5 * Math.hypot(Ct, _t, Ft);
+    if (Mt < 1e-14) continue;
+    const xt = 1 / (2 * Mt);
+    f[0] += Ct * xt * Mt, f[1] += _t * xt * Mt, f[2] += Ft * xt * Mt, d[0] += (j + L + X) / 3, d[1] += (O + U + rt) / 3, d[2] += (D + J + H) / 3, v += Mt, y++;
+  }
+  if (y === 0 || v < 1e-14) return null;
+  d[0] /= y, d[1] /= y, d[2] /= y;
+  const x = Math.hypot(f[0], f[1], f[2]), P = (x < v * 0.2 ? uo(b) : null) ?? (x > 1e-12 ? [f[0] / x, f[1] / x, f[2] / x] : [0, 1, 0]), M = [n[0] - r[0], n[1] - r[1], n[2] - r[2]], F = Math.hypot(M[0], M[1], M[2]);
+  F > 1e-12 && (P[0] * M[0] + P[1] * M[1] + P[2] * M[2]) / F < 0 && (P[0] = -P[0], P[1] = -P[1], P[2] = -P[2]);
+  let I = lo(b, P, d);
+  I > 1e-12 || (I = v * 0.5);
+  let z = 1 / 0, T = -1 / 0;
+  for (const S of b) {
+    const w = P[0] * (S[0] - d[0]) + P[1] * (S[1] - d[1]) + P[2] * (S[2] - d[2]);
+    w < z && (z = w), w > T && (T = w);
+  }
+  return Number.isFinite(z) || (z = 0, T = 0), {
+    center: d,
+    normal: P,
+    area: I,
+    span: fo(b, P),
+    along: { min: z, max: T },
+    bbox: { min: m, max: k }
+  };
+}
+function po(o, r) {
+  if (!(r > 1e-12) || !(o > 0)) return !0;
+  const n = o / r, i = Math.sqrt(r);
+  return n < Math.max(0.4, i * 0.08);
+}
+function yo(o, r, n, i, c, a = 0) {
+  return yn(n, i, c, a);
+}
+function mo(o, r, n) {
+  const { normal: i } = bt(n, 0), c = [r[0] - o[0], r[1] - o[1], r[2] - o[2]];
+  return Math.abs(c[0] * i[0]) + Math.abs(c[1] * i[1]) + Math.abs(c[2] * i[2]);
+}
+function vo(o) {
+  const r = o.positions, n = [1 / 0, 1 / 0, 1 / 0], i = [-1 / 0, -1 / 0, -1 / 0];
+  for (let c = 0; c < r.length; c += 3)
+    r[c] < n[0] && (n[0] = r[c]), r[c + 1] < n[1] && (n[1] = r[c + 1]), r[c + 2] < n[2] && (n[2] = r[c + 2]), r[c] > i[0] && (i[0] = r[c]), r[c + 1] > i[1] && (i[1] = r[c + 1]), r[c + 2] > i[2] && (i[2] = r[c + 2]);
+  return {
+    min: n,
+    max: i,
+    size: [i[0] - n[0], i[1] - n[1], i[2] - n[2]]
+  };
+}
+function mn(o, r) {
+  const { normal: n } = bt(o, 0), { normal: i } = bt(r, 0), c = n[0] * i[0] + n[1] * i[1] + n[2] * i[2];
+  if (c > 0.999999) return [0, 0, 0, 1];
+  if (c < -0.999999) {
+    let m = 0, k = 1, b = 0;
+    Math.abs(n[1]) < 0.9 ? (m = 0, k = 1, b = 0) : (m = 1, k = 0, b = 0);
+    let x = n[1] * b - n[2] * k, E = n[2] * m - n[0] * b, g = n[0] * k - n[1] * m;
+    const P = Math.hypot(x, E, g) || 1;
+    return x /= P, E /= P, g /= P, [x, E, g, 0];
+  }
+  let a = n[1] * i[2] - n[2] * i[1], f = n[2] * i[0] - n[0] * i[2], d = n[0] * i[1] - n[1] * i[0], v = 1 + c;
+  const y = Math.hypot(a, f, d, v) || 1;
+  return [a / y, f / y, d / y, v / y];
+}
+function go(o, r) {
+  const [n, i, c, a] = o, f = a * r[0] + i * r[2] - c * r[1], d = a * r[1] + c * r[0] - n * r[2], v = a * r[2] + n * r[1] - i * r[0], y = -n * r[0] - i * r[1] - c * r[2];
+  return [
+    f * a + y * -n + d * -c - v * -i,
+    d * a + y * -i + v * -n - f * -c,
+    v * a + y * -c + f * -i - d * -n
+  ];
+}
+function bo(o, r, n, i) {
+  const c = mn(o, r), [a, f, d, v] = c, y = a + a, m = f + f, k = d + d, b = a * y, x = a * m, E = a * k, g = f * m, P = f * k, M = d * k, F = v * y, I = v * m, z = v * k, T = n;
+  return [
+    (1 - (g + M)) * T,
+    (x + z) * T,
+    (E - I) * T,
+    0,
+    (x - z) * T,
+    (1 - (b + M)) * T,
+    (P + F) * T,
+    0,
+    (E + I) * T,
+    (P - F) * T,
+    (1 - (b + g)) * T,
+    0,
+    i[0],
+    i[1],
+    i[2],
+    1
+  ];
+}
+function xo(o) {
+  let r = 1, n = 1 / 0;
+  for (let i = 0; i < 3; i++) {
+    const c = (i + 1) % 3, a = (i + 2) % 3, f = Math.max(o[c], o[a], 1e-9), d = Math.abs(o[c] - o[a]) / f, v = Math.max(o[0], o[1], o[2], 1e-9), y = d * 10 + o[i] / v;
+    y < n && (n = y, r = i);
+  }
+  return r;
+}
+function cn(o) {
+  if (o.length < 8) return null;
+  let n = 0, i = 0, c = 0, a = 0, f = 0, d = 0, v = 0, y = 0, m = 0, k = 0, b = 0, x = 0, E = 0, g = 0;
+  for (const T of o) {
+    const S = T[0], w = T[1], B = T[2], R = S * S + w * w + B * B, j = 2 * S, O = 2 * w, D = 2 * B;
+    n += j * j, i += j * O, c += j * D, a += j, f += O * O, d += O * D, v += O, y += D * D, m += D, k += 1, b += j * R, x += O * R, E += D * R, g += R;
+  }
+  const P = [
+    [n, i, c, a, b],
+    [i, f, d, v, x],
+    [c, d, y, m, E],
+    [a, v, m, k, g]
+  ];
+  for (let T = 0; T < 4; T++) {
+    let S = T;
+    for (let R = T + 1; R < 4; R++) Math.abs(P[R][T]) > Math.abs(P[S][T]) && (S = R);
+    if (Math.abs(P[S][T]) < 1e-12) return null;
+    const w = P[T];
+    P[T] = P[S], P[S] = w;
+    const B = P[T][T];
+    for (let R = T; R < 5; R++) P[T][R] /= B;
+    for (let R = 0; R < 4; R++) {
+      if (R === T) continue;
+      const j = P[R][T];
+      for (let O = T; O < 5; O++) P[R][O] -= j * P[T][O];
+    }
+  }
+  const M = P[0][4], F = P[1][4], I = P[2][4], z = Math.sqrt(Math.max(0, P[3][4] + M * M + F * F + I * I));
+  return !(z > 1e-6) || !Number.isFinite(z) ? null : { center: [M, F, I], radius: z };
+}
+function _o(o) {
+  const r = cn(o);
+  if (!r) return null;
+  const n = o.filter((i) => {
+    const c = Math.hypot(i[0] - r.center[0], i[1] - r.center[1], i[2] - r.center[2]);
+    return Math.abs(c - r.radius) < r.radius * 0.12;
+  });
+  return n.length < 8 || n.length > o.length * 0.98 ? r : cn(n) ?? r;
+}
+function de(o, r) {
+  const n = vo(o), i = xo(n.size), c = o.positions, a = c.length / 3;
+  if (a < 8) throw new Error("爪扣网格为空");
+  const f = [0, 0, 0];
+  for (let H = 0; H < a; H++)
+    f[0] += c[H * 3], f[1] += c[H * 3 + 1], f[2] += c[H * 3 + 2];
+  const d = [f[0] / a, f[1] / a, f[2] / a], v = [0, 0, 0];
+  v[i] = 1;
+  const y = (H, G) => (c[H * 3] - d[0]) * G[0] + (c[H * 3 + 1] - d[1]) * G[1] + (c[H * 3 + 2] - d[2]) * G[2], m = (H, G) => {
+    const Y = c[H * 3] - d[0], mt = c[H * 3 + 1] - d[1], ft = c[H * 3 + 2] - d[2], ut = Y * G[0] + mt * G[1] + ft * G[2];
+    return Math.hypot(Y - G[0] * ut, mt - G[1] * ut, ft - G[2] * ut);
+  };
+  let k = 1 / 0, b = -1 / 0;
+  for (let H = 0; H < a; H++) {
+    const G = y(H, v);
+    G < k && (k = G), G > b && (b = G);
+  }
+  const E = Math.max(b - k, 1e-9) * 0.08;
+  let g = 1 / 0, P = 1 / 0;
+  for (let H = 0; H < a; H++) {
+    const G = y(H, v), Y = m(H, v);
+    G <= k + E && Y < g && (g = Y), G >= b - E && Y < P && (P = Y);
+  }
+  const M = g <= P ? v : [-v[0], -v[1], -v[2]];
+  let F = 1 / 0, I = -1 / 0, z = 0;
+  const T = new Array(a), S = new Array(a);
+  for (let H = 0; H < a; H++) {
+    const G = y(H, M), Y = m(H, M);
+    T[H] = G, S[H] = Y, G < F && (F = G), G > I && (I = G), Y > z && (z = Y);
+  }
+  const w = Math.max(I - F, 1e-9), B = [];
+  for (let H = 0; H < a; H++) {
+    const G = (T[H] - F) / w, Y = S[H];
+    if (r === "peg") {
+      if (G < 0.32 || G > 0.97 || Y < z * 0.45) continue;
+    } else if (G < 0.3 || G > 0.92 || Y > z * 0.62 || Y < z * 0.2)
+      continue;
+    B.push([c[H * 3], c[H * 3 + 1], c[H * 3 + 2]]);
+  }
+  const R = _o(B);
+  if (!R) throw new Error(r === "peg" ? "爪扣未能识别球头" : "爪扣未能识别凹窝");
+  const j = [R.center[0] - d[0], R.center[1] - d[1], R.center[2] - d[2]], O = j[0] * M[0] + j[1] * M[1] + j[2] * M[2], D = [
+    d[0] + M[0] * O,
+    d[1] + M[1] * O,
+    d[2] + M[2] * O
+  ];
+  let L = 0, U = 0, J = -1 / 0;
+  for (let H = 0; H < a; H++) {
+    const G = (T[H] - F) / w, Y = S[H];
+    G < 0.12 && Y > L && (L = Y), G >= 0.22 && G <= 0.82 && Y > U && (U = Y);
+  }
+  L > 0 || (L = z), U > 0 || (U = L);
+  const X = Math.max(U * 1.15, L * 0.7);
+  for (let H = 0; H < a; H++)
+    S[H] < X || T[H] > O || T[H] > J && (J = T[H]);
+  const rt = Number.isFinite(J) ? Math.max(J - F, w * 0.04) : w * 0.08;
+  return {
+    axis: M,
+    center: D,
+    radius: R.radius,
+    flangeRadius: L,
+    bodyRadius: U,
+    base: F - O,
+    tip: I - O,
+    flangeThickness: rt
+  };
+}
+function ln(o, r, n, i) {
+  const { normal: c } = bt(r, 0), a = go(mn(o.axis, c), [
+    o.center[0] * i,
+    o.center[1] * i,
+    o.center[2] * i
+  ]);
+  return bo(o.axis, c, i, [
+    n[0] - a[0],
+    n[1] - a[1],
+    n[2] - a[2]
+  ]);
+}
+function Mo(o, r, n) {
+  const i = de(o, "socket"), c = de(r, "peg");
+  return !(c.radius > 1e-6) || !(n > 0) ? 0 : Math.max(0, i.tip) * (n / (c.radius * 2));
+}
+function wo(o) {
+  return o > 0 ? Math.min(0.25, o * 0.2) : 0;
+}
+function Te(o, r, n, i, c) {
+  const { normal: a } = bt(r, 0), f = a[0] * o[0] + a[1] * o[1] + a[2] * o[2], d = n + i - c - f;
+  return [o[0] + a[0] * d, o[1] + a[1] * d, o[2] + a[2] * d];
+}
+function $o(o, r, n, i, c, a = i) {
+  const f = de(o, "socket"), d = de(r, "peg");
+  if (!(d.radius > 1e-6) || !(c > 1e-9)) throw new Error("爪扣尺寸无效");
+  const v = c / (d.radius * 2), { normal: y } = bt(n, 0), m = [-y[0], -y[1], -y[2]], k = f.base + Math.max(f.flangeThickness * 1.25, Math.abs(f.base) * 0.05), b = f.tip + f.radius * 0.12, x = Math.max(b - k, f.radius), E = (k + b) / 2, g = Math.min(Math.max(f.bodyRadius * 1.05, f.radius * 1.15), f.flangeRadius * 0.88) * v;
+  return {
+    aoMatrix: ln(f, m, i, v),
+    tuMatrix: ln(d, y, a, v),
+    scale: v,
+    clearRadius: g,
+    clearLength: x * v,
+    clearCenter: [
+      i[0] + m[0] * E * v,
+      i[1] + m[1] * E * v,
+      i[2] + m[2] * E * v
+    ]
+  };
+}
+let Se = null, Ie = null;
+async function Zt() {
+  if (Se) return Se;
+  if (!Ie)
+    throw new Error("几何内核 WASM 未传入 Worker");
+  const o = await Yr({
+    wasmBinary: Ie,
+    locateFile: (r) => r
+  });
+  return o.setup(), Se = o, o;
+}
+function vn(o, r, n) {
+  return new o.Mesh({
+    numProp: 3,
+    vertProperties: r,
+    triVerts: n
+  });
+}
+function at(o) {
+  const r = o.getMesh(), n = r.numProp, i = r.vertProperties.length / n, c = new Float32Array(i * 3);
+  for (let a = 0; a < i; a++)
+    c[a * 3] = r.vertProperties[a * n], c[a * 3 + 1] = r.vertProperties[a * n + 1], c[a * 3 + 2] = r.vertProperties[a * n + 2];
+  return { positions: c, indices: new Uint32Array(r.triVerts) };
+}
+function St(o, r, n) {
+  try {
+    const i = vn(o, r, n);
+    return i.merge(), new o.Manifold(i);
+  } catch {
+    return null;
+  }
+}
+function un(o, r, n) {
+  let i = null;
+  try {
+    const f = vn(o, r, n);
+    f.tolerance = 1e-8, i = new o.Manifold(f);
+  } catch {
+    i = St(o, r, n);
+  }
+  if (!i) throw new Error("爪扣网格无法构建实体");
+  const c = i.decompose();
+  if (c.length <= 1) {
+    for (const f of c) f.delete();
+    return i;
+  }
+  i.delete();
+  let a = c[0];
+  for (let f = 1; f < c.length; f++) {
+    const d = a.add(c[f]);
+    a.delete(), c[f].delete(), a = d;
+  }
+  if (a.status() !== "NoError")
+    throw a.delete(), new Error("爪扣网格无法构建实体");
+  return a;
+}
+function Fe(o, r, n) {
+  let i = ue(r, n);
+  i = dn(i.positions, i.indices), i = ue(i.positions, i.indices, 1e-4);
+  let c = St(o, i.positions, i.indices);
+  if (!c)
+    try {
+      const f = o.Manifold.hull(
+        Array.from({ length: i.positions.length / 3 }, (v, y) => [
+          i.positions[y * 3],
+          i.positions[y * 3 + 1],
+          i.positions[y * 3 + 2]
+        ])
+      ), d = at(f);
+      return f.delete(), d;
+    } catch {
+      return i;
+    }
+  const a = at(c);
+  return c.delete(), a;
+}
+function fn(o, r, n) {
+  const i = Math.max(1.001, n);
+  return o.translate([-r[0], -r[1], -r[2]]).scale(i).translate(r);
+}
+function Po(o, r, n, i, c, a, f, d, v, y, m, k) {
+  const b = r.intersect(n), x = Math.abs(b.volume());
+  if (!(x > 1e-10))
+    throw b.delete(), new Error("无有效交集");
+  const E = f >= d, g = E ? r : n, P = E ? n : r, M = E ? [-a.normal[0], -a.normal[1], -a.normal[2]] : [a.normal[0], a.normal[1], a.normal[2]], F = a.center, I = at(b), z = a.bbox ?? $t(I.positions, I.indices).bbox, T = po(x, a.area), S = Math.max(mo(z.min, z.max, M), 1e-3), w = Math.sqrt(Math.max(a.area, 1e-6)), B = Math.max(Math.cbrt(x), w * 0.25, 1e-3), R = P.subtract(g);
+  let j = R.add(b);
+  R.delete();
+  let O;
+  if (T) {
+    const L = 1 + Math.max(S * 0.15, w * 0.01, 1e-3) / B, U = fn(b, F, L);
+    O = g.subtract(U), U.delete();
+  } else {
+    const D = Math.max(w * 0.04, S * 0.06, 0.15), L = 1 + D / B;
+    let U = fn(b, F, L);
+    const J = S * 0.35 + D, X = U.translate([M[0] * J, M[1] * J, M[2] * J]);
+    U.delete(), U = X, O = g.subtract(U), U.delete();
+  }
+  if (b.delete(), v === "sphere" || v === "square" || v === "ballSnap" || v === "qiuSnap") {
+    const D = a.span && a.span > 1e-9 ? pn(a.span, y) : yo(a.area, m, z.min, z.max, M, y);
+    if (D > 1e-12)
+      try {
+        const U = ho(at(j).positions, M, 0.99) - (M[0] * F[0] + M[1] * F[1] + M[2] * F[2]), J = ao(F, M, D, U), X = v === "ballSnap" || v === "qiuSnap" ? at(g).positions : void 0, rt = gn(
+          o,
+          O,
+          j,
+          M,
+          J,
+          v,
+          D,
+          k,
+          !0,
+          F,
+          X
+        );
+        O = rt.pos, j = rt.neg;
+      } catch (L) {
+        throw O.delete(), j.delete(), L;
+      }
+  }
+  return r.delete(), n.delete(), E ? { a: O, b: j } : { a: j, b: O };
+}
+function Co(o, r, n, i) {
+  const c = o.intersect(r);
+  if (Math.abs(c.volume()) > 1e-10) return c;
+  c.delete();
+  const a = i[0] - n[0], f = i[1] - n[1], d = i[2] - n[2], v = Math.hypot(a, f, d) || 1, y = Math.max(1e-3, v * 2e-3), m = a / v * y, k = f / v * y, b = d / v * y;
+  for (const x of [1, -1]) {
+    const E = o.translate([m * x, k * x, b * x]), g = E.intersect(r);
+    if (E.delete(), Math.abs(g.volume()) > 1e-10) return g;
+    g.delete();
+  }
+  return null;
+}
+function To(o, r, n, i, c, a, f, d, v = !1) {
+  const y = en(a.ao.positions, a.ao.indices), m = en(a.tu.positions, a.tu.indices), k = Mo(y, m, c), { normal: b } = bt(i, 0), x = b[0] * f[0] + b[1] * f[1] + b[2] * f[2];
+  let E = f, g = f;
+  if (k > 0 && v) {
+    const R = Te(f, b, x, k, wo(k));
+    E = R, g = R;
+  } else if (k > 0) {
+    const j = sn(
+      d ?? at(r).positions,
+      f,
+      b,
+      Math.max(c * 0.55, 1),
+      0.04
+    ), O = sn(
+      at(n).positions,
+      f,
+      b,
+      Math.max(c * 1.25, 1e-3),
+      0.95
+    );
+    let L = (O ?? x) - 0.25;
+    j != null && L > j && (L = j), E = Te(f, b, L, k, 0), g = O != null ? Te(f, b, O, k, 0.25) : E;
+  }
+  const P = $o(y, m, b, E, c, g), M = un(o, y.positions, y.indices), F = un(o, m.positions, m.indices), I = M.transform(P.aoMatrix);
+  M.delete();
+  const z = F.transform(P.tuMatrix);
+  F.delete();
+  const T = o.Manifold.cylinder(P.clearLength, P.clearRadius, P.clearRadius, 48, !0).transform(
+    fe(i, P.clearCenter)
+  ), S = r.subtract(T);
+  r.delete(), T.delete();
+  const w = S.add(I);
+  S.delete(), I.delete();
+  const B = n.add(z);
+  return n.delete(), z.delete(), { pos: w, neg: B };
+}
+function gn(o, r, n, i, c, a, f, d, v = !1, y, m, k = !1) {
+  const b = v ? c : so(c, i, f), x = fe(i, b), E = oo(f);
+  if (a === "qiuSnap" || a === "ballSnap") {
+    if (!d) throw new Error("爪扣模型未加载");
+    return To(
+      o,
+      r,
+      n,
+      i,
+      f,
+      d,
+      y ?? c,
+      m,
+      k
+    );
+  }
+  if (a === "sphere") {
+    const z = f / 2, T = z + E, S = o.Manifold.sphere(T, 28).transform(x), w = o.Manifold.cylinder(f, T, T, 28, !0).transform(x), B = S.add(w);
+    S.delete(), w.delete();
+    const R = o.Manifold.sphere(z, 28).transform(x), j = r.subtract(B), O = n.add(R);
+    return r.delete(), n.delete(), B.delete(), R.delete(), { pos: j, neg: O };
+  }
+  const g = f + 2 * E, P = o.Manifold.cube([g, g, g], !0).transform(x), M = o.Manifold.cube([f, f, f], !0).transform(x), F = r.subtract(P), I = n.add(M);
+  return r.delete(), n.delete(), P.delete(), M.delete(), { pos: F, neg: I };
+}
+function So(o, r, n, i) {
+  let c;
+  if (r === "box")
+    c = o.Manifold.cube([n[0] || 10, n[1] || 10, n[2] || 10], !0);
+  else if (r === "cylinder")
+    c = o.Manifold.cylinder(n[1] || 20, n[0] || 5, n[0] || 5, 32, !0);
+  else if (r === "sphere")
+    c = o.Manifold.sphere(n[0] || 8, 24);
+  else {
+    const a = Math.max(3, Math.floor(n[2] || 6)), f = n[0] || 8, d = n[1] || 16, v = Array.from({ length: a }, (y, m) => {
+      const k = m / a * Math.PI * 2;
+      return [Math.cos(k) * f, Math.sin(k) * f];
+    });
+    c = o.Manifold.extrude([v], d, 0, 0, [1, 1], !0);
+  }
+  return c.transform(i);
+}
+function Tt(o, r, n) {
+  switch (r.kind) {
+    case "primary": {
+      const i = n[r.meshId];
+      if (!i) return { solid: null, buffers: { positions: new Float32Array(), indices: new Uint32Array() } };
+      const c = nn(i.positions, r.transform);
+      return { solid: St(o, c, i.indices), buffers: { positions: c, indices: i.indices } };
+    }
+    case "primitive": {
+      const i = So(o, r.type, r.params, r.transform);
+      return { solid: i, buffers: at(i) };
+    }
+    case "transform": {
+      const i = Tt(o, r.node, n);
+      if (i.solid) {
+        const c = i.solid.transform(r.transform);
+        return i.solid.delete(), { solid: c, buffers: at(c) };
+      }
+      return {
+        solid: null,
+        buffers: {
+          positions: nn(i.buffers.positions, r.transform),
+          indices: i.buffers.indices
+        }
+      };
+    }
+    case "clean": {
+      const i = Tt(o, r.node, n), c = Fe(o, i.buffers.positions, i.buffers.indices);
+      return i.solid?.delete(), { solid: St(o, c.positions, c.indices), buffers: c };
+    }
+    case "simplify": {
+      const i = Tt(o, r.node, n);
+      if (i.solid) {
+        const c = i.solid.boundingBox(), a = Math.hypot(
+          c.max[0] - c.min[0],
+          c.max[1] - c.min[1],
+          c.max[2] - c.min[2]
+        ), f = i.solid.simplify(a * (1 - r.targetRatio) * 0.02);
+        return i.solid.delete(), { solid: f, buffers: at(f) };
+      }
+      return i;
+    }
+    case "sliceBase": {
+      const i = Tt(o, r.node, n);
+      if (i.solid) {
+        const c = r.axis === "x" ? [1, 0, 0] : r.axis === "y" ? [0, 1, 0] : [0, 0, 1], a = i.solid.trimByPlane(c, r.height);
+        return i.solid.delete(), { solid: a, buffers: at(a) };
+      }
+      return i;
+    }
+    case "trimPlane": {
+      const i = Tt(o, r.node, n);
+      let c = i;
+      if (!c.solid) {
+        const a = Fe(o, c.buffers.positions, c.buffers.indices);
+        i.solid?.delete(), c = {
+          solid: St(o, a.positions, a.indices),
+          buffers: a
+        };
+      }
+      if (c.solid) {
+        const a = Math.hypot(r.normal[0], r.normal[1], r.normal[2]) || 1, f = [
+          r.normal[0] / a,
+          r.normal[1] / a,
+          r.normal[2] / a
+        ], d = c.solid.trimByPlane(f, r.offset / a);
+        return c.solid.delete(), { solid: d, buffers: at(d) };
+      }
+      return c;
+    }
+    case "boolean": {
+      const i = Tt(o, r.a, n), c = Tt(o, r.b, n), a = (v) => {
+        if (v.solid) return v;
+        const y = Fe(o, v.buffers.positions, v.buffers.indices);
+        return { solid: St(o, y.positions, y.indices), buffers: y };
+      }, f = a(i), d = a(c);
+      if (f.solid && d.solid) {
+        const v = r.op === "union" ? f.solid.add(d.solid) : r.op === "difference" ? f.solid.subtract(d.solid) : f.solid.intersect(d.solid);
+        return f.solid.delete(), d.solid.delete(), { solid: v, buffers: at(v) };
+      }
+      return f.solid?.delete(), d.solid?.delete(), f;
+    }
+    case "merge": {
+      const i = r.nodes.map((a) => Tt(o, a, n)), c = i.map((a) => a.solid).filter((a) => !!a);
+      if (c.length) {
+        const a = c.length === 1 ? c[0] : o.Manifold.union(c);
+        return i.forEach((f, d) => {
+          (c.length > 1 || d > 0) && f.solid?.delete();
+        }), { solid: a, buffers: at(a) };
+      }
+      return i[0] ?? { solid: null, buffers: { positions: new Float32Array(), indices: new Uint32Array() } };
+    }
+  }
+}
+function Fo(o, r, n) {
+  const i = [];
+  let c = 0, a = 0, f = 0, d = 0, v = 0, y = 0, m = 0, k = !1;
+  const b = [1 / 0, 1 / 0, 1 / 0], x = [-1 / 0, -1 / 0, -1 / 0];
+  let E = 1 / 0;
+  o.forEach((I, z) => {
+    const T = $t(I.positions, I.indices);
+    c += T.triangleCount, a += T.vertexCount, f += T.volume, d += T.surfaceArea, v += T.openEdgeCount, y += T.nonManifoldEdgeCount, m += T.componentCount, k = k || T.invertedNormals, E = Math.min(E, Qr(I.positions, I.indices));
+    for (let S = 0; S < 3; S++)
+      b[S] = Math.min(b[S], T.bbox.min[S]), x[S] = Math.max(x[S], T.bbox.max[S]);
+  });
+  const g = v === 0, P = y === 0 && n.every(Boolean) && g, M = !n.every(Boolean) && g, F = (I) => i.push(I);
+  return y > 0 ? F({
+    id: "nonmanifold",
+    level: "red",
+    title: "非流形边",
+    explanation: "一条边被超过两个三角形共享，切片器无法判断内外，这会导致打印件断成两截。",
+    count: y,
+    blocking: !0
+  }) : F({ id: "nonmanifold", level: "green", title: "流形边检查通过", explanation: "每条边最多被两个三角形共享。", blocking: !1 }), F(g ? { id: "watertight", level: "green", title: "水密检查通过", explanation: "网格封闭，可以计算体积。", blocking: !1 } : {
+    id: "watertight",
+    level: "red",
+    title: "表面不水密",
+    explanation: "存在开边或破洞，体积无法准确计算，切片时可能缺层。",
+    count: v,
+    blocking: !0
+  }), F(M ? {
+    id: "selfintersect",
+    level: "red",
+    title: "自相交或无法构建实体",
+    explanation: "三角形互相穿透或拓扑无法形成实体，布尔与切片均不可靠。",
+    blocking: !0
+  } : { id: "selfintersect", level: "green", title: "自交检查通过", explanation: "几何内核可以构造成实体。", blocking: !1 }), E > 0 && E < r ? F({
+    id: "thinwall",
+    level: "yellow",
+    title: "薄壁",
+    explanation: `最薄处约 ${E.toFixed(2)} mm，低于常用打印工艺下限，切片后可能消失。`,
+    blocking: !1
+  }) : F({ id: "thinwall", level: "green", title: "壁厚检查通过", explanation: "采样壁厚高于设定下限。", blocking: !1 }), m > o.length ? F({
+    id: "islands",
+    level: "yellow",
+    title: "浮空碎片",
+    explanation: "与主体不连通的游离几何体，打印时可能掉落或单独成件。",
+    count: m,
+    blocking: !1
+  }) : F({ id: "islands", level: "green", title: "连通性通过", explanation: "未发现多余的游离碎片。", blocking: !1 }), F(k ? {
+    id: "normals",
+    level: "yellow",
+    title: "法线反向",
+    explanation: "部分面朝向内侧，可能被切片器误判为空洞。",
+    blocking: !1
+  } : { id: "normals", level: "green", title: "法线方向正常", explanation: "体积符号为正，外法线朝外。", blocking: !1 }), {
+    items: i,
+    triangleCount: c,
+    vertexCount: a,
+    volumeMm3: Math.abs(f),
+    surfaceAreaMm2: d,
+    bbox: {
+      min: b,
+      max: x,
+      size: [x[0] - b[0], x[1] - b[1], x[2] - b[2]]
+    },
+    watertight: g,
+    manifold: P,
+    selfIntersect: M,
+    invertedNormals: k,
+    openEdgeCount: v,
+    nonManifoldEdgeCount: y,
+    componentCount: m,
+    minThicknessMm: Number.isFinite(E) ? E : 0
+  };
+}
+self.onmessage = async (o) => {
+  const r = o.data, n = (i) => self.postMessage(i);
+  try {
+    if (r.type === "init") {
+      r.wasmBinary && (Ie = r.wasmBinary), await Zt(), n({ id: r.id, type: "ready" });
+      return;
+    }
+    if (r.type === "evaluate") {
+      const i = await Zt(), c = [], a = [], f = [];
+      for (const y of r.roots) {
+        const m = Tt(i, y, r.sources);
+        c.push(m.buffers), a.push(!!m.solid && m.solid.status() === "NoError"), m.solid?.delete(), r.wantThicknessColors && f.push(to(m.buffers.positions, m.buffers.indices, r.wallMinMm));
+      }
+      const d = c.map((y, m) => eo(y.positions, y.indices, r.wallMinMm, m)), v = Fo(c, r.wallMinMm, a);
+      n({
+        id: r.id,
+        type: "evaluated",
+        meshes: c,
+        diagnosis: v,
+        thicknessColors: r.wantThicknessColors ? f : void 0,
+        defects: d
+      });
+      return;
+    }
+    if (r.type === "decompose") {
+      const i = await Zt(), c = St(i, r.mesh.positions, r.mesh.indices);
+      if (!c) {
+        n({ id: r.id, type: "decomposed", meshes: [r.mesh] });
+        return;
+      }
+      const a = c.decompose();
+      c.delete();
+      const f = a.map((d) => {
+        const v = at(d);
+        return d.delete(), v;
+      });
+      n({ id: r.id, type: "decomposed", meshes: f.length ? f : [r.mesh] });
+      return;
+    }
+    if (r.type === "splitByPlane") {
+      const i = await Zt(), c = Math.hypot(r.normal[0], r.normal[1], r.normal[2]) || 1, a = [r.normal[0] / c, r.normal[1] / c, r.normal[2] / c], f = r.offset / c;
+      let d = St(i, r.mesh.positions, r.mesh.indices);
+      if (!d) {
+        n({ id: r.id, type: "error", message: "当前网格无法构建实体，请先修复再拆件" });
+        return;
+      }
+      const v = r.connector === "sphere" || r.connector === "square" || r.connector === "ballSnap" || r.connector === "qiuSnap";
+      if ((r.connector === "ballSnap" || r.connector === "qiuSnap") && !r.qiuSnap) {
+        d.delete(), n({ id: r.id, type: "error", message: "爪扣模型未加载" });
+        return;
+      }
+      const y = r.width, m = r.height, k = !!(y && m && y > 0 && m > 0), b = $t(r.mesh.positions, r.mesh.indices), x = Nt(r.mesh.positions);
+      let E = [r.center[0], r.center[1], r.center[2]], g = { min: b.bbox.min, max: b.bbox.max }, P = 0;
+      const M = (T) => {
+        if (!(Math.abs(T.volume()) > 1e-10)) return;
+        const S = at(T), w = [
+          x[0] + a[0],
+          x[1] + a[1],
+          x[2] + a[2]
+        ], B = an(S, x, w);
+        if (B && B.area > 1e-12) {
+          E = B.center, g = B.bbox, P = B.span;
+          return;
+        }
+        E = Nt(S.positions);
+        const R = $t(S.positions, S.indices);
+        g = { min: R.bbox.min, max: R.bbox.max };
+      };
+      let F, I;
+      if (k) {
+        const T = v ? 1e-3 : Math.max(r.gapMm, 1e-3), S = i.Manifold.cube([y, m, T], !0).transform(
+          fe(a, r.center)
+        ), w = d.intersect(S);
+        if (!(Math.abs(w.volume()) > 1e-10)) {
+          w.delete(), S.delete();
+          const U = [at(d)];
+          d.delete(), n({ id: r.id, type: "splitByPlane", meshes: U });
+          return;
+        }
+        v && M(w), w.delete();
+        const R = d.subtract(S);
+        d.delete(), S.delete();
+        const j = R.decompose();
+        if (R.delete(), j.length < 2) {
+          const U = j.length ? [at(j[0])] : [r.mesh];
+          for (const J of j) J.delete();
+          n({ id: r.id, type: "splitByPlane", meshes: U });
+          return;
+        }
+        const O = [], D = [];
+        for (const U of j) {
+          const J = Nt(at(U).positions);
+          a[0] * J[0] + a[1] * J[1] + a[2] * J[2] >= f ? O.push(U) : D.push(U);
+        }
+        const L = (U) => {
+          let J = U[0];
+          for (let X = 1; X < U.length; X++) {
+            const rt = J.add(U[X]);
+            J.delete(), U[X].delete(), J = rt;
+          }
+          return J;
+        };
+        if (O.length && D.length)
+          F = L(O), I = L(D);
+        else {
+          const U = j.map((J) => ({ p: J, vol: Math.abs(J.volume()) }));
+          U.sort((J, X) => X.vol - J.vol), F = U[0].p, I = L(U.slice(1).map((J) => J.p));
+        }
+      } else {
+        if (v) {
+          const { x: w, y: B } = Ht(a);
+          let R = 1 / 0, j = -1 / 0, O = 1 / 0, D = -1 / 0;
+          const L = b.bbox.min, U = b.bbox.max;
+          for (const G of [L[0], U[0]])
+            for (const Y of [L[1], U[1]])
+              for (const mt of [L[2], U[2]]) {
+                const ft = G * w[0] + Y * w[1] + mt * w[2], ut = G * B[0] + Y * B[1] + mt * B[2];
+                ft < R && (R = ft), ft > j && (j = ft), ut < O && (O = ut), ut > D && (D = ut);
+              }
+          const J = Math.max(j - R, 1e-3) * 1.05, X = Math.max(D - O, 1e-3) * 1.05, rt = i.Manifold.cube([J, X, 1e-3], !0).transform(
+            fe(a, r.center)
+          ), H = d.intersect(rt);
+          M(H), H.delete(), rt.delete();
+        }
+        const T = d.splitByPlane(a, f);
+        d.delete();
+        const S = v ? 0 : Math.max(0, r.gapMm) / 2;
+        if (F = T[0], I = T[1], S > 1e-9) {
+          const w = F.trimByPlane(a, f + S), B = I.trimByPlane([-a[0], -a[1], -a[2]], -f + S);
+          F.delete(), I.delete(), F = w, I = B;
+        }
+      }
+      if (v) {
+        const T = P > 1e-9 ? pn(P, r.connectorSize) : yn(g.min, g.max, a, r.connectorSize);
+        if (T > 1e-12)
+          try {
+            const S = gn(
+              i,
+              F,
+              I,
+              a,
+              E,
+              r.connector,
+              T,
+              r.qiuSnap,
+              !1,
+              E,
+              void 0,
+              !0
+            );
+            F = S.pos, I = S.neg;
+          } catch (S) {
+            F.delete(), I.delete(), n({
+              id: r.id,
+              type: "error",
+              message: S instanceof Error ? `卡扣布尔失败：${S.message}` : "卡扣布尔失败"
+            });
+            return;
+          }
+      }
+      const z = [at(F), at(I)];
+      if (F.delete(), I.delete(), z.some((T) => !T.indices.length)) {
+        n({ id: r.id, type: "error", message: "切面未把模型分成两块，请调整切面位置" });
+        return;
+      }
+      n({ id: r.id, type: "splitByPlane", meshes: z });
+      return;
+    }
+    if (r.type === "assembleByContacts") {
+      const i = await Zt(), c = r.meshes.length;
+      if (c < 2) {
+        n({ id: r.id, type: "error", message: "至少需要 2 个零件才能按接触面装配" });
+        return;
+      }
+      if ((r.connector === "ballSnap" || r.connector === "qiuSnap") && !r.qiuSnap) {
+        n({ id: r.id, type: "error", message: "爪扣模型未加载" });
+        return;
+      }
+      const a = [], f = [], d = [], v = [];
+      for (let g = 0; g < c; g++) {
+        const P = r.meshes[g], M = $t(P.positions, P.indices);
+        if (M.openEdgeCount > 0 || M.nonManifoldEdgeCount > 0) {
+          for (const I of a) I?.delete();
+          n({
+            id: r.id,
+            type: "error",
+            message: `零件 ${g + 1} 不是封闭实体，请先修复再装配`
+          });
+          return;
+        }
+        const F = St(i, P.positions, P.indices);
+        if (!F) {
+          for (const I of a) I?.delete();
+          n({ id: r.id, type: "error", message: `零件 ${g + 1} 无法构建实体` });
+          return;
+        }
+        a.push(F), f.push(Nt(P.positions)), d.push(Math.abs(M.volume) || Math.abs(F.volume())), v.push({ min: M.bbox.min, max: M.bbox.max });
+      }
+      const y = [];
+      for (let g = 0; g < c; g++)
+        for (let P = g + 1; P < c; P++) {
+          if (!co(v[g], v[P], 1e-3)) continue;
+          const M = a[g], F = a[P], I = Co(M, F, f[g], f[P]);
+          if (!I) continue;
+          const z = at(I), T = Math.abs(I.volume());
+          I.delete();
+          const S = an(z, f[g], f[P]);
+          !S || !(S.area > 1e-12) || !(T > 1e-10) || y.push({
+            idxA: g,
+            idxB: P,
+            center: S.center,
+            normal: S.normal,
+            area: S.area,
+            span: S.span,
+            along: S.along,
+            volume: T,
+            bbox: S.bbox
+          });
+        }
+      y.sort((g, P) => P.area - g.area);
+      const m = y.length ? y[0].area : 0, k = [];
+      let b = 0, x = 0;
+      for (const g of y) {
+        const P = a[g.idxA], M = a[g.idxB];
+        if (!P || !M) {
+          x++;
+          continue;
+        }
+        try {
+          const F = P.intersect(M), I = Math.abs(F.volume()) > 1e-10;
+          if (F.delete(), !I) {
+            x++;
+            continue;
+          }
+          const z = Po(
+            i,
+            P,
+            M,
+            f[g.idxA],
+            f[g.idxB],
+            { center: g.center, normal: g.normal, area: g.area, span: g.span, along: g.along, bbox: g.bbox },
+            d[g.idxA],
+            d[g.idxB],
+            r.connector,
+            r.connectorSize,
+            m,
+            r.qiuSnap
+          );
+          a[g.idxA] = z.a, a[g.idxB] = z.b;
+          const T = at(z.a), S = at(z.b);
+          f[g.idxA] = Nt(T.positions), f[g.idxB] = Nt(S.positions), d[g.idxA] = Math.abs($t(T.positions, T.indices).volume), d[g.idxB] = Math.abs($t(S.positions, S.indices).volume), v[g.idxA] = {
+            min: $t(T.positions, T.indices).bbox.min,
+            max: $t(T.positions, T.indices).bbox.max
+          }, v[g.idxB] = {
+            min: $t(S.positions, S.indices).bbox.min,
+            max: $t(S.positions, S.indices).bbox.max
+          }, k.push({
+            idxA: g.idxA,
+            idxB: g.idxB,
+            center: g.center,
+            normal: g.normal,
+            area: g.area
+          }), b++;
+        } catch {
+          x++;
+        }
+      }
+      if (b === 0 && y.length === 0) {
+        for (const g of a) g?.delete();
+        n({ id: r.id, type: "error", message: "未检测到零件间接触面，无法装配" });
+        return;
+      }
+      const E = [];
+      for (let g = 0; g < c; g++) {
+        const P = a[g];
+        if (!P) {
+          E.push(r.meshes[g]);
+          continue;
+        }
+        E.push(at(P)), P.delete();
+      }
+      n({
+        id: r.id,
+        type: "assembleByContacts",
+        meshes: E,
+        contacts: k,
+        applied: b,
+        skipped: x
+      });
+    }
+  } catch (i) {
+    n({ id: r.id, type: "error", message: i instanceof Error ? i.message : String(i) });
+  }
+};
+var Io = /* @__PURE__ */ Object.freeze({
+  __proto__: null
+});