printbench 0.8.3 → 0.8.6

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

@@ -0,0 +1,2945 @@
+async function Yr(o = {}) {
+  var r, n = o, i = !!globalThis.window, a = !!globalThis.WorkerGlobalScope, c = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+  if (c) {
+    const { createRequire: t } = await Promise.resolve().then(function() {
+      return Ao;
+    });
+    var f = t(import.meta.url);
+  }
+  var d = !1;
+  n.setup = function() {
+    if (d) return;
+    d = !0, n.initTBB();
+    function t(u, h, S = ((W) => W)) {
+      if (h)
+        for (let W of h)
+          u.push_back(S(W));
+      return u;
+    }
+    function e(u, h = ((S) => S)) {
+      const S = [], W = u.size();
+      for (let K = 0; K < W; K++) S.push(h(u.get(K)));
+      return S;
+    }
+    function s(u, h = ((S) => S)) {
+      const S = [], 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)));
+        S.push(yt);
+      }
+      return S;
+    }
+    function l(u) {
+      return u[0].length < 3 && (u = [u]), t(new n.Vector2_vec2(), u, (h) => t(new n.Vector_vec2(), h, (S) => S instanceof Array ? { x: S[0], y: S[1] } : S));
+    }
+    function p(u) {
+      for (let h = 0; h < u.size(); h++) u.get(h).delete();
+      u.delete();
+    }
+    function x(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 P(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 I(u) {
+      return u == "EvenOdd" ? 0 : u == "NonZero" ? 1 : u == "Negative" ? 3 : 2;
+    }
+    function B(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 S = l(u), W = new N(S, I(h));
+        return p(S), W;
+      }
+    }
+    n.CrossSection.prototype.translate = function(...u) {
+      return this._Translate(x(u));
+    }, n.CrossSection.prototype.scale = function(u) {
+      return typeof u == "number" ? this._Scale({ x: u, y: u }) : this._Scale(x([u]));
+    }, n.CrossSection.prototype.mirror = function(u) {
+      return this._Mirror(x([u]));
+    }, n.CrossSection.prototype.warp = function(u) {
+      const h = Ot(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"), S = this._Warp(h);
+      return jt(h), S;
+    }, 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", S = 2, W = 0) {
+      return this._Offset(u, B(h), S, W);
+    }, n.CrossSection.prototype.simplify = function(u = 1e-6) {
+      return this._Simplify(u);
+    }, n.CrossSection.prototype.extrude = function(u, h = 0, S = 0, W = [1, 1], K = !1) {
+      W = x([W]);
+      const Z = n._Extrude(this._ToPolygons(), u, h, S, 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, (S) => [S.x, S.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 = Ot(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"), S = this._Warp(h);
+      jt(h);
+      const W = S.status();
+      if (W !== "NoError")
+        throw new n.ManifoldError(W);
+      return S;
+    }, n.Manifold.prototype.warpBatch = function(u) {
+      const h = Ot(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"), S = this._WarpBatch(h);
+      jt(h);
+      const W = S.status();
+      if (W !== "NoError")
+        throw new n.ManifoldError(W);
+      return S;
+    }, 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 S = this.numProp(), W = Ot(function(Z, ot, yt) {
+        const ct = [];
+        for (let it = 0; it < u; ++it)
+          ct[it] = dt(Z + 8 * it, "double");
+        const Et = [];
+        for (let it = 0; it < 3; ++it)
+          Et[it] = dt(ot + 8 * it, "double");
+        const Rt = [];
+        for (let it = 0; it < S; ++it)
+          Rt[it] = dt(yt + 8 * it, "double");
+        h(ct, Et, Rt);
+        for (let it = 0; it < u; ++it)
+          Dt(Z + 8 * it, ct[it], "double");
+      }, "viii"), K = this._SetProperties(u, W);
+      return jt(W), K;
+    }, n.Manifold.prototype.translate = function(...u) {
+      return this._Translate(P(u));
+    }, n.Manifold.prototype.rotate = function(u, h, S) {
+      return Array.isArray(u) ? this._Rotate(...u) : this._Rotate(u, h || 0, S || 0);
+    }, n.Manifold.prototype.scale = function(u) {
+      return typeof u == "number" ? this._Scale({ x: u, y: u, z: u }) : this._Scale(P([u]));
+    }, n.Manifold.prototype.mirror = function(u) {
+      return this._Mirror(P([u]));
+    }, n.Manifold.prototype.trimByPlane = function(u, h = 0) {
+      return this._TrimByPlane(P([u]), h);
+    }, n.Manifold.prototype.slice = function(u = 0) {
+      const h = this._Slice(u), S = new N(h, I("Positive"));
+      return p(h), S;
+    }, n.Manifold.prototype.project = function() {
+      const u = this._Project(), h = new N(u, I("Positive"));
+      return p(u), h;
+    }, n.Manifold.prototype.rayCast = function(u, h) {
+      const S = this._RayCast(P([u]), P([h])), W = e(S, (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 S.delete(), W;
+    }, n.Manifold.prototype.split = function(u) {
+      const h = this._Split(u), S = e(h);
+      return h.delete(), S;
+    }, n.Manifold.prototype.splitByPlane = function(u, h = 0) {
+      const S = this._SplitByPlane(P([u]), h), W = e(S);
+      return S.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: S = new Uint32Array(), vertProperties: W = new Float32Array(), mergeFromVert: K, mergeToVert: Z, runIndex: ot, runOriginalID: yt, faceID: ct, halfedgeTangent: Et, runTransform: Rt, runFlags: it, tolerance: Ce = 0 } = {}) {
+        this.numProp = h, this.triVerts = S, this.vertProperties = W, this.mergeFromVert = K, this.mergeToVert = Z, this.runIndex = ot, this.runOriginalID = yt, this.faceID = ct, this.halfedgeTangent = Et, this.runTransform = Rt, 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: S } = n._Merge(this);
+        return Object.assign(this, { ...S }), 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 S = new Array(16);
+        for (const W of [0, 1, 2, 3])
+          for (const K of [0, 1, 2])
+            S[4 * W + K] = this.runTransform[12 * h + 3 * W + K];
+        return S[15] = 1, S;
+      }
+      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, ...S) {
+      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, ...S]);
+      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 S = l(u), W = new N(S, I(h));
+      return p(S), 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 = x(u);
+      const S = u[1] || !1;
+      return n._Square(h, S);
+    }, 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 S = new n.Vector_crossSection();
+        for (const K of h) S.push_back(q(K));
+        const W = n["_crossSection" + u](S);
+        return S.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, (S) => S instanceof Array ? { x: S[0], y: S[1] } : S);
+    }
+    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 S = n._crossSectionHullPoints(h);
+      return h.delete(), S;
+    }, 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), S = h.status();
+      if (S !== "NoError")
+        throw new n.ManifoldError(S);
+      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 = P(u);
+      const S = u[1] || !1;
+      return n._Cube(h, S);
+    }, n.Manifold.cylinder = function(u, h, S = -1, W = 0, K = !1) {
+      return n._Cylinder(u, h, S, W, K);
+    }, n.Manifold.sphere = function(u, h = 0) {
+      return n._Sphere(u, h);
+    }, n.Manifold.smooth = function(u, h = []) {
+      const S = new n.Vector_smoothness();
+      t(S, h);
+      const W = n._Smooth(u, S);
+      return S.delete(), W;
+    }, n.Manifold.extrude = function(u, h, S = 0, W = 0, K = [1, 1], Z = !1) {
+      return (u instanceof N ? u : n.CrossSection(u, "Positive")).extrude(h, S, W, K, Z);
+    }, n.Manifold.revolve = function(u, h = 0, S = 360) {
+      return (u instanceof N ? u : n.CrossSection(u, "Positive")).revolve(h, S);
+    }, n.Manifold.reserveIDs = function(u) {
+      return n._ReserveIDs(u);
+    };
+    function pt(u) {
+      return function(...h) {
+        h.length == 1 && (h = h[0]);
+        const S = new n.Vector_manifold();
+        for (const K of h) S.push_back(K);
+        const W = n["_manifold" + u + "N"](S);
+        return S.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, S, 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 = Ot(function(ct) {
+        const Et = dt(ct, "double"), Rt = dt(ct + 8, "double"), it = dt(ct + 16, "double");
+        return u([Et, Rt, it]);
+      }, "di"), yt = n._LevelSet(ot, Z, S, W, K);
+      return jt(ot), yt;
+    }, n.ExecutionContext.prototype.fromMesh = function(u) {
+      return this._FromMesh(u);
+    }, n.ExecutionContext.prototype.smooth = function(u, h = []) {
+      const S = new n.Vector_smoothness();
+      t(S, h);
+      const W = this._Smooth(u, S);
+      return S.delete(), W;
+    }, n.ExecutionContext.prototype.levelSet = function(u, h, S, 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 = Ot(function(ct) {
+        const Et = dt(ct, "double"), Rt = dt(ct + 8, "double"), it = dt(ct + 16, "double");
+        return u([Et, Rt, it]);
+      }, "di"), yt = this._LevelSet(ot, Z, S, W, K);
+      return jt(ot), yt;
+    };
+    function gt(u, h) {
+      t(u, h, (S) => S instanceof Array ? { x: S[0], y: S[1], z: S[2] } : S);
+    }
+    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 S = n._manifoldHullPoints(h);
+      return h.delete(), S;
+    }, n.Manifold.prototype = Object.create(st.prototype), Object.defineProperty(n.Manifold, Symbol.hasInstance, { get: () => (u) => u instanceof st }), n.triangulate = function(u, h = -1, S = !0) {
+      const W = l(u), K = e(n._Triangulate(W, h, S), (Z) => [Z[0], Z[1], Z[2]]);
+      return p(W), K;
+    };
+  };
+  var y = import.meta.url, m = "";
+  function v(t) {
+    return n.locateFile ? n.locateFile(t, m) : m + t;
+  }
+  var A, g;
+  if (c) {
+    var b = f("node:fs");
+    y.startsWith("file:") && (m = f("node:path").dirname(f("node:url").fileURLToPath(y)) + "/"), g = (t) => {
+      t = w(t) ? new URL(t) : t;
+      var e = b.readFileSync(t);
+      return e;
+    }, A = async (t, e = !0) => {
+      t = w(t) ? new URL(t) : t;
+      var s = b.readFileSync(t, e ? void 0 : "utf8");
+      return s;
+    }, process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2);
+  } else if (i || a) {
+    try {
+      m = new URL(".", y).href;
+    } catch {
+    }
+    a && (g = (t) => {
+      var e = new XMLHttpRequest();
+      return e.open("GET", t, !1), e.responseType = "arraybuffer", e.send(null), new Uint8Array(e.response);
+    }), A = async (t) => {
+      if (w(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), M, R = !1, w = (t) => t.startsWith("file://"), _, F, z, $, k, T, V, C, j, O, U, L, D = !1;
+  function J() {
+    var t = ce.buffer;
+    z = new Int8Array(t), k = new Int16Array(t), $ = new Uint8Array(t), T = new Uint16Array(t), V = new Int32Array(t), C = new Uint32Array(t), j = new Float32Array(t), O = new Float64Array(t), U = 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());
+    Wt(Tt);
+  }
+  function rt() {
+    D = !0, Ut.J();
+  }
+  function H() {
+    if (n.postRun)
+      for (typeof n.postRun == "function" && (n.postRun = [n.postRun]); n.postRun.length; )
+        xt(n.postRun.shift());
+    Wt(Mt);
+  }
+  function G(t) {
+    n.onAbort?.(t), t = "Aborted(" + t + ")", E(t), R = !0, t += ". Build with -sASSERTIONS for more info.";
+    var e = new WebAssembly.RuntimeError(t);
+    throw F?.(e), e;
+  }
+  var Y;
+  function mt() {
+    return n.locateFile ? v("manifold.wasm") : "".href;
+  }
+  function ft(t) {
+    if (t == Y && M)
+      return new Uint8Array(M);
+    if (g)
+      return g(t);
+    throw "both async and sync fetching of the wasm failed";
+  }
+  async function ut(t) {
+    if (!M)
+      try {
+        var e = await A(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 && !w(e) && !c)
+      try {
+        var l = fetch(e, { credentials: "same-origin" }), p = await WebAssembly.instantiateStreaming(l, s);
+        return p;
+      } catch (x) {
+        E(`wasm streaming compile failed: ${x}`), E("falling back to ArrayBuffer instantiation");
+      }
+    return Pt(e, s);
+  }
+  function _t() {
+    var t = { a: Gr };
+    return t;
+  }
+  async function At() {
+    function t(x, P) {
+      return Ut = x.exports, Ut = Kr(Ut), Jr(Ut), J(), Ut;
+    }
+    function e(x) {
+      return t(x.instance);
+    }
+    var s = _t();
+    if (n.instantiateWasm)
+      return new Promise((x, P) => {
+        n.instantiateWasm(s, (I, B) => {
+          x(t(I));
+        });
+      });
+    Y ??= mt();
+    var l = await Ct(M, Y, s), p = e(l);
+    return p;
+  }
+  var Wt = (t) => {
+    for (; t.length > 0; )
+      t.shift()(n);
+  }, Mt = [], xt = (t) => Mt.push(t), Tt = [], qt = (t) => Tt.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 k[t >>> 1 >>> 0];
+      case "i32":
+        return V[t >>> 2 >>> 0];
+      case "i64":
+        return U[t >>> 3 >>> 0];
+      case "float":
+        return j[t >>> 2 >>> 0];
+      case "double":
+        return O[t >>> 3 >>> 0];
+      case "*":
+        return C[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":
+        k[t >>> 1 >>> 0] = e;
+        break;
+      case "i32":
+        V[t >>> 2 >>> 0] = e;
+        break;
+      case "i64":
+        U[t >>> 3 >>> 0] = BigInt(e);
+        break;
+      case "float":
+        j[t >>> 2 >>> 0] = e;
+        break;
+      case "double":
+        O[t >>> 3 >>> 0] = e;
+        break;
+      case "*":
+        C[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) {
+      C[this.ptr + 4 >>> 2 >>> 0] = e;
+    }
+    get_type() {
+      return C[this.ptr + 4 >>> 2 >>> 0];
+    }
+    set_destructor(e) {
+      C[this.ptr + 8 >>> 2 >>> 0] = e;
+    }
+    get_destructor() {
+      return C[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) {
+      C[this.ptr + 16 >>> 2 >>> 0] = e;
+    }
+    get_adjusted_ptr() {
+      return C[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(C[t >>> 2 >>> 0]);
+  }
+  var Nt = {}, zt = {}, te = {}, Mn = class extends Error {
+    constructor(e) {
+      super(e), this.name = "InternalError";
+    }
+  }, ee = (t) => {
+    throw new Mn(t);
+  }, It = (t, e, s) => {
+    t.forEach((I) => te[I] = e);
+    function l(I) {
+      var B = s(I);
+      B.length !== t.length && ee("Mismatched type converter count");
+      for (var N = 0; N < t.length; ++N)
+        vt(t[N], B[N]);
+    }
+    var p = new Array(e.length), x = [], P = 0;
+    for (let [I, B] of e.entries())
+      zt.hasOwnProperty(B) ? p[I] = zt[B] : (x.push(B), Nt.hasOwnProperty(B) || (Nt[B] = []), Nt[B].push(() => {
+        p[I] = zt[B], ++P, P === x.length && l(p);
+      }));
+    x.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, x = p.map((P) => P.getterReturnType).concat(p.map((P) => P.setterArgumentType));
+    It([t], x, (P) => {
+      var I = {};
+      for (var [B, N] of p.entries()) {
+        const q = P[B], Q = N.getter, et = N.getterContext, tt = P[B + p.length], st = N.setter, pt = N.setterContext;
+        I[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 I)
+          Q[et] = I[et].read(q);
+        return l(q), Q;
+      }, toWireType: (q, Q) => {
+        for (var et in I)
+          if (!(et in Q) && !I[et].optional)
+            throw new TypeError(`Missing field: "${et}"`);
+        var tt = s();
+        for (et in I)
+          I[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++ >>> 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`), zt.hasOwnProperty(t)) {
+      if (s.ignoreDuplicateRegistrations)
+        return;
+      nt(`Cannot register type '${l}' twice`);
+    }
+    if (zt[t] = e, delete te[t], Nt.hasOwnProperty(t)) {
+      var p = Nt[t];
+      delete Nt[t], p.forEach((x) => x());
+    }
+  }
+  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) => $[l >>> 0];
+      case 2:
+        return s ? (l) => k[l >>> 1 >>> 0] : (l) => T[l >>> 1 >>> 0];
+      case 4:
+        return s ? (l) => V[l >>> 2 >>> 0] : (l) => C[l >>> 2 >>> 0];
+      case 8:
+        return s ? (l) => U[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 x = l === 0n;
+    let P = (I) => I;
+    if (x) {
+      const I = s * 8;
+      P = (B) => BigInt.asUintN(I, B), p = P(p);
+    }
+    vt(t, { name: e, fromWireType: P, toWireType: (I, B) => (typeof B == "number" && (B = BigInt(B)), B), readValueFromPointer: Ee(e, s, !x), 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, x) {
+      return x ? s : l;
+    }, readValueFromPointer: function(p) {
+      return this.fromWireType($[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 x = s.$$.ptrType.registeredClass, P = s.$$.ptr; l.baseClass; )
+        p = l.upcast(p), l = l.baseClass;
+      for (; x.baseClass; )
+        P = x.upcast(P), x = x.baseClass;
+      return l === x && p === 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);
+  }, An = 48, In = 57, kn = (t) => {
+    t = t.replace(/[^a-zA-Z0-9_]/g, "$");
+    var e = t.charCodeAt(0);
+    return e >= An && e <= In ? `_${t}` : t;
+  };
+  function En(t, e, s, l, p, x, P, I) {
+    this.name = t, this.constructor = e, this.instancePrototype = s, this.rawDestructor = l, this.baseClass = p, this.getActualType = x, this.upcast = P, this.downcast = I, 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 x = this.registeredClass.getActualType(e), P = ze[x];
+    if (!P)
+      return p.call(this);
+    var I;
+    this.isConst ? I = P.constPointerType : I = P.pointerType;
+    var B = Be(e, this.registeredClass, I.registeredClass);
+    return B === null ? p.call(this) : this.isSmartPointer ? oe(I.registeredClass.instancePrototype, { ptrType: I, ptr: B, smartPtrType: this, smartPtr: t }) : oe(I.registeredClass.instancePrototype, { ptrType: I, ptr: B });
+  }
+  var Un = () => {
+    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, x, P, I, B, N, q) {
+    this.name = t, this.registeredClass = e, this.isReference = s, this.isConst = l, this.isSmartPointer = p, this.pointeeType = x, this.sharingPolicy = P, this.rawGetPointee = I, this.rawConstructor = B, 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), Dn = (t, e, s = [], l = !1) => {
+    var p = ie(e), x = p(...s);
+    function P(I) {
+      return t[0] == "p" ? I >>> 0 : I;
+    }
+    return P(x);
+  }, Nn = (t, e, s = !1) => (...l) => Dn(t, e, l, s), wt = (t, e, s = !1) => {
+    t = lt(t);
+    function l() {
+      if (t.includes("p"))
+        return Nn(t, e, s);
+      var x = ie(e);
+      return x;
+    }
+    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 kt(e), s;
+  }, ae = (t, e) => {
+    var s = [], l = {};
+    function p(x) {
+      if (!l[x] && !zt[x]) {
+        if (te[x]) {
+          te[x].forEach(p);
+          return;
+        }
+        s.push(x), l[x] = !0;
+      }
+    }
+    throw e.forEach(p), new Hn(`${t}: ` + s.map(je).join([", "]));
+  };
+  function Ln(t, e, s, l, p, x, P, I, B, N, q, Q, et) {
+    t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, x >>>= 0, P >>>= 0, I >>>= 0, B >>>= 0, N >>>= 0, q >>>= 0, Q >>>= 0, et >>>= 0, q = lt(q), x = wt(p, x), I &&= wt(P, I), N &&= wt(B, 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 (S.constructor_body === void 0)
+          throw new Gt(`${q} has no accessible constructor`);
+        var yt = S.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(S.constructor_body).toString()}) parameters instead!`);
+        return yt.apply(this, ot);
+      }), h = Object.create(gt, { constructor: { value: u } });
+      u.prototype = h;
+      var S = new En(q, u, h, et, pt, x, I, N);
+      S.baseClass && (S.baseClass.__derivedClasses ??= [], S.baseClass.__derivedClasses.push(S));
+      var W = new se(q, S, !0, !1, !1), K = new se(q + "*", S, !1, !1, !1), Z = new se(q + " const*", S, !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(C[e + l * 4 >>> 2 >>> 0]);
+    return s;
+  };
+  function Ue(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 = Ue(t), x = t.length - 2, P = [], I = ["fn"];
+    e && I.push("thisWired");
+    for (var B = 0; B < x; ++B)
+      P.push(`arg${B}`), I.push(`arg${B}Wired`);
+    P = P.join(","), I = I.join(",");
+    var N = `return function (${P}) {
+`;
+    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 B = 0; B < x; ++B) {
+      var et = `toArg${B}Wire`;
+      N += `var arg${B}Wired = ${et}(${q}, arg${B});
+`, Q.push(et);
+    }
+    if (N += (s || l ? "var rv = " : "") + `invoker(${I});
+`, p)
+      N += `runDestructors(destructors);
+`;
+    else
+      for (var B = e ? 1 : 2; B < t.length; ++B) {
+        var tt = B === 1 ? "thisWired" : "arg" + (B - 2) + "Wired";
+        t[B].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, x) {
+    var P = e.length;
+    P < 2 && nt("argTypes array size mismatch! Must at least get return value and 'this' types!");
+    for (var I = e[1] !== null && s !== null, B = Ue(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 < P; ++tt) {
+      var st = e[tt];
+      et.push(st.toWireType.bind(st));
+    }
+    if (!B)
+      for (var tt = I ? 1 : 2; tt < e.length; ++tt)
+        e[tt].destructorFunction !== null && et.push(e[tt].destructorFunction);
+    var gt = qn(e, I, N, x)(...et);
+    return re(t, gt);
+  }
+  var Jn = function(t, e, s, l, p, x) {
+    t >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, x >>>= 0;
+    var P = ge(e, s);
+    p = wt(l, p), It([], [t], (I) => {
+      I = I[0];
+      var B = `constructor ${I.name}`;
+      if (I.registeredClass.constructor_body === void 0 && (I.registeredClass.constructor_body = []), I.registeredClass.constructor_body[e - 1] !== void 0)
+        throw new Gt(`Cannot register multiple constructors with identical number of parameters (${e - 1}) for class '${I.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
+      return I.registeredClass.constructor_body[e - 1] = () => {
+        ae(`Cannot construct ${I.name} due to unbound types`, P);
+      }, It([], P, (N) => (N.splice(1, 0, null), I.registeredClass.constructor_body[e - 1] = be(B, N, null, p, x), [])), [];
+    });
+  }, De = (t) => {
+    t = t.trim();
+    const e = t.indexOf("(");
+    return e === -1 ? t : t.slice(0, e);
+  }, Gn = function(t, e, s, l, p, x, P, I, B, N) {
+    t >>>= 0, e >>>= 0, l >>>= 0, p >>>= 0, x >>>= 0, P >>>= 0;
+    var q = ge(s, l);
+    e = lt(e), e = De(e), x = wt(p, x, B), It([], [t], (Q) => {
+      Q = Q[0];
+      var et = `${Q.name}.${e}`;
+      e.startsWith("@@") && (e = Symbol[e.substring(2)]), I && 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, x, P, B);
+        return st[e].overloadTable === void 0 ? (u.argCount = s - 2, st[e] = u) : st[e].overloadTable[s - 2] = u, [];
+      }), [];
+    });
+  }, Ne = [], Vt = [0, 1, , 1, null, 1, !0, 1, !1, 1];
+  function xe(t) {
+    t >>>= 0, t > 9 && --Vt[t + 1] === 0 && (Vt[t] = void 0, Ne.push(t));
+  }
+  var ht = { toValue: (t) => (t || nt(`Cannot use deleted val. handle = ${t}`), Vt[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() || Vt.length;
+        return Vt[e] = t, Vt[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($[l >>> 0]);
+        };
+      case 2:
+        return s ? function(l) {
+          return this.fromWireType(k[l >>> 1 >>> 0]);
+        } : function(l) {
+          return this.fromWireType(T[l >>> 1 >>> 0]);
+        };
+      case 4:
+        return s ? function(l) {
+          return this.fromWireType(V[l >>> 2 >>> 0]);
+        } : function(l) {
+          return this.fromWireType(C[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 x = Xn(p);
+    switch (x) {
+      case "object": {
+        let N = function() {
+        };
+        N.values = {}, vt(t, { name: e, constructor: N, valueType: x, 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 P = {};
+        vt(t, { name: e, keysMap: P, valueType: x, fromWireType: (N) => N, toWireType: (N, q) => q, readValueFromPointer: _e(e, s, l), destructorFunction: null }), Xt(e, P), delete n[e].argCount;
+        break;
+      }
+      case "string": {
+        var I = {}, B = {}, P = {};
+        vt(t, { name: e, valuesMap: I, reverseMap: B, keysMap: P, valueType: x, fromWireType: function(q) {
+          return this.reverseMap[q];
+        }, toWireType: function(q, Q) {
+          return this.valuesMap[Q];
+        }, readValueFromPointer: _e(e, s, l), destructorFunction: null }), Xt(e, P), delete n[e].argCount;
+        break;
+      }
+    }
+  }
+  var Le = (t, e) => {
+    var s = zt[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, x = Object.create(l.constructor.prototype, { value: { value: s }, constructor: { value: re(`${l.name}_${e}`, function() {
+        }) } });
+        p.values[s] = x, p[e] = x;
+        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, x, P, I) {
+    t >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, x >>>= 0;
+    var B = ge(e, s);
+    t = lt(t), t = De(t), p = wt(l, p, P), Xt(t, function() {
+      ae(`Cannot call ${t} due to unbound types`, B);
+    }, e - 1), It([], B, (N) => {
+      var q = [N[0], null].concat(N.slice(1));
+      return Oe(t, be(t, q, null, p, x, P), e - 1), [];
+    });
+  }
+  var nr = function(t, e, s, l, p) {
+    t >>>= 0, e >>>= 0, s >>>= 0, e = lt(e);
+    const x = l === 0;
+    let P = (B) => B;
+    if (x) {
+      var I = 32 - 8 * s;
+      P = (B) => B << I >>> I, p = P(p);
+    }
+    vt(t, { name: e, fromWireType: P, toWireType: (B, N) => N, readValueFromPointer: Ee(e, s, l !== 0), destructorFunction: null });
+  }, rr = (t, e, s) => {
+    const l = (p, x) => {
+      let P = 0;
+      return { next() {
+        if (P >= p)
+          return { done: !0 };
+        const I = P;
+        return P++, { value: x(I), done: !1 };
+      }, [Symbol.iterator]() {
+        return this;
+      } };
+    };
+    t[Symbol.iterator] || (t[Symbol.iterator] = function() {
+      const p = this[e]();
+      return l(p, (x) => this[s](x));
+    });
+  }, 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 x = p[0];
+      return rr(x.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 x(P) {
+      var I = C[P >>> 2 >>> 0], B = C[P + 4 >>> 2 >>> 0];
+      return new p(z.buffer, B, I);
+    }
+    s = lt(s), vt(t, { name: s, fromWireType: x, readValueFromPointer: x }, { 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, x = s + l - 1, P = 0; P < t.length; ++P) {
+      var I = t.codePointAt(P);
+      if (I <= 127) {
+        if (s >= x) break;
+        e[s++ >>> 0] = I;
+      } else if (I <= 2047) {
+        if (s + 1 >= x) break;
+        e[s++ >>> 0] = 192 | I >> 6, e[s++ >>> 0] = 128 | I & 63;
+      } else if (I <= 65535) {
+        if (s + 2 >= x) break;
+        e[s++ >>> 0] = 224 | I >> 12, e[s++ >>> 0] = 128 | I >> 6 & 63, e[s++ >>> 0] = 128 | I & 63;
+      } else {
+        if (s + 3 >= x) break;
+        e[s++ >>> 0] = 240 | I >> 18, e[s++ >>> 0] = 128 | I >> 12 & 63, e[s++ >>> 0] = 128 | I >> 6 & 63, e[s++ >>> 0] = 128 | I & 63, P++;
+      }
+    }
+    return e[s >>> 0] = 0, s - p;
+  }, lr = (t, e, s) => cr(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 x = ""; e < p; ) {
+      var P = t[e++];
+      if (!(P & 128)) {
+        x += String.fromCharCode(P);
+        continue;
+      }
+      var I = t[e++] & 63;
+      if ((P & 224) == 192) {
+        x += String.fromCharCode((P & 31) << 6 | I);
+        continue;
+      }
+      var B = t[e++] & 63;
+      if ((P & 240) == 224 ? P = (P & 15) << 12 | I << 6 | B : P = (P & 7) << 18 | I << 12 | B << 6 | t[e++] & 63, P < 65536)
+        x += String.fromCharCode(P);
+      else {
+        var N = P - 65536;
+        x += String.fromCharCode(55296 | N >> 10, 56320 | N & 1023);
+      }
+    }
+    return x;
+  }, dr = (t, e, s) => (t >>>= 0, t ? fr($, t, e, s) : "");
+  function hr(t, e) {
+    t >>>= 0, e >>>= 0, e = lt(e), vt(t, { name: e, fromWireType(s) {
+      var l = C[s >>> 2 >>> 0], p = s + 4, x;
+      return x = dr(p, l, !0), kt(s), x;
+    }, toWireType(s, l) {
+      l instanceof ArrayBuffer && (l = new Uint8Array(l));
+      var p, x = typeof l == "string";
+      x || ArrayBuffer.isView(l) && l.BYTES_PER_ELEMENT == 1 || nt("Cannot pass non-string to std::string"), x ? p = ur(l) : p = l.length;
+      var P = Pe(4 + p + 1), I = P + 4;
+      return C[P >>> 2 >>> 0] = p, x ? lr(l, I, p + 1) : $.set(l, I >>> 0), s !== null && s.push(kt, P), P;
+    }, readValueFromPointer: Jt, destructorFunction(s) {
+      kt(s);
+    } });
+  }
+  var Ge = globalThis.TextDecoder ? new TextDecoder("utf-16le") : void 0, pr = (t, e, s) => {
+    var l = t >>> 1, p = Je(T, l, e / 2, s);
+    if (p - l > 16 && Ge) return Ge.decode(T.subarray(l >>> 0, p >>> 0));
+    for (var x = "", P = l; P < p; ++P) {
+      var I = T[P >>> 0];
+      x += String.fromCharCode(I);
+    }
+    return x;
+  }, 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, x = 0; x < p; ++x) {
+      var P = t.charCodeAt(x);
+      k[e >>> 1 >>> 0] = P, e += 2;
+    }
+    return k[e >>> 1 >>> 0] = 0, e - l;
+  }, mr = (t) => t.length * 2, vr = (t, e, s) => {
+    for (var l = "", p = t >>> 2, x = 0; !(x >= e / 4); x++) {
+      var P = C[p + x >>> 0];
+      if (!P && !s) break;
+      l += String.fromCodePoint(P);
+    }
+    return l;
+  }, gr = (t, e, s) => {
+    if (e >>>= 0, s ??= 2147483647, s < 4) return 0;
+    for (var l = e, p = l + s - 4, x = 0; x < t.length; ++x) {
+      var P = t.codePointAt(x);
+      if (P > 65535 && x++, V[e >>> 2 >>> 0] = P, e += 4, e + 4 > p) break;
+    }
+    return V[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, x;
+    e === 2 ? (l = pr, p = yr, x = mr) : (l = vr, p = gr, x = br), vt(t, { name: s, fromWireType: (P) => {
+      var I = C[P >>> 2 >>> 0], B = l(P + 4, I * e, !0);
+      return kt(P), B;
+    }, toWireType: (P, I) => {
+      typeof I != "string" && nt(`Cannot pass non-string to C++ string type ${s}`);
+      var B = x(I), N = Pe(4 + B + e);
+      return C[N >>> 2 >>> 0] = B / e, p(I, N + 4, B + e), P !== null && P.push(kt, N), N;
+    }, readValueFromPointer: Jt, destructorFunction(P) {
+      kt(P);
+    } });
+  }
+  function _r(t, e, s, l, p, x) {
+    t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, x >>>= 0, Qt[t] = { name: lt(e), rawConstructor: wt(s, l), rawDestructor: wt(p, x), fields: [] };
+  }
+  function Mr(t, e, s, l, p, x, P, I, B, N) {
+    t >>>= 0, e >>>= 0, s >>>= 0, l >>>= 0, p >>>= 0, x >>>= 0, P >>>= 0, I >>>= 0, B >>>= 0, N >>>= 0, Qt[t].fields.push({ fieldName: lt(e), getterReturnType: s, getter: wt(l, p), getterContext: x, setterArgumentType: P, setter: wt(I, B), 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(C[e + l * 4 >>> 2 >>> 0], `parameter ${l}`);
+    return s;
+  }, Tr = (t, e, s) => {
+    var l = [], p = t(l, s);
+    return l.length && (C[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, ...x] = Cr(t, e), P = p.toWireType.bind(p), I = x.map((tt) => tt.readValueFromPointer.bind(tt));
+    t--;
+    var B = { toValue: ht.toValue }, N = I.map((tt, st) => {
+      var pt = `argFromPtr${st}`;
+      return B[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:
+        B.getStringOrSymbol = Ke, q = "toValue(handle)[getStringOrSymbol(methodName)]";
+        break;
+    }
+    q += `(${N})`, p.isVoid || (B.toReturnWire = P, B.emval_returnValue = Tr, q = `return emval_returnValue(toReturnWire, destructorsRef, ${q})`), q = `return function (handle, methodName, destructorsRef, args) {
+${q}
+}`;
+    var Q = new Function(Object.keys(B), q)(...Object.values(B)), et = `methodCaller<(${x.map((tt) => tt.name)}) => ${p.name}>`;
+    return Pr(re(et, Q));
+  };
+  function Ar(t, e) {
+    return t >>>= 0, e >>>= 0, t = ht.toValue(t), e = ht.toValue(e), t == e;
+  }
+  function Ir(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 && (Vt[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 Ur(t) {
+    t >>>= 0;
+    var e = $.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 x = Math.min(s, Or(Math.max(t, p), 65536)), P = jr(x);
+      if (P)
+        return !0;
+    }
+    return !1;
+  }
+  var Dr = (t, e) => {
+    if (Bt)
+      for (var s = t; s < t + e; s++) {
+        var l = ie(s);
+        l && Bt.set(l, s);
+      }
+  }, Bt, Nr = (t) => (Bt || (Bt = /* @__PURE__ */ new WeakMap(), Dr(0, Yt.length)), Bt.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 } }), x = p.exports.f;
+    return x;
+  }, Ot = (t, e) => {
+    var s = Nr(t);
+    if (s)
+      return s;
+    var l = Hr();
+    try {
+      $e(l, t);
+    } catch (x) {
+      if (!(x instanceof TypeError))
+        throw x;
+      var p = qr(t, e);
+      $e(l, p);
+    }
+    return Bt.set(t, l), l;
+  }, jt = (t) => {
+    Bt.delete(ie(t)), $e(t, null), we.push(t);
+  };
+  if (Fn(), Un(), n.noExitRuntime && n.noExitRuntime, n.print && n.print, n.printErr && (E = n.printErr), n.wasmBinary && (M = 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 = Ot, n.removeFunction = jt;
+  var Ze, Pe, kt, ce, Yt;
+  function Jr(t) {
+    Ze = t.K, Pe = t.M, kt = 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: Ar, B: Ir, t: kr, f: Er, s: Rr, A: Wr, e: zr, v: Vr, D: Ur };
+  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, !R && (rt(), _?.(n), n.onRuntimeInitialized?.(), H());
+    }
+    n.setStatus ? (n.setStatus("Running..."), setTimeout(() => {
+      setTimeout(() => n.setStatus(""), 1), t();
+    }, 1)) : t();
+  }
+  var Ut;
+  return Ut = await At(), Xr(), D ? r = n : r = new Promise((t, e) => {
+    _ = t, F = 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, a = /* @__PURE__ */ new Map();
+  let c = 0, f = 0, d = 0;
+  const y = [1 / 0, 1 / 0, 1 / 0], m = [-1 / 0, -1 / 0, -1 / 0];
+  for (let w = 0; w < n; w++) {
+    const _ = o[w * 3], F = o[w * 3 + 1], z = o[w * 3 + 2];
+    _ < y[0] && (y[0] = _), F < y[1] && (y[1] = F), z < y[2] && (y[2] = z), _ > m[0] && (m[0] = _), F > m[1] && (m[1] = F), z > m[2] && (m[2] = z);
+  }
+  const v = new Int32Array(n);
+  for (let w = 0; w < n; w++) v[w] = w;
+  const A = (w) => {
+    for (; v[w] !== w; )
+      v[w] = v[v[w]], w = v[w];
+    return w;
+  }, g = (w, _) => {
+    const F = A(w), z = A(_);
+    F !== z && (v[F] = z);
+  };
+  for (let w = 0; w < i; w++) {
+    const _ = r[w * 3], F = r[w * 3 + 1], z = r[w * 3 + 2], $ = o[_ * 3], k = o[_ * 3 + 1], T = o[_ * 3 + 2], V = o[F * 3], C = o[F * 3 + 1], j = o[F * 3 + 2], O = o[z * 3], U = o[z * 3 + 1], L = o[z * 3 + 2], D = V - $, J = C - k, X = j - T, rt = O - $, H = U - k, G = L - T, Y = J * G - X * H, mt = X * rt - D * G, ft = D * H - J * rt, ut = 0.5 * Math.hypot(Y, mt, ft);
+    ut < 1e-12 && d++, f += ut, c += $ * Y + k * mt + T * ft;
+    for (const [Pt, Ct] of [[_, F], [F, z], [z, _]]) {
+      const _t = Zr(Pt, Ct);
+      a.set(_t, (a.get(_t) ?? 0) + 1), g(Pt, Ct);
+    }
+  }
+  let b = 0, E = 0;
+  for (const w of a.values())
+    w === 1 ? b++ : w > 2 && E++;
+  const M = /* @__PURE__ */ new Set();
+  for (let w = 0; w < n; w++) M.add(A(w));
+  const R = c / 6;
+  return {
+    triangleCount: i,
+    vertexCount: n,
+    openEdgeCount: b,
+    nonManifoldEdgeCount: E,
+    componentCount: Math.max(1, M.size),
+    volume: R,
+    surfaceArea: f,
+    bbox: {
+      min: y,
+      max: m,
+      size: [m[0] - y[0], m[1] - y[1], m[2] - y[2]]
+    },
+    invertedNormals: R < 0,
+    degenerateCount: d
+  };
+}
+function Qr(o, r, n = 200) {
+  const i = r.length / 3;
+  if (i === 0) return 0;
+  const a = Math.max(1, Math.floor(i / n));
+  let c = 1 / 0;
+  const f = [];
+  for (let d = 0; d < i; d += a) {
+    const y = r[d * 3], m = r[d * 3 + 1], v = r[d * 3 + 2], A = o[y * 3], g = o[y * 3 + 1], b = o[y * 3 + 2], E = o[m * 3], M = o[m * 3 + 1], R = o[m * 3 + 2], w = o[v * 3], _ = o[v * 3 + 1], F = o[v * 3 + 2], z = (A + E + w) / 3, $ = (g + M + _) / 3, k = (b + R + F) / 3, T = (M - g) * (F - b) - (R - b) * (_ - g), V = (R - b) * (w - A) - (E - A) * (F - b), C = (E - A) * (_ - g) - (M - g) * (w - A), j = Math.hypot(T, V, C) || 1;
+    f.push([z, $, k, -T / j, -V / j, -C / j]);
+  }
+  for (const [d, y, m, v, A, g] of f) {
+    let b = 1 / 0;
+    for (let E = 0; E < i; E += Math.max(1, Math.floor(a / 2))) {
+      const M = r[E * 3], R = r[E * 3 + 1], w = r[E * 3 + 2], _ = Ie(
+        d,
+        y,
+        m,
+        v,
+        A,
+        g,
+        o[M * 3],
+        o[M * 3 + 1],
+        o[M * 3 + 2],
+        o[R * 3],
+        o[R * 3 + 1],
+        o[R * 3 + 2],
+        o[w * 3],
+        o[w * 3 + 1],
+        o[w * 3 + 2]
+      );
+      _ > 1e-3 && _ < b && (b = _);
+    }
+    b < c && (c = b);
+  }
+  return Number.isFinite(c) ? c : 0;
+}
+function Ie(o, r, n, i, a, c, f, d, y, m, v, A, g, b, E) {
+  const R = m - f, w = v - d, _ = A - y, F = g - f, z = b - d, $ = E - y, k = a * $ - c * z, T = c * F - i * $, V = i * z - a * F, C = R * k + w * T + _ * V;
+  if (Math.abs(C) < 1e-8) return 1 / 0;
+  const j = 1 / C, O = o - f, U = r - d, L = n - y, D = (O * k + U * T + L * V) * j;
+  if (D < 0 || D > 1) return 1 / 0;
+  const J = U * _ - L * w, X = L * R - O * _, rt = O * w - U * R, H = (i * J + a * X + c * rt) * j;
+  if (H < 0 || D + H > 1) return 1 / 0;
+  const G = (F * J + z * X + $ * rt) * j;
+  return G > 0 ? G : 1 / 0;
+}
+function to(o, r, n) {
+  const i = o.length / 3, a = new Float32Array(i * 3), c = r.length / 3, f = Math.min(i, 800), d = Math.max(1, Math.floor(i / f)), y = new Float32Array(i);
+  y.fill(n * 4);
+  for (let m = 0; m < i; m += d) {
+    let v = 0, A = 0, g = 0;
+    for (let F = 0; F < c; F++)
+      if (r[F * 3] === m || r[F * 3 + 1] === m || r[F * 3 + 2] === m) {
+        const z = r[F * 3], $ = r[F * 3 + 1], k = r[F * 3 + 2], T = o[z * 3], V = o[z * 3 + 1], C = o[z * 3 + 2], j = o[$ * 3], O = o[$ * 3 + 1], U = o[$ * 3 + 2], L = o[k * 3], D = o[k * 3 + 1], J = o[k * 3 + 2];
+        v += (O - V) * (J - C) - (U - C) * (D - V), A += (U - C) * (L - T) - (j - T) * (J - C), g += (j - T) * (D - V) - (O - V) * (L - T);
+      }
+    const b = Math.hypot(v, A, g) || 1, E = o[m * 3], M = o[m * 3 + 1], R = o[m * 3 + 2];
+    let w = 1 / 0;
+    const _ = Math.max(1, Math.floor(c / 120));
+    for (let F = 0; F < c; F += _) {
+      const z = r[F * 3], $ = r[F * 3 + 1], k = r[F * 3 + 2], T = Ie(
+        E,
+        M,
+        R,
+        -v / b,
+        -A / b,
+        -g / b,
+        o[z * 3],
+        o[z * 3 + 1],
+        o[z * 3 + 2],
+        o[$ * 3],
+        o[$ * 3 + 1],
+        o[$ * 3 + 2],
+        o[k * 3],
+        o[k * 3 + 1],
+        o[k * 3 + 2]
+      );
+      T > 1e-3 && T < w && (w = T);
+    }
+    y[m] = Number.isFinite(w) ? w : n * 4;
+  }
+  for (let m = 0; m < i; m++) {
+    const v = Math.min(1, y[m] / (n * 3));
+    a[m * 3] = 1 - v, a[m * 3 + 1] = v, a[m * 3 + 2] = 0.15;
+  }
+  return a;
+}
+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 a = o.length / 3, c = r.length / 3, f = /* @__PURE__ */ new Map(), d = new Int32Array(a);
+  for (let T = 0; T < a; T++) d[T] = T;
+  const y = (T) => {
+    for (; d[T] !== T; )
+      d[T] = d[d[T]], T = d[T];
+    return T;
+  }, m = (T, V) => {
+    const C = y(T), j = y(V);
+    C !== j && (d[C] = j);
+  };
+  for (let T = 0; T < c; T++) {
+    const V = r[T * 3], C = r[T * 3 + 1], j = r[T * 3 + 2];
+    for (const [O, U] of [[V, C], [C, j], [j, V]]) {
+      const L = O < U ? `${O}_${U}` : `${U}_${O}`, D = f.get(L);
+      D ? D.count++ : f.set(L, { a: O, b: U, count: 1 }), m(O, U);
+    }
+  }
+  const v = [], A = [];
+  let g, b;
+  for (const T of f.values())
+    T.count === 1 && v.length < 24e3 ? (Qe(v, o, T.a, T.b), g ??= tn(o, T.a, T.b)) : T.count > 2 && A.length < 12e3 && (Qe(A, o, T.a, T.b), b ??= tn(o, T.a, T.b));
+  const E = [];
+  let M;
+  const R = Math.max(1, Math.floor(c / 400));
+  for (let T = 0; T < c && E.length < 9e3; T += R) {
+    const V = r[T * 3], C = r[T * 3 + 1], j = r[T * 3 + 2], O = o[V * 3], U = o[V * 3 + 1], L = o[V * 3 + 2], D = o[C * 3], J = o[C * 3 + 1], X = o[C * 3 + 2], rt = o[j * 3], H = o[j * 3 + 1], G = o[j * 3 + 2], Y = (O + D + rt) / 3, mt = (U + J + H) / 3, ft = (L + X + G) / 3, ut = (J - U) * (G - L) - (X - L) * (H - U), Pt = (X - L) * (rt - O) - (D - O) * (G - L), Ct = (D - O) * (H - U) - (J - U) * (rt - O), _t = Math.hypot(ut, Pt, Ct) || 1;
+    let At = 1 / 0;
+    const Wt = Math.max(1, Math.floor(c / 80));
+    for (let Mt = 0; Mt < c; Mt += Wt) {
+      const xt = r[Mt * 3], Tt = r[Mt * 3 + 1], qt = r[Mt * 3 + 2], dt = Ie(
+        Y,
+        mt,
+        ft,
+        -ut / _t,
+        -Pt / _t,
+        -Ct / _t,
+        o[xt * 3],
+        o[xt * 3 + 1],
+        o[xt * 3 + 2],
+        o[Tt * 3],
+        o[Tt * 3 + 1],
+        o[Tt * 3 + 2],
+        o[qt * 3],
+        o[qt * 3 + 1],
+        o[qt * 3 + 2]
+      );
+      dt > 1e-3 && dt < At && (At = dt);
+    }
+    At < n && (E.push(O, U, L, D, J, X, rt, H, G), M ??= [Y, mt, ft]);
+  }
+  const w = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map();
+  for (let T = 0; T < a; T++) {
+    const V = y(T);
+    w.set(V, (w.get(V) ?? 0) + 1), _.has(V) || _.set(V, T);
+  }
+  let F = -1, z = -1;
+  for (const [T, V] of w)
+    V > z && (z = V, F = T);
+  const $ = [];
+  let k;
+  if (w.size > 1)
+    for (let T = 0; T < c && $.length < 9e3; T++) {
+      const V = r[T * 3];
+      if (y(V) === F) continue;
+      const C = r[T * 3 + 1], j = r[T * 3 + 2];
+      if ($.push(
+        o[V * 3],
+        o[V * 3 + 1],
+        o[V * 3 + 2],
+        o[C * 3],
+        o[C * 3 + 1],
+        o[C * 3 + 2],
+        o[j * 3],
+        o[j * 3 + 1],
+        o[j * 3 + 2]
+      ), !k) {
+        const O = _.get(y(V)) ?? V;
+        k = [o[O * 3], o[O * 3 + 1], o[O * 3 + 2]];
+      }
+    }
+  return {
+    partIndex: i,
+    openEdgePositions: new Float32Array(v),
+    nonManifoldEdgePositions: new Float32Array(A),
+    thinTriPositions: new Float32Array(E),
+    islandTriPositions: new Float32Array($),
+    focus: {
+      watertight: g,
+      nonmanifold: b,
+      thinwall: M,
+      islands: k,
+      selfintersect: b ?? g,
+      normals: g
+    }
+  };
+}
+function ue(o, r, n = 1e-5, i, a, c) {
+  const f = /* @__PURE__ */ new Map(), d = [], y = [], m = [], v = [], A = [], g = 1 / n, b = o.length / 3, E = !1, M = !1, R = !1;
+  for (let _ = 0; _ < b; _++) {
+    const F = o[_ * 3], z = o[_ * 3 + 1], $ = o[_ * 3 + 2];
+    let k = `${Math.round(F * g)}_${Math.round(z * g)}_${Math.round($ * g)}`, T = f.get(k);
+    T === void 0 && (T = d.length / 3, f.set(k, T), d.push(F, z, $)), A[_] = T;
+  }
+  const w = [];
+  for (let _ = 0; _ < r.length; _ += 3) {
+    const F = A[r[_]], z = A[r[_ + 1]], $ = A[r[_ + 2]];
+    F === z || z === $ || F === $ || w.push(F, z, $);
+  }
+  return {
+    positions: new Float32Array(d),
+    indices: new Uint32Array(w),
+    colors: M ? new Float32Array(y) : void 0,
+    uvs: E ? new Float32Array(m) : void 0,
+    normals: R ? new Float32Array(v) : void 0
+  };
+}
+function dn(o, r) {
+  const n = /* @__PURE__ */ new Map(), i = (v, A) => {
+    const g = v < A ? `${v}_${A}` : `${A}_${v}`, b = n.get(g) ?? [];
+    b.push(v, A), n.set(g, b);
+  };
+  for (let v = 0; v < r.length; v += 3)
+    i(r[v], r[v + 1]), i(r[v + 1], r[v + 2]), i(r[v + 2], r[v]);
+  const a = /* @__PURE__ */ new Map();
+  for (const [v, A] of n)
+    if (A.length === 2) {
+      const [g, b] = v.split("_").map(Number);
+      n.get(v).length === 2 && a.set(g, b);
+    }
+  const c = [];
+  for (const [, v] of n)
+    v.length === 2 && c.push([v[0], v[1]]);
+  const f = /* @__PURE__ */ new Map();
+  for (const [v, A] of c) {
+    const g = f.get(v) ?? [];
+    g.push(A), f.set(v, g);
+  }
+  const d = /* @__PURE__ */ new Set(), y = [];
+  for (const [v, A] of f)
+    for (const g of A) {
+      const b = `${v}_${g}`;
+      if (d.has(b)) continue;
+      const E = [v];
+      let M = g, R = v;
+      d.add(b);
+      let w = 0;
+      for (; M !== v && w++ < 1e4; ) {
+        E.push(M);
+        const _ = f.get(M) ?? [], F = _.find((z) => z !== R) ?? _[0];
+        if (F === void 0) break;
+        d.add(`${M}_${F}`), R = M, M = F;
+      }
+      if (E.length >= 3) {
+        const _ = E[0];
+        for (let F = 1; F < E.length - 1; F++)
+          y.push(_, E[F], E[F + 1]);
+      }
+    }
+  if (!y.length) return { positions: o, indices: r };
+  const m = new Uint32Array(r.length + y.length);
+  return m.set(r, 0), m.set(y, r.length), { positions: o, indices: m };
+}
+function en(o, r) {
+  const n = ue(o, r), i = n.indices.length, a = dn(n.positions, n.indices), c = a.indices;
+  if (c !== n.indices && c.length > i)
+    for (let f = i; f < c.length; f += 3) {
+      const d = c[f + 1];
+      c[f + 1] = c[f + 2], c[f + 2] = d;
+    }
+  return ue(a.positions, c, 1e-4);
+}
+function nn(o, r) {
+  const n = new Float32Array(o.length);
+  for (let i = 0; i < o.length; i += 3) {
+    const a = o[i], c = o[i + 1], f = o[i + 2];
+    n[i] = r[0] * a + r[4] * c + r[8] * f + r[12], n[i + 1] = r[1] * a + r[5] * c + r[9] * f + r[13], n[i + 2] = r[2] * a + r[6] * c + r[10] * f + r[14];
+  }
+  return n;
+}
+function bt(o, r, n = "z-up") {
+  const i = Math.hypot(o[0], o[1], o[2]);
+  return i < 1e-12 ? { normal: n === "y-up" ? [0, 1, 0] : [0, 0, 1], offset: r } : {
+    normal: [o[0] / i, o[1] / i, o[2] / i],
+    offset: r / i
+  };
+}
+function Lt(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], a = n[2] * r[0] - n[0] * r[2], c = n[0] * r[1] - n[1] * r[0], f = Math.hypot(i, a, c) || 1, d = [i / f, a / f, c / f], y = [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, z: r };
+}
+function fe(o, r) {
+  const { x: n, y: i, z: a } = Lt(o);
+  return [n[0], n[1], n[2], 0, i[0], i[1], i[2], 0, a[0], a[1], a[2], 0, r[0], r[1], r[2], 1];
+}
+function no(o, r, n) {
+  const { x: i, y: a } = Lt(n);
+  let c = 1 / 0, f = -1 / 0, d = 1 / 0, y = -1 / 0;
+  for (const v of [o[0], r[0]])
+    for (const A of [o[1], r[1]])
+      for (const g of [o[2], r[2]]) {
+        const b = v * i[0] + A * i[1] + g * i[2], E = v * a[0] + A * a[1] + g * a[2];
+        b < c && (c = b), b > f && (f = b), E < d && (d = E), E > y && (y = E);
+      }
+  const m = Math.min(f - c, y - d);
+  return Number.isFinite(m) && m > 0 ? m : 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), a = o * 0.9;
+  return r > 0 ? Math.min(r, a) : Math.min(i, a);
+}
+function yn(o, r, n, i = 0, a = hn) {
+  const c = no(o, r, n);
+  if (!(c > 0)) return 0;
+  const f = c * Math.max(0, a), d = c * 0.9;
+  return i > 0 ? Math.min(i, d) : Math.min(f, d);
+}
+function so(o, r, n) {
+  const { normal: i } = bt(r, 0), a = n * 0.3;
+  return [o[0] + i[0] * a, o[1] + i[1] * a, o[2] + i[2] * a];
+}
+const io = 0.65;
+function ao(o, r, n, i, a = io) {
+  const { normal: c } = bt(r, 0), f = i + n * (a - 0.5);
+  return [o[0] + c[0] * f, o[1] + c[1] * f, o[2] + c[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 Ht(o) {
+  const r = o.length / 3;
+  if (r < 1) return [0, 0, 0];
+  let n = 0, i = 0, a = 0;
+  for (let c = 0; c < r; c++)
+    n += o[c * 3], i += o[c * 3 + 1], a += o[c * 3 + 2];
+  return [n / r, i / r, a / 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: a, y: c } = Lt(i), f = o.map((g) => {
+    const b = g[0] - n[0], E = g[1] - n[1], M = g[2] - n[2];
+    return { x: b * a[0] + E * a[1] + M * a[2], y: b * c[0] + E * c[1] + M * c[2] };
+  });
+  let d = 0;
+  for (let g = 1; g < f.length; g++)
+    (f[g].y < f[d].y || f[g].y === f[d].y && f[g].x < f[d].x) && (d = g);
+  const y = f[d], m = f.map((g, b) => ({ p: g, i: b })).sort((g, b) => {
+    const E = rn(y, g.p, b.p);
+    return Math.abs(E) < 1e-14 ? on(y, g.p) - on(y, b.p) : E > 0 ? -1 : 1;
+  }), v = [];
+  for (const g of m) {
+    const b = g.p;
+    for (; v.length >= 2 && rn(v[v.length - 2], v[v.length - 1], b) <= 0; ) v.pop();
+    v.push(b);
+  }
+  if (v.length < 3) return 0;
+  let A = 0;
+  for (let g = 0; g < v.length; g++) {
+    const b = (g + 1) % v.length;
+    A += v[g].x * v[b].y - v[b].x * v[g].y;
+  }
+  return Math.abs(A) * 0.5;
+}
+function le(o, r) {
+  const [n, i, a, c, f, d] = o;
+  return [n * r[0] + i * r[1] + a * r[2], i * r[0] + c * r[1] + f * r[2], a * 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 U of o)
+    r += U[0], n += U[1], i += U[2];
+  const a = o.length;
+  r /= a, n /= a, i /= a;
+  let c = 0, f = 0, d = 0, y = 0, m = 0, v = 0;
+  for (const U of o) {
+    const L = U[0] - r, D = U[1] - n, J = U[2] - i;
+    c += L * L, f += L * D, d += L * J, y += D * D, m += D * J, v += J * J;
+  }
+  const A = [c, f, d, y, m, v], g = (U, L) => {
+    let D = U;
+    for (let J = 0; J < 24; J++) {
+      const X = L(D), rt = Math.hypot(X[0], X[1], X[2]);
+      if (rt < 1e-18) return D;
+      D = [X[0] / rt, X[1] / rt, X[2] / rt];
+    }
+    return D;
+  }, b = g([1, 0.3, 0.2], (U) => le(A, U)), E = le(A, b), M = b[0] * E[0] + b[1] * E[1] + b[2] * E[2], R = (U) => {
+    const L = le(A, U), D = M * (b[0] * U[0] + b[1] * U[1] + b[2] * U[2]);
+    return [L[0] - D * b[0], L[1] - D * b[1], L[2] - D * b[2]];
+  }, w = Math.abs(b[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0], _ = [
+    w[1] * b[2] - w[2] * b[1],
+    w[2] * b[0] - w[0] * b[2],
+    w[0] * b[1] - w[1] * b[0]
+  ], F = Math.hypot(_[0], _[1], _[2]) || 1, z = [_[0] / F, _[1] / F, _[2] / F], $ = [
+    b[1] * z[2] - b[2] * z[1],
+    b[2] * z[0] - b[0] * z[2],
+    b[0] * z[1] - b[1] * z[0]
+  ], k = (U) => {
+    const L = le(A, U);
+    return U[0] * L[0] + U[1] * L[1] + U[2] * L[2];
+  }, T = g(z, R), V = g($, R), C = k(T) >= k(V) ? T : V, j = [
+    b[1] * C[2] - b[2] * C[1],
+    b[2] * C[0] - b[0] * C[2],
+    b[0] * C[1] - b[1] * C[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 } = Lt(r);
+  let a = 1 / 0, c = -1 / 0, f = 1 / 0, d = -1 / 0;
+  for (const m of o) {
+    const v = m[0] * n[0] + m[1] * n[1] + m[2] * n[2], A = m[0] * i[0] + m[1] * i[1] + m[2] * i[2];
+    v < a && (a = v), v > c && (c = v), A < f && (f = A), A > d && (d = A);
+  }
+  const y = Math.min(c - a, d - f);
+  return Number.isFinite(y) && y > 0 ? y : 0;
+}
+function ho(o, r, n = 0.99) {
+  const { normal: i } = bt(r, 0), a = Math.floor(o.length / 3);
+  if (a < 1) return 0;
+  const c = new Float64Array(a);
+  for (let d = 0; d < a; d++)
+    c[d] = i[0] * o[d * 3] + i[1] * o[d * 3 + 1] + i[2] * o[d * 3 + 2];
+  c.sort();
+  const f = Math.min(a - 1, Math.max(0, Math.floor((a - 1) * n)));
+  return c[f];
+}
+function sn(o, r, n, i, a = 0.99) {
+  if (!(i > 0)) return null;
+  const { normal: c } = bt(n, 0), { x: f, y: d } = Lt(c), y = i * i, m = [], v = Math.floor(o.length / 3);
+  for (let g = 0; g < v; g++) {
+    const b = o[g * 3] - r[0], E = o[g * 3 + 1] - r[1], M = o[g * 3 + 2] - r[2], R = b * f[0] + E * f[1] + M * f[2], w = b * d[0] + E * d[1] + M * d[2];
+    R * R + w * w > y || m.push(c[0] * o[g * 3] + c[1] * o[g * 3 + 1] + c[2] * o[g * 3 + 2]);
+  }
+  if (m.length < 8) return null;
+  m.sort((g, b) => g - b);
+  const A = Math.min(m.length - 1, Math.max(0, Math.floor((m.length - 1) * a)));
+  return m[A];
+}
+function an(o, r, n, i = "z-up") {
+  const { positions: a, indices: c } = o, f = c.length / 3;
+  if (f < 1) return null;
+  const d = [0, 0, 0], y = [0, 0, 0];
+  let m = 0, v = 0;
+  const A = [1 / 0, 1 / 0, 1 / 0], g = [-1 / 0, -1 / 0, -1 / 0], b = [];
+  for (let V = 0; V < a.length; V += 3) {
+    const C = [a[V], a[V + 1], a[V + 2]];
+    b.push(C), C[0] < A[0] && (A[0] = C[0]), C[1] < A[1] && (A[1] = C[1]), C[2] < A[2] && (A[2] = C[2]), C[0] > g[0] && (g[0] = C[0]), C[1] > g[1] && (g[1] = C[1]), C[2] > g[2] && (g[2] = C[2]);
+  }
+  for (let V = 0; V < f; V++) {
+    const C = c[V * 3], j = c[V * 3 + 1], O = c[V * 3 + 2], U = a[C * 3], L = a[C * 3 + 1], D = a[C * 3 + 2], J = a[j * 3], X = a[j * 3 + 1], rt = a[j * 3 + 2], H = a[O * 3], G = a[O * 3 + 1], Y = a[O * 3 + 2], mt = J - U, ft = X - L, ut = rt - D, Pt = H - U, Ct = G - L, _t = Y - D, At = ft * _t - ut * Ct, Wt = ut * Pt - mt * _t, Mt = mt * Ct - ft * Pt, xt = 0.5 * Math.hypot(At, Wt, Mt);
+    if (xt < 1e-14) continue;
+    const Tt = 1 / (2 * xt);
+    d[0] += At * Tt * xt, d[1] += Wt * Tt * xt, d[2] += Mt * Tt * xt, y[0] += (U + J + H) / 3, y[1] += (L + X + G) / 3, y[2] += (D + rt + Y) / 3, m += xt, v++;
+  }
+  if (v === 0 || m < 1e-14) return null;
+  y[0] /= v, y[1] /= v, y[2] /= v;
+  const E = Math.hypot(d[0], d[1], d[2]), R = E < m * 0.2 ? uo(b) : null, w = i === "y-up" ? [0, 1, 0] : [0, 0, 1], _ = R ?? (E > 1e-12 ? [d[0] / E, d[1] / E, d[2] / E] : w), F = [n[0] - r[0], n[1] - r[1], n[2] - r[2]], z = Math.hypot(F[0], F[1], F[2]);
+  z > 1e-12 && (_[0] * F[0] + _[1] * F[1] + _[2] * F[2]) / z < 0 && (_[0] = -_[0], _[1] = -_[1], _[2] = -_[2]);
+  let $ = lo(b, _, y);
+  $ > 1e-12 || ($ = m * 0.5);
+  let k = 1 / 0, T = -1 / 0;
+  for (const V of b) {
+    const C = _[0] * (V[0] - y[0]) + _[1] * (V[1] - y[1]) + _[2] * (V[2] - y[2]);
+    C < k && (k = C), C > T && (T = C);
+  }
+  return Number.isFinite(k) || (k = 0, T = 0), {
+    center: y,
+    normal: _,
+    area: $,
+    span: fo(b, _),
+    along: { min: k, max: T },
+    bbox: { min: A, max: g }
+  };
+}
+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, a, c = 0) {
+  return yn(n, i, a, c);
+}
+function mo(o, r, n) {
+  const { normal: i } = bt(n, 0), a = [r[0] - o[0], r[1] - o[1], r[2] - o[2]];
+  return Math.abs(a[0] * i[0]) + Math.abs(a[1] * i[1]) + Math.abs(a[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 a = 0; a < r.length; a += 3)
+    r[a] < n[0] && (n[0] = r[a]), r[a + 1] < n[1] && (n[1] = r[a + 1]), r[a + 2] < n[2] && (n[2] = r[a + 2]), r[a] > i[0] && (i[0] = r[a]), r[a + 1] > i[1] && (i[1] = r[a + 1]), r[a + 2] > i[2] && (i[2] = r[a + 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), a = n[0] * i[0] + n[1] * i[1] + n[2] * i[2];
+  if (a > 0.999999) return [0, 0, 0, 1];
+  if (a < -0.999999) {
+    let v = 0, A = 1, g = 0;
+    Math.abs(n[1]) < 0.9 ? (v = 0, A = 1, g = 0) : (v = 1, A = 0, g = 0);
+    let b = n[1] * g - n[2] * A, E = n[2] * v - n[0] * g, M = n[0] * A - n[1] * v;
+    const R = Math.hypot(b, E, M) || 1;
+    return b /= R, E /= R, M /= R, [b, E, M, 0];
+  }
+  let c = 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], y = 1 + a;
+  const m = Math.hypot(c, f, d, y) || 1;
+  return [c / m, f / m, d / m, y / m];
+}
+function go(o, r) {
+  const [n, i, a, c] = o, f = c * r[0] + i * r[2] - a * r[1], d = c * r[1] + a * r[0] - n * r[2], y = c * r[2] + n * r[1] - i * r[0], m = -n * r[0] - i * r[1] - a * r[2];
+  return [
+    f * c + m * -n + d * -a - y * -i,
+    d * c + m * -i + y * -n - f * -a,
+    y * c + m * -a + f * -i - d * -n
+  ];
+}
+function bo(o, r, n, i) {
+  const a = mn(o, r), [c, f, d, y] = a, m = c + c, v = f + f, A = d + d, g = c * m, b = c * v, E = c * A, M = f * v, R = f * A, w = d * A, _ = y * m, F = y * v, z = y * A, $ = n;
+  return [
+    (1 - (M + w)) * $,
+    (b + z) * $,
+    (E - F) * $,
+    0,
+    (b - z) * $,
+    (1 - (g + w)) * $,
+    (R + _) * $,
+    0,
+    (E + F) * $,
+    (R - _) * $,
+    (1 - (g + M)) * $,
+    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 a = (i + 1) % 3, c = (i + 2) % 3, f = Math.max(o[a], o[c], 1e-9), d = Math.abs(o[a] - o[c]) / f, y = Math.max(o[0], o[1], o[2], 1e-9), m = d * 10 + o[i] / y;
+    m < n && (n = m, r = i);
+  }
+  return r;
+}
+function cn(o) {
+  if (o.length < 8) return null;
+  let n = 0, i = 0, a = 0, c = 0, f = 0, d = 0, y = 0, m = 0, v = 0, A = 0, g = 0, b = 0, E = 0, M = 0;
+  for (const $ of o) {
+    const k = $[0], T = $[1], V = $[2], C = k * k + T * T + V * V, j = 2 * k, O = 2 * T, U = 2 * V;
+    n += j * j, i += j * O, a += j * U, c += j, f += O * O, d += O * U, y += O, m += U * U, v += U, A += 1, g += j * C, b += O * C, E += U * C, M += C;
+  }
+  const R = [
+    [n, i, a, c, g],
+    [i, f, d, y, b],
+    [a, d, m, v, E],
+    [c, y, v, A, M]
+  ];
+  for (let $ = 0; $ < 4; $++) {
+    let k = $;
+    for (let C = $ + 1; C < 4; C++) Math.abs(R[C][$]) > Math.abs(R[k][$]) && (k = C);
+    if (Math.abs(R[k][$]) < 1e-12) return null;
+    const T = R[$];
+    R[$] = R[k], R[k] = T;
+    const V = R[$][$];
+    for (let C = $; C < 5; C++) R[$][C] /= V;
+    for (let C = 0; C < 4; C++) {
+      if (C === $) continue;
+      const j = R[C][$];
+      for (let O = $; O < 5; O++) R[C][O] -= j * R[$][O];
+    }
+  }
+  const w = R[0][4], _ = R[1][4], F = R[2][4], z = Math.sqrt(Math.max(0, R[3][4] + w * w + _ * _ + F * F));
+  return !(z > 1e-6) || !Number.isFinite(z) ? null : { center: [w, _, F], radius: z };
+}
+function _o(o) {
+  const r = cn(o);
+  if (!r) return null;
+  const n = o.filter((i) => {
+    const a = Math.hypot(i[0] - r.center[0], i[1] - r.center[1], i[2] - r.center[2]);
+    return Math.abs(a - 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), a = o.positions, c = a.length / 3;
+  if (c < 8) throw new Error("爪扣网格为空");
+  const f = [0, 0, 0];
+  for (let H = 0; H < c; H++)
+    f[0] += a[H * 3], f[1] += a[H * 3 + 1], f[2] += a[H * 3 + 2];
+  const d = [f[0] / c, f[1] / c, f[2] / c], y = [0, 0, 0];
+  y[i] = 1;
+  const m = (H, G) => (a[H * 3] - d[0]) * G[0] + (a[H * 3 + 1] - d[1]) * G[1] + (a[H * 3 + 2] - d[2]) * G[2], v = (H, G) => {
+    const Y = a[H * 3] - d[0], mt = a[H * 3 + 1] - d[1], ft = a[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 A = 1 / 0, g = -1 / 0;
+  for (let H = 0; H < c; H++) {
+    const G = m(H, y);
+    G < A && (A = G), G > g && (g = G);
+  }
+  const E = Math.max(g - A, 1e-9) * 0.08;
+  let M = 1 / 0, R = 1 / 0;
+  for (let H = 0; H < c; H++) {
+    const G = m(H, y), Y = v(H, y);
+    G <= A + E && Y < M && (M = Y), G >= g - E && Y < R && (R = Y);
+  }
+  const w = M <= R ? y : [-y[0], -y[1], -y[2]];
+  let _ = 1 / 0, F = -1 / 0, z = 0;
+  const $ = new Array(c), k = new Array(c);
+  for (let H = 0; H < c; H++) {
+    const G = m(H, w), Y = v(H, w);
+    $[H] = G, k[H] = Y, G < _ && (_ = G), G > F && (F = G), Y > z && (z = Y);
+  }
+  const T = Math.max(F - _, 1e-9), V = [];
+  for (let H = 0; H < c; H++) {
+    const G = ($[H] - _) / T, Y = k[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;
+    V.push([a[H * 3], a[H * 3 + 1], a[H * 3 + 2]]);
+  }
+  const C = _o(V);
+  if (!C) throw new Error(r === "peg" ? "爪扣未能识别球头" : "爪扣未能识别凹窝");
+  const j = [C.center[0] - d[0], C.center[1] - d[1], C.center[2] - d[2]], O = j[0] * w[0] + j[1] * w[1] + j[2] * w[2], U = [
+    d[0] + w[0] * O,
+    d[1] + w[1] * O,
+    d[2] + w[2] * O
+  ];
+  let L = 0, D = 0, J = -1 / 0;
+  for (let H = 0; H < c; H++) {
+    const G = ($[H] - _) / T, Y = k[H];
+    G < 0.12 && Y > L && (L = Y), G >= 0.22 && G <= 0.82 && Y > D && (D = Y);
+  }
+  L > 0 || (L = z), D > 0 || (D = L);
+  const X = Math.max(D * 1.15, L * 0.7);
+  for (let H = 0; H < c; H++)
+    k[H] < X || $[H] > O || $[H] > J && (J = $[H]);
+  const rt = Number.isFinite(J) ? Math.max(J - _, T * 0.04) : T * 0.08;
+  return {
+    axis: w,
+    center: U,
+    radius: C.radius,
+    flangeRadius: L,
+    bodyRadius: D,
+    base: _ - O,
+    tip: F - O,
+    flangeThickness: rt
+  };
+}
+function ln(o, r, n, i) {
+  const { normal: a } = bt(r, 0), c = go(mn(o.axis, a), [
+    o.center[0] * i,
+    o.center[1] * i,
+    o.center[2] * i
+  ]);
+  return bo(o.axis, a, i, [
+    n[0] - c[0],
+    n[1] - c[1],
+    n[2] - c[2]
+  ]);
+}
+function Mo(o, r, n) {
+  const i = de(o, "socket"), a = de(r, "peg");
+  return !(a.radius > 1e-6) || !(n > 0) ? 0 : Math.max(0, i.tip) * (n / (a.radius * 2));
+}
+function wo(o) {
+  return o > 0 ? Math.min(0.25, o * 0.2) : 0;
+}
+function Te(o, r, n, i, a) {
+  const { normal: c } = bt(r, 0), f = c[0] * o[0] + c[1] * o[1] + c[2] * o[2], d = n + i - a - f;
+  return [o[0] + c[0] * d, o[1] + c[1] * d, o[2] + c[2] * d];
+}
+function $o(o, r, n, i, a, c = i) {
+  const f = de(o, "socket"), d = de(r, "peg");
+  if (!(d.radius > 1e-6) || !(a > 1e-9)) throw new Error("爪扣尺寸无效");
+  const y = a / (d.radius * 2), { normal: m } = bt(n, 0), v = [-m[0], -m[1], -m[2]], A = f.base + Math.max(f.flangeThickness * 1.25, Math.abs(f.base) * 0.05), g = f.tip + f.radius * 0.12, b = Math.max(g - A, f.radius), E = (A + g) / 2, M = Math.min(Math.max(f.bodyRadius * 1.05, f.radius * 1.15), f.flangeRadius * 0.88) * y;
+  return {
+    aoMatrix: ln(f, v, i, y),
+    tuMatrix: ln(d, m, c, y),
+    scale: y,
+    clearRadius: M,
+    clearLength: b * y,
+    clearCenter: [
+      i[0] + v[0] * E * y,
+      i[1] + v[1] * E * y,
+      i[2] + v[2] * E * y
+    ]
+  };
+}
+let Se = null, Ae = null;
+async function Zt() {
+  if (Se) return Se;
+  if (!Ae)
+    throw new Error("几何内核 WASM 未传入 Worker");
+  const o = await Yr({
+    wasmBinary: Ae,
+    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, a = new Float32Array(i * 3);
+  for (let c = 0; c < i; c++)
+    a[c * 3] = r.vertProperties[c * n], a[c * 3 + 1] = r.vertProperties[c * n + 1], a[c * 3 + 2] = r.vertProperties[c * n + 2];
+  return { positions: a, indices: new Uint32Array(r.triVerts) };
+}
+function Ft(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 = Ft(o, r, n);
+  }
+  if (!i) throw new Error("爪扣网格无法构建实体");
+  const a = i.decompose();
+  if (a.length <= 1) {
+    for (const f of a) f.delete();
+    return i;
+  }
+  i.delete();
+  let c = a[0];
+  for (let f = 1; f < a.length; f++) {
+    const d = c.add(a[f]);
+    c.delete(), a[f].delete(), c = d;
+  }
+  if (c.status() !== "NoError")
+    throw c.delete(), new Error("爪扣网格无法构建实体");
+  return c;
+}
+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 a = Ft(o, i.positions, i.indices);
+  if (!a)
+    try {
+      const f = o.Manifold.hull(
+        Array.from({ length: i.positions.length / 3 }, (y, m) => [
+          i.positions[m * 3],
+          i.positions[m * 3 + 1],
+          i.positions[m * 3 + 2]
+        ])
+      ), d = at(f);
+      return f.delete(), d;
+    } catch {
+      return i;
+    }
+  const c = at(a);
+  return a.delete(), c;
+}
+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, a, c, f, d, y, m, v, A) {
+  const g = r.intersect(n), b = Math.abs(g.volume());
+  if (!(b > 1e-10))
+    throw g.delete(), new Error("无有效交集");
+  const E = f >= d, M = E ? r : n, R = E ? n : r, w = E ? [-c.normal[0], -c.normal[1], -c.normal[2]] : [c.normal[0], c.normal[1], c.normal[2]], _ = c.center, F = at(g), z = c.bbox ?? $t(F.positions, F.indices).bbox, $ = po(b, c.area), k = Math.max(mo(z.min, z.max, w), 1e-3), T = Math.sqrt(Math.max(c.area, 1e-6)), V = Math.max(Math.cbrt(b), T * 0.25, 1e-3), C = R.subtract(M);
+  let j = C.add(g);
+  C.delete();
+  let O;
+  if ($) {
+    const L = 1 + Math.max(k * 0.15, T * 0.01, 1e-3) / V, D = fn(g, _, L);
+    O = M.subtract(D), D.delete();
+  } else {
+    const U = Math.max(T * 0.04, k * 0.06, 0.15), L = 1 + U / V;
+    let D = fn(g, _, L);
+    const J = k * 0.35 + U, X = D.translate([w[0] * J, w[1] * J, w[2] * J]);
+    D.delete(), D = X, O = M.subtract(D), D.delete();
+  }
+  if (g.delete(), y === "sphere" || y === "square" || y === "ballSnap" || y === "qiuSnap") {
+    const U = c.span && c.span > 1e-9 ? pn(c.span, m) : yo(c.area, v, z.min, z.max, w, m);
+    if (U > 1e-12)
+      try {
+        const D = ho(at(j).positions, w, 0.99) - (w[0] * _[0] + w[1] * _[1] + w[2] * _[2]), J = ao(_, w, U, D), X = y === "ballSnap" || y === "qiuSnap" ? at(M).positions : void 0, rt = gn(
+          o,
+          O,
+          j,
+          w,
+          J,
+          y,
+          U,
+          A,
+          !0,
+          _,
+          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 a = o.intersect(r);
+  if (Math.abs(a.volume()) > 1e-10) return a;
+  a.delete();
+  const c = i[0] - n[0], f = i[1] - n[1], d = i[2] - n[2], y = Math.hypot(c, f, d) || 1, m = Math.max(1e-3, y * 2e-3), v = c / y * m, A = f / y * m, g = d / y * m;
+  for (const b of [1, -1]) {
+    const E = o.translate([v * b, A * b, g * b]), M = E.intersect(r);
+    if (E.delete(), Math.abs(M.volume()) > 1e-10) return M;
+    M.delete();
+  }
+  return null;
+}
+function To(o, r, n, i, a, c, f, d, y = !1) {
+  const m = en(c.ao.positions, c.ao.indices), v = en(c.tu.positions, c.tu.indices), A = Mo(m, v, a), { normal: g } = bt(i, 0), b = g[0] * f[0] + g[1] * f[1] + g[2] * f[2];
+  let E = f, M = f;
+  if (A > 0 && y) {
+    const C = Te(f, g, b, A, wo(A));
+    E = C, M = C;
+  } else if (A > 0) {
+    const j = sn(
+      d ?? at(r).positions,
+      f,
+      g,
+      Math.max(a * 0.55, 1),
+      0.04
+    ), O = sn(
+      at(n).positions,
+      f,
+      g,
+      Math.max(a * 1.25, 1e-3),
+      0.95
+    );
+    let L = (O ?? b) - 0.25;
+    j != null && L > j && (L = j), E = Te(f, g, L, A, 0), M = O != null ? Te(f, g, O, A, 0.25) : E;
+  }
+  const R = $o(m, v, g, E, a, M), w = un(o, m.positions, m.indices), _ = un(o, v.positions, v.indices), F = w.transform(R.aoMatrix);
+  w.delete();
+  const z = _.transform(R.tuMatrix);
+  _.delete();
+  const $ = o.Manifold.cylinder(R.clearLength, R.clearRadius, R.clearRadius, 48, !0).transform(
+    fe(i, R.clearCenter)
+  ), k = r.subtract($);
+  r.delete(), $.delete();
+  const T = k.add(F);
+  k.delete(), F.delete();
+  const V = n.add(z);
+  return n.delete(), z.delete(), { pos: T, neg: V };
+}
+function gn(o, r, n, i, a, c, f, d, y = !1, m, v, A = !1) {
+  const g = y ? a : so(a, i, f), b = fe(i, g), E = oo(f);
+  if (c === "qiuSnap" || c === "ballSnap") {
+    if (!d) throw new Error("爪扣模型未加载");
+    return To(
+      o,
+      r,
+      n,
+      i,
+      f,
+      d,
+      m ?? a,
+      v,
+      A
+    );
+  }
+  if (c === "sphere") {
+    const z = f / 2, $ = z + E, k = o.Manifold.sphere($, 28).transform(b), T = o.Manifold.cylinder(f, $, $, 28, !0).transform(b), V = k.add(T);
+    k.delete(), T.delete();
+    const C = o.Manifold.sphere(z, 28).transform(b), j = r.subtract(V), O = n.add(C);
+    return r.delete(), n.delete(), V.delete(), C.delete(), { pos: j, neg: O };
+  }
+  const M = f + 2 * E, R = o.Manifold.cube([M, M, M], !0).transform(b), w = o.Manifold.cube([f, f, f], !0).transform(b), _ = r.subtract(R), F = n.add(w);
+  return r.delete(), n.delete(), R.delete(), w.delete(), { pos: _, neg: F };
+}
+function So(o, r, n, i) {
+  let a;
+  if (r === "box")
+    a = o.Manifold.cube([n[0] || 10, n[1] || 10, n[2] || 10], !0);
+  else if (r === "cylinder")
+    a = o.Manifold.cylinder(n[1] || 20, n[0] || 5, n[0] || 5, 32, !0);
+  else if (r === "sphere")
+    a = o.Manifold.sphere(n[0] || 8, 24);
+  else {
+    const c = Math.max(3, Math.floor(n[2] || 6)), f = n[0] || 8, d = n[1] || 16, y = Array.from({ length: c }, (m, v) => {
+      const A = v / c * Math.PI * 2;
+      return [Math.cos(A) * f, Math.sin(A) * f];
+    });
+    a = o.Manifold.extrude([y], d, 0, 0, [1, 1], !0);
+  }
+  return a.transform(i);
+}
+function St(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 a = nn(i.positions, r.transform);
+      return { solid: Ft(o, a, i.indices), buffers: { positions: a, 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 = St(o, r.node, n);
+      if (i.solid) {
+        const a = i.solid.transform(r.transform);
+        return i.solid.delete(), { solid: a, buffers: at(a) };
+      }
+      return {
+        solid: null,
+        buffers: {
+          positions: nn(i.buffers.positions, r.transform),
+          indices: i.buffers.indices
+        }
+      };
+    }
+    case "clean": {
+      const i = St(o, r.node, n), a = Fe(o, i.buffers.positions, i.buffers.indices);
+      return i.solid?.delete(), { solid: Ft(o, a.positions, a.indices), buffers: a };
+    }
+    case "simplify": {
+      const i = St(o, r.node, n);
+      if (i.solid) {
+        const a = i.solid.boundingBox(), c = Math.hypot(
+          a.max[0] - a.min[0],
+          a.max[1] - a.min[1],
+          a.max[2] - a.min[2]
+        ), f = i.solid.simplify(c * (1 - r.targetRatio) * 0.02);
+        return i.solid.delete(), { solid: f, buffers: at(f) };
+      }
+      return i;
+    }
+    case "sliceBase": {
+      const i = St(o, r.node, n);
+      if (i.solid) {
+        const a = r.axis === "x" ? [1, 0, 0] : r.axis === "y" ? [0, 1, 0] : [0, 0, 1], c = i.solid.trimByPlane(a, r.height);
+        return i.solid.delete(), { solid: c, buffers: at(c) };
+      }
+      return i;
+    }
+    case "trimPlane": {
+      const i = St(o, r.node, n);
+      let a = i;
+      if (!a.solid) {
+        const c = Fe(o, a.buffers.positions, a.buffers.indices);
+        i.solid?.delete(), a = {
+          solid: Ft(o, c.positions, c.indices),
+          buffers: c
+        };
+      }
+      if (a.solid) {
+        const c = Math.hypot(r.normal[0], r.normal[1], r.normal[2]) || 1, f = [
+          r.normal[0] / c,
+          r.normal[1] / c,
+          r.normal[2] / c
+        ], d = a.solid.trimByPlane(f, r.offset / c);
+        return a.solid.delete(), { solid: d, buffers: at(d) };
+      }
+      return a;
+    }
+    case "boolean": {
+      const i = St(o, r.a, n), a = St(o, r.b, n), c = (y) => {
+        if (y.solid) return y;
+        const m = Fe(o, y.buffers.positions, y.buffers.indices);
+        return { solid: Ft(o, m.positions, m.indices), buffers: m };
+      }, f = c(i), d = c(a);
+      if (f.solid && d.solid) {
+        const y = 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: y, buffers: at(y) };
+      }
+      return f.solid?.delete(), d.solid?.delete(), f;
+    }
+    case "merge": {
+      const i = r.nodes.map((c) => St(o, c, n)), a = i.map((c) => c.solid).filter((c) => !!c);
+      if (a.length) {
+        const c = a.length === 1 ? a[0] : o.Manifold.union(a);
+        return i.forEach((f, d) => {
+          (a.length > 1 || d > 0) && f.solid?.delete();
+        }), { solid: c, buffers: at(c) };
+      }
+      return i[0] ?? { solid: null, buffers: { positions: new Float32Array(), indices: new Uint32Array() } };
+    }
+  }
+}
+function Fo(o, r, n) {
+  const i = [];
+  let a = 0, c = 0, f = 0, d = 0, y = 0, m = 0, v = 0, A = !1;
+  const g = [1 / 0, 1 / 0, 1 / 0], b = [-1 / 0, -1 / 0, -1 / 0];
+  let E = 1 / 0;
+  o.forEach((F, z) => {
+    const $ = $t(F.positions, F.indices);
+    a += $.triangleCount, c += $.vertexCount, f += $.volume, d += $.surfaceArea, y += $.openEdgeCount, m += $.nonManifoldEdgeCount, v += $.componentCount, A = A || $.invertedNormals, E = Math.min(E, Qr(F.positions, F.indices));
+    for (let k = 0; k < 3; k++)
+      g[k] = Math.min(g[k], $.bbox.min[k]), b[k] = Math.max(b[k], $.bbox.max[k]);
+  });
+  const M = y === 0, R = m === 0 && n.every(Boolean) && M, w = !n.every(Boolean) && M, _ = (F) => i.push(F);
+  return m > 0 ? _({
+    id: "nonmanifold",
+    level: "red",
+    title: "非流形边",
+    explanation: "一条边被超过两个三角形共享，切片器无法判断内外，这会导致打印件断成两截。",
+    count: m,
+    blocking: !0
+  }) : _({ id: "nonmanifold", level: "green", title: "流形边检查通过", explanation: "每条边最多被两个三角形共享。", blocking: !1 }), _(M ? { id: "watertight", level: "green", title: "水密检查通过", explanation: "网格封闭，可以计算体积。", blocking: !1 } : {
+    id: "watertight",
+    level: "red",
+    title: "表面不水密",
+    explanation: "存在开边或破洞，体积无法准确计算，切片时可能缺层。",
+    count: y,
+    blocking: !0
+  }), _(w ? {
+    id: "selfintersect",
+    level: "red",
+    title: "自相交或无法构建实体",
+    explanation: "三角形互相穿透或拓扑无法形成实体，布尔与切片均不可靠。",
+    blocking: !0
+  } : { id: "selfintersect", level: "green", title: "自交检查通过", explanation: "几何内核可以构造成实体。", blocking: !1 }), E > 0 && E < r ? _({
+    id: "thinwall",
+    level: "yellow",
+    title: "薄壁",
+    explanation: `最薄处约 ${E.toFixed(2)} mm，低于常用打印工艺下限，切片后可能消失。`,
+    blocking: !1
+  }) : _({ id: "thinwall", level: "green", title: "壁厚检查通过", explanation: "采样壁厚高于设定下限。", blocking: !1 }), v > o.length ? _({
+    id: "islands",
+    level: "yellow",
+    title: "浮空碎片",
+    explanation: "与主体不连通的游离几何体，打印时可能掉落或单独成件。",
+    count: v,
+    blocking: !1
+  }) : _({ id: "islands", level: "green", title: "连通性通过", explanation: "未发现多余的游离碎片。", blocking: !1 }), _(A ? {
+    id: "normals",
+    level: "yellow",
+    title: "法线反向",
+    explanation: "部分面朝向内侧，可能被切片器误判为空洞。",
+    blocking: !1
+  } : { id: "normals", level: "green", title: "法线方向正常", explanation: "体积符号为正，外法线朝外。", blocking: !1 }), {
+    items: i,
+    triangleCount: a,
+    vertexCount: c,
+    volumeMm3: Math.abs(f),
+    surfaceAreaMm2: d,
+    bbox: {
+      min: g,
+      max: b,
+      size: [b[0] - g[0], b[1] - g[1], b[2] - g[2]]
+    },
+    watertight: M,
+    manifold: R,
+    selfIntersect: w,
+    invertedNormals: A,
+    openEdgeCount: y,
+    nonManifoldEdgeCount: m,
+    componentCount: v,
+    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 && (Ae = r.wasmBinary), await Zt(), n({ id: r.id, type: "ready" });
+      return;
+    }
+    if (r.type === "evaluate") {
+      const i = await Zt(), a = [], c = [], f = [];
+      for (const m of r.roots) {
+        const v = St(i, m, r.sources);
+        a.push(v.buffers), c.push(!!v.solid && v.solid.status() === "NoError"), v.solid?.delete(), r.wantThicknessColors && f.push(to(v.buffers.positions, v.buffers.indices, r.wallMinMm));
+      }
+      const d = a.map((m, v) => eo(m.positions, m.indices, r.wallMinMm, v)), y = Fo(a, r.wallMinMm, c);
+      n({
+        id: r.id,
+        type: "evaluated",
+        meshes: a,
+        diagnosis: y,
+        thicknessColors: r.wantThicknessColors ? f : void 0,
+        defects: d
+      });
+      return;
+    }
+    if (r.type === "decompose") {
+      const i = await Zt(), a = Ft(i, r.mesh.positions, r.mesh.indices);
+      if (!a) {
+        n({ id: r.id, type: "decomposed", meshes: [r.mesh] });
+        return;
+      }
+      const c = a.decompose();
+      a.delete();
+      const f = c.map((d) => {
+        const y = at(d);
+        return d.delete(), y;
+      });
+      n({ id: r.id, type: "decomposed", meshes: f.length ? f : [r.mesh] });
+      return;
+    }
+    if (r.type === "splitByPlane") {
+      const i = await Zt(), a = Math.hypot(r.normal[0], r.normal[1], r.normal[2]) || 1, c = [r.normal[0] / a, r.normal[1] / a, r.normal[2] / a], f = r.offset / a;
+      let d = Ft(i, r.mesh.positions, r.mesh.indices);
+      if (!d) {
+        n({ id: r.id, type: "error", message: "当前网格无法构建实体，请先修复再拆件" });
+        return;
+      }
+      const y = 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 m = r.width, v = r.height, A = !!(m && v && m > 0 && v > 0), g = $t(r.mesh.positions, r.mesh.indices), b = Ht(r.mesh.positions);
+      let E = [r.center[0], r.center[1], r.center[2]], M = { min: g.bbox.min, max: g.bbox.max }, R = 0;
+      const w = ($) => {
+        if (!(Math.abs($.volume()) > 1e-10)) return;
+        const k = at($), T = [
+          b[0] + c[0],
+          b[1] + c[1],
+          b[2] + c[2]
+        ], V = an(k, b, T, r.upAxis ?? "z-up");
+        if (V && V.area > 1e-12) {
+          E = V.center, M = V.bbox, R = V.span;
+          return;
+        }
+        E = Ht(k.positions);
+        const C = $t(k.positions, k.indices);
+        M = { min: C.bbox.min, max: C.bbox.max };
+      };
+      let _, F;
+      if (A) {
+        const $ = y ? 1e-3 : Math.max(r.gapMm, 1e-3), k = i.Manifold.cube([m, v, $], !0).transform(
+          fe(c, r.center)
+        ), T = d.intersect(k);
+        if (!(Math.abs(T.volume()) > 1e-10)) {
+          T.delete(), k.delete();
+          const D = [at(d)];
+          d.delete(), n({ id: r.id, type: "splitByPlane", meshes: D });
+          return;
+        }
+        y && w(T), T.delete();
+        const C = d.subtract(k);
+        d.delete(), k.delete();
+        const j = C.decompose();
+        if (C.delete(), j.length < 2) {
+          const D = j.length ? [at(j[0])] : [r.mesh];
+          for (const J of j) J.delete();
+          n({ id: r.id, type: "splitByPlane", meshes: D });
+          return;
+        }
+        const O = [], U = [];
+        for (const D of j) {
+          const J = Ht(at(D).positions);
+          c[0] * J[0] + c[1] * J[1] + c[2] * J[2] >= f ? O.push(D) : U.push(D);
+        }
+        const L = (D) => {
+          let J = D[0];
+          for (let X = 1; X < D.length; X++) {
+            const rt = J.add(D[X]);
+            J.delete(), D[X].delete(), J = rt;
+          }
+          return J;
+        };
+        if (O.length && U.length)
+          _ = L(O), F = L(U);
+        else {
+          const D = j.map((J) => ({ p: J, vol: Math.abs(J.volume()) }));
+          D.sort((J, X) => X.vol - J.vol), _ = D[0].p, F = L(D.slice(1).map((J) => J.p));
+        }
+      } else {
+        if (y) {
+          const { x: T, y: V } = Lt(c);
+          let C = 1 / 0, j = -1 / 0, O = 1 / 0, U = -1 / 0;
+          const L = g.bbox.min, D = g.bbox.max;
+          for (const G of [L[0], D[0]])
+            for (const Y of [L[1], D[1]])
+              for (const mt of [L[2], D[2]]) {
+                const ft = G * T[0] + Y * T[1] + mt * T[2], ut = G * V[0] + Y * V[1] + mt * V[2];
+                ft < C && (C = ft), ft > j && (j = ft), ut < O && (O = ut), ut > U && (U = ut);
+              }
+          const J = Math.max(j - C, 1e-3) * 1.05, X = Math.max(U - O, 1e-3) * 1.05, rt = i.Manifold.cube([J, X, 1e-3], !0).transform(
+            fe(c, r.center)
+          ), H = d.intersect(rt);
+          w(H), H.delete(), rt.delete();
+        }
+        const $ = d.splitByPlane(c, f);
+        d.delete();
+        const k = y ? 0 : Math.max(0, r.gapMm) / 2;
+        if (_ = $[0], F = $[1], k > 1e-9) {
+          const T = _.trimByPlane(c, f + k), V = F.trimByPlane([-c[0], -c[1], -c[2]], -f + k);
+          _.delete(), F.delete(), _ = T, F = V;
+        }
+      }
+      if (y) {
+        const $ = R > 1e-9 ? pn(R, r.connectorSize) : yn(M.min, M.max, c, r.connectorSize);
+        if ($ > 1e-12)
+          try {
+            const k = gn(
+              i,
+              _,
+              F,
+              c,
+              E,
+              r.connector,
+              $,
+              r.qiuSnap,
+              !1,
+              E,
+              void 0,
+              !0
+            );
+            _ = k.pos, F = k.neg;
+          } catch (k) {
+            _.delete(), F.delete(), n({
+              id: r.id,
+              type: "error",
+              message: k instanceof Error ? `卡扣布尔失败：${k.message}` : "卡扣布尔失败"
+            });
+            return;
+          }
+      }
+      const z = [at(_), at(F)];
+      if (_.delete(), F.delete(), z.some(($) => !$.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(), a = r.meshes.length;
+      if (a < 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 c = [], f = [], d = [], y = [];
+      for (let M = 0; M < a; M++) {
+        const R = r.meshes[M], w = $t(R.positions, R.indices);
+        if (w.openEdgeCount > 0 || w.nonManifoldEdgeCount > 0) {
+          for (const F of c) F?.delete();
+          n({
+            id: r.id,
+            type: "error",
+            message: `零件 ${M + 1} 不是封闭实体，请先修复再装配`
+          });
+          return;
+        }
+        const _ = Ft(i, R.positions, R.indices);
+        if (!_) {
+          for (const F of c) F?.delete();
+          n({ id: r.id, type: "error", message: `零件 ${M + 1} 无法构建实体` });
+          return;
+        }
+        c.push(_), f.push(Ht(R.positions)), d.push(Math.abs(w.volume) || Math.abs(_.volume())), y.push({ min: w.bbox.min, max: w.bbox.max });
+      }
+      const m = [];
+      for (let M = 0; M < a; M++)
+        for (let R = M + 1; R < a; R++) {
+          if (!co(y[M], y[R], 1e-3)) continue;
+          const w = c[M], _ = c[R], F = Co(w, _, f[M], f[R]);
+          if (!F) continue;
+          const z = at(F), $ = Math.abs(F.volume());
+          F.delete();
+          const k = an(z, f[M], f[R], r.upAxis ?? "z-up");
+          !k || !(k.area > 1e-12) || !($ > 1e-10) || m.push({
+            idxA: M,
+            idxB: R,
+            center: k.center,
+            normal: k.normal,
+            area: k.area,
+            span: k.span,
+            along: k.along,
+            volume: $,
+            bbox: k.bbox
+          });
+        }
+      m.sort((M, R) => R.area - M.area);
+      const v = m.length ? m[0].area : 0, A = [];
+      let g = 0, b = 0;
+      for (const M of m) {
+        const R = c[M.idxA], w = c[M.idxB];
+        if (!R || !w) {
+          b++;
+          continue;
+        }
+        try {
+          const _ = R.intersect(w), F = Math.abs(_.volume()) > 1e-10;
+          if (_.delete(), !F) {
+            b++;
+            continue;
+          }
+          const z = Po(
+            i,
+            R,
+            w,
+            f[M.idxA],
+            f[M.idxB],
+            { center: M.center, normal: M.normal, area: M.area, span: M.span, along: M.along, bbox: M.bbox },
+            d[M.idxA],
+            d[M.idxB],
+            r.connector,
+            r.connectorSize,
+            v,
+            r.qiuSnap
+          );
+          c[M.idxA] = z.a, c[M.idxB] = z.b;
+          const $ = at(z.a), k = at(z.b);
+          f[M.idxA] = Ht($.positions), f[M.idxB] = Ht(k.positions), d[M.idxA] = Math.abs($t($.positions, $.indices).volume), d[M.idxB] = Math.abs($t(k.positions, k.indices).volume), y[M.idxA] = {
+            min: $t($.positions, $.indices).bbox.min,
+            max: $t($.positions, $.indices).bbox.max
+          }, y[M.idxB] = {
+            min: $t(k.positions, k.indices).bbox.min,
+            max: $t(k.positions, k.indices).bbox.max
+          }, A.push({
+            idxA: M.idxA,
+            idxB: M.idxB,
+            center: M.center,
+            normal: M.normal,
+            area: M.area
+          }), g++;
+        } catch {
+          b++;
+        }
+      }
+      if (g === 0 && m.length === 0) {
+        for (const M of c) M?.delete();
+        n({ id: r.id, type: "error", message: "未检测到零件间接触面，无法装配" });
+        return;
+      }
+      const E = [];
+      for (let M = 0; M < a; M++) {
+        const R = c[M];
+        if (!R) {
+          E.push(r.meshes[M]);
+          continue;
+        }
+        E.push(at(R)), R.delete();
+      }
+      n({
+        id: r.id,
+        type: "assembleByContacts",
+        meshes: E,
+        contacts: A,
+        applied: g,
+        skipped: b
+      });
+    }
+  } catch (i) {
+    n({ id: r.id, type: "error", message: i instanceof Error ? i.message : String(i) });
+  }
+};
+var Ao = /* @__PURE__ */ Object.freeze({
+  __proto__: null
+});