@tscircuit/cli 0.1.1909 → 0.1.1910

package/dist/cli/main.js

@@ -70540,9 +70540,88 @@ var require_gerber_to_svg = __commonJS((exports2, module2) => {
 
 // node_modules/fflate/esm/index.mjs
 import { createRequire as createRequire4 } from "module";
+function deflateSync(data, opts) {
+  return dopt(data, opts || {}, 0, 0);
+}
 function unzlibSync(data, opts) {
   return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
 }
+function strToU8(str, latin1) {
+  if (latin1) {
+    var ar_1 = new u8(str.length);
+    for (var i3 = 0;i3 < str.length; ++i3)
+      ar_1[i3] = str.charCodeAt(i3);
+    return ar_1;
+  }
+  if (te3)
+    return te3.encode(str);
+  var l3 = str.length;
+  var ar3 = new u8(str.length + (str.length >> 1));
+  var ai3 = 0;
+  var w4 = function(v4) {
+    ar3[ai3++] = v4;
+  };
+  for (var i3 = 0;i3 < l3; ++i3) {
+    if (ai3 + 5 > ar3.length) {
+      var n3 = new u8(ai3 + 8 + (l3 - i3 << 1));
+      n3.set(ar3);
+      ar3 = n3;
+    }
+    var c3 = str.charCodeAt(i3);
+    if (c3 < 128 || latin1)
+      w4(c3);
+    else if (c3 < 2048)
+      w4(192 | c3 >> 6), w4(128 | c3 & 63);
+    else if (c3 > 55295 && c3 < 57344)
+      c3 = 65536 + (c3 & 1023 << 10) | str.charCodeAt(++i3) & 1023, w4(240 | c3 >> 18), w4(128 | c3 >> 12 & 63), w4(128 | c3 >> 6 & 63), w4(128 | c3 & 63);
+    else
+      w4(224 | c3 >> 12), w4(128 | c3 >> 6 & 63), w4(128 | c3 & 63);
+  }
+  return slc(ar3, 0, ai3);
+}
+function zipSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var r4 = {};
+  var files = [];
+  fltn(data, "", r4, opts);
+  var o3 = 0;
+  var tot = 0;
+  for (var fn3 in r4) {
+    var _a4 = r4[fn3], file = _a4[0], p3 = _a4[1];
+    var compression = p3.level == 0 ? 0 : 8;
+    var f2 = strToU8(fn3), s2 = f2.length;
+    var com = p3.comment, m3 = com && strToU8(com), ms5 = m3 && m3.length;
+    var exl = exfl(p3.extra);
+    if (s2 > 65535)
+      err(11);
+    var d3 = compression ? deflateSync(file, p3) : file, l3 = d3.length;
+    var c3 = crc();
+    c3.p(file);
+    files.push(mrg(p3, {
+      size: file.length,
+      crc: c3.d(),
+      c: d3,
+      f: f2,
+      m: m3,
+      u: s2 != fn3.length || m3 && com.length != ms5,
+      o: o3,
+      compression
+    }));
+    o3 += 30 + s2 + exl + l3;
+    tot += 76 + 2 * (s2 + exl) + (ms5 || 0) + l3;
+  }
+  var out = new u8(tot + 22), oe3 = o3, cdl = tot - o3;
+  for (var i3 = 0;i3 < files.length; ++i3) {
+    var f2 = files[i3];
+    wzh(out, f2.o, f2, f2.f, f2.u, f2.c.length);
+    var badd = 30 + f2.f.length + exfl(f2.extra);
+    out.set(f2.c, f2.o + badd);
+    wzh(out, o3, f2, f2.f, f2.u, f2.c.length, f2.o, f2.m), o3 += 16 + badd + (f2.m ? f2.m.length : 0);
+  }
+  wzf(out, o3, files.length, cdl, oe3);
+  return out;
+}
 var require3, _a3, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, clim, freb = function(eb2, start) {
   var b3 = new u16(31);
   for (var i2 = 0;i2 < 31; ++i2) {
@@ -70590,7 +70669,7 @@ var require3, _a3, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb,
     }
   }
   return co3;
-}, flt, i2, i2, i2, i2, fdt, i2, flrm, fdrm, max = function(a2) {
+}, flt, i2, i2, i2, i2, fdt, i2, flm, flrm, fdm, fdrm, max = function(a2) {
   var m3 = a2[0];
   for (var i3 = 1;i3 < a2.length; ++i3) {
     if (a2[i3] > m3)
@@ -70759,13 +70838,406 @@ var require3, _a3, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb,
       final = 1, st3.m = lbt, st3.d = dm3, st3.n = dbt;
   } while (!final);
   return bt2 != buf.length && noBuf ? slc(buf, 0, bt2) : buf.subarray(0, bt2);
-}, et3, zls = function(d3, dict) {
+}, wbits = function(d3, p3, v4) {
+  v4 <<= p3 & 7;
+  var o3 = p3 / 8 | 0;
+  d3[o3] |= v4;
+  d3[o3 + 1] |= v4 >> 8;
+}, wbits16 = function(d3, p3, v4) {
+  v4 <<= p3 & 7;
+  var o3 = p3 / 8 | 0;
+  d3[o3] |= v4;
+  d3[o3 + 1] |= v4 >> 8;
+  d3[o3 + 2] |= v4 >> 16;
+}, hTree = function(d3, mb3) {
+  var t49 = [];
+  for (var i3 = 0;i3 < d3.length; ++i3) {
+    if (d3[i3])
+      t49.push({ s: i3, f: d3[i3] });
+  }
+  var s2 = t49.length;
+  var t210 = t49.slice();
+  if (!s2)
+    return { t: et3, l: 0 };
+  if (s2 == 1) {
+    var v4 = new u8(t49[0].s + 1);
+    v4[t49[0].s] = 1;
+    return { t: v4, l: 1 };
+  }
+  t49.sort(function(a2, b3) {
+    return a2.f - b3.f;
+  });
+  t49.push({ s: -1, f: 25001 });
+  var l3 = t49[0], r4 = t49[1], i02 = 0, i12 = 1, i22 = 2;
+  t49[0] = { s: -1, f: l3.f + r4.f, l: l3, r: r4 };
+  while (i12 != s2 - 1) {
+    l3 = t49[t49[i02].f < t49[i22].f ? i02++ : i22++];
+    r4 = t49[i02 != i12 && t49[i02].f < t49[i22].f ? i02++ : i22++];
+    t49[i12++] = { s: -1, f: l3.f + r4.f, l: l3, r: r4 };
+  }
+  var maxSym = t210[0].s;
+  for (var i3 = 1;i3 < s2; ++i3) {
+    if (t210[i3].s > maxSym)
+      maxSym = t210[i3].s;
+  }
+  var tr3 = new u16(maxSym + 1);
+  var mbt = ln3(t49[i12 - 1], tr3, 0);
+  if (mbt > mb3) {
+    var i3 = 0, dt3 = 0;
+    var lft = mbt - mb3, cst = 1 << lft;
+    t210.sort(function(a2, b3) {
+      return tr3[b3.s] - tr3[a2.s] || a2.f - b3.f;
+    });
+    for (;i3 < s2; ++i3) {
+      var i2_1 = t210[i3].s;
+      if (tr3[i2_1] > mb3) {
+        dt3 += cst - (1 << mbt - tr3[i2_1]);
+        tr3[i2_1] = mb3;
+      } else
+        break;
+    }
+    dt3 >>= lft;
+    while (dt3 > 0) {
+      var i2_2 = t210[i3].s;
+      if (tr3[i2_2] < mb3)
+        dt3 -= 1 << mb3 - tr3[i2_2]++ - 1;
+      else
+        ++i3;
+    }
+    for (;i3 >= 0 && dt3; --i3) {
+      var i2_3 = t210[i3].s;
+      if (tr3[i2_3] == mb3) {
+        --tr3[i2_3];
+        ++dt3;
+      }
+    }
+    mbt = mb3;
+  }
+  return { t: new u8(tr3), l: mbt };
+}, ln3 = function(n3, l3, d3) {
+  return n3.s == -1 ? Math.max(ln3(n3.l, l3, d3 + 1), ln3(n3.r, l3, d3 + 1)) : l3[n3.s] = d3;
+}, lc3 = function(c3) {
+  var s2 = c3.length;
+  while (s2 && !c3[--s2])
+    ;
+  var cl3 = new u16(++s2);
+  var cli = 0, cln = c3[0], cls = 1;
+  var w4 = function(v4) {
+    cl3[cli++] = v4;
+  };
+  for (var i3 = 1;i3 <= s2; ++i3) {
+    if (c3[i3] == cln && i3 != s2)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (;cls > 138; cls -= 138)
+          w4(32754);
+        if (cls > 2) {
+          w4(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w4(cln), --cls;
+        for (;cls > 6; cls -= 6)
+          w4(8304);
+        if (cls > 2)
+          w4(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w4(cln);
+      cls = 1;
+      cln = c3[i3];
+    }
+  }
+  return { c: cl3.subarray(0, cli), n: s2 };
+}, clen = function(cf3, cl3) {
+  var l3 = 0;
+  for (var i3 = 0;i3 < cl3.length; ++i3)
+    l3 += cf3[i3] * cl3[i3];
+  return l3;
+}, wfblk = function(out, pos, dat) {
+  var s2 = dat.length;
+  var o3 = shft(pos + 2);
+  out[o3] = s2 & 255;
+  out[o3 + 1] = s2 >> 8;
+  out[o3 + 2] = out[o3] ^ 255;
+  out[o3 + 3] = out[o3 + 1] ^ 255;
+  for (var i3 = 0;i3 < s2; ++i3)
+    out[o3 + i3 + 4] = dat[i3];
+  return (o3 + 4 + s2) * 8;
+}, wblk = function(dat, out, final, syms, lf3, df3, eb2, li3, bs3, bl3, p3) {
+  wbits(out, p3++, final);
+  ++lf3[256];
+  var _a4 = hTree(lf3, 15), dlt = _a4.t, mlb = _a4.l;
+  var _b4 = hTree(df3, 15), ddt = _b4.t, mdb = _b4.l;
+  var _c3 = lc3(dlt), lclt = _c3.c, nlc = _c3.n;
+  var _d3 = lc3(ddt), lcdt = _d3.c, ndc = _d3.n;
+  var lcfreq = new u16(19);
+  for (var i3 = 0;i3 < lclt.length; ++i3)
+    ++lcfreq[lclt[i3] & 31];
+  for (var i3 = 0;i3 < lcdt.length; ++i3)
+    ++lcfreq[lcdt[i3] & 31];
+  var _e3 = hTree(lcfreq, 7), lct = _e3.t, mlcb = _e3.l;
+  var nlcc = 19;
+  for (;nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl3 + 5 << 3;
+  var ftlen = clen(lf3, flt) + clen(df3, fdt) + eb2;
+  var dtlen = clen(lf3, dlt) + clen(df3, ddt) + eb2 + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs3 >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p3, dat.subarray(bs3, bs3 + bl3));
+  var lm3, ll3, dm3, dl2;
+  wbits(out, p3, 1 + (dtlen < ftlen)), p3 += 2;
+  if (dtlen < ftlen) {
+    lm3 = hMap(dlt, mlb, 0), ll3 = dlt, dm3 = hMap(ddt, mdb, 0), dl2 = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p3, nlc - 257);
+    wbits(out, p3 + 5, ndc - 1);
+    wbits(out, p3 + 10, nlcc - 4);
+    p3 += 14;
+    for (var i3 = 0;i3 < nlcc; ++i3)
+      wbits(out, p3 + 3 * i3, lct[clim[i3]]);
+    p3 += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it3 = 0;it3 < 2; ++it3) {
+      var clct = lcts[it3];
+      for (var i3 = 0;i3 < clct.length; ++i3) {
+        var len = clct[i3] & 31;
+        wbits(out, p3, llm[len]), p3 += lct[len];
+        if (len > 15)
+          wbits(out, p3, clct[i3] >> 5 & 127), p3 += clct[i3] >> 12;
+      }
+    }
+  } else {
+    lm3 = flm, ll3 = flt, dm3 = fdm, dl2 = fdt;
+  }
+  for (var i3 = 0;i3 < li3; ++i3) {
+    var sym = syms[i3];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p3, lm3[len + 257]), p3 += ll3[len + 257];
+      if (len > 7)
+        wbits(out, p3, sym >> 23 & 31), p3 += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p3, dm3[dst]), p3 += dl2[dst];
+      if (dst > 3)
+        wbits16(out, p3, sym >> 5 & 8191), p3 += fdeb[dst];
+    } else {
+      wbits16(out, p3, lm3[sym]), p3 += ll3[sym];
+    }
+  }
+  wbits16(out, p3, lm3[256]);
+  return p3 + ll3[256];
+}, deo, et3, dflt = function(dat, lvl, plvl, pre, post, st3) {
+  var s2 = st3.z || dat.length;
+  var o3 = new u8(pre + s2 + 5 * (1 + Math.ceil(s2 / 7000)) + post);
+  var w4 = o3.subarray(pre, o3.length - post);
+  var lst = st3.l;
+  var pos = (st3.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w4[0] = st3.r >> 3;
+    var opt = deo[lvl - 1];
+    var n3 = opt >> 13, c3 = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st3.p || new u16(32768), head = st3.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i4) {
+      return (dat[i4] ^ dat[i4 + 1] << bs1_1 ^ dat[i4 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25000);
+    var lf3 = new u16(288), df3 = new u16(32);
+    var lc_1 = 0, eb2 = 0, i3 = st3.i || 0, li3 = 0, wi3 = st3.w || 0, bs3 = 0;
+    for (;i3 + 2 < s2; ++i3) {
+      var hv2 = hsh(i3);
+      var imod = i3 & 32767, pimod = head[hv2];
+      prev[imod] = pimod;
+      head[hv2] = imod;
+      if (wi3 <= i3) {
+        var rem = s2 - i3;
+        if ((lc_1 > 7000 || li3 > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w4, 0, syms, lf3, df3, eb2, li3, bs3, i3 - bs3, pos);
+          li3 = lc_1 = eb2 = 0, bs3 = i3;
+          for (var j4 = 0;j4 < 286; ++j4)
+            lf3[j4] = 0;
+          for (var j4 = 0;j4 < 30; ++j4)
+            df3[j4] = 0;
+        }
+        var l3 = 2, d3 = 0, ch_1 = c3, dif = imod - pimod & 32767;
+        if (rem > 2 && hv2 == hsh(i3 - dif)) {
+          var maxn = Math.min(n3, rem) - 1;
+          var maxd = Math.min(32767, i3);
+          var ml2 = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i3 + l3] == dat[i3 + l3 - dif]) {
+              var nl3 = 0;
+              for (;nl3 < ml2 && dat[i3 + nl3] == dat[i3 + nl3 - dif]; ++nl3)
+                ;
+              if (nl3 > l3) {
+                l3 = nl3, d3 = dif;
+                if (nl3 > maxn)
+                  break;
+                var mmd = Math.min(dif, nl3 - 2);
+                var md3 = 0;
+                for (var j4 = 0;j4 < mmd; ++j4) {
+                  var ti3 = i3 - dif + j4 & 32767;
+                  var pti = prev[ti3];
+                  var cd3 = ti3 - pti & 32767;
+                  if (cd3 > md3)
+                    md3 = cd3, pimod = ti3;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d3) {
+          syms[li3++] = 268435456 | revfl[l3] << 18 | revfd[d3];
+          var lin = revfl[l3] & 31, din = revfd[d3] & 31;
+          eb2 += fleb[lin] + fdeb[din];
+          ++lf3[257 + lin];
+          ++df3[din];
+          wi3 = i3 + l3;
+          ++lc_1;
+        } else {
+          syms[li3++] = dat[i3];
+          ++lf3[dat[i3]];
+        }
+      }
+    }
+    for (i3 = Math.max(i3, wi3);i3 < s2; ++i3) {
+      syms[li3++] = dat[i3];
+      ++lf3[dat[i3]];
+    }
+    pos = wblk(dat, w4, lst, syms, lf3, df3, eb2, li3, bs3, i3 - bs3, pos);
+    if (!lst) {
+      st3.r = pos & 7 | w4[pos / 8 | 0] << 3;
+      pos -= 7;
+      st3.h = head, st3.p = prev, st3.i = i3, st3.w = wi3;
+    }
+  } else {
+    for (var i3 = st3.w || 0;i3 < s2 + lst; i3 += 65535) {
+      var e4 = i3 + 65535;
+      if (e4 >= s2) {
+        w4[pos / 8 | 0] = lst;
+        e4 = s2;
+      }
+      pos = wfblk(w4, pos + 1, dat.subarray(i3, e4));
+    }
+    st3.i = s2;
+  }
+  return slc(o3, 0, pre + shft(pos) + post);
+}, crct, crc = function() {
+  var c3 = -1;
+  return {
+    p: function(d3) {
+      var cr3 = c3;
+      for (var i3 = 0;i3 < d3.length; ++i3)
+        cr3 = crct[cr3 & 255 ^ d3[i3]] ^ cr3 >>> 8;
+      c3 = cr3;
+    },
+    d: function() {
+      return ~c3;
+    }
+  };
+}, dopt = function(dat, opt, pre, post, st3) {
+  if (!st3) {
+    st3 = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st3.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st3.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st3);
+}, mrg = function(a2, b3) {
+  var o3 = {};
+  for (var k4 in a2)
+    o3[k4] = a2[k4];
+  for (var k4 in b3)
+    o3[k4] = b3[k4];
+  return o3;
+}, wbytes = function(d3, b3, v4) {
+  for (;v4; ++b3)
+    d3[b3] = v4, v4 >>>= 8;
+}, zls = function(d3, dict) {
   if ((d3[0] & 15) != 8 || d3[0] >> 4 > 7 || (d3[0] << 8 | d3[1]) % 31)
     err(6, "invalid zlib data");
   if ((d3[1] >> 5 & 1) == +!dict)
     err(6, "invalid zlib data: " + (d3[1] & 32 ? "need" : "unexpected") + " dictionary");
   return (d3[1] >> 3 & 4) + 2;
-}, Inflate, Unzlib, td3, tds = 0;
+}, Inflate, Unzlib, fltn = function(d3, p3, t49, o3) {
+  for (var k4 in d3) {
+    var val = d3[k4], n3 = p3 + k4, op3 = o3;
+    if (Array.isArray(val))
+      op3 = mrg(o3, val[1]), val = val[0];
+    if (ArrayBuffer.isView(val))
+      t49[n3] = [val, op3];
+    else {
+      t49[n3 += "/"] = [new u8(0), op3];
+      fltn(val, n3, t49, o3);
+    }
+  }
+}, te3, td3, tds = 0, exfl = function(ex3) {
+  var le3 = 0;
+  if (ex3) {
+    for (var k4 in ex3) {
+      var l3 = ex3[k4].length;
+      if (l3 > 65535)
+        err(9);
+      le3 += l3 + 4;
+    }
+  }
+  return le3;
+}, wzh = function(d3, b3, f2, fn3, u4, c3, ce3, co3) {
+  var fl4 = fn3.length, ex3 = f2.extra, col = co3 && co3.length;
+  var exl = exfl(ex3);
+  wbytes(d3, b3, ce3 != null ? 33639248 : 67324752), b3 += 4;
+  if (ce3 != null)
+    d3[b3++] = 20, d3[b3++] = f2.os;
+  d3[b3] = 20, b3 += 2;
+  d3[b3++] = f2.flag << 1 | (c3 < 0 && 8), d3[b3++] = u4 && 8;
+  d3[b3++] = f2.compression & 255, d3[b3++] = f2.compression >> 8;
+  var dt3 = new Date(f2.mtime == null ? Date.now() : f2.mtime), y4 = dt3.getFullYear() - 1980;
+  if (y4 < 0 || y4 > 119)
+    err(10);
+  wbytes(d3, b3, y4 << 25 | dt3.getMonth() + 1 << 21 | dt3.getDate() << 16 | dt3.getHours() << 11 | dt3.getMinutes() << 5 | dt3.getSeconds() >> 1), b3 += 4;
+  if (c3 != -1) {
+    wbytes(d3, b3, f2.crc);
+    wbytes(d3, b3 + 4, c3 < 0 ? -c3 - 2 : c3);
+    wbytes(d3, b3 + 8, f2.size);
+  }
+  wbytes(d3, b3 + 12, fl4);
+  wbytes(d3, b3 + 14, exl), b3 += 16;
+  if (ce3 != null) {
+    wbytes(d3, b3, col);
+    wbytes(d3, b3 + 6, f2.attrs);
+    wbytes(d3, b3 + 10, ce3), b3 += 14;
+  }
+  d3.set(fn3, b3);
+  b3 += fl4;
+  if (exl) {
+    for (var k4 in ex3) {
+      var exf = ex3[k4], l3 = exf.length;
+      wbytes(d3, b3, +k4);
+      wbytes(d3, b3 + 2, l3);
+      d3.set(exf, b3 + 4), b3 += 4 + l3;
+    }
+  }
+  if (col)
+    d3.set(co3, b3), b3 += col;
+  return b3;
+}, wzf = function(o3, b3, c3, d3, e4) {
+  wbytes(o3, b3, 101010256);
+  wbytes(o3, b3 + 8, c3);
+  wbytes(o3, b3 + 10, c3);
+  wbytes(o3, b3 + 12, d3);
+  wbytes(o3, b3 + 16, e4);
+};
 var init_esm = __esm(() => {
   require3 = createRequire4("/");
   try {
@@ -70803,7 +71275,9 @@ var init_esm = __esm(() => {
   fdt = new u8(32);
   for (i2 = 0;i2 < 32; ++i2)
     fdt[i2] = 5;
+  flm = /* @__PURE__ */ hMap(flt, 9, 0);
   flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+  fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
   fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
   ec2 = [
     "unexpected EOF",
@@ -70821,7 +71295,18 @@ var init_esm = __esm(() => {
     "stream finishing",
     "invalid zip data"
   ];
+  deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
   et3 = /* @__PURE__ */ new u8(0);
+  crct = /* @__PURE__ */ function() {
+    var t49 = new Int32Array(256);
+    for (var i3 = 0;i3 < 256; ++i3) {
+      var c3 = i3, k4 = 9;
+      while (--k4)
+        c3 = (c3 & 1 && -306674912) ^ c3 >>> 1;
+      t49[i3] = c3;
+    }
+    return t49;
+  }();
   Inflate = /* @__PURE__ */ function() {
     function Inflate2(opts, cb3) {
       if (typeof opts == "function")
@@ -70880,6 +71365,7 @@ var init_esm = __esm(() => {
     };
     return Unzlib2;
   }();
+  te3 = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder;
   td3 = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
   try {
     td3.decode(et3, { stream: true });
@@ -71235,12 +71721,12 @@ function updateCrc(currentCrc, data, length67) {
   }
   return c3;
 }
-function crc(data, length67) {
+function crc2(data, length67) {
   return (updateCrc(initialCrc, data, length67) ^ initialCrc) >>> 0;
 }
 function checkCrc(buffer, crcLength, chunkName) {
   const expectedCrc = buffer.readUint32();
-  const actualCrc = crc(new Uint8Array(buffer.buffer, buffer.byteOffset + buffer.offset - crcLength - 4, crcLength), crcLength);
+  const actualCrc = crc2(new Uint8Array(buffer.buffer, buffer.byteOffset + buffer.offset - crcLength - 4, crcLength), crcLength);
   if (actualCrc !== expectedCrc) {
     throw new Error(`CRC mismatch for chunk ${chunkName}. Expected ${expectedCrc}, found ${actualCrc}`);
   }
@@ -77586,7 +78072,7 @@ import {
 } from "@tscircuit/math-utils";
 import { applyToPoint as applyToPoint29, identity as identity10 } from "transformation-matrix";
 import { convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg22 } from "circuit-to-svg";
-import { deflateSync } from "node:zlib";
+import { deflateSync as deflateSync2 } from "node:zlib";
 import {
   glyphAdvanceRatio as glyphAdvanceRatio3,
   glyphWidthRatio as glyphWidthRatio2,
@@ -78719,11 +79205,11 @@ var import_gerber_to_svg, renderTscircuitRepro = async (tsx, options = {}) => {
   return baseSvg.replace("</svg>", `${overlays}
 </svg>`);
 }, crcTable2, crc32 = (bytes) => {
-  let crc2 = 4294967295;
+  let crc3 = 4294967295;
   for (const byte of bytes) {
-    crc2 = crcTable2[(crc2 ^ byte) & 255] ^ crc2 >>> 8;
+    crc3 = crcTable2[(crc3 ^ byte) & 255] ^ crc3 >>> 8;
   }
-  return (crc2 ^ 4294967295) >>> 0;
+  return (crc3 ^ 4294967295) >>> 0;
 }, writeUInt32 = (value) => {
   const bytes = new Uint8Array(4);
   const view = new DataView(bytes.buffer);
@@ -78767,7 +79253,7 @@ var import_gerber_to_svg, renderTscircuitRepro = async (tsx, options = {}) => {
   return concatBytes([
     new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]),
     createChunk("IHDR", header),
-    createChunk("IDAT", deflateSync(scanlines, { level: 1 })),
+    createChunk("IDAT", deflateSync2(scanlines, { level: 1 })),
     createChunk("IEND", new Uint8Array)
   ]);
 }, getLegendLabel = (entry) => {
@@ -78850,11 +79336,11 @@ var init_dist3 = __esm(() => {
   import_gerber_to_svg = __toESM2(require_gerber_to_svg(), 1);
   crcTable2 = new Uint32Array(256);
   for (let i3 = 0;i3 < crcTable2.length; i3++) {
-    let crc2 = i3;
+    let crc3 = i3;
     for (let bit = 0;bit < 8; bit++) {
-      crc2 = crc2 & 1 ? 3988292384 ^ crc2 >>> 1 : crc2 >>> 1;
+      crc3 = crc3 & 1 ? 3988292384 ^ crc3 >>> 1 : crc3 >>> 1;
     }
-    crcTable2[i3] = crc2 >>> 0;
+    crcTable2[i3] = crc3 >>> 0;
   }
   textEncoder = new TextEncoder;
   markerLegend = [
@@ -122065,7 +122551,7 @@ var require_UPNG = __commonJS((exports2) => {
         break;
       }
       offset += len;
-      var crc2 = bin.readUint(data, offset);
+      var crc3 = bin.readUint(data, offset);
       offset += 4;
     }
     if (foff != 0) {
@@ -122649,7 +123135,7 @@ var require_UPNG = __commonJS((exports2) => {
   UPNG.encode._main = function(nimg, w4, h4, dels, tabs) {
     if (tabs == null)
       tabs = {};
-    var crc2 = UPNG.crc.crc, wUi = UPNG._bin.writeUint, wUs = UPNG._bin.writeUshort, wAs = UPNG._bin.writeASCII;
+    var crc3 = UPNG.crc.crc, wUi = UPNG._bin.writeUint, wUs = UPNG._bin.writeUshort, wAs = UPNG._bin.writeASCII;
     var offset = 8, anim = nimg.frames.length > 1, pltAlpha = false;
     var leng = 8 + (16 + 5 + 4) + (anim ? 20 : 0);
     if (tabs["sRGB"] != null)
@@ -122694,7 +123180,7 @@ var require_UPNG = __commonJS((exports2) => {
     offset++;
     data[offset] = 0;
     offset++;
-    wUi(data, offset, crc2(data, offset - 17, 17));
+    wUi(data, offset, crc3(data, offset - 17, 17));
     offset += 4;
     if (tabs["sRGB"] != null) {
       wUi(data, offset, 1);
@@ -122703,7 +123189,7 @@ var require_UPNG = __commonJS((exports2) => {
       offset += 4;
       data[offset] = tabs["sRGB"];
       offset++;
-      wUi(data, offset, crc2(data, offset - 5, 5));
+      wUi(data, offset, crc3(data, offset - 5, 5));
       offset += 4;
     }
     if (tabs["pHYs"] != null) {
@@ -122717,7 +123203,7 @@ var require_UPNG = __commonJS((exports2) => {
       offset += 4;
       data[offset] = tabs["pHYs"][2];
       offset++;
-      wUi(data, offset, crc2(data, offset - 13, 13));
+      wUi(data, offset, crc3(data, offset - 13, 13));
       offset += 4;
     }
     if (anim) {
@@ -122729,7 +123215,7 @@ var require_UPNG = __commonJS((exports2) => {
       offset += 4;
       wUi(data, offset, tabs["loop"] != null ? tabs["loop"] : 0);
       offset += 4;
-      wUi(data, offset, crc2(data, offset - 12, 12));
+      wUi(data, offset, crc3(data, offset - 12, 12));
       offset += 4;
     }
     if (nimg.ctype == 3) {
@@ -122745,7 +123231,7 @@ var require_UPNG = __commonJS((exports2) => {
         data[offset + ti3 + 2] = b3;
       }
       offset += dl2 * 3;
-      wUi(data, offset, crc2(data, offset - dl2 * 3 - 4, dl2 * 3 + 4));
+      wUi(data, offset, crc3(data, offset - dl2 * 3 - 4, dl2 * 3 + 4));
       offset += 4;
       if (pltAlpha) {
         wUi(data, offset, dl2);
@@ -122755,7 +123241,7 @@ var require_UPNG = __commonJS((exports2) => {
         for (var i3 = 0;i3 < dl2; i3++)
           data[offset + i3] = nimg.plte[i3] >>> 24 & 255;
         offset += dl2;
-        wUi(data, offset, crc2(data, offset - dl2 - 4, dl2 + 4));
+        wUi(data, offset, crc3(data, offset - dl2 - 4, dl2 + 4));
         offset += 4;
       }
     }
@@ -122785,7 +123271,7 @@ var require_UPNG = __commonJS((exports2) => {
         offset++;
         data[offset] = fr3.blend;
         offset++;
-        wUi(data, offset, crc2(data, offset - 30, 30));
+        wUi(data, offset, crc3(data, offset - 30, 30));
         offset += 4;
       }
       var imgd = fr3.cimg, dl2 = imgd.length;
@@ -122800,14 +123286,14 @@ var require_UPNG = __commonJS((exports2) => {
       }
       data.set(imgd, offset);
       offset += dl2;
-      wUi(data, offset, crc2(data, ioff, offset - ioff));
+      wUi(data, offset, crc3(data, ioff, offset - ioff));
       offset += 4;
     }
     wUi(data, offset, 0);
     offset += 4;
     wAs(data, offset, "IEND");
     offset += 4;
-    wUi(data, offset, crc2(data, offset - 4, 4));
+    wUi(data, offset, crc3(data, offset - 4, 4));
     offset += 4;
     return data.buffer;
   };
@@ -123226,7 +123712,7 @@ var require_UPNG = __commonJS((exports2) => {
         node.est.L = 0;
         continue;
       }
-      var ln3 = {
+      var ln4 = {
         i0: node.i0,
         i1: s02,
         bst: null,
@@ -123235,8 +123721,8 @@ var require_UPNG = __commonJS((exports2) => {
         left: null,
         right: null
       };
-      ln3.bst = UPNG.quantize.stats(nimg, ln3.i0, ln3.i1);
-      ln3.est = UPNG.quantize.estats(ln3.bst);
+      ln4.bst = UPNG.quantize.stats(nimg, ln4.i0, ln4.i1);
+      ln4.est = UPNG.quantize.estats(ln4.bst);
       var rn3 = {
         i0: s02,
         i1: node.i1,
@@ -123249,16 +123735,16 @@ var require_UPNG = __commonJS((exports2) => {
       rn3.bst = {
         R: [],
         m: [],
-        N: node.bst.N - ln3.bst.N
+        N: node.bst.N - ln4.bst.N
       };
       for (var i3 = 0;i3 < 16; i3++)
-        rn3.bst.R[i3] = node.bst.R[i3] - ln3.bst.R[i3];
+        rn3.bst.R[i3] = node.bst.R[i3] - ln4.bst.R[i3];
       for (var i3 = 0;i3 < 4; i3++)
-        rn3.bst.m[i3] = node.bst.m[i3] - ln3.bst.m[i3];
+        rn3.bst.m[i3] = node.bst.m[i3] - ln4.bst.m[i3];
       rn3.est = UPNG.quantize.estats(rn3.bst);
-      node.left = ln3;
+      node.left = ln4;
       node.right = rn3;
-      leafs[mi3] = ln3;
+      leafs[mi3] = ln4;
       leafs.push(rn3);
     }
     leafs.sort(function(a2, b3) {
@@ -123279,11 +123765,11 @@ var require_UPNG = __commonJS((exports2) => {
       node0 = nd2.right;
       node1 = nd2.left;
     }
-    var ln3 = UPNG.quantize.getNearest(node0, r4, g6, b3, a2);
-    if (ln3.tdst <= planeDst * planeDst)
-      return ln3;
+    var ln4 = UPNG.quantize.getNearest(node0, r4, g6, b3, a2);
+    if (ln4.tdst <= planeDst * planeDst)
+      return ln4;
     var rn3 = UPNG.quantize.getNearest(node1, r4, g6, b3, a2);
-    return rn3.tdst < ln3.tdst ? rn3 : ln3;
+    return rn3.tdst < ln4.tdst ? rn3 : ln4;
   };
   UPNG.quantize.planeDst = function(est, r4, g6, b3, a2) {
     var e4 = est.e;
@@ -135600,6 +136086,7 @@ var package_default = {
     "circuit-json-to-3d-png": "^0.0.6",
     "circuit-json-to-bom-csv": "^0.0.7",
     "circuit-json-to-connectivity-map": "^0.0.25",
+    "circuit-json-to-fdm-component-box": "^0.0.2",
     "circuit-json-to-footprinter": "^0.0.15",
     "circuit-json-to-gerber": "^0.0.94",
     "circuit-json-to-kicad": "0.0.157",
@@ -310607,6 +311094,3396 @@ var convertCircuitJsonToPickAndPlaceCsv = (circuitJson, opts = {}) => import_pap
   Rotation: row.rotation
 })));
 
+// node_modules/manifold-3d/manifold.js
+async function Module(moduleArg = {}) {
+  var moduleRtn;
+  var Module2 = moduleArg;
+  var ENVIRONMENT_IS_WEB = !!globalThis.window;
+  var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
+  var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
+  if (ENVIRONMENT_IS_NODE) {
+    const { createRequire: createRequire6 } = await import("node:module");
+    var require4 = createRequire6(import.meta.url);
+  }
+  var _ManifoldInitialized = false;
+  Module2.setup = function() {
+    if (_ManifoldInitialized)
+      return;
+    _ManifoldInitialized = true;
+    Module2.initTBB();
+    function toVec(vec, list, f2 = (x4) => x4) {
+      if (list) {
+        for (let x4 of list) {
+          vec.push_back(f2(x4));
+        }
+      }
+      return vec;
+    }
+    function fromVec(vec, f2 = (x4) => x4) {
+      const result = [];
+      const size = vec.size();
+      for (let i3 = 0;i3 < size; i3++)
+        result.push(f2(vec.get(i3)));
+      return result;
+    }
+    function vec2polygons(vec, f2 = (x4) => x4) {
+      const result = [];
+      const nPoly = vec.size();
+      for (let i3 = 0;i3 < nPoly; i3++) {
+        const v4 = vec.get(i3);
+        const nPts = v4.size();
+        const poly = [];
+        for (let j4 = 0;j4 < nPts; j4++) {
+          poly.push(f2(v4.get(j4)));
+        }
+        result.push(poly);
+      }
+      return result;
+    }
+    function polygons2vec(polygons) {
+      if (polygons[0].length < 3) {
+        polygons = [polygons];
+      }
+      return toVec(new Module2.Vector2_vec2, polygons, (poly) => toVec(new Module2.Vector_vec2, poly, (p3) => {
+        if (p3 instanceof Array)
+          return { x: p3[0], y: p3[1] };
+        return p3;
+      }));
+    }
+    function disposePolygons(polygonsVec) {
+      for (let i3 = 0;i3 < polygonsVec.size(); i3++)
+        polygonsVec.get(i3).delete();
+      polygonsVec.delete();
+    }
+    function vararg2vec2(vec) {
+      if (vec[0] instanceof Array)
+        return { x: vec[0][0], y: vec[0][1] };
+      if (typeof vec[0] == "number")
+        return { x: vec[0] || 0, y: vec[1] || 0 };
+      return vec[0];
+    }
+    function vararg2vec3(vec) {
+      if (vec[0] instanceof Array)
+        return { x: vec[0][0], y: vec[0][1], z: vec[0][2] };
+      if (typeof vec[0] == "number")
+        return { x: vec[0] || 0, y: vec[1] || 0, z: vec[2] || 0 };
+      return vec[0];
+    }
+    function fillRuleToInt(fillRule) {
+      return fillRule == "EvenOdd" ? 0 : fillRule == "NonZero" ? 1 : fillRule == "Negative" ? 3 : 2;
+    }
+    function joinTypeToInt(joinType) {
+      return joinType == "Round" ? 1 : joinType == "Miter" ? 2 : 0;
+    }
+    const CrossSectionCtor = Module2.CrossSection;
+    function cross3(polygons, fillRule = "Positive") {
+      if (polygons instanceof CrossSectionCtor) {
+        return polygons;
+      } else {
+        const polygonsVec = polygons2vec(polygons);
+        const cs3 = new CrossSectionCtor(polygonsVec, fillRuleToInt(fillRule));
+        disposePolygons(polygonsVec);
+        return cs3;
+      }
+    }
+    Module2.CrossSection.prototype.translate = function(...vec) {
+      return this._Translate(vararg2vec2(vec));
+    };
+    Module2.CrossSection.prototype.scale = function(vec) {
+      if (typeof vec == "number") {
+        return this._Scale({ x: vec, y: vec });
+      }
+      return this._Scale(vararg2vec2([vec]));
+    };
+    Module2.CrossSection.prototype.mirror = function(vec) {
+      return this._Mirror(vararg2vec2([vec]));
+    };
+    Module2.CrossSection.prototype.warp = function(func) {
+      const wasmFuncPtr = addFunction(function(vec2Ptr) {
+        const x4 = getValue(vec2Ptr, "double");
+        const y4 = getValue(vec2Ptr + 8, "double");
+        const vert = [x4, y4];
+        func(vert);
+        setValue(vec2Ptr, vert[0], "double");
+        setValue(vec2Ptr + 8, vert[1], "double");
+      }, "vi");
+      const out2 = this._Warp(wasmFuncPtr);
+      removeFunction(wasmFuncPtr);
+      return out2;
+    };
+    Module2.CrossSection.prototype.decompose = function() {
+      const vec = this._Decompose();
+      const result = fromVec(vec);
+      vec.delete();
+      return result;
+    };
+    Module2.CrossSection.prototype.bounds = function() {
+      const result = this._Bounds();
+      return { min: ["x", "y"].map((f2) => result.min[f2]), max: ["x", "y"].map((f2) => result.max[f2]) };
+    };
+    Module2.CrossSection.prototype.offset = function(delta, joinType = "Round", miterLimit = 2, circularSegments = 0) {
+      return this._Offset(delta, joinTypeToInt(joinType), miterLimit, circularSegments);
+    };
+    Module2.CrossSection.prototype.simplify = function(epsilon = 0.000001) {
+      return this._Simplify(epsilon);
+    };
+    Module2.CrossSection.prototype.extrude = function(height, nDivisions = 0, twistDegrees = 0, scaleTop = [1, 1], center2 = false) {
+      scaleTop = vararg2vec2([scaleTop]);
+      const man = Module2._Extrude(this._ToPolygons(), height, nDivisions, twistDegrees, scaleTop);
+      return center2 ? man.translate([0, 0, -height / 2]) : man;
+    };
+    Module2.CrossSection.prototype.revolve = function(circularSegments = 0, revolveDegrees = 360) {
+      return Module2._Revolve(this._ToPolygons(), circularSegments, revolveDegrees);
+    };
+    Module2.CrossSection.prototype.add = function(other) {
+      return this._add(cross3(other));
+    };
+    Module2.CrossSection.prototype.subtract = function(other) {
+      return this._subtract(cross3(other));
+    };
+    Module2.CrossSection.prototype.intersect = function(other) {
+      return this._intersect(cross3(other));
+    };
+    Module2.CrossSection.prototype.toPolygons = function() {
+      const vec = this._ToPolygons();
+      const result = vec2polygons(vec, (v4) => [v4.x, v4.y]);
+      vec.delete();
+      return result;
+    };
+    Module2.Manifold.prototype.smoothOut = function(minSharpAngle = 52.5, minSmoothness = 0) {
+      return this._SmoothOut(minSharpAngle, minSmoothness);
+    };
+    Module2.Manifold.prototype.warp = function(func) {
+      const wasmFuncPtr = addFunction(function(vec3Ptr) {
+        const x4 = getValue(vec3Ptr, "double");
+        const y4 = getValue(vec3Ptr + 8, "double");
+        const z56 = getValue(vec3Ptr + 16, "double");
+        const vert = [x4, y4, z56];
+        func(vert);
+        setValue(vec3Ptr, vert[0], "double");
+        setValue(vec3Ptr + 8, vert[1], "double");
+        setValue(vec3Ptr + 16, vert[2], "double");
+      }, "vi");
+      const out2 = this._Warp(wasmFuncPtr);
+      removeFunction(wasmFuncPtr);
+      const status = out2.status();
+      if (status !== "NoError") {
+        throw new Module2.ManifoldError(status);
+      }
+      return out2;
+    };
+    Module2.Manifold.prototype.warpBatch = function(func) {
+      const wasmFuncPtr = addFunction(function(ptr, count) {
+        const heapF64 = Module2.HEAPF64 ?? HEAPF64;
+        if (!heapF64) {
+          throw new Error("WASM heap is not initialized (HEAPF64 unavailable)");
+        }
+        const verts = new Float64Array(heapF64.buffer, ptr, count * 3);
+        func(verts, count);
+      }, "vii");
+      const out2 = this._WarpBatch(wasmFuncPtr);
+      removeFunction(wasmFuncPtr);
+      const status = out2.status();
+      if (status !== "NoError") {
+        throw new Module2.ManifoldError(status);
+      }
+      return out2;
+    };
+    Module2.Manifold.prototype.calculateNormals = function(normalIdx = 0, minSharpAngle = 52.5) {
+      return this._CalculateNormals(normalIdx, minSharpAngle);
+    };
+    Module2.Manifold.prototype.smoothByNormals = function(normalIdx = 0) {
+      return this._SmoothByNormals(normalIdx);
+    };
+    Module2.Manifold.prototype.setProperties = function(numProp, func) {
+      const oldNumProp = this.numProp();
+      const wasmFuncPtr = addFunction(function(newPtr, vec3Ptr, oldPtr) {
+        const newProp = [];
+        for (let i3 = 0;i3 < numProp; ++i3) {
+          newProp[i3] = getValue(newPtr + 8 * i3, "double");
+        }
+        const pos = [];
+        for (let i3 = 0;i3 < 3; ++i3) {
+          pos[i3] = getValue(vec3Ptr + 8 * i3, "double");
+        }
+        const oldProp = [];
+        for (let i3 = 0;i3 < oldNumProp; ++i3) {
+          oldProp[i3] = getValue(oldPtr + 8 * i3, "double");
+        }
+        func(newProp, pos, oldProp);
+        for (let i3 = 0;i3 < numProp; ++i3) {
+          setValue(newPtr + 8 * i3, newProp[i3], "double");
+        }
+      }, "viii");
+      const out2 = this._SetProperties(numProp, wasmFuncPtr);
+      removeFunction(wasmFuncPtr);
+      return out2;
+    };
+    Module2.Manifold.prototype.translate = function(...vec) {
+      return this._Translate(vararg2vec3(vec));
+    };
+    Module2.Manifold.prototype.rotate = function(xOrVec, y4, z56) {
+      if (Array.isArray(xOrVec)) {
+        return this._Rotate(...xOrVec);
+      } else {
+        return this._Rotate(xOrVec, y4 || 0, z56 || 0);
+      }
+    };
+    Module2.Manifold.prototype.scale = function(vec) {
+      if (typeof vec == "number") {
+        return this._Scale({ x: vec, y: vec, z: vec });
+      }
+      return this._Scale(vararg2vec3([vec]));
+    };
+    Module2.Manifold.prototype.mirror = function(vec) {
+      return this._Mirror(vararg2vec3([vec]));
+    };
+    Module2.Manifold.prototype.trimByPlane = function(normal, offset = 0) {
+      return this._TrimByPlane(vararg2vec3([normal]), offset);
+    };
+    Module2.Manifold.prototype.slice = function(height = 0) {
+      const polygonsVec = this._Slice(height);
+      const result = new CrossSectionCtor(polygonsVec, fillRuleToInt("Positive"));
+      disposePolygons(polygonsVec);
+      return result;
+    };
+    Module2.Manifold.prototype.project = function() {
+      const polygonsVec = this._Project();
+      const result = new CrossSectionCtor(polygonsVec, fillRuleToInt("Positive"));
+      disposePolygons(polygonsVec);
+      return result;
+    };
+    Module2.Manifold.prototype.rayCast = function(origin, endpoint) {
+      const vec = this._RayCast(vararg2vec3([origin]), vararg2vec3([endpoint]));
+      const result = fromVec(vec, (hit) => ({ faceID: hit.faceID, distance: hit.distance, position: ["x", "y", "z"].map((f2) => hit.position[f2]), normal: ["x", "y", "z"].map((f2) => hit.normal[f2]) }));
+      vec.delete();
+      return result;
+    };
+    Module2.Manifold.prototype.split = function(manifold) {
+      const vec = this._Split(manifold);
+      const result = fromVec(vec);
+      vec.delete();
+      return result;
+    };
+    Module2.Manifold.prototype.splitByPlane = function(normal, offset = 0) {
+      const vec = this._SplitByPlane(vararg2vec3([normal]), offset);
+      const result = fromVec(vec);
+      vec.delete();
+      return result;
+    };
+    Module2.Manifold.prototype.decompose = function() {
+      const vec = this._Decompose();
+      const result = fromVec(vec);
+      vec.delete();
+      return result;
+    };
+    Module2.Manifold.prototype.boundingBox = function() {
+      const result = this._boundingBox();
+      return { min: ["x", "y", "z"].map((f2) => result.min[f2]), max: ["x", "y", "z"].map((f2) => result.max[f2]) };
+    };
+    Module2.Manifold.prototype.simplify = function(tolerance = 0) {
+      return this._Simplify(tolerance);
+    };
+
+    class Mesh {
+      constructor({ numProp = 3, triVerts = new Uint32Array, vertProperties = new Float32Array, mergeFromVert, mergeToVert, runIndex, runOriginalID, faceID, halfedgeTangent, runTransform, runFlags, tolerance = 0 } = {}) {
+        this.numProp = numProp;
+        this.triVerts = triVerts;
+        this.vertProperties = vertProperties;
+        this.mergeFromVert = mergeFromVert;
+        this.mergeToVert = mergeToVert;
+        this.runIndex = runIndex;
+        this.runOriginalID = runOriginalID;
+        this.faceID = faceID;
+        this.halfedgeTangent = halfedgeTangent;
+        this.runTransform = runTransform;
+        this.runFlags = runFlags;
+        this.tolerance = tolerance;
+      }
+      get numTri() {
+        return this.triVerts.length / 3;
+      }
+      get numVert() {
+        return this.vertProperties.length / this.numProp;
+      }
+      get numRun() {
+        return this.runOriginalID.length;
+      }
+      merge() {
+        const { changed, mesh } = Module2._Merge(this);
+        Object.assign(this, { ...mesh });
+        return changed;
+      }
+      verts(tri) {
+        return this.triVerts.subarray(3 * tri, 3 * (tri + 1));
+      }
+      position(vert) {
+        return this.vertProperties.subarray(this.numProp * vert, this.numProp * vert + 3);
+      }
+      extras(vert) {
+        return this.vertProperties.subarray(this.numProp * vert + 3, this.numProp * (vert + 1));
+      }
+      tangent(halfedge) {
+        return this.halfedgeTangent.subarray(4 * halfedge, 4 * (halfedge + 1));
+      }
+      transform(run3) {
+        const mat4 = new Array(16);
+        for (const col of [0, 1, 2, 3]) {
+          for (const row of [0, 1, 2]) {
+            mat4[4 * col + row] = this.runTransform[12 * run3 + 3 * col + row];
+          }
+        }
+        mat4[15] = 1;
+        return mat4;
+      }
+      backside(run3) {
+        return this.runFlags != null && run3 < this.runFlags.length && (this.runFlags[run3] & 1) !== 0;
+      }
+      hasNormals(run3) {
+        return this.runFlags != null && run3 < this.runFlags.length && (this.runFlags[run3] & 2) !== 0;
+      }
+    }
+    Module2.Mesh = Mesh;
+    Module2.Manifold.prototype.getMesh = function(normalIdx = -1) {
+      return new Mesh(this._GetMeshJS(normalIdx));
+    };
+    Module2.ManifoldError = function ManifoldError(code, ...args) {
+      let message = "Unknown error";
+      switch (code) {
+        case "NonFiniteVertex":
+          message = "Non-finite vertex";
+          break;
+        case "NotManifold":
+          message = "Not manifold";
+          break;
+        case "VertexOutOfBounds":
+          message = "Vertex index out of bounds";
+          break;
+        case "PropertiesWrongLength":
+          message = "Properties have wrong length";
+          break;
+        case "MissingPositionProperties":
+          message = "Less than three properties";
+          break;
+        case "MergeVectorsDifferentLengths":
+          message = "Merge vectors have different lengths";
+          break;
+        case "MergeIndexOutOfBounds":
+          message = "Merge index out of bounds";
+          break;
+        case "TransformWrongLength":
+          message = "Transform vector has wrong length";
+          break;
+        case "RunIndexWrongLength":
+          message = "Run index vector has wrong length";
+          break;
+        case "FaceIDWrongLength":
+          message = "Face ID vector has wrong length";
+          break;
+        case "InvalidConstruction":
+          message = "Manifold constructed with invalid parameters";
+          break;
+        case "ResultTooLarge":
+          message = "Result exceeds maximum size";
+          break;
+        case "InvalidTangents":
+          message = "Invalid halfedge tangents";
+          break;
+      }
+      const base = Error.apply(this, [message, ...args]);
+      base.name = this.name = "ManifoldError";
+      this.message = base.message;
+      this.stack = base.stack;
+      this.code = code;
+    };
+    Module2.ManifoldError.prototype = Object.create(Error.prototype, { constructor: { value: Module2.ManifoldError, writable: true, configurable: true } });
+    Module2.CrossSection = function(polygons, fillRule = "Positive") {
+      const polygonsVec = polygons2vec(polygons);
+      const cs3 = new CrossSectionCtor(polygonsVec, fillRuleToInt(fillRule));
+      disposePolygons(polygonsVec);
+      return cs3;
+    };
+    Module2.CrossSection.ofPolygons = function(polygons, fillRule = "Positive") {
+      return new Module2.CrossSection(polygons, fillRule);
+    };
+    Module2.CrossSection.square = function(...args) {
+      let size = undefined;
+      if (args.length == 0)
+        size = { x: 1, y: 1 };
+      else if (typeof args[0] == "number")
+        size = { x: args[0], y: args[0] };
+      else
+        size = vararg2vec2(args);
+      const center2 = args[1] || false;
+      return Module2._Square(size, center2);
+    };
+    Module2.CrossSection.circle = function(radius, circularSegments = 0) {
+      return Module2._Circle(radius, circularSegments);
+    };
+    function crossSectionBatchbool(name) {
+      return function(...args) {
+        if (args.length == 1)
+          args = args[0];
+        const v4 = new Module2.Vector_crossSection;
+        for (const cs3 of args)
+          v4.push_back(cross3(cs3));
+        const result = Module2["_crossSection" + name](v4);
+        v4.delete();
+        return result;
+      };
+    }
+    Module2.CrossSection.compose = crossSectionBatchbool("Compose");
+    Module2.CrossSection.union = crossSectionBatchbool("UnionN");
+    Module2.CrossSection.difference = crossSectionBatchbool("DifferenceN");
+    Module2.CrossSection.intersection = crossSectionBatchbool("IntersectionN");
+    function pushVec2(vec, ps3) {
+      toVec(vec, ps3, (p3) => {
+        if (p3 instanceof Array)
+          return { x: p3[0], y: p3[1] };
+        return p3;
+      });
+    }
+    Module2.CrossSection.hull = function(...args) {
+      if (args.length == 1)
+        args = args[0];
+      let pts = new Module2.Vector_vec2;
+      for (const cs3 of args) {
+        if (cs3 instanceof CrossSectionCtor) {
+          Module2._crossSectionCollectVertices(pts, cs3);
+        } else if (cs3 instanceof Array && cs3.length == 2 && typeof cs3[0] == "number") {
+          pts.push_back({ x: cs3[0], y: cs3[1] });
+        } else if (cs3.x) {
+          pts.push_back(cs3);
+        } else {
+          const wrap = cs3[0].length == 2 && typeof cs3[0][0] == "number" || cs3[0].x;
+          const polys = wrap ? [cs3] : cs3;
+          for (const poly of polys)
+            pushVec2(pts, poly);
+        }
+      }
+      const result = Module2._crossSectionHullPoints(pts);
+      pts.delete();
+      return result;
+    };
+    Module2.CrossSection.prototype = Object.create(CrossSectionCtor.prototype);
+    Object.defineProperty(Module2.CrossSection, Symbol.hasInstance, { get: () => (t49) => t49 instanceof CrossSectionCtor });
+    const ManifoldCtor = Module2.Manifold;
+    Module2.Manifold = function(mesh) {
+      const manifold = new ManifoldCtor(mesh);
+      const status = manifold.status();
+      if (status !== "NoError") {
+        throw new Module2.ManifoldError(status);
+      }
+      return manifold;
+    };
+    Module2.Manifold.ofMesh = function(mesh) {
+      return new Module2.Manifold(mesh);
+    };
+    Module2.Manifold.tetrahedron = function() {
+      return Module2._Tetrahedron();
+    };
+    Module2.Manifold.cube = function(...args) {
+      let size = undefined;
+      if (args.length == 0)
+        size = { x: 1, y: 1, z: 1 };
+      else if (typeof args[0] == "number")
+        size = { x: args[0], y: args[0], z: args[0] };
+      else
+        size = vararg2vec3(args);
+      const center2 = args[1] || false;
+      return Module2._Cube(size, center2);
+    };
+    Module2.Manifold.cylinder = function(height, radiusLow, radiusHigh = -1, circularSegments = 0, center2 = false) {
+      return Module2._Cylinder(height, radiusLow, radiusHigh, circularSegments, center2);
+    };
+    Module2.Manifold.sphere = function(radius, circularSegments = 0) {
+      return Module2._Sphere(radius, circularSegments);
+    };
+    Module2.Manifold.smooth = function(mesh, sharpenedEdges = []) {
+      const sharp = new Module2.Vector_smoothness;
+      toVec(sharp, sharpenedEdges);
+      const result = Module2._Smooth(mesh, sharp);
+      sharp.delete();
+      return result;
+    };
+    Module2.Manifold.extrude = function(polygons, height, nDivisions = 0, twistDegrees = 0, scaleTop = [1, 1], center2 = false) {
+      const cs3 = polygons instanceof CrossSectionCtor ? polygons : Module2.CrossSection(polygons, "Positive");
+      return cs3.extrude(height, nDivisions, twistDegrees, scaleTop, center2);
+    };
+    Module2.Manifold.revolve = function(polygons, circularSegments = 0, revolveDegrees = 360) {
+      const cs3 = polygons instanceof CrossSectionCtor ? polygons : Module2.CrossSection(polygons, "Positive");
+      return cs3.revolve(circularSegments, revolveDegrees);
+    };
+    Module2.Manifold.reserveIDs = function(n3) {
+      return Module2._ReserveIDs(n3);
+    };
+    function manifoldBatchbool(name) {
+      return function(...args) {
+        if (args.length == 1)
+          args = args[0];
+        const v4 = new Module2.Vector_manifold;
+        for (const m3 of args)
+          v4.push_back(m3);
+        const result = Module2["_manifold" + name + "N"](v4);
+        v4.delete();
+        return result;
+      };
+    }
+    Module2.Manifold.union = manifoldBatchbool("Union");
+    Module2.Manifold.compose = Module2.Manifold.union;
+    Module2.Manifold.difference = manifoldBatchbool("Difference");
+    Module2.Manifold.intersection = manifoldBatchbool("Intersection");
+    Module2.Manifold.levelSet = function(sdf, bounds, edgeLength, level = 0, tolerance = -1) {
+      const bounds2 = { min: { x: bounds.min[0], y: bounds.min[1], z: bounds.min[2] }, max: { x: bounds.max[0], y: bounds.max[1], z: bounds.max[2] } };
+      const wasmFuncPtr = addFunction(function(vec3Ptr) {
+        const x4 = getValue(vec3Ptr, "double");
+        const y4 = getValue(vec3Ptr + 8, "double");
+        const z56 = getValue(vec3Ptr + 16, "double");
+        const vert = [x4, y4, z56];
+        return sdf(vert);
+      }, "di");
+      const out2 = Module2._LevelSet(wasmFuncPtr, bounds2, edgeLength, level, tolerance);
+      removeFunction(wasmFuncPtr);
+      return out2;
+    };
+    Module2.ExecutionContext.prototype.fromMesh = function(mesh) {
+      return this._FromMesh(mesh);
+    };
+    Module2.ExecutionContext.prototype.smooth = function(mesh, sharpenedEdges = []) {
+      const sharp = new Module2.Vector_smoothness;
+      toVec(sharp, sharpenedEdges);
+      const result = this._Smooth(mesh, sharp);
+      sharp.delete();
+      return result;
+    };
+    Module2.ExecutionContext.prototype.levelSet = function(sdf, bounds, edgeLength, level = 0, tolerance = -1) {
+      const bounds2 = { min: { x: bounds.min[0], y: bounds.min[1], z: bounds.min[2] }, max: { x: bounds.max[0], y: bounds.max[1], z: bounds.max[2] } };
+      const wasmFuncPtr = addFunction(function(vec3Ptr) {
+        const x4 = getValue(vec3Ptr, "double");
+        const y4 = getValue(vec3Ptr + 8, "double");
+        const z56 = getValue(vec3Ptr + 16, "double");
+        const vert = [x4, y4, z56];
+        return sdf(vert);
+      }, "di");
+      const out2 = this._LevelSet(wasmFuncPtr, bounds2, edgeLength, level, tolerance);
+      removeFunction(wasmFuncPtr);
+      return out2;
+    };
+    function pushVec3(vec, ps3) {
+      toVec(vec, ps3, (p3) => {
+        if (p3 instanceof Array)
+          return { x: p3[0], y: p3[1], z: p3[2] };
+        return p3;
+      });
+    }
+    Module2.Manifold.hull = function(...args) {
+      if (args.length == 1)
+        args = args[0];
+      let pts = new Module2.Vector_vec3;
+      for (const m3 of args) {
+        if (m3 instanceof ManifoldCtor) {
+          Module2._manifoldCollectVertices(pts, m3);
+        } else if (m3 instanceof Array && m3.length == 3 && typeof m3[0] == "number") {
+          pts.push_back({ x: m3[0], y: m3[1], z: m3[2] });
+        } else if (m3.x) {
+          pts.push_back(m3);
+        } else {
+          pushVec3(pts, m3);
+        }
+      }
+      const result = Module2._manifoldHullPoints(pts);
+      pts.delete();
+      return result;
+    };
+    Module2.Manifold.prototype = Object.create(ManifoldCtor.prototype);
+    Object.defineProperty(Module2.Manifold, Symbol.hasInstance, { get: () => (t49) => t49 instanceof ManifoldCtor });
+    Module2.triangulate = function(polygons, epsilon = -1, allowConvex = true) {
+      const polygonsVec = polygons2vec(polygons);
+      const result = fromVec(Module2._Triangulate(polygonsVec, epsilon, allowConvex), (x4) => [x4[0], x4[1], x4[2]]);
+      disposePolygons(polygonsVec);
+      return result;
+    };
+  };
+  var arguments_ = [];
+  var thisProgram = "./this.program";
+  var quit_ = (status, toThrow) => {
+    throw toThrow;
+  };
+  var _scriptName = import.meta.url;
+  var scriptDirectory = "";
+  function locateFile(path69) {
+    if (Module2["locateFile"]) {
+      return Module2["locateFile"](path69, scriptDirectory);
+    }
+    return scriptDirectory + path69;
+  }
+  var readAsync, readBinary;
+  if (ENVIRONMENT_IS_NODE) {
+    var fs61 = require4("node:fs");
+    if (_scriptName.startsWith("file:")) {
+      scriptDirectory = require4("node:path").dirname(require4("node:url").fileURLToPath(_scriptName)) + "/";
+    }
+    readBinary = (filename) => {
+      filename = isFileURI(filename) ? new URL(filename) : filename;
+      var ret = fs61.readFileSync(filename);
+      return ret;
+    };
+    readAsync = async (filename, binary = true) => {
+      filename = isFileURI(filename) ? new URL(filename) : filename;
+      var ret = fs61.readFileSync(filename, binary ? undefined : "utf8");
+      return ret;
+    };
+    if (process.argv.length > 1) {
+      thisProgram = process.argv[1].replace(/\\/g, "/");
+    }
+    arguments_ = process.argv.slice(2);
+    quit_ = (status, toThrow) => {
+      process.exitCode = status;
+      throw toThrow;
+    };
+  } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+    try {
+      scriptDirectory = new URL(".", _scriptName).href;
+    } catch {}
+    {
+      if (ENVIRONMENT_IS_WORKER) {
+        readBinary = (url2) => {
+          var xhr = new XMLHttpRequest;
+          xhr.open("GET", url2, false);
+          xhr.responseType = "arraybuffer";
+          xhr.send(null);
+          return new Uint8Array(xhr.response);
+        };
+      }
+      readAsync = async (url2) => {
+        if (isFileURI(url2)) {
+          return new Promise((resolve11, reject) => {
+            var xhr = new XMLHttpRequest;
+            xhr.open("GET", url2, true);
+            xhr.responseType = "arraybuffer";
+            xhr.onload = () => {
+              if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+                resolve11(xhr.response);
+                return;
+              }
+              reject(xhr.status);
+            };
+            xhr.onerror = reject;
+            xhr.send(null);
+          });
+        }
+        var response = await fetch(url2, { credentials: "same-origin" });
+        if (response.ok) {
+          return response.arrayBuffer();
+        }
+        throw new Error(response.status + " : " + response.url);
+      };
+    }
+  }
+  var out = console.log.bind(console);
+  var err2 = console.error.bind(console);
+  var wasmBinary;
+  var ABORT = false;
+  var isFileURI = (filename) => filename.startsWith("file://");
+  var readyPromiseResolve, readyPromiseReject;
+  var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+  var HEAP64, HEAPU64;
+  var runtimeInitialized = false;
+  function updateMemoryViews() {
+    var b3 = wasmMemory.buffer;
+    HEAP8 = new Int8Array(b3);
+    HEAP16 = new Int16Array(b3);
+    HEAPU8 = new Uint8Array(b3);
+    HEAPU16 = new Uint16Array(b3);
+    HEAP32 = new Int32Array(b3);
+    HEAPU32 = new Uint32Array(b3);
+    HEAPF32 = new Float32Array(b3);
+    HEAPF64 = new Float64Array(b3);
+    HEAP64 = new BigInt64Array(b3);
+    HEAPU64 = new BigUint64Array(b3);
+  }
+  function preRun() {
+    if (Module2["preRun"]) {
+      if (typeof Module2["preRun"] == "function")
+        Module2["preRun"] = [Module2["preRun"]];
+      while (Module2["preRun"].length) {
+        addOnPreRun(Module2["preRun"].shift());
+      }
+    }
+    callRuntimeCallbacks(onPreRuns);
+  }
+  function initRuntime() {
+    runtimeInitialized = true;
+    wasmExports["J"]();
+  }
+  function postRun() {
+    if (Module2["postRun"]) {
+      if (typeof Module2["postRun"] == "function")
+        Module2["postRun"] = [Module2["postRun"]];
+      while (Module2["postRun"].length) {
+        addOnPostRun(Module2["postRun"].shift());
+      }
+    }
+    callRuntimeCallbacks(onPostRuns);
+  }
+  function abort(what) {
+    Module2["onAbort"]?.(what);
+    what = "Aborted(" + what + ")";
+    err2(what);
+    ABORT = true;
+    what += ". Build with -sASSERTIONS for more info.";
+    var e4 = new WebAssembly.RuntimeError(what);
+    readyPromiseReject?.(e4);
+    throw e4;
+  }
+  var wasmBinaryFile;
+  function findWasmBinary() {
+    if (Module2["locateFile"]) {
+      return locateFile("manifold.wasm");
+    }
+    return new URL("manifold.wasm", import.meta.url).href;
+  }
+  function getBinarySync(file) {
+    if (file == wasmBinaryFile && wasmBinary) {
+      return new Uint8Array(wasmBinary);
+    }
+    if (readBinary) {
+      return readBinary(file);
+    }
+    throw "both async and sync fetching of the wasm failed";
+  }
+  async function getWasmBinary(binaryFile) {
+    if (!wasmBinary) {
+      try {
+        var response = await readAsync(binaryFile);
+        return new Uint8Array(response);
+      } catch {}
+    }
+    return getBinarySync(binaryFile);
+  }
+  async function instantiateArrayBuffer(binaryFile, imports) {
+    try {
+      var binary = await getWasmBinary(binaryFile);
+      var instance = await WebAssembly.instantiate(binary, imports);
+      return instance;
+    } catch (reason) {
+      err2(`failed to asynchronously prepare wasm: ${reason}`);
+      abort(reason);
+    }
+  }
+  async function instantiateAsync(binary, binaryFile, imports) {
+    if (!binary && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
+      try {
+        var response = fetch(binaryFile, { credentials: "same-origin" });
+        var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
+        return instantiationResult;
+      } catch (reason) {
+        err2(`wasm streaming compile failed: ${reason}`);
+        err2("falling back to ArrayBuffer instantiation");
+      }
+    }
+    return instantiateArrayBuffer(binaryFile, imports);
+  }
+  function getWasmImports() {
+    var imports = { a: wasmImports };
+    return imports;
+  }
+  async function createWasm() {
+    function receiveInstance(instance, module2) {
+      wasmExports = instance.exports;
+      wasmExports = applySignatureConversions(wasmExports);
+      assignWasmExports(wasmExports);
+      updateMemoryViews();
+      return wasmExports;
+    }
+    function receiveInstantiationResult(result2) {
+      return receiveInstance(result2["instance"]);
+    }
+    var info = getWasmImports();
+    if (Module2["instantiateWasm"]) {
+      return new Promise((resolve11, reject) => {
+        Module2["instantiateWasm"](info, (inst, mod) => {
+          resolve11(receiveInstance(inst, mod));
+        });
+      });
+    }
+    wasmBinaryFile ??= findWasmBinary();
+    var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+    var exports2 = receiveInstantiationResult(result);
+    return exports2;
+  }
+
+  class ExitStatus {
+    name = "ExitStatus";
+    constructor(status) {
+      this.message = `Program terminated with exit(${status})`;
+      this.status = status;
+    }
+  }
+  var callRuntimeCallbacks = (callbacks) => {
+    while (callbacks.length > 0) {
+      callbacks.shift()(Module2);
+    }
+  };
+  var onPostRuns = [];
+  var addOnPostRun = (cb3) => onPostRuns.push(cb3);
+  var onPreRuns = [];
+  var addOnPreRun = (cb3) => onPreRuns.push(cb3);
+  function getValue(ptr, type = "i8") {
+    if (type.endsWith("*"))
+      type = "*";
+    switch (type) {
+      case "i1":
+        return HEAP8[ptr >>> 0];
+      case "i8":
+        return HEAP8[ptr >>> 0];
+      case "i16":
+        return HEAP16[ptr >>> 1 >>> 0];
+      case "i32":
+        return HEAP32[ptr >>> 2 >>> 0];
+      case "i64":
+        return HEAP64[ptr >>> 3 >>> 0];
+      case "float":
+        return HEAPF32[ptr >>> 2 >>> 0];
+      case "double":
+        return HEAPF64[ptr >>> 3 >>> 0];
+      case "*":
+        return HEAPU32[ptr >>> 2 >>> 0];
+      default:
+        abort(`invalid type for getValue: ${type}`);
+    }
+  }
+  var noExitRuntime = true;
+  function setValue(ptr, value, type = "i8") {
+    if (type.endsWith("*"))
+      type = "*";
+    switch (type) {
+      case "i1":
+        HEAP8[ptr >>> 0] = value;
+        break;
+      case "i8":
+        HEAP8[ptr >>> 0] = value;
+        break;
+      case "i16":
+        HEAP16[ptr >>> 1 >>> 0] = value;
+        break;
+      case "i32":
+        HEAP32[ptr >>> 2 >>> 0] = value;
+        break;
+      case "i64":
+        HEAP64[ptr >>> 3 >>> 0] = BigInt(value);
+        break;
+      case "float":
+        HEAPF32[ptr >>> 2 >>> 0] = value;
+        break;
+      case "double":
+        HEAPF64[ptr >>> 3 >>> 0] = value;
+        break;
+      case "*":
+        HEAPU32[ptr >>> 2 >>> 0] = value;
+        break;
+      default:
+        abort(`invalid type for setValue: ${type}`);
+    }
+  }
+
+  class ExceptionInfo {
+    constructor(excPtr) {
+      this.excPtr = excPtr;
+      this.ptr = excPtr - 24;
+    }
+    set_type(type) {
+      HEAPU32[this.ptr + 4 >>> 2 >>> 0] = type;
+    }
+    get_type() {
+      return HEAPU32[this.ptr + 4 >>> 2 >>> 0];
+    }
+    set_destructor(destructor) {
+      HEAPU32[this.ptr + 8 >>> 2 >>> 0] = destructor;
+    }
+    get_destructor() {
+      return HEAPU32[this.ptr + 8 >>> 2 >>> 0];
+    }
+    set_caught(caught) {
+      caught = caught ? 1 : 0;
+      HEAP8[this.ptr + 12 >>> 0] = caught;
+    }
+    get_caught() {
+      return HEAP8[this.ptr + 12 >>> 0] != 0;
+    }
+    set_rethrown(rethrown) {
+      rethrown = rethrown ? 1 : 0;
+      HEAP8[this.ptr + 13 >>> 0] = rethrown;
+    }
+    get_rethrown() {
+      return HEAP8[this.ptr + 13 >>> 0] != 0;
+    }
+    init(type, destructor) {
+      this.set_adjusted_ptr(0);
+      this.set_type(type);
+      this.set_destructor(destructor);
+    }
+    set_adjusted_ptr(adjustedPtr) {
+      HEAPU32[this.ptr + 16 >>> 2 >>> 0] = adjustedPtr;
+    }
+    get_adjusted_ptr() {
+      return HEAPU32[this.ptr + 16 >>> 2 >>> 0];
+    }
+  }
+  var exceptionLast = 0;
+  var uncaughtExceptionCount = 0;
+  function ___cxa_throw(ptr, type, destructor) {
+    ptr >>>= 0;
+    type >>>= 0;
+    destructor >>>= 0;
+    var info = new ExceptionInfo(ptr);
+    info.init(type, destructor);
+    exceptionLast = ptr;
+    uncaughtExceptionCount++;
+    throw exceptionLast;
+  }
+  var __abort_js = () => abort("");
+  var structRegistrations = {};
+  var runDestructors = (destructors) => {
+    while (destructors.length) {
+      var ptr = destructors.pop();
+      var del = destructors.pop();
+      del(ptr);
+    }
+  };
+  function readPointer(pointer) {
+    return this.fromWireType(HEAPU32[pointer >>> 2 >>> 0]);
+  }
+  var awaitingDependencies = {};
+  var registeredTypes = {};
+  var typeDependencies = {};
+  var InternalError = class InternalError2 extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "InternalError";
+    }
+  };
+  var throwInternalError = (message) => {
+    throw new InternalError(message);
+  };
+  var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
+    myTypes.forEach((type) => typeDependencies[type] = dependentTypes);
+    function onComplete(typeConverters2) {
+      var myTypeConverters = getTypeConverters(typeConverters2);
+      if (myTypeConverters.length !== myTypes.length) {
+        throwInternalError("Mismatched type converter count");
+      }
+      for (var i3 = 0;i3 < myTypes.length; ++i3) {
+        registerType(myTypes[i3], myTypeConverters[i3]);
+      }
+    }
+    var typeConverters = new Array(dependentTypes.length);
+    var unregisteredTypes = [];
+    var registered2 = 0;
+    for (let [i3, dt3] of dependentTypes.entries()) {
+      if (registeredTypes.hasOwnProperty(dt3)) {
+        typeConverters[i3] = registeredTypes[dt3];
+      } else {
+        unregisteredTypes.push(dt3);
+        if (!awaitingDependencies.hasOwnProperty(dt3)) {
+          awaitingDependencies[dt3] = [];
+        }
+        awaitingDependencies[dt3].push(() => {
+          typeConverters[i3] = registeredTypes[dt3];
+          ++registered2;
+          if (registered2 === unregisteredTypes.length) {
+            onComplete(typeConverters);
+          }
+        });
+      }
+    }
+    if (unregisteredTypes.length === 0) {
+      onComplete(typeConverters);
+    }
+  };
+  var __embind_finalize_value_object = function(structType) {
+    structType >>>= 0;
+    var reg = structRegistrations[structType];
+    delete structRegistrations[structType];
+    var rawConstructor = reg.rawConstructor;
+    var rawDestructor = reg.rawDestructor;
+    var fieldRecords = reg.fields;
+    var fieldTypes = fieldRecords.map((field) => field.getterReturnType).concat(fieldRecords.map((field) => field.setterArgumentType));
+    whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes2) => {
+      var fields = {};
+      for (var [i3, field] of fieldRecords.entries()) {
+        const getterReturnType = fieldTypes2[i3];
+        const getter = field.getter;
+        const getterContext = field.getterContext;
+        const setterArgumentType = fieldTypes2[i3 + fieldRecords.length];
+        const setter = field.setter;
+        const setterContext = field.setterContext;
+        fields[field.fieldName] = { read: (ptr) => getterReturnType.fromWireType(getter(getterContext, ptr)), write: (ptr, o3) => {
+          var destructors = [];
+          setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o3));
+          runDestructors(destructors);
+        }, optional: getterReturnType.optional };
+      }
+      return [{ name: reg.name, fromWireType: (ptr) => {
+        var rv2 = {};
+        for (var i4 in fields) {
+          rv2[i4] = fields[i4].read(ptr);
+        }
+        rawDestructor(ptr);
+        return rv2;
+      }, toWireType: (destructors, o3) => {
+        for (var fieldName in fields) {
+          if (!(fieldName in o3) && !fields[fieldName].optional) {
+            throw new TypeError(`Missing field: "${fieldName}"`);
+          }
+        }
+        var ptr = rawConstructor();
+        for (fieldName in fields) {
+          fields[fieldName].write(ptr, o3[fieldName]);
+        }
+        if (destructors !== null) {
+          destructors.push(rawDestructor, ptr);
+        }
+        return ptr;
+      }, readValueFromPointer: readPointer, destructorFunction: rawDestructor }];
+    });
+  };
+  var AsciiToString = (ptr) => {
+    ptr >>>= 0;
+    var str = "";
+    while (true) {
+      var ch3 = HEAPU8[ptr++ >>> 0];
+      if (!ch3)
+        return str;
+      str += String.fromCharCode(ch3);
+    }
+  };
+  var BindingError = class BindingError2 extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BindingError";
+    }
+  };
+  var throwBindingError = (message) => {
+    throw new BindingError(message);
+  };
+  function sharedRegisterType(rawType, registeredInstance, options = {}) {
+    var name = registeredInstance.name;
+    if (!rawType) {
+      throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
+    }
+    if (registeredTypes.hasOwnProperty(rawType)) {
+      if (options.ignoreDuplicateRegistrations) {
+        return;
+      } else {
+        throwBindingError(`Cannot register type '${name}' twice`);
+      }
+    }
+    registeredTypes[rawType] = registeredInstance;
+    delete typeDependencies[rawType];
+    if (awaitingDependencies.hasOwnProperty(rawType)) {
+      var callbacks = awaitingDependencies[rawType];
+      delete awaitingDependencies[rawType];
+      callbacks.forEach((cb3) => cb3());
+    }
+  }
+  function registerType(rawType, registeredInstance, options = {}) {
+    return sharedRegisterType(rawType, registeredInstance, options);
+  }
+  var integerReadValueFromPointer = (name, width, signed) => {
+    switch (width) {
+      case 1:
+        return signed ? (pointer) => HEAP8[pointer >>> 0] : (pointer) => HEAPU8[pointer >>> 0];
+      case 2:
+        return signed ? (pointer) => HEAP16[pointer >>> 1 >>> 0] : (pointer) => HEAPU16[pointer >>> 1 >>> 0];
+      case 4:
+        return signed ? (pointer) => HEAP32[pointer >>> 2 >>> 0] : (pointer) => HEAPU32[pointer >>> 2 >>> 0];
+      case 8:
+        return signed ? (pointer) => HEAP64[pointer >>> 3 >>> 0] : (pointer) => HEAPU64[pointer >>> 3 >>> 0];
+      default:
+        throw new TypeError(`invalid integer width (${width}): ${name}`);
+    }
+  };
+  var __embind_register_bigint = function(primitiveType, name, size, minRange, maxRange) {
+    primitiveType >>>= 0;
+    name >>>= 0;
+    size >>>= 0;
+    name = AsciiToString(name);
+    const isUnsignedType = minRange === 0n;
+    let fromWireType = (value) => value;
+    if (isUnsignedType) {
+      const bitSize = size * 8;
+      fromWireType = (value) => BigInt.asUintN(bitSize, value);
+      maxRange = fromWireType(maxRange);
+    }
+    registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => {
+      if (typeof value == "number") {
+        value = BigInt(value);
+      }
+      return value;
+    }, readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), destructorFunction: null });
+  };
+  function __embind_register_bool(rawType, name, trueValue, falseValue) {
+    rawType >>>= 0;
+    name >>>= 0;
+    name = AsciiToString(name);
+    registerType(rawType, { name, fromWireType: function(wt3) {
+      return !!wt3;
+    }, toWireType: function(destructors, o3) {
+      return o3 ? trueValue : falseValue;
+    }, readValueFromPointer: function(pointer) {
+      return this.fromWireType(HEAPU8[pointer >>> 0]);
+    }, destructorFunction: null });
+  }
+  var shallowCopyInternalPointer = (o3) => ({ count: o3.count, deleteScheduled: o3.deleteScheduled, preservePointerOnDelete: o3.preservePointerOnDelete, ptr: o3.ptr, ptrType: o3.ptrType, smartPtr: o3.smartPtr, smartPtrType: o3.smartPtrType });
+  var throwInstanceAlreadyDeleted = (obj) => {
+    function getInstanceTypeName(handle) {
+      return handle.$$.ptrType.registeredClass.name;
+    }
+    throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
+  };
+  var finalizationRegistry = false;
+  var detachFinalizer = (handle) => {};
+  var runDestructor = ($$) => {
+    if ($$.smartPtr) {
+      $$.smartPtrType.rawDestructor($$.smartPtr);
+    } else {
+      $$.ptrType.registeredClass.rawDestructor($$.ptr);
+    }
+  };
+  var releaseClassHandle = ($$) => {
+    $$.count.value -= 1;
+    var toDelete = $$.count.value === 0;
+    if (toDelete) {
+      runDestructor($$);
+    }
+  };
+  var attachFinalizer = (handle) => {
+    if (!globalThis.FinalizationRegistry) {
+      attachFinalizer = (handle2) => handle2;
+      return handle;
+    }
+    finalizationRegistry = new FinalizationRegistry((info) => {
+      releaseClassHandle(info.$$);
+    });
+    attachFinalizer = (handle2) => {
+      var $$ = handle2.$$;
+      var hasSmartPtr = !!$$.smartPtr;
+      if (hasSmartPtr) {
+        var info = { $$ };
+        finalizationRegistry.register(handle2, info, handle2);
+      }
+      return handle2;
+    };
+    detachFinalizer = (handle2) => finalizationRegistry.unregister(handle2);
+    return attachFinalizer(handle);
+  };
+  var deletionQueue = [];
+  var flushPendingDeletes = () => {
+    while (deletionQueue.length) {
+      var obj = deletionQueue.pop();
+      obj.$$.deleteScheduled = false;
+      obj["delete"]();
+    }
+  };
+  var delayFunction;
+  var init_ClassHandle = () => {
+    let proto = ClassHandle.prototype;
+    Object.assign(proto, { isAliasOf(other) {
+      if (!(this instanceof ClassHandle)) {
+        return false;
+      }
+      if (!(other instanceof ClassHandle)) {
+        return false;
+      }
+      var leftClass = this.$$.ptrType.registeredClass;
+      var left = this.$$.ptr;
+      other.$$ = other.$$;
+      var rightClass = other.$$.ptrType.registeredClass;
+      var right = other.$$.ptr;
+      while (leftClass.baseClass) {
+        left = leftClass.upcast(left);
+        leftClass = leftClass.baseClass;
+      }
+      while (rightClass.baseClass) {
+        right = rightClass.upcast(right);
+        rightClass = rightClass.baseClass;
+      }
+      return leftClass === rightClass && left === right;
+    }, clone() {
+      if (!this.$$.ptr) {
+        throwInstanceAlreadyDeleted(this);
+      }
+      if (this.$$.preservePointerOnDelete) {
+        this.$$.count.value += 1;
+        return this;
+      } else {
+        var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { $$: { value: shallowCopyInternalPointer(this.$$) } }));
+        clone.$$.count.value += 1;
+        clone.$$.deleteScheduled = false;
+        return clone;
+      }
+    }, delete() {
+      if (!this.$$.ptr) {
+        throwInstanceAlreadyDeleted(this);
+      }
+      if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+        throwBindingError("Object already scheduled for deletion");
+      }
+      detachFinalizer(this);
+      releaseClassHandle(this.$$);
+      if (!this.$$.preservePointerOnDelete) {
+        this.$$.smartPtr = undefined;
+        this.$$.ptr = undefined;
+      }
+    }, isDeleted() {
+      return !this.$$.ptr;
+    }, deleteLater() {
+      if (!this.$$.ptr) {
+        throwInstanceAlreadyDeleted(this);
+      }
+      if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+        throwBindingError("Object already scheduled for deletion");
+      }
+      deletionQueue.push(this);
+      if (deletionQueue.length === 1 && delayFunction) {
+        delayFunction(flushPendingDeletes);
+      }
+      this.$$.deleteScheduled = true;
+      return this;
+    } });
+    const symbolDispose = Symbol.dispose;
+    if (symbolDispose) {
+      proto[symbolDispose] = proto["delete"];
+    }
+  };
+  function ClassHandle() {}
+  var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
+  var registeredPointers = {};
+  var ensureOverloadTable = (proto, methodName, humanName) => {
+    if (proto[methodName].overloadTable === undefined) {
+      var prevFunc = proto[methodName];
+      proto[methodName] = function(...args) {
+        if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
+          throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
+        }
+        return proto[methodName].overloadTable[args.length].apply(this, args);
+      };
+      proto[methodName].overloadTable = [];
+      proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+    }
+  };
+  var exposePublicSymbol = (name, value, numArguments) => {
+    if (Module2.hasOwnProperty(name)) {
+      if (numArguments === undefined || Module2[name].overloadTable !== undefined && Module2[name].overloadTable[numArguments] !== undefined) {
+        throwBindingError(`Cannot register public name '${name}' twice`);
+      }
+      ensureOverloadTable(Module2, name, name);
+      if (Module2[name].overloadTable.hasOwnProperty(numArguments)) {
+        throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
+      }
+      Module2[name].overloadTable[numArguments] = value;
+    } else {
+      Module2[name] = value;
+      Module2[name].argCount = numArguments;
+    }
+  };
+  var char_0 = 48;
+  var char_9 = 57;
+  var makeLegalFunctionName = (name) => {
+    name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+    var f2 = name.charCodeAt(0);
+    if (f2 >= char_0 && f2 <= char_9) {
+      return `_${name}`;
+    }
+    return name;
+  };
+  function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
+    this.name = name;
+    this.constructor = constructor;
+    this.instancePrototype = instancePrototype;
+    this.rawDestructor = rawDestructor;
+    this.baseClass = baseClass;
+    this.getActualType = getActualType;
+    this.upcast = upcast;
+    this.downcast = downcast;
+    this.pureVirtualFunctions = [];
+  }
+  var upcastPointer = (ptr, ptrClass, desiredClass) => {
+    while (ptrClass !== desiredClass) {
+      if (!ptrClass.upcast) {
+        throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`);
+      }
+      ptr = ptrClass.upcast(ptr);
+      ptrClass = ptrClass.baseClass;
+    }
+    return ptr;
+  };
+  var embindRepr = (v4) => {
+    if (v4 === null) {
+      return "null";
+    }
+    var t49 = typeof v4;
+    if (t49 === "object" || t49 === "array" || t49 === "function") {
+      return v4.toString();
+    } else {
+      return "" + v4;
+    }
+  };
+  function constNoSmartPtrRawPointerToWireType(destructors, handle) {
+    if (handle === null) {
+      if (this.isReference) {
+        throwBindingError(`null is not a valid ${this.name}`);
+      }
+      return 0;
+    }
+    if (!handle.$$) {
+      throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+    }
+    if (!handle.$$.ptr) {
+      throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+    }
+    var handleClass = handle.$$.ptrType.registeredClass;
+    var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+    return ptr;
+  }
+  function genericPointerToWireType(destructors, handle) {
+    var ptr;
+    if (handle === null) {
+      if (this.isReference) {
+        throwBindingError(`null is not a valid ${this.name}`);
+      }
+      if (this.isSmartPointer) {
+        ptr = this.rawConstructor();
+        if (destructors !== null) {
+          destructors.push(this.rawDestructor, ptr);
+        }
+        return ptr;
+      } else {
+        return 0;
+      }
+    }
+    if (!handle || !handle.$$) {
+      throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+    }
+    if (!handle.$$.ptr) {
+      throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+    }
+    if (!this.isConst && handle.$$.ptrType.isConst) {
+      throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
+    }
+    var handleClass = handle.$$.ptrType.registeredClass;
+    ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+    if (this.isSmartPointer) {
+      if (handle.$$.smartPtr === undefined) {
+        throwBindingError("Passing raw pointer to smart pointer is illegal");
+      }
+      switch (this.sharingPolicy) {
+        case 0:
+          if (handle.$$.smartPtrType === this) {
+            ptr = handle.$$.smartPtr;
+          } else {
+            throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
+          }
+          break;
+        case 1:
+          ptr = handle.$$.smartPtr;
+          break;
+        case 2:
+          if (handle.$$.smartPtrType === this) {
+            ptr = handle.$$.smartPtr;
+          } else {
+            var clonedHandle = handle["clone"]();
+            ptr = this.rawShare(ptr, Emval.toHandle(() => clonedHandle["delete"]()));
+            if (destructors !== null) {
+              destructors.push(this.rawDestructor, ptr);
+            }
+          }
+          break;
+        default:
+          throwBindingError("Unsupported sharing policy");
+      }
+    }
+    return ptr;
+  }
+  function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
+    if (handle === null) {
+      if (this.isReference) {
+        throwBindingError(`null is not a valid ${this.name}`);
+      }
+      return 0;
+    }
+    if (!handle.$$) {
+      throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+    }
+    if (!handle.$$.ptr) {
+      throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+    }
+    if (handle.$$.ptrType.isConst) {
+      throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`);
+    }
+    var handleClass = handle.$$.ptrType.registeredClass;
+    var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+    return ptr;
+  }
+  var downcastPointer = (ptr, ptrClass, desiredClass) => {
+    if (ptrClass === desiredClass) {
+      return ptr;
+    }
+    if (desiredClass.baseClass === undefined) {
+      return null;
+    }
+    var rv2 = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+    if (rv2 === null) {
+      return null;
+    }
+    return desiredClass.downcast(rv2);
+  };
+  var registeredInstances = {};
+  var getBasestPointer = (class_, ptr) => {
+    if (ptr === undefined) {
+      throwBindingError("ptr should not be undefined");
+    }
+    while (class_.baseClass) {
+      ptr = class_.upcast(ptr);
+      class_ = class_.baseClass;
+    }
+    return ptr;
+  };
+  var getInheritedInstance = (class_, ptr) => {
+    ptr = getBasestPointer(class_, ptr);
+    return registeredInstances[ptr];
+  };
+  var makeClassHandle = (prototype, record) => {
+    if (!record.ptrType || !record.ptr) {
+      throwInternalError("makeClassHandle requires ptr and ptrType");
+    }
+    var hasSmartPtrType = !!record.smartPtrType;
+    var hasSmartPtr = !!record.smartPtr;
+    if (hasSmartPtrType !== hasSmartPtr) {
+      throwInternalError("Both smartPtrType and smartPtr must be specified");
+    }
+    record.count = { value: 1 };
+    return attachFinalizer(Object.create(prototype, { $$: { value: record, writable: true } }));
+  };
+  function RegisteredPointer_fromWireType(ptr) {
+    var rawPointer = this.getPointee(ptr);
+    if (!rawPointer) {
+      this.destructor(ptr);
+      return null;
+    }
+    var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
+    if (registeredInstance !== undefined) {
+      if (registeredInstance.$$.count.value === 0) {
+        registeredInstance.$$.ptr = rawPointer;
+        registeredInstance.$$.smartPtr = ptr;
+        return registeredInstance["clone"]();
+      } else {
+        var rv2 = registeredInstance["clone"]();
+        this.destructor(ptr);
+        return rv2;
+      }
+    }
+    function makeDefaultHandle() {
+      if (this.isSmartPointer) {
+        return makeClassHandle(this.registeredClass.instancePrototype, { ptrType: this.pointeeType, ptr: rawPointer, smartPtrType: this, smartPtr: ptr });
+      } else {
+        return makeClassHandle(this.registeredClass.instancePrototype, { ptrType: this, ptr });
+      }
+    }
+    var actualType = this.registeredClass.getActualType(rawPointer);
+    var registeredPointerRecord = registeredPointers[actualType];
+    if (!registeredPointerRecord) {
+      return makeDefaultHandle.call(this);
+    }
+    var toType;
+    if (this.isConst) {
+      toType = registeredPointerRecord.constPointerType;
+    } else {
+      toType = registeredPointerRecord.pointerType;
+    }
+    var dp3 = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
+    if (dp3 === null) {
+      return makeDefaultHandle.call(this);
+    }
+    if (this.isSmartPointer) {
+      return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp3, smartPtrType: this, smartPtr: ptr });
+    } else {
+      return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp3 });
+    }
+  }
+  var init_RegisteredPointer = () => {
+    Object.assign(RegisteredPointer.prototype, { getPointee(ptr) {
+      if (this.rawGetPointee) {
+        ptr = this.rawGetPointee(ptr);
+      }
+      return ptr;
+    }, destructor(ptr) {
+      this.rawDestructor?.(ptr);
+    }, readValueFromPointer: readPointer, fromWireType: RegisteredPointer_fromWireType });
+  };
+  function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
+    this.name = name;
+    this.registeredClass = registeredClass;
+    this.isReference = isReference;
+    this.isConst = isConst;
+    this.isSmartPointer = isSmartPointer;
+    this.pointeeType = pointeeType;
+    this.sharingPolicy = sharingPolicy;
+    this.rawGetPointee = rawGetPointee;
+    this.rawConstructor = rawConstructor;
+    this.rawShare = rawShare;
+    this.rawDestructor = rawDestructor;
+    if (!isSmartPointer && registeredClass.baseClass === undefined) {
+      if (isConst) {
+        this.toWireType = constNoSmartPtrRawPointerToWireType;
+        this.destructorFunction = null;
+      } else {
+        this.toWireType = nonConstNoSmartPtrRawPointerToWireType;
+        this.destructorFunction = null;
+      }
+    } else {
+      this.toWireType = genericPointerToWireType;
+    }
+  }
+  var replacePublicSymbol = (name, value, numArguments) => {
+    if (!Module2.hasOwnProperty(name)) {
+      throwInternalError("Replacing nonexistent public symbol");
+    }
+    if (Module2[name].overloadTable !== undefined && numArguments !== undefined) {
+      Module2[name].overloadTable[numArguments] = value;
+    } else {
+      Module2[name] = value;
+      Module2[name].argCount = numArguments;
+    }
+  };
+  var getWasmTableEntry = (funcPtr) => wasmTable.get(funcPtr);
+  var dynCall = (sig, ptr, args = [], promising = false) => {
+    var func = getWasmTableEntry(ptr);
+    var rtn = func(...args);
+    function convert(rtn2) {
+      return sig[0] == "p" ? rtn2 >>> 0 : rtn2;
+    }
+    return convert(rtn);
+  };
+  var getDynCaller = (sig, ptr, promising = false) => (...args) => dynCall(sig, ptr, args, promising);
+  var embind__requireFunction = (signature, rawFunction, isAsync2 = false) => {
+    signature = AsciiToString(signature);
+    function makeDynCaller() {
+      if (signature.includes("p")) {
+        return getDynCaller(signature, rawFunction, isAsync2);
+      }
+      var rtn = getWasmTableEntry(rawFunction);
+      return rtn;
+    }
+    var fp4 = makeDynCaller();
+    if (typeof fp4 != "function") {
+      throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
+    }
+    return fp4;
+  };
+
+  class UnboundTypeError extends Error {
+  }
+  var getTypeName = (type) => {
+    var ptr = ___getTypeName(type);
+    var rv2 = AsciiToString(ptr);
+    _free(ptr);
+    return rv2;
+  };
+  var throwUnboundTypeError = (message, types3) => {
+    var unboundTypes = [];
+    var seen = {};
+    function visit(type) {
+      if (seen[type]) {
+        return;
+      }
+      if (registeredTypes[type]) {
+        return;
+      }
+      if (typeDependencies[type]) {
+        typeDependencies[type].forEach(visit);
+        return;
+      }
+      unboundTypes.push(type);
+      seen[type] = true;
+    }
+    types3.forEach(visit);
+    throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "]));
+  };
+  function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
+    rawType >>>= 0;
+    rawPointerType >>>= 0;
+    rawConstPointerType >>>= 0;
+    baseClassRawType >>>= 0;
+    getActualTypeSignature >>>= 0;
+    getActualType >>>= 0;
+    upcastSignature >>>= 0;
+    upcast >>>= 0;
+    downcastSignature >>>= 0;
+    downcast >>>= 0;
+    name >>>= 0;
+    destructorSignature >>>= 0;
+    rawDestructor >>>= 0;
+    name = AsciiToString(name);
+    getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
+    upcast &&= embind__requireFunction(upcastSignature, upcast);
+    downcast &&= embind__requireFunction(downcastSignature, downcast);
+    rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+    var legalFunctionName = makeLegalFunctionName(name);
+    exposePublicSymbol(legalFunctionName, function() {
+      throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType]);
+    });
+    whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], (base) => {
+      base = base[0];
+      var baseClass;
+      var basePrototype;
+      if (baseClassRawType) {
+        baseClass = base.registeredClass;
+        basePrototype = baseClass.instancePrototype;
+      } else {
+        basePrototype = ClassHandle.prototype;
+      }
+      var constructor = createNamedFunction(name, function(...args) {
+        if (Object.getPrototypeOf(this) !== instancePrototype) {
+          throw new BindingError(`Use 'new' to construct ${name}`);
+        }
+        if (registeredClass.constructor_body === undefined) {
+          throw new BindingError(`${name} has no accessible constructor`);
+        }
+        var body = registeredClass.constructor_body[args.length];
+        if (body === undefined) {
+          throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
+        }
+        return body.apply(this, args);
+      });
+      var instancePrototype = Object.create(basePrototype, { constructor: { value: constructor } });
+      constructor.prototype = instancePrototype;
+      var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
+      if (registeredClass.baseClass) {
+        registeredClass.baseClass.__derivedClasses ??= [];
+        registeredClass.baseClass.__derivedClasses.push(registeredClass);
+      }
+      var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
+      var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false);
+      var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false);
+      registeredPointers[rawType] = { pointerType: pointerConverter, constPointerType: constPointerConverter };
+      replacePublicSymbol(legalFunctionName, constructor);
+      return [referenceConverter, pointerConverter, constPointerConverter];
+    });
+  }
+  var heap32VectorToArray = (count, firstElement) => {
+    var array = [];
+    for (var i3 = 0;i3 < count; i3++) {
+      array.push(HEAPU32[firstElement + i3 * 4 >>> 2 >>> 0]);
+    }
+    return array;
+  };
+  function usesDestructorStack(argTypes) {
+    for (var i3 = 1;i3 < argTypes.length; ++i3) {
+      if (argTypes[i3] !== null && argTypes[i3].destructorFunction === undefined) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync2) {
+    var needsDestructorStack = usesDestructorStack(argTypes);
+    var argCount = argTypes.length - 2;
+    var argsList = [];
+    var argsListWired = ["fn"];
+    if (isClassMethodFunc) {
+      argsListWired.push("thisWired");
+    }
+    for (var i3 = 0;i3 < argCount; ++i3) {
+      argsList.push(`arg${i3}`);
+      argsListWired.push(`arg${i3}Wired`);
+    }
+    argsList = argsList.join(",");
+    argsListWired = argsListWired.join(",");
+    var invokerFnBody = `return function (${argsList}) {
+`;
+    if (needsDestructorStack) {
+      invokerFnBody += `var destructors = [];
+`;
+    }
+    var dtorStack = needsDestructorStack ? "destructors" : "null";
+    var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire"];
+    if (isClassMethodFunc) {
+      invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);
+`;
+    }
+    for (var i3 = 0;i3 < argCount; ++i3) {
+      var argName = `toArg${i3}Wire`;
+      invokerFnBody += `var arg${i3}Wired = ${argName}(${dtorStack}, arg${i3});
+`;
+      args1.push(argName);
+    }
+    invokerFnBody += (returns || isAsync2 ? "var rv = " : "") + `invoker(${argsListWired});
+`;
+    if (needsDestructorStack) {
+      invokerFnBody += `runDestructors(destructors);
+`;
+    } else {
+      for (var i3 = isClassMethodFunc ? 1 : 2;i3 < argTypes.length; ++i3) {
+        var paramName = i3 === 1 ? "thisWired" : "arg" + (i3 - 2) + "Wired";
+        if (argTypes[i3].destructorFunction !== null) {
+          invokerFnBody += `${paramName}_dtor(${paramName});
+`;
+          args1.push(`${paramName}_dtor`);
+        }
+      }
+    }
+    if (returns) {
+      invokerFnBody += `var ret = fromRetWire(rv);
+return ret;
+`;
+    }
+    invokerFnBody += `}
+`;
+    return new Function(args1, invokerFnBody);
+  }
+  function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync2) {
+    var argCount = argTypes.length;
+    if (argCount < 2) {
+      throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
+    }
+    var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+    var needsDestructorStack = usesDestructorStack(argTypes);
+    var returns = !argTypes[0].isVoid;
+    var retType = argTypes[0];
+    var instType = argTypes[1];
+    var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, retType.fromWireType.bind(retType), instType?.toWireType.bind(instType)];
+    for (var i3 = 2;i3 < argCount; ++i3) {
+      var argType = argTypes[i3];
+      closureArgs.push(argType.toWireType.bind(argType));
+    }
+    if (!needsDestructorStack) {
+      for (var i3 = isClassMethodFunc ? 1 : 2;i3 < argTypes.length; ++i3) {
+        if (argTypes[i3].destructorFunction !== null) {
+          closureArgs.push(argTypes[i3].destructorFunction);
+        }
+      }
+    }
+    let invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync2);
+    var invokerFn = invokerFactory(...closureArgs);
+    return createNamedFunction(humanName, invokerFn);
+  }
+  var __embind_register_class_constructor = function(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
+    rawClassType >>>= 0;
+    rawArgTypesAddr >>>= 0;
+    invokerSignature >>>= 0;
+    invoker >>>= 0;
+    rawConstructor >>>= 0;
+    var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+    invoker = embind__requireFunction(invokerSignature, invoker);
+    whenDependentTypesAreResolved([], [rawClassType], (classType) => {
+      classType = classType[0];
+      var humanName = `constructor ${classType.name}`;
+      if (classType.registeredClass.constructor_body === undefined) {
+        classType.registeredClass.constructor_body = [];
+      }
+      if (classType.registeredClass.constructor_body[argCount - 1] !== undefined) {
+        throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount - 1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
+      }
+      classType.registeredClass.constructor_body[argCount - 1] = () => {
+        throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes);
+      };
+      whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
+        argTypes.splice(1, 0, null);
+        classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
+        return [];
+      });
+      return [];
+    });
+  };
+  var getFunctionName = (signature) => {
+    signature = signature.trim();
+    const argsIndex = signature.indexOf("(");
+    if (argsIndex === -1)
+      return signature;
+    return signature.slice(0, argsIndex);
+  };
+  var __embind_register_class_function = function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual, isAsync2, isNonnullReturn) {
+    rawClassType >>>= 0;
+    methodName >>>= 0;
+    rawArgTypesAddr >>>= 0;
+    invokerSignature >>>= 0;
+    rawInvoker >>>= 0;
+    context >>>= 0;
+    var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+    methodName = AsciiToString(methodName);
+    methodName = getFunctionName(methodName);
+    rawInvoker = embind__requireFunction(invokerSignature, rawInvoker, isAsync2);
+    whenDependentTypesAreResolved([], [rawClassType], (classType) => {
+      classType = classType[0];
+      var humanName = `${classType.name}.${methodName}`;
+      if (methodName.startsWith("@@")) {
+        methodName = Symbol[methodName.substring(2)];
+      }
+      if (isPureVirtual) {
+        classType.registeredClass.pureVirtualFunctions.push(methodName);
+      }
+      function unboundTypesHandler() {
+        throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes);
+      }
+      var proto = classType.registeredClass.instancePrototype;
+      var method = proto[methodName];
+      if (method === undefined || method.overloadTable === undefined && method.className !== classType.name && method.argCount === argCount - 2) {
+        unboundTypesHandler.argCount = argCount - 2;
+        unboundTypesHandler.className = classType.name;
+        proto[methodName] = unboundTypesHandler;
+      } else {
+        ensureOverloadTable(proto, methodName, humanName);
+        proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+      }
+      whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
+        var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync2);
+        if (proto[methodName].overloadTable === undefined) {
+          memberFunction.argCount = argCount - 2;
+          proto[methodName] = memberFunction;
+        } else {
+          proto[methodName].overloadTable[argCount - 2] = memberFunction;
+        }
+        return [];
+      });
+      return [];
+    });
+  };
+  var emval_freelist = [];
+  var emval_handles = [0, 1, , 1, null, 1, true, 1, false, 1];
+  function __emval_decref(handle) {
+    handle >>>= 0;
+    if (handle > 9 && --emval_handles[handle + 1] === 0) {
+      emval_handles[handle] = undefined;
+      emval_freelist.push(handle);
+    }
+  }
+  var Emval = { toValue: (handle) => {
+    if (!handle) {
+      throwBindingError(`Cannot use deleted val. handle = ${handle}`);
+    }
+    return emval_handles[handle];
+  }, toHandle: (value) => {
+    switch (value) {
+      case undefined:
+        return 2;
+      case null:
+        return 4;
+      case true:
+        return 6;
+      case false:
+        return 8;
+      default: {
+        const handle = emval_freelist.pop() || emval_handles.length;
+        emval_handles[handle] = value;
+        emval_handles[handle + 1] = 1;
+        return handle;
+      }
+    }
+  } };
+  var EmValType = { name: "emscripten::val", fromWireType: (handle) => {
+    var rv2 = Emval.toValue(handle);
+    __emval_decref(handle);
+    return rv2;
+  }, toWireType: (destructors, value) => Emval.toHandle(value), readValueFromPointer: readPointer, destructorFunction: null };
+  function __embind_register_emval(rawType) {
+    rawType >>>= 0;
+    return registerType(rawType, EmValType);
+  }
+  var enumReadValueFromPointer = (name, width, signed) => {
+    switch (width) {
+      case 1:
+        return signed ? function(pointer) {
+          return this.fromWireType(HEAP8[pointer >>> 0]);
+        } : function(pointer) {
+          return this.fromWireType(HEAPU8[pointer >>> 0]);
+        };
+      case 2:
+        return signed ? function(pointer) {
+          return this.fromWireType(HEAP16[pointer >>> 1 >>> 0]);
+        } : function(pointer) {
+          return this.fromWireType(HEAPU16[pointer >>> 1 >>> 0]);
+        };
+      case 4:
+        return signed ? function(pointer) {
+          return this.fromWireType(HEAP32[pointer >>> 2 >>> 0]);
+        } : function(pointer) {
+          return this.fromWireType(HEAPU32[pointer >>> 2 >>> 0]);
+        };
+      default:
+        throw new TypeError(`invalid integer width (${width}): ${name}`);
+    }
+  };
+  function getEnumValueType(rawValueType) {
+    return rawValueType === 0 ? "object" : rawValueType === 1 ? "number" : "string";
+  }
+  function __embind_register_enum(rawType, name, size, isSigned, rawValueType) {
+    rawType >>>= 0;
+    name >>>= 0;
+    size >>>= 0;
+    name = AsciiToString(name);
+    const valueType = getEnumValueType(rawValueType);
+    switch (valueType) {
+      case "object": {
+        let ctor = function() {};
+        ctor.values = {};
+        registerType(rawType, { name, constructor: ctor, valueType, fromWireType: function(c3) {
+          return this.constructor.values[c3];
+        }, toWireType: (destructors, c3) => c3.value, readValueFromPointer: enumReadValueFromPointer(name, size, isSigned), destructorFunction: null });
+        exposePublicSymbol(name, ctor);
+        break;
+      }
+      case "number": {
+        var keysMap = {};
+        registerType(rawType, { name, keysMap, valueType, fromWireType: (c3) => c3, toWireType: (destructors, c3) => c3, readValueFromPointer: enumReadValueFromPointer(name, size, isSigned), destructorFunction: null });
+        exposePublicSymbol(name, keysMap);
+        delete Module2[name].argCount;
+        break;
+      }
+      case "string": {
+        var valuesMap = {};
+        var reverseMap = {};
+        var keysMap = {};
+        registerType(rawType, { name, valuesMap, reverseMap, keysMap, valueType, fromWireType: function(c3) {
+          return this.reverseMap[c3];
+        }, toWireType: function(destructors, c3) {
+          return this.valuesMap[c3];
+        }, readValueFromPointer: enumReadValueFromPointer(name, size, isSigned), destructorFunction: null });
+        exposePublicSymbol(name, keysMap);
+        delete Module2[name].argCount;
+        break;
+      }
+    }
+  }
+  var requireRegisteredType = (rawType, humanName) => {
+    var impl = registeredTypes[rawType];
+    if (impl === undefined) {
+      throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
+    }
+    return impl;
+  };
+  function __embind_register_enum_value(rawEnumType, name, enumValue) {
+    rawEnumType >>>= 0;
+    name >>>= 0;
+    var enumType2 = requireRegisteredType(rawEnumType, "enum");
+    name = AsciiToString(name);
+    switch (enumType2.valueType) {
+      case "object": {
+        var Enum = enumType2.constructor;
+        var Value = Object.create(enumType2.constructor.prototype, { value: { value: enumValue }, constructor: { value: createNamedFunction(`${enumType2.name}_${name}`, function() {}) } });
+        Enum.values[enumValue] = Value;
+        Enum[name] = Value;
+        break;
+      }
+      case "number": {
+        enumType2.keysMap[name] = enumValue;
+        break;
+      }
+      case "string": {
+        enumType2.valuesMap[name] = enumValue;
+        enumType2.reverseMap[enumValue] = name;
+        enumType2.keysMap[name] = name;
+        break;
+      }
+    }
+  }
+  var floatReadValueFromPointer = (name, width) => {
+    switch (width) {
+      case 4:
+        return function(pointer) {
+          return this.fromWireType(HEAPF32[pointer >>> 2 >>> 0]);
+        };
+      case 8:
+        return function(pointer) {
+          return this.fromWireType(HEAPF64[pointer >>> 3 >>> 0]);
+        };
+      default:
+        throw new TypeError(`invalid float width (${width}): ${name}`);
+    }
+  };
+  var __embind_register_float = function(rawType, name, size) {
+    rawType >>>= 0;
+    name >>>= 0;
+    size >>>= 0;
+    name = AsciiToString(name);
+    registerType(rawType, { name, fromWireType: (value) => value, toWireType: (destructors, value) => value, readValueFromPointer: floatReadValueFromPointer(name, size), destructorFunction: null });
+  };
+  function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn3, isAsync2, isNonnullReturn) {
+    name >>>= 0;
+    rawArgTypesAddr >>>= 0;
+    signature >>>= 0;
+    rawInvoker >>>= 0;
+    fn3 >>>= 0;
+    var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+    name = AsciiToString(name);
+    name = getFunctionName(name);
+    rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync2);
+    exposePublicSymbol(name, function() {
+      throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);
+    }, argCount - 1);
+    whenDependentTypesAreResolved([], argTypes, (argTypes2) => {
+      var invokerArgsArray = [argTypes2[0], null].concat(argTypes2.slice(1));
+      replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn3, isAsync2), argCount - 1);
+      return [];
+    });
+  }
+  var __embind_register_integer = function(primitiveType, name, size, minRange, maxRange) {
+    primitiveType >>>= 0;
+    name >>>= 0;
+    size >>>= 0;
+    name = AsciiToString(name);
+    const isUnsignedType = minRange === 0;
+    let fromWireType = (value) => value;
+    if (isUnsignedType) {
+      var bitshift = 32 - 8 * size;
+      fromWireType = (value) => value << bitshift >>> bitshift;
+      maxRange = fromWireType(maxRange);
+    }
+    registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => value, readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), destructorFunction: null });
+  };
+  var installIndexedIterator = (proto, sizeMethodName, getMethodName) => {
+    const makeIterator = (size, getValue2) => {
+      let index = 0;
+      return { next() {
+        if (index >= size) {
+          return { done: true };
+        }
+        const current2 = index;
+        index++;
+        const value = getValue2(current2);
+        return { value, done: false };
+      }, [Symbol.iterator]() {
+        return this;
+      } };
+    };
+    if (!proto[Symbol.iterator]) {
+      proto[Symbol.iterator] = function() {
+        const size = this[sizeMethodName]();
+        return makeIterator(size, (i3) => this[getMethodName](i3));
+      };
+    }
+  };
+  var __embind_register_iterable = function(rawClassType, rawElementType, sizeMethodName, getMethodName) {
+    rawClassType >>>= 0;
+    rawElementType >>>= 0;
+    sizeMethodName >>>= 0;
+    getMethodName >>>= 0;
+    sizeMethodName = AsciiToString(sizeMethodName);
+    getMethodName = AsciiToString(getMethodName);
+    whenDependentTypesAreResolved([], [rawClassType, rawElementType], (types3) => {
+      const classType = types3[0];
+      installIndexedIterator(classType.registeredClass.instancePrototype, sizeMethodName, getMethodName);
+      return [];
+    });
+  };
+  function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+    rawType >>>= 0;
+    name >>>= 0;
+    var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
+    var TA2 = typeMapping[dataTypeIndex];
+    function decodeMemoryView(handle) {
+      var size = HEAPU32[handle >>> 2 >>> 0];
+      var data = HEAPU32[handle + 4 >>> 2 >>> 0];
+      return new TA2(HEAP8.buffer, data, size);
+    }
+    name = AsciiToString(name);
+    registerType(rawType, { name, fromWireType: decodeMemoryView, readValueFromPointer: decodeMemoryView }, { ignoreDuplicateRegistrations: true });
+  }
+  var EmValOptionalType = Object.assign({ optional: true }, EmValType);
+  function __embind_register_optional(rawOptionalType, rawType) {
+    rawOptionalType >>>= 0;
+    rawType >>>= 0;
+    registerType(rawOptionalType, EmValOptionalType);
+  }
+  var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+    outIdx >>>= 0;
+    if (!(maxBytesToWrite > 0))
+      return 0;
+    var startIdx = outIdx;
+    var endIdx = outIdx + maxBytesToWrite - 1;
+    for (var i3 = 0;i3 < str.length; ++i3) {
+      var u4 = str.codePointAt(i3);
+      if (u4 <= 127) {
+        if (outIdx >= endIdx)
+          break;
+        heap[outIdx++ >>> 0] = u4;
+      } else if (u4 <= 2047) {
+        if (outIdx + 1 >= endIdx)
+          break;
+        heap[outIdx++ >>> 0] = 192 | u4 >> 6;
+        heap[outIdx++ >>> 0] = 128 | u4 & 63;
+      } else if (u4 <= 65535) {
+        if (outIdx + 2 >= endIdx)
+          break;
+        heap[outIdx++ >>> 0] = 224 | u4 >> 12;
+        heap[outIdx++ >>> 0] = 128 | u4 >> 6 & 63;
+        heap[outIdx++ >>> 0] = 128 | u4 & 63;
+      } else {
+        if (outIdx + 3 >= endIdx)
+          break;
+        heap[outIdx++ >>> 0] = 240 | u4 >> 18;
+        heap[outIdx++ >>> 0] = 128 | u4 >> 12 & 63;
+        heap[outIdx++ >>> 0] = 128 | u4 >> 6 & 63;
+        heap[outIdx++ >>> 0] = 128 | u4 & 63;
+        i3++;
+      }
+    }
+    heap[outIdx >>> 0] = 0;
+    return outIdx - startIdx;
+  };
+  var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+  var lengthBytesUTF8 = (str) => {
+    var len = 0;
+    for (var i3 = 0;i3 < str.length; ++i3) {
+      var c3 = str.charCodeAt(i3);
+      if (c3 <= 127) {
+        len++;
+      } else if (c3 <= 2047) {
+        len += 2;
+      } else if (c3 >= 55296 && c3 <= 57343) {
+        len += 4;
+        ++i3;
+      } else {
+        len += 3;
+      }
+    }
+    return len;
+  };
+  var UTF8Decoder = globalThis.TextDecoder && new TextDecoder;
+  var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+    var maxIdx = idx + maxBytesToRead;
+    if (ignoreNul)
+      return maxIdx;
+    while (heapOrArray[idx] && !(idx >= maxIdx))
+      ++idx;
+    return idx;
+  };
+  var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
+    idx >>>= 0;
+    var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+    }
+    var str = "";
+    while (idx < endPtr) {
+      var u02 = heapOrArray[idx++];
+      if (!(u02 & 128)) {
+        str += String.fromCharCode(u02);
+        continue;
+      }
+      var u12 = heapOrArray[idx++] & 63;
+      if ((u02 & 224) == 192) {
+        str += String.fromCharCode((u02 & 31) << 6 | u12);
+        continue;
+      }
+      var u22 = heapOrArray[idx++] & 63;
+      if ((u02 & 240) == 224) {
+        u02 = (u02 & 15) << 12 | u12 << 6 | u22;
+      } else {
+        u02 = (u02 & 7) << 18 | u12 << 12 | u22 << 6 | heapOrArray[idx++] & 63;
+      }
+      if (u02 < 65536) {
+        str += String.fromCharCode(u02);
+      } else {
+        var ch3 = u02 - 65536;
+        str += String.fromCharCode(55296 | ch3 >> 10, 56320 | ch3 & 1023);
+      }
+    }
+    return str;
+  };
+  var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
+    ptr >>>= 0;
+    return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
+  };
+  function __embind_register_std_string(rawType, name) {
+    rawType >>>= 0;
+    name >>>= 0;
+    name = AsciiToString(name);
+    var stdStringIsUTF8 = true;
+    registerType(rawType, { name, fromWireType(value) {
+      var length67 = HEAPU32[value >>> 2 >>> 0];
+      var payload = value + 4;
+      var str;
+      if (stdStringIsUTF8) {
+        str = UTF8ToString(payload, length67, true);
+      } else {
+        str = "";
+        for (var i3 = 0;i3 < length67; ++i3) {
+          str += String.fromCharCode(HEAPU8[payload + i3 >>> 0]);
+        }
+      }
+      _free(value);
+      return str;
+    }, toWireType(destructors, value) {
+      if (value instanceof ArrayBuffer) {
+        value = new Uint8Array(value);
+      }
+      var length67;
+      var valueIsOfTypeString = typeof value == "string";
+      if (!(valueIsOfTypeString || ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1)) {
+        throwBindingError("Cannot pass non-string to std::string");
+      }
+      if (stdStringIsUTF8 && valueIsOfTypeString) {
+        length67 = lengthBytesUTF8(value);
+      } else {
+        length67 = value.length;
+      }
+      var base = _malloc(4 + length67 + 1);
+      var ptr = base + 4;
+      HEAPU32[base >>> 2 >>> 0] = length67;
+      if (valueIsOfTypeString) {
+        if (stdStringIsUTF8) {
+          stringToUTF8(value, ptr, length67 + 1);
+        } else {
+          for (var i3 = 0;i3 < length67; ++i3) {
+            var charCode = value.charCodeAt(i3);
+            if (charCode > 255) {
+              _free(base);
+              throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
+            }
+            HEAPU8[ptr + i3 >>> 0] = charCode;
+          }
+        }
+      } else {
+        HEAPU8.set(value, ptr >>> 0);
+      }
+      if (destructors !== null) {
+        destructors.push(_free, base);
+      }
+      return base;
+    }, readValueFromPointer: readPointer, destructorFunction(ptr) {
+      _free(ptr);
+    } });
+  }
+  var UTF16Decoder = globalThis.TextDecoder ? new TextDecoder("utf-16le") : undefined;
+  var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => {
+    var idx = ptr >>> 1;
+    var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul);
+    if (endIdx - idx > 16 && UTF16Decoder)
+      return UTF16Decoder.decode(HEAPU16.subarray(idx >>> 0, endIdx >>> 0));
+    var str = "";
+    for (var i3 = idx;i3 < endIdx; ++i3) {
+      var codeUnit = HEAPU16[i3 >>> 0];
+      str += String.fromCharCode(codeUnit);
+    }
+    return str;
+  };
+  var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
+    maxBytesToWrite ??= 2147483647;
+    if (maxBytesToWrite < 2)
+      return 0;
+    maxBytesToWrite -= 2;
+    var startPtr = outPtr;
+    var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+    for (var i3 = 0;i3 < numCharsToWrite; ++i3) {
+      var codeUnit = str.charCodeAt(i3);
+      HEAP16[outPtr >>> 1 >>> 0] = codeUnit;
+      outPtr += 2;
+    }
+    HEAP16[outPtr >>> 1 >>> 0] = 0;
+    return outPtr - startPtr;
+  };
+  var lengthBytesUTF16 = (str) => str.length * 2;
+  var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => {
+    var str = "";
+    var startIdx = ptr >>> 2;
+    for (var i3 = 0;!(i3 >= maxBytesToRead / 4); i3++) {
+      var utf32 = HEAPU32[startIdx + i3 >>> 0];
+      if (!utf32 && !ignoreNul)
+        break;
+      str += String.fromCodePoint(utf32);
+    }
+    return str;
+  };
+  var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
+    outPtr >>>= 0;
+    maxBytesToWrite ??= 2147483647;
+    if (maxBytesToWrite < 4)
+      return 0;
+    var startPtr = outPtr;
+    var endPtr = startPtr + maxBytesToWrite - 4;
+    for (var i3 = 0;i3 < str.length; ++i3) {
+      var codePoint = str.codePointAt(i3);
+      if (codePoint > 65535) {
+        i3++;
+      }
+      HEAP32[outPtr >>> 2 >>> 0] = codePoint;
+      outPtr += 4;
+      if (outPtr + 4 > endPtr)
+        break;
+    }
+    HEAP32[outPtr >>> 2 >>> 0] = 0;
+    return outPtr - startPtr;
+  };
+  var lengthBytesUTF32 = (str) => {
+    var len = 0;
+    for (var i3 = 0;i3 < str.length; ++i3) {
+      var codePoint = str.codePointAt(i3);
+      if (codePoint > 65535) {
+        i3++;
+      }
+      len += 4;
+    }
+    return len;
+  };
+  function __embind_register_std_wstring(rawType, charSize, name) {
+    rawType >>>= 0;
+    charSize >>>= 0;
+    name >>>= 0;
+    name = AsciiToString(name);
+    var decodeString, encodeString, lengthBytesUTF;
+    if (charSize === 2) {
+      decodeString = UTF16ToString;
+      encodeString = stringToUTF16;
+      lengthBytesUTF = lengthBytesUTF16;
+    } else {
+      decodeString = UTF32ToString;
+      encodeString = stringToUTF32;
+      lengthBytesUTF = lengthBytesUTF32;
+    }
+    registerType(rawType, { name, fromWireType: (value) => {
+      var length67 = HEAPU32[value >>> 2 >>> 0];
+      var str = decodeString(value + 4, length67 * charSize, true);
+      _free(value);
+      return str;
+    }, toWireType: (destructors, value) => {
+      if (!(typeof value == "string")) {
+        throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
+      }
+      var length67 = lengthBytesUTF(value);
+      var ptr = _malloc(4 + length67 + charSize);
+      HEAPU32[ptr >>> 2 >>> 0] = length67 / charSize;
+      encodeString(value, ptr + 4, length67 + charSize);
+      if (destructors !== null) {
+        destructors.push(_free, ptr);
+      }
+      return ptr;
+    }, readValueFromPointer: readPointer, destructorFunction(ptr) {
+      _free(ptr);
+    } });
+  }
+  function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
+    rawType >>>= 0;
+    name >>>= 0;
+    constructorSignature >>>= 0;
+    rawConstructor >>>= 0;
+    destructorSignature >>>= 0;
+    rawDestructor >>>= 0;
+    structRegistrations[rawType] = { name: AsciiToString(name), rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), fields: [] };
+  }
+  function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+    structType >>>= 0;
+    fieldName >>>= 0;
+    getterReturnType >>>= 0;
+    getterSignature >>>= 0;
+    getter >>>= 0;
+    getterContext >>>= 0;
+    setterArgumentType >>>= 0;
+    setterSignature >>>= 0;
+    setter >>>= 0;
+    setterContext >>>= 0;
+    structRegistrations[structType].fields.push({ fieldName: AsciiToString(fieldName), getterReturnType, getter: embind__requireFunction(getterSignature, getter), getterContext, setterArgumentType, setter: embind__requireFunction(setterSignature, setter), setterContext });
+  }
+  var __embind_register_void = function(rawType, name) {
+    rawType >>>= 0;
+    name >>>= 0;
+    name = AsciiToString(name);
+    registerType(rawType, { isVoid: true, name, fromWireType: () => {
+      return;
+    }, toWireType: (destructors, o3) => {
+      return;
+    } });
+  };
+  function __emval_array_to_memory_view(dst, src) {
+    dst >>>= 0;
+    src >>>= 0;
+    dst = Emval.toValue(dst);
+    src = Emval.toValue(src);
+    dst.set(src);
+  }
+  var emval_methodCallers = [];
+  var emval_addMethodCaller = (caller) => {
+    var id2 = emval_methodCallers.length;
+    emval_methodCallers.push(caller);
+    return id2;
+  };
+  var emval_lookupTypes = (argCount, argTypes) => {
+    var a2 = new Array(argCount);
+    for (var i3 = 0;i3 < argCount; ++i3) {
+      a2[i3] = requireRegisteredType(HEAPU32[argTypes + i3 * 4 >>> 2 >>> 0], `parameter ${i3}`);
+    }
+    return a2;
+  };
+  var emval_returnValue = (toReturnWire, destructorsRef, handle) => {
+    var destructors = [];
+    var result = toReturnWire(destructors, handle);
+    if (destructors.length) {
+      HEAPU32[destructorsRef >>> 2 >>> 0] = Emval.toHandle(destructors);
+    }
+    return result;
+  };
+  var emval_symbols = {};
+  var getStringOrSymbol = (address) => {
+    var symbol = emval_symbols[address];
+    if (symbol === undefined) {
+      return AsciiToString(address);
+    }
+    return symbol;
+  };
+  var __emval_create_invoker = function(argCount, argTypesPtr, kind) {
+    argTypesPtr >>>= 0;
+    var GenericWireTypeSize = 8;
+    var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr);
+    var toReturnWire = retType.toWireType.bind(retType);
+    var argFromPtr = argTypes.map((type) => type.readValueFromPointer.bind(type));
+    argCount--;
+    var captures = { toValue: Emval.toValue };
+    var args = argFromPtr.map((argFromPtr2, i3) => {
+      var captureName = `argFromPtr${i3}`;
+      captures[captureName] = argFromPtr2;
+      return `${captureName}(args${i3 ? "+" + i3 * GenericWireTypeSize : ""})`;
+    });
+    var functionBody;
+    switch (kind) {
+      case 0:
+        functionBody = "toValue(handle)";
+        break;
+      case 2:
+        functionBody = "new (toValue(handle))";
+        break;
+      case 3:
+        functionBody = "";
+        break;
+      case 1:
+        captures["getStringOrSymbol"] = getStringOrSymbol;
+        functionBody = "toValue(handle)[getStringOrSymbol(methodName)]";
+        break;
+    }
+    functionBody += `(${args})`;
+    if (!retType.isVoid) {
+      captures["toReturnWire"] = toReturnWire;
+      captures["emval_returnValue"] = emval_returnValue;
+      functionBody = `return emval_returnValue(toReturnWire, destructorsRef, ${functionBody})`;
+    }
+    functionBody = `return function (handle, methodName, destructorsRef, args) {
+${functionBody}
+}`;
+    var invokerFunction = new Function(Object.keys(captures), functionBody)(...Object.values(captures));
+    var functionName = `methodCaller<(${argTypes.map((t49) => t49.name)}) => ${retType.name}>`;
+    return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+  };
+  function __emval_equals(first, second) {
+    first >>>= 0;
+    second >>>= 0;
+    first = Emval.toValue(first);
+    second = Emval.toValue(second);
+    return first == second;
+  }
+  function __emval_get_property(handle, key) {
+    handle >>>= 0;
+    key >>>= 0;
+    handle = Emval.toValue(handle);
+    key = Emval.toValue(key);
+    return Emval.toHandle(handle[key]);
+  }
+  function __emval_incref(handle) {
+    handle >>>= 0;
+    if (handle > 9) {
+      emval_handles[handle + 1] += 1;
+    }
+  }
+  function __emval_invoke(caller, handle, methodName, destructorsRef, args) {
+    caller >>>= 0;
+    handle >>>= 0;
+    methodName >>>= 0;
+    destructorsRef >>>= 0;
+    args >>>= 0;
+    return emval_methodCallers[caller](handle, methodName, destructorsRef, args);
+  }
+  function __emval_new_cstring(v4) {
+    v4 >>>= 0;
+    return Emval.toHandle(getStringOrSymbol(v4));
+  }
+  function __emval_new_object() {
+    return Emval.toHandle({});
+  }
+  function __emval_run_destructors(handle) {
+    handle >>>= 0;
+    var destructors = Emval.toValue(handle);
+    runDestructors(destructors);
+    __emval_decref(handle);
+  }
+  function __emval_set_property(handle, key, value) {
+    handle >>>= 0;
+    key >>>= 0;
+    value >>>= 0;
+    handle = Emval.toValue(handle);
+    key = Emval.toValue(key);
+    value = Emval.toValue(value);
+    handle[key] = value;
+  }
+  var getHeapMax = () => 4294901760;
+  var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+  var growMemory = (size) => {
+    var oldHeapSize = wasmMemory.buffer.byteLength;
+    var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+    try {
+      wasmMemory.grow(pages);
+      updateMemoryViews();
+      return 1;
+    } catch (e4) {}
+  };
+  function _emscripten_resize_heap(requestedSize) {
+    requestedSize >>>= 0;
+    var oldSize = HEAPU8.length;
+    var maxHeapSize = getHeapMax();
+    if (requestedSize > maxHeapSize) {
+      return false;
+    }
+    for (var cutDown = 1;cutDown <= 4; cutDown *= 2) {
+      var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+      overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+      var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+      var replacement = growMemory(newSize);
+      if (replacement) {
+        return true;
+      }
+    }
+    return false;
+  }
+  var updateTableMap = (offset, count) => {
+    if (functionsInTableMap) {
+      for (var i3 = offset;i3 < offset + count; i3++) {
+        var item = getWasmTableEntry(i3);
+        if (item) {
+          functionsInTableMap.set(item, i3);
+        }
+      }
+    }
+  };
+  var functionsInTableMap;
+  var getFunctionAddress = (func) => {
+    if (!functionsInTableMap) {
+      functionsInTableMap = new WeakMap;
+      updateTableMap(0, wasmTable.length);
+    }
+    return functionsInTableMap.get(func) || 0;
+  };
+  var freeTableIndexes = [];
+  var getEmptyTableSlot = () => {
+    if (freeTableIndexes.length) {
+      return freeTableIndexes.pop();
+    }
+    return wasmTable["grow"](1);
+  };
+  var setWasmTableEntry = (idx, func) => wasmTable.set(idx, func);
+  var uleb128EncodeWithLen = (arr) => {
+    const n3 = arr.length;
+    return [n3 % 128 | 128, n3 >> 7, ...arr];
+  };
+  var wasmTypeCodes = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+  var generateTypePack = (types3) => uleb128EncodeWithLen(Array.from(types3, (type) => {
+    var code = wasmTypeCodes[type];
+    return code;
+  }));
+  var convertJsFunctionToWasm = (func, sig) => {
+    var bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...uleb128EncodeWithLen([1, 96, ...generateTypePack(sig.slice(1)), ...generateTypePack(sig[0] === "v" ? "" : sig[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+    var module2 = new WebAssembly.Module(bytes);
+    var instance = new WebAssembly.Instance(module2, { e: { f: func } });
+    var wrappedFunc = instance.exports["f"];
+    return wrappedFunc;
+  };
+  var addFunction = (func, sig) => {
+    var rtn = getFunctionAddress(func);
+    if (rtn) {
+      return rtn;
+    }
+    var ret = getEmptyTableSlot();
+    try {
+      setWasmTableEntry(ret, func);
+    } catch (err3) {
+      if (!(err3 instanceof TypeError)) {
+        throw err3;
+      }
+      var wrapped = convertJsFunctionToWasm(func, sig);
+      setWasmTableEntry(ret, wrapped);
+    }
+    functionsInTableMap.set(func, ret);
+    return ret;
+  };
+  var removeFunction = (index) => {
+    functionsInTableMap.delete(getWasmTableEntry(index));
+    setWasmTableEntry(index, null);
+    freeTableIndexes.push(index);
+  };
+  init_ClassHandle();
+  init_RegisteredPointer();
+  {
+    if (Module2["noExitRuntime"])
+      noExitRuntime = Module2["noExitRuntime"];
+    if (Module2["print"])
+      out = Module2["print"];
+    if (Module2["printErr"])
+      err2 = Module2["printErr"];
+    if (Module2["wasmBinary"])
+      wasmBinary = Module2["wasmBinary"];
+    if (Module2["arguments"])
+      arguments_ = Module2["arguments"];
+    if (Module2["thisProgram"])
+      thisProgram = Module2["thisProgram"];
+    if (Module2["preInit"]) {
+      if (typeof Module2["preInit"] == "function")
+        Module2["preInit"] = [Module2["preInit"]];
+      while (Module2["preInit"].length > 0) {
+        Module2["preInit"].shift()();
+      }
+    }
+  }
+  Module2["addFunction"] = addFunction;
+  Module2["removeFunction"] = removeFunction;
+  var ___getTypeName, _malloc, _free, memory, __indirect_function_table, wasmMemory, wasmTable;
+  function assignWasmExports(wasmExports2) {
+    ___getTypeName = wasmExports2["K"];
+    _malloc = wasmExports2["M"];
+    _free = wasmExports2["N"];
+    memory = wasmMemory = wasmExports2["I"];
+    __indirect_function_table = wasmTable = wasmExports2["L"];
+  }
+  var wasmImports = { l: ___cxa_throw, C: __abort_js, q: __embind_finalize_value_object, z: __embind_register_bigint, G: __embind_register_bool, j: __embind_register_class, i: __embind_register_class_constructor, a: __embind_register_class_function, E: __embind_register_emval, x: __embind_register_enum, d: __embind_register_enum_value, y: __embind_register_float, c: __embind_register_function, p: __embind_register_integer, m: __embind_register_iterable, h: __embind_register_memory_view, n: __embind_register_optional, F: __embind_register_std_string, w: __embind_register_std_wstring, r: __embind_register_value_object, k: __embind_register_value_object_field, H: __embind_register_void, u: __emval_array_to_memory_view, g: __emval_create_invoker, b: __emval_decref, o: __emval_equals, B: __emval_get_property, t: __emval_incref, f: __emval_invoke, s: __emval_new_cstring, A: __emval_new_object, e: __emval_run_destructors, v: __emval_set_property, D: _emscripten_resize_heap };
+  function applySignatureConversions(wasmExports2) {
+    wasmExports2 = Object.assign({}, wasmExports2);
+    var makeWrapper_pp = (f2) => (a02) => f2(a02) >>> 0;
+    var makeWrapper_p = (f2) => () => f2() >>> 0;
+    wasmExports2["K"] = makeWrapper_pp(wasmExports2["K"]);
+    wasmExports2["M"] = makeWrapper_pp(wasmExports2["M"]);
+    wasmExports2["_emscripten_stack_alloc"] = makeWrapper_pp(wasmExports2["_emscripten_stack_alloc"]);
+    wasmExports2["emscripten_stack_get_current"] = makeWrapper_p(wasmExports2["emscripten_stack_get_current"]);
+    return wasmExports2;
+  }
+  function run2() {
+    preRun();
+    function doRun() {
+      Module2["calledRun"] = true;
+      if (ABORT)
+        return;
+      initRuntime();
+      readyPromiseResolve?.(Module2);
+      Module2["onRuntimeInitialized"]?.();
+      postRun();
+    }
+    if (Module2["setStatus"]) {
+      Module2["setStatus"]("Running...");
+      setTimeout(() => {
+        setTimeout(() => Module2["setStatus"](""), 1);
+        doRun();
+      }, 1);
+    } else {
+      doRun();
+    }
+  }
+  var wasmExports;
+  wasmExports = await createWasm();
+  run2();
+  if (runtimeInitialized) {
+    moduleRtn = Module2;
+  } else {
+    moduleRtn = new Promise((resolve11, reject) => {
+      readyPromiseResolve = resolve11;
+      readyPromiseReject = reject;
+    });
+  }
+  return moduleRtn;
+}
+var manifold_default = Module;
+
+// node_modules/circuit-json-to-fdm-component-box/dist/chunk-7FCNDFKL.js
+init_esm();
+import outlinePolygons from "@tscircuit/alphabet/outline-polygons";
+import {
+  glyphAdvanceRatio as glyphAdvanceRatio4,
+  kerningRatio as kerningRatio2,
+  spaceWidthRatio as spaceWidthRatio3,
+  textMetrics as textMetrics2
+} from "@tscircuit/alphabet";
+var naturalRefdesCollator = new Intl.Collator("en", {
+  numeric: true,
+  sensitivity: "base"
+});
+var asCircuitRecord = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  return value;
+};
+var normalizeIdentity = (value) => value.trim().replace(/\s+/g, " ").toUpperCase();
+var getSupplierPartNumbers = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  const entries = [];
+  for (const [supplier, partNumbers] of Object.entries(value)) {
+    if (!Array.isArray(partNumbers))
+      continue;
+    const normalized = partNumbers.filter((partNumber) => typeof partNumber === "string").map((partNumber) => partNumber.trim()).filter(Boolean);
+    if (normalized.length > 0)
+      entries.push([supplier, normalized]);
+  }
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+};
+var supplierPriority = [
+  "jlcpcb",
+  "lcsc",
+  "digikey",
+  "mouser",
+  "pcbway",
+  "macrofab"
+];
+var getPreferredSupplierIdentity = (supplierPartNumbers) => {
+  if (!supplierPartNumbers)
+    return;
+  const suppliers = Object.keys(supplierPartNumbers).sort((a2, b3) => {
+    const aPriority = supplierPriority.indexOf(a2.toLowerCase());
+    const bPriority = supplierPriority.indexOf(b3.toLowerCase());
+    return (aPriority < 0 ? Number.POSITIVE_INFINITY : aPriority) - (bPriority < 0 ? Number.POSITIVE_INFINITY : bPriority) || a2.localeCompare(b3);
+  });
+  const supplier = suppliers[0];
+  const partNumber = supplier ? supplierPartNumbers[supplier]?.[0] : undefined;
+  return supplier && partNumber ? `supplier:${supplier.toLowerCase()}:${normalizeIdentity(partNumber)}` : undefined;
+};
+var getPassiveValue = (source) => {
+  switch (source.ftype) {
+    case "simple_resistor":
+      return source.resistance;
+    case "simple_capacitor":
+      return source.capacitance;
+    case "simple_inductor":
+      return source.inductance;
+    default:
+      return;
+  }
+};
+var getComponentKey = (component, groupByComponent) => {
+  const sourceId = component.source.source_component_id;
+  if (!groupByComponent)
+    return `source:${sourceId}`;
+  const manufacturerPartNumber = component.source.manufacturer_part_number;
+  if (typeof manufacturerPartNumber === "string" && manufacturerPartNumber.trim()) {
+    return `mpn:${normalizeIdentity(manufacturerPartNumber)}`;
+  }
+  const supplierIdentity = getPreferredSupplierIdentity(getSupplierPartNumbers(component.source.supplier_part_numbers));
+  if (supplierIdentity)
+    return supplierIdentity;
+  const passiveValue = getPassiveValue(component.source);
+  const packageIdentity = component.footprint ?? component.physicalSize;
+  if (passiveValue !== undefined && passiveValue !== null && packageIdentity && typeof component.source.ftype === "string") {
+    return `passive:${component.source.ftype}:${String(passiveValue)}:${normalizeIdentity(packageIdentity)}`;
+  }
+  return `source:${sourceId}`;
+};
+var selectComponents = (circuitJson, options) => {
+  if (!Array.isArray(circuitJson)) {
+    throw new TypeError("Circuit JSON must be an array");
+  }
+  const sources = [];
+  const placedBySourceId = /* @__PURE__ */ new Map;
+  const cadByPcbComponentId = /* @__PURE__ */ new Map;
+  let hasPcbComponents = false;
+  for (const element of circuitJson) {
+    const record = asCircuitRecord(element);
+    if (!record)
+      continue;
+    if (record.type === "source_component") {
+      if (typeof record.source_component_id !== "string" || record.source_component_id.trim() === "" || typeof record.name !== "string" || record.name.trim() === "") {
+        throw new TypeError("Every source_component must have non-empty source_component_id and name fields");
+      }
+      sources.push(record);
+    }
+    if (record.type === "pcb_component") {
+      hasPcbComponents = true;
+      if (record.do_not_place !== true && typeof record.source_component_id === "string") {
+        placedBySourceId.set(record.source_component_id, record);
+      }
+    }
+    if (record.type === "cad_component" && typeof record.pcb_component_id === "string") {
+      cadByPcbComponentId.set(record.pcb_component_id, record);
+    }
+  }
+  const shouldFilterUnplaced = !options.includeUnplacedComponents && hasPcbComponents;
+  const selected = sources.filter((source) => {
+    if (!options.includeTestPoints && source.ftype === "simple_test_point") {
+      return false;
+    }
+    return !shouldFilterUnplaced || placedBySourceId.has(source.source_component_id);
+  }).map((source) => {
+    const pcb = placedBySourceId.get(source.source_component_id);
+    const cad = pcb && typeof pcb.pcb_component_id === "string" ? cadByPcbComponentId.get(pcb.pcb_component_id) : undefined;
+    const footprint = typeof cad?.footprinter_string === "string" && cad.footprinter_string.trim() ? cad.footprinter_string.trim() : undefined;
+    const physicalSize = typeof pcb?.width === "number" && typeof pcb.height === "number" ? `${pcb.width}x${pcb.height}` : undefined;
+    return { source, footprint, physicalSize };
+  });
+  if (selected.length === 0) {
+    throw new Error(shouldFilterUnplaced ? "Circuit JSON has no placed, populated components to assign to compartments" : "Circuit JSON has no components to assign to compartments");
+  }
+  const duplicateRefdes = selected.map(({ source }) => source.name.trim()).find((refdes, index, all) => all.indexOf(refdes) !== index);
+  if (duplicateRefdes) {
+    throw new Error(`Duplicate component refdes: ${duplicateRefdes}`);
+  }
+  return selected;
+};
+var extractComponentGroups = (circuitJson, options = {}) => {
+  const groupByComponent = options.groupByComponent ?? true;
+  const grouped = /* @__PURE__ */ new Map;
+  for (const component of selectComponents(circuitJson, options)) {
+    const componentKey = getComponentKey(component, groupByComponent);
+    const refdes = component.source.name.trim();
+    const existing = grouped.get(componentKey);
+    if (existing) {
+      existing.referenceDesignators.push(refdes);
+      existing.quantity += 1;
+      continue;
+    }
+    const manufacturerPartNumber = typeof component.source.manufacturer_part_number === "string" && component.source.manufacturer_part_number.trim() ? component.source.manufacturer_part_number.trim() : undefined;
+    grouped.set(componentKey, {
+      componentKey,
+      referenceDesignators: [refdes],
+      quantity: 1,
+      componentType: typeof component.source.ftype === "string" ? component.source.ftype : undefined,
+      manufacturerPartNumber,
+      supplierPartNumbers: getSupplierPartNumbers(component.source.supplier_part_numbers),
+      footprint: component.footprint
+    });
+  }
+  const groups = [...grouped.values()];
+  for (const group of groups) {
+    group.referenceDesignators.sort((a2, b3) => naturalRefdesCollator.compare(a2, b3));
+  }
+  return groups.sort((a2, b3) => naturalRefdesCollator.compare(a2.referenceDesignators[0], b3.referenceDesignators[0]));
+};
+var DEFAULT_FDM_COMPONENT_BOX_OPTIONS = {
+  compartmentWidth: 26,
+  compartmentDepth: 22,
+  compartmentHeight: 12,
+  wallThickness: 1.6,
+  floorThickness: 1.6,
+  labelBandDepth: 6.5,
+  labelThickness: 0.6,
+  labelPadding: 0.75,
+  minimumLabelStrokeWidth: 0.45,
+  includeUnplacedComponents: false,
+  includeTestPoints: false,
+  groupByComponent: true,
+  boxColor: "#D9D9D9FF",
+  labelColor: "#151515FF"
+};
+var pointsMatch = (a2, b3) => Math.abs(a2.x - b3.x) < 0.000000000001 && Math.abs(a2.y - b3.y) < 0.000000000001;
+var getLabelTextGeometry = (text) => {
+  const contours = [];
+  let cursorX = 0;
+  let previousCharacter;
+  for (const character of text) {
+    if (character === " ") {
+      cursorX += spaceWidthRatio3;
+      previousCharacter = character;
+      continue;
+    }
+    const glyph = outlinePolygons[character];
+    if (!glyph) {
+      throw new Error(`Label ${JSON.stringify(text)} contains unsupported character ${JSON.stringify(character)}`);
+    }
+    cursorX += previousCharacter ? kerningRatio2[previousCharacter]?.[character] ?? 0 : 0;
+    for (const ring of glyph) {
+      const unclosedRing = ring.length > 1 && pointsMatch(ring[0], ring[ring.length - 1]) ? ring.slice(0, -1) : ring;
+      contours.push(unclosedRing.map(({ x: x4, y: y4 }) => ({ x: x4 + cursorX, y: y4 })));
+    }
+    cursorX += glyphAdvanceRatio4[character] ?? spaceWidthRatio3;
+    previousCharacter = character;
+  }
+  if (contours.length === 0) {
+    throw new Error(`Label ${JSON.stringify(text)} has no printable glyphs`);
+  }
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const ring of contours) {
+    for (const point9 of ring) {
+      minX = Math.min(minX, point9.x);
+      minY = Math.min(minY, point9.y);
+      maxX = Math.max(maxX, point9.x);
+      maxY = Math.max(maxY, point9.y);
+    }
+  }
+  return {
+    contours,
+    bounds: { minX, minY, maxX, maxY },
+    rawWidth: maxX - minX,
+    rawHeight: maxY - minY
+  };
+};
+var getScaledLabelMetrics = (text, availableWidth, availableHeight) => {
+  const geometry = getLabelTextGeometry(text);
+  const scale6 = Math.min(availableWidth / geometry.rawWidth, availableHeight / geometry.rawHeight);
+  return {
+    ...geometry,
+    scale: scale6,
+    strokeWidth: textMetrics2.strokeWidthRatio * scale6
+  };
+};
+var createLabelManifold = (module2, placement, options, boxHeight) => {
+  const availableWidth = options.compartmentWidth - options.labelPadding * 2;
+  const availableHeight = options.labelBandDepth - options.labelPadding * 2;
+  const { contours, bounds, rawWidth, rawHeight, scale: scale6, strokeWidth } = getScaledLabelMetrics(placement.label, availableWidth, availableHeight);
+  if (strokeWidth < options.minimumLabelStrokeWidth) {
+    throw new Error(`Label ${JSON.stringify(placement.label)} needs a ${strokeWidth.toFixed(3)}mm text stroke, below minimumLabelStrokeWidth ${options.minimumLabelStrokeWidth}mm; increase compartmentWidth or labelBandDepth`);
+  }
+  const scaledWidth = rawWidth * scale6;
+  const scaledHeight = rawHeight * scale6;
+  const offsetX = placement.labelCenter.x - scaledWidth / 2 - bounds.minX * scale6;
+  const offsetY = placement.labelCenter.y - scaledHeight / 2 - bounds.minY * scale6;
+  const transformedContours = contours.map((ring) => ring.map(({ x: x4, y: y4 }) => [x4 * scale6 + offsetX, y4 * scale6 + offsetY]));
+  const crossSection = module2.CrossSection.ofPolygons(transformedContours, "Positive");
+  let unpositioned;
+  try {
+    unpositioned = crossSection.extrude(options.labelThickness);
+    return unpositioned.translate([0, 0, boxHeight]);
+  } finally {
+    unpositioned?.delete();
+    crossSection.delete();
+  }
+};
+var manifoldModulePromise;
+var getManifoldModule = async () => {
+  manifoldModulePromise ??= manifold_default().then((module2) => {
+    module2.setup();
+    return module2;
+  });
+  return manifoldModulePromise;
+};
+var copyMesh = (mesh, name, materialIndex) => {
+  const vertices = new Float32Array(mesh.numVert * 3);
+  for (let vertexIndex = 0;vertexIndex < mesh.numVert; vertexIndex += 1) {
+    const sourceOffset = vertexIndex * mesh.numProp;
+    const destinationOffset = vertexIndex * 3;
+    vertices[destinationOffset] = mesh.vertProperties[sourceOffset];
+    vertices[destinationOffset + 1] = mesh.vertProperties[sourceOffset + 1];
+    vertices[destinationOffset + 2] = mesh.vertProperties[sourceOffset + 2];
+  }
+  return {
+    name,
+    vertices,
+    triangles: new Uint32Array(mesh.triVerts),
+    materialIndex
+  };
+};
+var deleteAll = (manifolds) => {
+  for (const manifold of manifolds)
+    manifold.delete();
+};
+var createPrintableMeshes = async (options, dimensions, compartments) => {
+  const module2 = await getManifoldModule();
+  const { Manifold } = module2;
+  const rowSolids = [];
+  const cavitySolids = [];
+  const labelSolids = [];
+  let outer;
+  let cavityUnion;
+  let box2;
+  try {
+    const rowInnerDepth = options.compartmentDepth + options.labelBandDepth;
+    const rowPitch = rowInnerDepth + options.wallThickness;
+    for (let row = 0;row < dimensions.rows; row += 1) {
+      const rowCellCount = Math.min(options.columns, compartments.length - row * options.columns);
+      const rowWidth = rowCellCount * options.compartmentWidth + (rowCellCount + 1) * options.wallThickness;
+      rowSolids.push(Manifold.cube([
+        rowWidth,
+        rowInnerDepth + options.wallThickness * 2,
+        dimensions.height
+      ]).translate([0, row * rowPitch, 0]));
+    }
+    for (const compartment of compartments) {
+      const cavityX = compartment.center.x - options.compartmentWidth / 2;
+      const cavityY = compartment.center.y - options.compartmentDepth / 2;
+      cavitySolids.push(Manifold.cube([
+        options.compartmentWidth,
+        options.compartmentDepth,
+        options.compartmentHeight + 0.1
+      ]).translate([cavityX, cavityY, options.floorThickness]));
+    }
+    outer = Manifold.union(rowSolids);
+    cavityUnion = Manifold.union(cavitySolids);
+    box2 = outer.subtract(cavityUnion);
+    if (box2.isEmpty() || box2.status() !== "NoError") {
+      throw new Error(`manifold-3d could not create the box: ${box2.status()}`);
+    }
+    const boxMesh = copyMesh(box2.getMesh(), "Box", 0);
+    const labelMeshes = [];
+    for (const compartment of compartments) {
+      const label = createLabelManifold(module2, compartment, options, dimensions.height);
+      labelSolids.push(label);
+      if (label.isEmpty() || label.status() !== "NoError") {
+        throw new Error(`manifold-3d could not create label ${compartment.refdes}: ${label.status()}`);
+      }
+      labelMeshes.push(copyMesh(label.getMesh(), `Label ${compartment.referenceDesignators.join(",")}`, 1));
+    }
+    return { box: boxMesh, labels: labelMeshes };
+  } finally {
+    box2?.delete();
+    cavityUnion?.delete();
+    outer?.delete();
+    deleteAll(labelSolids);
+    deleteAll(cavitySolids);
+    deleteAll(rowSolids);
+  }
+};
+var compactNumericRange = (refdes) => {
+  const parsed = refdes.map((value) => {
+    const match = /^(.*?)(\d+)$/.exec(value);
+    return match ? { prefix: match[1], number: Number(match[2]) } : undefined;
+  });
+  if (parsed.some((value) => !value))
+    return;
+  const values = parsed;
+  const prefix = values[0].prefix;
+  if (values.some((value) => value.prefix !== prefix))
+    return;
+  const ranges = [];
+  for (const number of [...new Set(values.map((value) => value.number))].sort((a2, b3) => a2 - b3)) {
+    const previous = ranges[ranges.length - 1];
+    if (previous && number === previous.end + 1)
+      previous.end = number;
+    else
+      ranges.push({ start: number, end: number });
+  }
+  return ranges.map(({ start, end }) => start === end ? `${prefix}${start}` : `${prefix}${start}-${end}`).join(",");
+};
+var middleAbbreviations = (value) => {
+  const abbreviations = [];
+  for (let kept = value.length - 1;kept >= 2; kept -= 1) {
+    const startLength = Math.ceil(kept / 2);
+    const endLength = Math.floor(kept / 2);
+    abbreviations.push(`${value.slice(0, startLength)}...${value.slice(value.length - endLength)}`);
+  }
+  return abbreviations;
+};
+var tokenAbbreviations = (value) => {
+  const count = /\+\d+$/.exec(value)?.[0] ?? "";
+  const refdes = count ? value.slice(0, -count.length) : value;
+  const tokens = refdes.split("_");
+  if (tokens.length < 2)
+    return [];
+  const separated = [4, 3, 2, 1].map((charactersPerToken) => [
+    tokens[0],
+    ...tokens.slice(1).map((token) => token.slice(0, charactersPerToken))
+  ].join("_").concat(count));
+  const condensed = [3, 2, 1].map((charactersPerToken) => [
+    tokens[0],
+    ...tokens.slice(1).map((token) => token.slice(0, charactersPerToken))
+  ].join("").concat(count));
+  return [...separated, ...condensed];
+};
+var formatComponentGroupLabel = (referenceDesignators, options) => {
+  const full = referenceDesignators.join(",");
+  const compact = compactNumericRange(referenceDesignators);
+  const counted = referenceDesignators.length > 1 ? `${referenceDesignators[0]}+${referenceDesignators.length - 1}` : referenceDesignators[0];
+  const candidates = [
+    ...new Set([full, compact, counted].filter((candidate) => Boolean(candidate)))
+  ];
+  candidates.push(...tokenAbbreviations(counted));
+  candidates.push(...middleAbbreviations(counted));
+  for (const candidate of candidates) {
+    const { strokeWidth: strokeWidth2 } = getScaledLabelMetrics(candidate, options.availableWidth, options.availableHeight);
+    if (strokeWidth2 >= options.minimumStrokeWidth)
+      return candidate;
+  }
+  const { strokeWidth } = getScaledLabelMetrics(counted, options.availableWidth, options.availableHeight);
+  throw new Error(`Refdes group ${JSON.stringify(referenceDesignators)} needs a ${strokeWidth.toFixed(3)}mm text stroke, below minimumLabelStrokeWidth ${options.minimumStrokeWidth}mm; increase compartmentWidth or labelBandDepth`);
+};
+var assertPositive = (value, name) => {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive finite number`);
+  }
+  return value;
+};
+var normalizeColor = (value, name) => {
+  if (!/^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i.test(value)) {
+    throw new TypeError(`${name} must use #RRGGBB or #RRGGBBAA notation`);
+  }
+  return `${value.toUpperCase()}${value.length === 7 ? "FF" : ""}`;
+};
+var resolveFdmComponentBoxOptions = (componentGroups, options) => {
+  if (componentGroups.length === 0) {
+    throw new Error("At least one component is required");
+  }
+  const requestedColumns = options.columns ?? Math.ceil(Math.sqrt(componentGroups.length));
+  if (!Number.isInteger(requestedColumns) || requestedColumns <= 0) {
+    throw new RangeError("columns must be a positive integer");
+  }
+  const columns = Math.min(requestedColumns, componentGroups.length);
+  const compartmentWidth = assertPositive(options.compartmentWidth ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.compartmentWidth, "compartmentWidth");
+  const compartmentDepth = assertPositive(options.compartmentDepth ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.compartmentDepth, "compartmentDepth");
+  const compartmentHeight = assertPositive(options.compartmentHeight ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.compartmentHeight, "compartmentHeight");
+  const wallThickness = assertPositive(options.wallThickness ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.wallThickness, "wallThickness");
+  const floorThickness = assertPositive(options.floorThickness ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.floorThickness, "floorThickness");
+  const labelBandDepth = assertPositive(options.labelBandDepth ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.labelBandDepth, "labelBandDepth");
+  const labelThickness = assertPositive(options.labelThickness ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.labelThickness, "labelThickness");
+  const labelPadding = assertPositive(options.labelPadding ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.labelPadding, "labelPadding");
+  const minimumLabelStrokeWidth = assertPositive(options.minimumLabelStrokeWidth ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.minimumLabelStrokeWidth, "minimumLabelStrokeWidth");
+  if (labelPadding * 2 >= compartmentWidth) {
+    throw new RangeError("labelPadding leaves no horizontal room for text");
+  }
+  if (labelPadding * 2 >= labelBandDepth) {
+    throw new RangeError("labelPadding leaves no vertical room for text");
+  }
+  const rows = Math.ceil(componentGroups.length / columns);
+  const rowInnerDepth = compartmentDepth + labelBandDepth;
+  const rowPitch = rowInnerDepth + wallThickness;
+  const dimensions = {
+    width: columns * compartmentWidth + (columns + 1) * wallThickness,
+    depth: rows * rowInnerDepth + (rows + 1) * wallThickness,
+    height: floorThickness + compartmentHeight,
+    columns,
+    rows
+  };
+  const compartments = componentGroups.map((group, index) => {
+    const row = Math.floor(index / columns);
+    const column = index % columns;
+    const rowY = row * rowPitch;
+    const cavityX = wallThickness + column * (compartmentWidth + wallThickness);
+    const cavityY = rowY + wallThickness;
+    const labelY = cavityY + compartmentDepth;
+    return {
+      refdes: group.referenceDesignators[0],
+      referenceDesignators: [...group.referenceDesignators],
+      label: formatComponentGroupLabel(group.referenceDesignators, {
+        availableWidth: compartmentWidth - labelPadding * 2,
+        availableHeight: labelBandDepth - labelPadding * 2,
+        minimumStrokeWidth: minimumLabelStrokeWidth
+      }),
+      componentKey: group.componentKey,
+      quantity: group.quantity,
+      row,
+      column,
+      center: {
+        x: cavityX + compartmentWidth / 2,
+        y: cavityY + compartmentDepth / 2
+      },
+      labelCenter: {
+        x: cavityX + compartmentWidth / 2,
+        y: labelY + labelBandDepth / 2
+      },
+      width: compartmentWidth,
+      depth: compartmentDepth
+    };
+  });
+  const duplicateLabel = compartments.map(({ label }) => label).find((label, index, labels) => labels.indexOf(label) !== index);
+  if (duplicateLabel) {
+    throw new Error(`Compartment label ${JSON.stringify(duplicateLabel)} is ambiguous after abbreviation; increase compartmentWidth or labelBandDepth`);
+  }
+  return {
+    options: {
+      columns,
+      compartmentWidth,
+      compartmentDepth,
+      compartmentHeight,
+      wallThickness,
+      floorThickness,
+      labelBandDepth,
+      labelThickness,
+      labelPadding,
+      minimumLabelStrokeWidth,
+      includeUnplacedComponents: options.includeUnplacedComponents ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.includeUnplacedComponents,
+      includeTestPoints: options.includeTestPoints ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.includeTestPoints,
+      groupByComponent: options.groupByComponent ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.groupByComponent,
+      boxColor: normalizeColor(options.boxColor ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.boxColor, "boxColor"),
+      labelColor: normalizeColor(options.labelColor ?? DEFAULT_FDM_COMPONENT_BOX_OPTIONS.labelColor, "labelColor"),
+      title: options.title?.trim() || (() => {
+        const componentCount = componentGroups.reduce((sum, group) => sum + group.quantity, 0);
+        return componentCount === componentGroups.length ? `Assembly box for ${componentCount} components` : `Assembly box for ${componentCount} components in ${componentGroups.length} compartments`;
+      })()
+    },
+    dimensions,
+    compartments
+  };
+};
+var buildFdmComponentBox = async (circuitJson, options = {}) => {
+  const componentGroups = extractComponentGroups(circuitJson, {
+    includeUnplacedComponents: options.includeUnplacedComponents,
+    includeTestPoints: options.includeTestPoints,
+    groupByComponent: options.groupByComponent
+  });
+  const resolved = resolveFdmComponentBoxOptions(componentGroups, options);
+  const meshes = await createPrintableMeshes(resolved.options, resolved.dimensions, resolved.compartments);
+  return {
+    componentGroups,
+    componentRefdes: componentGroups.flatMap(({ referenceDesignators }) => referenceDesignators).sort((a2, b3) => naturalRefdesCollator.compare(a2, b3)),
+    options: resolved.options,
+    dimensions: resolved.dimensions,
+    compartments: resolved.compartments,
+    meshes
+  };
+};
+var CONTENT_TYPES_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />
+  <Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml" />
+</Types>
+`;
+var RELATIONSHIPS_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Target="/3D/3dmodel.model" Id="rel-1" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel" />
+</Relationships>
+`;
+var escapeXml3 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+var formatNumber5 = (value) => {
+  const normalized = Math.abs(value) < 0.0000005 ? 0 : value;
+  return normalized.toFixed(6).replace(/(?:\.0+|(?<decimal>\.[0-9]*?)0+)$/, "$<decimal>");
+};
+var appendMeshObject = (output, mesh, objectId) => {
+  output.push(`    <object id="${objectId}" type="model" name="${escapeXml3(mesh.name)}" pid="1" pindex="${mesh.materialIndex}">
+`, `      <mesh>
+`, `        <vertices>
+`);
+  for (let index = 0;index < mesh.vertices.length; index += 3) {
+    output.push(`          <vertex x="${formatNumber5(mesh.vertices[index])}" y="${formatNumber5(mesh.vertices[index + 1])}" z="${formatNumber5(mesh.vertices[index + 2])}" />
+`);
+  }
+  output.push(`        </vertices>
+`, `        <triangles>
+`);
+  for (let index = 0;index < mesh.triangles.length; index += 3) {
+    output.push(`          <triangle v1="${mesh.triangles[index]}" v2="${mesh.triangles[index + 1]}" v3="${mesh.triangles[index + 2]}" />
+`);
+  }
+  output.push(`        </triangles>
+`, `      </mesh>
+`, `    </object>
+`);
+};
+var createBambuModelSettings = (meshes, assemblyId, title) => {
+  const settings = [
+    `<?xml version="1.0" encoding="UTF-8"?>
+`,
+    `<config>
+`,
+    `  <object id="${assemblyId}">
+`,
+    `    <metadata key="name" value="${escapeXml3(title)}"/>
+`,
+    `    <metadata key="extruder" value="1"/>
+`
+  ];
+  for (const [index, mesh] of meshes.entries()) {
+    const objectId = index + 2;
+    const extruder = mesh.materialIndex + 1;
+    settings.push(`    <part id="${objectId}" subtype="normal_part">
+`, `      <metadata key="name" value="${escapeXml3(mesh.name)}"/>
+`, `      <metadata key="extruder" value="${extruder}"/>
+`, `      <mesh_stat face_count="${mesh.triangles.length / 3}" edges_fixed="0" degenerate_facets="0" facets_removed="0" facets_reversed="0" backwards_edges="0"/>
+`, `    </part>
+`);
+  }
+  settings.push(`  </object>
+`, `  <assemble>
+`, `  </assemble>
+`, `</config>
+`);
+  return settings.join("");
+};
+var createThreeMf = ({
+  box: box2,
+  labels,
+  boxColor,
+  labelColor,
+  title
+}) => {
+  const model = [
+    `<?xml version="1.0" encoding="UTF-8"?>
+`,
+    `<model unit="millimeter" xml:lang="en-US" xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02">
+`,
+    `  <metadata name="Title">${escapeXml3(title)}</metadata>
+`,
+    `  <metadata name="Designer">tscircuit</metadata>
+`,
+    `  <metadata name="Description">Labeled component-organization box generated from Circuit JSON</metadata>
+`,
+    `  <metadata name="Application">circuit-json-to-fdm-component-box</metadata>
+`,
+    `  <resources>
+`,
+    `    <basematerials id="1">
+`,
+    `      <base name="Box" displaycolor="${boxColor}" />
+`,
+    `      <base name="Labels" displaycolor="${labelColor}" />
+`,
+    `    </basematerials>
+`
+  ];
+  const meshes = [box2, ...labels];
+  for (const [index, mesh] of meshes.entries()) {
+    appendMeshObject(model, mesh, index + 2);
+  }
+  const assemblyId = meshes.length + 2;
+  model.push(`    <object id="${assemblyId}" type="model" name="${escapeXml3(title)}">
+`, `      <components>
+`);
+  for (let objectId = 2;objectId < assemblyId; objectId += 1) {
+    model.push(`        <component objectid="${objectId}" />
+`);
+  }
+  model.push(`      </components>
+`, `    </object>
+`, `  </resources>
+`, `  <build>
+`, `    <item objectid="${assemblyId}" />
+`, `  </build>
+`, `</model>
+`);
+  const bambuModelSettings = createBambuModelSettings(meshes, assemblyId, title);
+  return zipSync({
+    "[Content_Types].xml": strToU8(CONTENT_TYPES_XML),
+    "_rels/.rels": strToU8(RELATIONSHIPS_XML),
+    "3D/3dmodel.model": strToU8(model.join("")),
+    "Metadata/model_settings.config": strToU8(bambuModelSettings)
+  }, {
+    level: 6,
+    mtime: /* @__PURE__ */ new Date("1980-01-02T00:00:00.000Z")
+  });
+};
+var createFdmComponentBox = async (circuitJson, options = {}) => {
+  const built = await buildFdmComponentBox(circuitJson, options);
+  const boxTriangles = built.meshes.box.triangles.length / 3;
+  const labelTriangles = built.meshes.labels.reduce((sum, mesh) => sum + mesh.triangles.length / 3, 0);
+  return {
+    threeMf: createThreeMf({
+      box: built.meshes.box,
+      labels: built.meshes.labels,
+      boxColor: built.options.boxColor,
+      labelColor: built.options.labelColor,
+      title: built.options.title
+    }),
+    componentRefdes: built.componentRefdes,
+    componentGroups: built.componentGroups,
+    dimensions: built.dimensions,
+    compartments: built.compartments,
+    meshStats: {
+      boxTriangles,
+      labelTriangles,
+      totalTriangles: boxTriangles + labelTriangles
+    }
+  };
+};
+var circuitJsonToFdmComponentBox = async (circuitJson, options = {}) => (await createFdmComponentBox(circuitJson, options)).threeMf;
+
+// node_modules/circuit-json-to-fdm-component-box/dist/index.js
+import {
+  createSceneFromGLTF,
+  encodePNG,
+  renderSceneFromGLTF
+} from "poppygl";
+
 // lib/shared/export-snippet.ts
 import {
   convertCircuitJsonToAssemblySvg as convertCircuitJsonToAssemblySvg2,
@@ -311972,7 +315849,8 @@ var ALLOWED_EXPORT_FORMATS = [
   "kicad-library",
   "srj",
   "step",
-  "assembly-svg"
+  "assembly-svg",
+  "component-box-3mf"
 ];
 var OUTPUT_EXTENSIONS = {
   json: ".circuit.json",
@@ -311991,7 +315869,8 @@ var OUTPUT_EXTENSIONS = {
   kicad_zip: "-kicad.zip",
   "kicad-library": "",
   srj: ".simple-route.json",
-  step: ".step"
+  step: ".step",
+  "component-box-3mf": "-component-box.3mf"
 };
 var isRecord = (value) => typeof value === "object" && value !== null;
 var unwrapSimpleRouteJson = (value) => {
@@ -312194,6 +316073,9 @@ var exportSnippet = async ({
     case "assembly-svg":
       outputContent = convertCircuitJsonToAssemblySvg2(circuitJson);
       break;
+    case "component-box-3mf":
+      outputContent = Buffer.from(await circuitJsonToFdmComponentBox(circuitJson));
+      break;
     default:
       outputContent = JSON.stringify(circuitJson, null, 2);
   }
@@ -324916,7 +328798,7 @@ var getPointTransformer = (origin) => (point22) => ({
   x: toSchematicUnits(point22.x - origin.x),
   y: toSchematicUnits(origin.y - point22.y)
 });
-var formatNumber5 = (value) => String(round(value));
+var formatNumber6 = (value) => String(round(value));
 var SVG_PATH_COMMAND_PARAMETER_COUNTS = {
   A: 7,
   C: 6,
@@ -324971,7 +328853,7 @@ var transformSvgPath = (pathData, origin) => {
     if (upperCommand === "H" || upperCommand === "V") {
       const point22 = getOriginalPoint(upperCommand === "H" ? values[0] : isRelative ? 0 : currentX, upperCommand === "V" ? values[0] : isRelative ? 0 : currentY, isRelative);
       const transformed = transformPoint2(point22);
-      output.push(`L ${formatNumber5(transformed.x)} ${formatNumber5(transformed.y)}`);
+      output.push(`L ${formatNumber6(transformed.x)} ${formatNumber6(transformed.y)}`);
       currentX = point22.x;
       currentY = point22.y;
       continue;
@@ -324979,7 +328861,7 @@ var transformSvgPath = (pathData, origin) => {
     if (["M", "L", "T"].includes(upperCommand)) {
       const point22 = getOriginalPoint(values[0], values[1], isRelative);
       const transformed = transformPoint2(point22);
-      output.push(`${upperCommand} ${formatNumber5(transformed.x)} ${formatNumber5(transformed.y)}`);
+      output.push(`${upperCommand} ${formatNumber6(transformed.x)} ${formatNumber6(transformed.y)}`);
       currentX = point22.x;
       currentY = point22.y;
       if (upperCommand === "M") {
@@ -324996,7 +328878,7 @@ var transformSvgPath = (pathData, origin) => {
         const transformed = transformPoint2(point22);
         transformedValues.push(transformed.x, transformed.y);
       }
-      output.push(`${upperCommand} ${transformedValues.map(formatNumber5).join(" ")}`);
+      output.push(`${upperCommand} ${transformedValues.map(formatNumber6).join(" ")}`);
       currentX = isRelative ? currentX + values[values.length - 2] : values[values.length - 2];
       currentY = isRelative ? currentY + values[values.length - 1] : values[values.length - 1];
       continue;
@@ -325006,13 +328888,13 @@ var transformSvgPath = (pathData, origin) => {
       const transformedEndpoint = transformPoint2(endpoint);
       output.push([
         "A",
-        formatNumber5(toSchematicUnits(Math.abs(values[0]))),
-        formatNumber5(toSchematicUnits(Math.abs(values[1]))),
-        formatNumber5(-values[2]),
+        formatNumber6(toSchematicUnits(Math.abs(values[0]))),
+        formatNumber6(toSchematicUnits(Math.abs(values[1]))),
+        formatNumber6(-values[2]),
         String(values[3]),
         String(values[4] === 0 ? 1 : 0),
-        formatNumber5(transformedEndpoint.x),
-        formatNumber5(transformedEndpoint.y)
+        formatNumber6(transformedEndpoint.x),
+        formatNumber6(transformedEndpoint.y)
       ].join(" "));
       currentX = endpoint.x;
       currentY = endpoint.y;
@@ -335084,7 +338966,7 @@ var registerSetup = (program3) => {
 };
 
 // lib/shared/result-to-table.ts
-var formatNumber6 = (n3) => {
+var formatNumber7 = (n3) => {
   return n3.toExponential(6);
 };
 function formatRows(rows) {
@@ -335116,7 +338998,7 @@ var resultToTable = (result) => {
     for (let i3 = 0;i3 < result.numPoints; i3++) {
       const row = [
         i3.toString(),
-        ...uniqueData.map((d3) => formatNumber6(d3.values[i3]))
+        ...uniqueData.map((d3) => formatNumber7(d3.values[i3]))
       ];
       dataRows2.push(row);
     }
@@ -335131,8 +339013,8 @@ var resultToTable = (result) => {
     const row = [
       i3.toString(),
       ...uniqueData.flatMap((d3) => [
-        formatNumber6(d3.values[i3].real),
-        formatNumber6(d3.values[i3].img)
+        formatNumber7(d3.values[i3].real),
+        formatNumber7(d3.values[i3].img)
       ])
     ];
     dataRows.push(row);